class TemplateArgumentLoc;
class TemplateArgumentListInfo;
+/// \brief A simple array of base specifiers.
+typedef UsuallyTinyPtrVector<const CXXBaseSpecifier> CXXBaseSpecifierArray;
+
/// Expr - This represents one expression. Note that Expr's are subclasses of
/// Stmt. This allows an expression to be transparently used any place a Stmt
/// is required.
/// classes).
class CastExpr : public Expr {
public:
- typedef UsuallyTinyPtrVector<const CXXBaseSpecifier> CXXBaseVector;
-
/// CastKind - the kind of cast this represents.
enum CastKind {
/// CK_Unknown - Unknown cast kind.
private:
CastKind Kind;
Stmt *Op;
-
- /// InheritancePath - For derived-to-base and base-to-derived casts, the
- /// base vector has the inheritance path.
- CXXBaseVector *InheritancePath;
- void CheckInheritancePath() const {
+ /// BasePath - For derived-to-base and base-to-derived casts, the base array
+ /// contains the inheritance path.
+ CXXBaseSpecifierArray *BasePath;
+
+ void CheckBasePath() const {
#ifndef NDEBUG
switch (getCastKind()) {
// FIXME: We should add inheritance paths for these.
case CK_MemberPointerToBoolean:
case CK_AnyPointerToObjCPointerCast:
case CK_AnyPointerToBlockPointerCast:
- assert(!InheritancePath && "Cast kind has inheritance path!");
+ assert(!BasePath && "Cast kind shoudl not have a base path!");
break;
}
#endif
protected:
CastExpr(StmtClass SC, QualType ty, const CastKind kind, Expr *op,
- CXXBaseVector *path) :
+ CXXBaseSpecifierArray *BasePath) :
Expr(SC, ty,
// Cast expressions are type-dependent if the type is
// dependent (C++ [temp.dep.expr]p3).
// Cast expressions are value-dependent if the type is
// dependent or if the subexpression is value-dependent.
ty->isDependentType() || (op && op->isValueDependent())),
- Kind(kind), Op(op), InheritancePath(path) {
- CheckInheritancePath();
+ Kind(kind), Op(op), BasePath(BasePath) {
+ CheckBasePath();
}
/// \brief Construct an empty cast.
public:
ImplicitCastExpr(QualType ty, CastKind kind, Expr *op,
- CXXBaseVector *path, bool Lvalue) :
- CastExpr(ImplicitCastExprClass, ty, kind, op, path), LvalueCast(Lvalue) { }
+ CXXBaseSpecifierArray *BasePath, bool Lvalue)
+ : CastExpr(ImplicitCastExprClass, ty, kind, op, BasePath),
+ LvalueCast(Lvalue) { }
/// \brief Construct an empty implicit cast.
explicit ImplicitCastExpr(EmptyShell Shell)
/// If isLvalue, the result of the cast is an lvalue.
void Sema::ImpCastExprToType(Expr *&Expr, QualType Ty,
CastExpr::CastKind Kind,
- CastExpr::CXXBaseVector *InheritancePath,
+ CXXBaseSpecifierArray *BasePath,
bool isLvalue) {
QualType ExprTy = Context.getCanonicalType(Expr->getType());
QualType TypeTy = Context.getCanonicalType(Ty);
if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(Expr)) {
if (ImpCast->getCastKind() == Kind) {
- assert(!InheritancePath && "FIXME: Merge paths!");
+ assert(!BasePath && "FIXME: Merge paths!");
ImpCast->setType(Ty);
ImpCast->setLvalueCast(isLvalue);
return;
}
}
- Expr = new (Context) ImplicitCastExpr(Ty, Kind, Expr, InheritancePath,
- isLvalue);
+ Expr = new (Context) ImplicitCastExpr(Ty, Kind, Expr, BasePath, isLvalue);
}
void Sema::DeleteExpr(ExprTy *E) {