Add ExplicitCastExpr to replace the current CastExpr, and have ImplicitCastExpr and ExplicitCastExpr derive from a common base class (CastExpr):

Expr
  -> CastExpr
     -> ExplicitCastExpr
     -> ImplicitCastExpr 

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@54955 91177308-0d34-0410-b5e6-96231b3b80d8

13 files changed, 104 insertions, 131 deletions

diff --git a/Driver/RewriteObjC.cpp b/Driver/RewriteObjC.cpp
index 0796b686b9..8de2c0a693 100644
--- a/Driver/RewriteObjC.cpp
+++ b/Driver/RewriteObjC.cpp
@@ -883,7 +883,8 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV,
                                           SourceLocation(), II, 0);
       assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl");
       QualType castT = Context->getPointerType(Context->getTagDeclType(RD));
-      CastExpr *castExpr = new CastExpr(castT, IV->getBase(), SourceLocation());
+      CastExpr *castExpr = new ExplicitCastExpr(castT, IV->getBase(),
+                                                SourceLocation());
       // Don't forget the parens to enforce the proper binding.
       ParenExpr *PE = new ParenExpr(IV->getBase()->getLocStart(),
                                     IV->getBase()->getLocEnd(),
@@ -924,7 +925,8 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV,
                                           SourceLocation(), II, 0);
       assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl");
       QualType castT = Context->getPointerType(Context->getTagDeclType(RD));
-      CastExpr *castExpr = new CastExpr(castT, IV->getBase(), SourceLocation());
+      CastExpr *castExpr = new ExplicitCastExpr(castT, IV->getBase(),
+                                                SourceLocation());
       // Don't forget the parens to enforce the proper binding.
       ParenExpr *PE = new ParenExpr(IV->getBase()->getLocStart(),
                                     IV->getBase()->getLocEnd(), castExpr);
@@ -1023,7 +1025,7 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) {
   // Need to check for protocol refs (id <P>, Foo <P> *) in variable decls and cast exprs.
   if (DeclStmt *DS = dyn_cast<DeclStmt>(S))
     RewriteObjCQualifiedInterfaceTypes(DS->getDecl());
-  if (CastExpr *CE = dyn_cast<CastExpr>(S))
+  if (ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(S))
     RewriteObjCQualifiedInterfaceTypes(CE);
   
   if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || 
@@ -1931,7 +1933,7 @@ Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
                                  Context->getPointerType(DRE->getType()), 
                                  SourceLocation());
   // cast to NSConstantString *
-  CastExpr *cast = new CastExpr(Exp->getType(), Unop, SourceLocation());
+  CastExpr *cast = new ExplicitCastExpr(Exp->getType(), Unop, SourceLocation());
   ReplaceStmt(Exp, cast);
   delete Exp;
   return cast;
@@ -2067,7 +2069,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
                                                    ClsExprs.size());
       // To turn off a warning, type-cast to 'id'
       InitExprs.push_back(
-        new CastExpr(Context->getObjCIdType(), 
+        new ExplicitCastExpr(Context->getObjCIdType(), 
         Cls, SourceLocation())); // set 'super class', using objc_getClass().
       // struct objc_super
       QualType superType = getSuperStructType();
@@ -2116,7 +2118,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
       llvm::SmallVector<Expr*, 4> InitExprs;
       
       InitExprs.push_back(
-        new CastExpr(Context->getObjCIdType(), 
+        new ExplicitCastExpr(Context->getObjCIdType(), 
                      new DeclRefExpr(CurMethodDecl->getSelfDecl(), 
                                      Context->getObjCIdType(),
                                      SourceLocation()), 
@@ -2133,7 +2135,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
                                                    ClsExprs.size());
       // To turn off a warning, type-cast to 'id'
       InitExprs.push_back(
-        new CastExpr(Context->getObjCIdType(), 
+        new ExplicitCastExpr(Context->getObjCIdType(), 
         Cls, SourceLocation())); // set 'super class', using objc_getClass().
       // struct objc_super
       QualType superType = getSuperStructType();
@@ -2161,9 +2163,10 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
     } else {
       // Remove all type-casts because it may contain objc-style types; e.g.
       // Foo<Proto> *.
-      while (CastExpr *CE = dyn_cast<CastExpr>(recExpr))
+      while (ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(recExpr))
         recExpr = CE->getSubExpr();
-      recExpr = new CastExpr(Context->getObjCIdType(), recExpr, SourceLocation());
+      recExpr = new ExplicitCastExpr(Context->getObjCIdType(), recExpr,
+                                     SourceLocation());
       MsgExprs.push_back(recExpr);
     }
   }
@@ -2184,16 +2187,16 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
     // Make all implicit casts explicit...ICE comes in handy:-)
     if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(userExpr)) {
       // Reuse the ICE type, it is exactly what the doctor ordered.
-      userExpr = new CastExpr(ICE->getType()->isObjCQualifiedIdType()
+      userExpr = new ExplicitCastExpr(ICE->getType()->isObjCQualifiedIdType()
                                 ? Context->getObjCIdType()
                                 : ICE->getType(), userExpr, SourceLocation());
     }
     // Make id<P...> cast into an 'id' cast.
-    else if (CastExpr *CE = dyn_cast<CastExpr>(userExpr)) {
+    else if (ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(userExpr)) {
       if (CE->getType()->isObjCQualifiedIdType()) {
-        while ((CE = dyn_cast<CastExpr>(userExpr)))
+        while ((CE = dyn_cast<ExplicitCastExpr>(userExpr)))
           userExpr = CE->getSubExpr();
-        userExpr = new CastExpr(Context->getObjCIdType(), 
+        userExpr = new ExplicitCastExpr(Context->getObjCIdType(), 
                                 userExpr, SourceLocation());
       }
     } 
@@ -2237,7 +2240,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
   // If we don't do this cast, we get the following bizarre warning/note:
   // xx.m:13: warning: function called through a non-compatible type
   // xx.m:13: note: if this code is reached, the program will abort
-  cast = new CastExpr(Context->getPointerType(Context->VoidTy), DRE, 
+  cast = new ExplicitCastExpr(Context->getPointerType(Context->VoidTy), DRE, 
                       SourceLocation());
     
   // Now do the "normal" pointer to function cast.
@@ -2246,7 +2249,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
     // If we don't have a method decl, force a variadic cast.
     Exp->getMethodDecl() ? Exp->getMethodDecl()->isVariadic() : true);
   castType = Context->getPointerType(castType);
-  cast = new CastExpr(castType, cast, SourceLocation());
+  cast = new ExplicitCastExpr(castType, cast, SourceLocation());
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new ParenExpr(SourceLocation(), SourceLocation(), cast);
@@ -2265,14 +2268,14 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
     DeclRefExpr *STDRE = new DeclRefExpr(MsgSendStretFlavor, msgSendType, 
                                          SourceLocation());
     // Need to cast objc_msgSend_stret to "void *" (see above comment).
-    cast = new CastExpr(Context->getPointerType(Context->VoidTy), STDRE, 
+    cast = new ExplicitCastExpr(Context->getPointerType(Context->VoidTy), STDRE, 
                         SourceLocation());
     // Now do the "normal" pointer to function cast.
     castType = Context->getFunctionType(returnType, 
       &ArgTypes[0], ArgTypes.size(),
       Exp->getMethodDecl() ? Exp->getMethodDecl()->isVariadic() : false);
     castType = Context->getPointerType(castType);
-    cast = new CastExpr(castType, cast, SourceLocation());
+    cast = new ExplicitCastExpr(castType, cast, SourceLocation());
     
     // Don't forget the parens to enforce the proper binding.
     PE = new ParenExpr(SourceLocation(), SourceLocation(), cast);
diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index bc99edf174..ee24b6cd6c 100644
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -837,61 +837,80 @@ public:
   static CompoundLiteralExpr* CreateImpl(llvm::Deserializer& D, ASTContext& C);
 };
 
+/// CastExpr - Base class for Cast Operators (explicit, implicit, etc.).
+/// Classes that derive from CastExpr are:
+///
+///   ImplicitCastExpr
+///   ExplicitCastExpr
+///
+class CastExpr : public Expr {
+  Stmt *Op;
+protected:
+  CastExpr(StmtClass SC, QualType ty, Expr *op) : 
+    Expr(SC, ty), Op(op) {}
+  
+public:
+  Expr *getSubExpr() { return cast<Expr>(Op); }
+  const Expr *getSubExpr() const { return cast<Expr>(Op); }
+  
+  static bool classof(const Stmt *T) { 
+    switch (T->getStmtClass()) {
+    case ImplicitCastExprClass:
+    case ExplicitCastExprClass:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const CastExpr *) { return true; }
+  
+  // Iterators
+  virtual child_iterator child_begin();
+  virtual child_iterator child_end();
+};
+
 /// ImplicitCastExpr - Allows us to explicitly represent implicit type 
 /// conversions. For example: converting T[]->T*, void f()->void (*f)(), 
 /// float->double, short->int, etc.
 ///
-class ImplicitCastExpr : public Expr {
-  Stmt *Op;
+class ImplicitCastExpr : public CastExpr {
 public:
   ImplicitCastExpr(QualType ty, Expr *op) : 
-    Expr(ImplicitCastExprClass, ty), Op(op) {}
-    
-  Expr *getSubExpr() { return cast<Expr>(Op); }
-  const Expr *getSubExpr() const { return cast<Expr>(Op); }
+    CastExpr(ImplicitCastExprClass, ty, op) {}
 
-  virtual SourceRange getSourceRange() const { return Op->getSourceRange(); }
+  virtual SourceRange getSourceRange() const {
+    return getSubExpr()->getSourceRange();
+  }
 
   static bool classof(const Stmt *T) { 
     return T->getStmtClass() == ImplicitCastExprClass; 
   }
   static bool classof(const ImplicitCastExpr *) { return true; }
   
-  // Iterators
-  virtual child_iterator child_begin();
-  virtual child_iterator child_end();
-  
   virtual void EmitImpl(llvm::Serializer& S) const;
   static ImplicitCastExpr* CreateImpl(llvm::Deserializer& D, ASTContext& C);
 };
 
-/// CastExpr - [C99 6.5.4] Cast Operators.
+/// ExplicitCastExpr - [C99 6.5.4] Cast Operators.
 ///
-class CastExpr : public Expr {
-  Stmt *Op;
+class ExplicitCastExpr : public CastExpr {
   SourceLocation Loc; // the location of the left paren
 public:
-  CastExpr(QualType ty, Expr *op, SourceLocation l) : 
-    Expr(CastExprClass, ty), Op(op), Loc(l) {}
+  ExplicitCastExpr(QualType ty, Expr *op, SourceLocation l) : 
+    CastExpr(ExplicitCastExprClass, ty, op), Loc(l) {}
 
   SourceLocation getLParenLoc() const { return Loc; }
   
-  Expr *getSubExpr() const { return cast<Expr>(Op); }
-  
   virtual SourceRange getSourceRange() const {
     return SourceRange(Loc, getSubExpr()->getSourceRange().getEnd());
   }
   static bool classof(const Stmt *T) { 
-    return T->getStmtClass() == CastExprClass; 
+    return T->getStmtClass() == ExplicitCastExprClass; 
   }
-  static bool classof(const CastExpr *) { return true; }
-  
-  // Iterators
-  virtual child_iterator child_begin();
-  virtual child_iterator child_end();
+  static bool classof(const ExplicitCastExpr *) { return true; }
   
   virtual void EmitImpl(llvm::Serializer& S) const;
-  static CastExpr* CreateImpl(llvm::Deserializer& D, ASTContext& C);
+  static ExplicitCastExpr* CreateImpl(llvm::Deserializer& D, ASTContext& C);
 };
 
 class BinaryOperator : public Expr {
diff --git a/include/clang/AST/StmtNodes.def b/include/clang/AST/StmtNodes.def
index 1b1da77cda..8001d5484d 100644
--- a/include/clang/AST/StmtNodes.def
+++ b/include/clang/AST/StmtNodes.def
@@ -75,11 +75,12 @@ STMT(45, CastExpr              , Expr)
 STMT(46, BinaryOperator        , Expr)
 STMT(47, CompoundAssignOperator, BinaryOperator)
 STMT(48, ConditionalOperator   , Expr)
-STMT(49, ImplicitCastExpr      , Expr)
-STMT(50, CompoundLiteralExpr   , Expr)
-STMT(51, ExtVectorElementExpr  , Expr)
-STMT(52, InitListExpr          , Expr)
-STMT(53, VAArgExpr             , Expr)
+STMT(49, ImplicitCastExpr      , CastExpr)
+STMT(50, ExplicitCastExpr      , CastExpr)
+STMT(51, CompoundLiteralExpr   , Expr)
+STMT(52, ExtVectorElementExpr  , Expr)
+STMT(53, InitListExpr          , Expr)
+STMT(54, VAArgExpr             , Expr)
 
 // GNU Extensions.
 STMT(55, AddrLabelExpr        , Expr)
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index e78c3599f6..a3efab637d 100644
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -359,7 +359,7 @@ bool Expr::hasLocalSideEffect() const {
         return E->hasLocalSideEffect();
     return false;
   }
-  case CastExprClass:
+  case ExplicitCastExprClass:
     // If this is a cast to void, check the operand.  Otherwise, the result of
     // the cast is unused.
     if (getType()->isVoidType())
@@ -534,8 +534,6 @@ Expr *Expr::IgnoreParenCasts() {
       E = P->getSubExpr();
     else if (CastExpr *P = dyn_cast<CastExpr>(E))
       E = P->getSubExpr();
-    else if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E))
-      E = P->getSubExpr();
     else
       return E;
   }
@@ -645,16 +643,9 @@ bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const {
     return true;
   }
   case ImplicitCastExprClass:
-  case CastExprClass: {
-    const Expr *SubExpr;
-    SourceLocation CastLoc;
-    if (const CastExpr *C = dyn_cast<CastExpr>(this)) {
-      SubExpr = C->getSubExpr();
-      CastLoc = C->getLParenLoc();
-    } else {
-      SubExpr = cast<ImplicitCastExpr>(this)->getSubExpr();
-      CastLoc = getLocStart();
-    }
+  case ExplicitCastExprClass: {
+    const Expr *SubExpr = cast<CastExpr>(this)->getSubExpr();
+    SourceLocation CastLoc = getLocStart();
     if (!SubExpr->isConstantExpr(Ctx, Loc)) {
       if (Loc) *Loc = SubExpr->getLocStart();
       return false;
@@ -940,16 +931,9 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
     break;
   }
   case ImplicitCastExprClass:
-  case CastExprClass: {
-    const Expr *SubExpr;
-    SourceLocation CastLoc;
-    if (const CastExpr *C = dyn_cast<CastExpr>(this)) {
-      SubExpr = C->getSubExpr();
-      CastLoc = C->getLParenLoc();
-    } else {
-      SubExpr = cast<ImplicitCastExpr>(this)->getSubExpr();
-      CastLoc = getLocStart();
-    }
+  case ExplicitCastExprClass: {
+    const Expr *SubExpr = cast<CastExpr>(this)->getSubExpr();
+    SourceLocation CastLoc = getLocStart();
     
     // C99 6.6p6: shall only convert arithmetic types to integer types.
     if (!SubExpr->getType()->isArithmeticType() ||
@@ -1043,7 +1027,7 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
 /// cast to void*.
 bool Expr::isNullPointerConstant(ASTContext &Ctx) const {
   // Strip off a cast to void*, if it exists.
-  if (const CastExpr *CE = dyn_cast<CastExpr>(this)) {
+  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
     // Check that it is a cast to void*.
     if (const PointerType *PT = CE->getType()->getAsPointerType()) {
       QualType Pointee = PT->getPointeeType();
@@ -1326,10 +1310,6 @@ Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
 Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
 Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
 
-// ImplicitCastExpr
-Stmt::child_iterator ImplicitCastExpr::child_begin() { return &Op; }
-Stmt::child_iterator ImplicitCastExpr::child_end() { return &Op+1; }
-
 // CastExpr
 Stmt::child_iterator CastExpr::child_begin() { return &Op; }
 Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp
index 3fae5c90aa..8ba27f0133 100644
--- a/lib/AST/ExprConstant.cpp
+++ b/lib/AST/ExprConstant.cpp
@@ -216,9 +216,6 @@ public:
   bool VisitUnaryOperator(const UnaryOperator *E);
 
   bool VisitCastExpr(CastExpr* E) {
-    return HandleCast(E->getLParenLoc(), E->getSubExpr(), E->getType());
-  }
-  bool VisitImplicitCastExpr(ImplicitCastExpr* E) {
     return HandleCast(E->getLocStart(), E->getSubExpr(), E->getType());
   }
   bool VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E) {
diff --git a/lib/AST/StmtPrinter.cpp b/lib/AST/StmtPrinter.cpp
index abcab9cfd3..5b4c0ec7ce 100644
--- a/lib/AST/StmtPrinter.cpp
+++ b/lib/AST/StmtPrinter.cpp
@@ -689,7 +689,10 @@ void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
   OS << ".";
   OS << Node->getAccessor().getName();
 }
-void StmtPrinter::VisitCastExpr(CastExpr *Node) {
+void StmtPrinter::VisitCastExpr(CastExpr *) {
+  assert(0 && "CastExpr is an abstract class");
+}
+void StmtPrinter::VisitExplicitCastExpr(ExplicitCastExpr *Node) {
   OS << "(" << Node->getType().getAsString() << ")";
   PrintExpr(Node->getSubExpr());
 }
diff --git a/lib/AST/StmtSerialization.cpp b/lib/AST/StmtSerialization.cpp
index 99ca10d5be..9859846292 100644
--- a/lib/AST/StmtSerialization.cpp
+++ b/lib/AST/StmtSerialization.cpp
@@ -57,9 +57,6 @@ Stmt* Stmt::Create(Deserializer& D, ASTContext& C) {
       
     case CaseStmtClass:
       return CaseStmt::CreateImpl(D, C);
-    
-    case CastExprClass:
-      return CastExpr::CreateImpl(D, C);
       
     case CharacterLiteralClass:
       return CharacterLiteral::CreateImpl(D, C);
@@ -108,6 +105,9 @@ Stmt* Stmt::Create(Deserializer& D, ASTContext& C) {
       
     case ImplicitCastExprClass:
       return ImplicitCastExpr::CreateImpl(D, C);
+
+    case ExplicitCastExprClass:
+      return ExplicitCastExpr::CreateImpl(D, C);
       
     case IndirectGotoStmtClass:
       return IndirectGotoStmt::CreateImpl(D, C);
@@ -358,17 +358,17 @@ CaseStmt* CaseStmt::CreateImpl(Deserializer& D, ASTContext& C) {
   return stmt;
 }
 
-void CastExpr::EmitImpl(Serializer& S) const {
+void ExplicitCastExpr::EmitImpl(Serializer& S) const {
   S.Emit(getType());
   S.Emit(Loc);
-  S.EmitOwnedPtr(Op);
+  S.EmitOwnedPtr(getSubExpr());
 }
 
-CastExpr* CastExpr::CreateImpl(Deserializer& D, ASTContext& C) {
+ExplicitCastExpr* ExplicitCastExpr::CreateImpl(Deserializer& D, ASTContext& C) {
   QualType t = QualType::ReadVal(D);
   SourceLocation Loc = SourceLocation::ReadVal(D);
   Expr* Op = D.ReadOwnedPtr<Expr>(C);
-  return new CastExpr(t,Op,Loc);
+  return new ExplicitCastExpr(t,Op,Loc);
 }
   
 
@@ -631,7 +631,7 @@ ImaginaryLiteral* ImaginaryLiteral::CreateImpl(Deserializer& D, ASTContext& C) {
 
 void ImplicitCastExpr::EmitImpl(Serializer& S) const {
   S.Emit(getType());
-  S.EmitOwnedPtr(Op);
+  S.EmitOwnedPtr(getSubExpr());
 }
 
 ImplicitCastExpr* ImplicitCastExpr::CreateImpl(Deserializer& D, ASTContext& C) {
diff --git a/lib/Analysis/Environment.cpp b/lib/Analysis/Environment.cpp
index dd5caef7f0..7f6fbd3051 100644
--- a/lib/Analysis/Environment.cpp
+++ b/lib/Analysis/Environment.cpp
@@ -47,19 +47,8 @@ RVal Environment::GetRVal(Expr* E, BasicValueFactory& BasicVals) const {
         // are no-ops.  We blast through these to get the descendant
         // subexpression that has a value.
         
-      case Stmt::ImplicitCastExprClass: {
-        ImplicitCastExpr* C = cast<ImplicitCastExpr>(E);
-        QualType CT = C->getType();
-        
-        if (CT->isVoidType())
-          return UnknownVal();
-        
-        QualType ST = C->getSubExpr()->getType();
-        
-        break;
-      }
-        
-      case Stmt::CastExprClass: {
+      case Stmt::ImplicitCastExprClass:
+      case Stmt::ExplicitCastExprClass: {
         CastExpr* C = cast<CastExpr>(E);
         QualType CT = C->getType();
         QualType ST = C->getSubExpr()->getType();
diff --git a/lib/Analysis/GRExprEngine.cpp b/lib/Analysis/GRExprEngine.cpp
index 896f473df8..18c5a5825e 100644
--- a/lib/Analysis/GRExprEngine.cpp
+++ b/lib/Analysis/GRExprEngine.cpp
@@ -356,12 +356,6 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
       break;      
     }
       
-    case Stmt::CastExprClass: {
-      CastExpr* C = cast<CastExpr>(S);
-      VisitCast(C, C->getSubExpr(), Pred, Dst);
-      break;
-    }
-      
       // FIXME: ChooseExpr is really a constant.  We need to fix
       //        the CFG do not model them as explicit control-flow.
       
@@ -389,8 +383,9 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
       VisitDeclStmt(cast<DeclStmt>(S), Pred, Dst);
       break;
       
-    case Stmt::ImplicitCastExprClass: {
-      ImplicitCastExpr* C = cast<ImplicitCastExpr>(S);
+    case Stmt::ImplicitCastExprClass:
+    case Stmt::ExplicitCastExprClass: {
+      CastExpr* C = cast<CastExpr>(S);
       VisitCast(C, C->getSubExpr(), Pred, Dst);
       break;
     }
diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp
index ea60cbb1b0..fe9b5c9513 100644
--- a/lib/CodeGen/CGExprConstant.cpp
+++ b/lib/CodeGen/CGExprConstant.cpp
@@ -72,7 +72,7 @@ public:
     return Visit(E->getInitializer());
   }
   
-  llvm::Constant *VisitCastExpr(const CastExpr* E) {
+  llvm::Constant *VisitCastExpr(CastExpr* E) {
     llvm::Constant *C = Visit(E->getSubExpr());
     
     return EmitConversion(C, E->getSubExpr()->getType(), E->getType());    
diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp
index a8782c16e0..e5e80db2be 100644
--- a/lib/Sema/SemaChecking.cpp
+++ b/lib/Sema/SemaChecking.cpp
@@ -783,16 +783,10 @@ static DeclRefExpr* EvalAddr(Expr *E) {
     
   // For casts, we need to handle conversions from arrays to
   // pointer values, and pointer-to-pointer conversions.
-  case Stmt::CastExprClass:
+  case Stmt::ExplicitCastExprClass:
   case Stmt::ImplicitCastExprClass: {
     
-    Expr* SubExpr;
-    
-    if (ImplicitCastExpr *IE = dyn_cast<ImplicitCastExpr>(E))
-      SubExpr = IE->getSubExpr();
-    else
-      SubExpr = cast<CastExpr>(E)->getSubExpr();
-    
+    Expr* SubExpr = cast<CastExpr>(E)->getSubExpr();
     QualType T = SubExpr->getType();
     
     if (T->isPointerType() || T->isObjCQualifiedIdType())
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 906255e87f..5a1ad50cd2 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -946,7 +946,7 @@ bool Sema::CheckAddressConstantExpression(const Expr* Init) {
          diag::err_init_element_not_constant, Init->getSourceRange());
     return true;
   }
-  case Expr::CastExprClass: {
+  case Expr::ExplicitCastExprClass: {
     const Expr* SubExpr = cast<CastExpr>(Init)->getSubExpr();
 
     // Check for pointer->pointer cast
@@ -1058,7 +1058,7 @@ static const Expr* FindExpressionBaseAddress(const Expr* E) {
     // if we don't, we'll figure it out later
     return 0;
   }
-  case Expr::CastExprClass: {
+  case Expr::ExplicitCastExprClass: {
     const Expr* SubExpr = cast<CastExpr>(E)->getSubExpr();
 
     // Check for pointer->pointer cast
@@ -1183,14 +1183,8 @@ bool Sema::CheckArithmeticConstantExpression(const Expr* Init) {
     return true;
   }
   case Expr::ImplicitCastExprClass:
-  case Expr::CastExprClass: {
-    const Expr *SubExpr;
-    if (const CastExpr *C = dyn_cast<CastExpr>(Init)) {
-      SubExpr = C->getSubExpr();
-    } else {
-      SubExpr = cast<ImplicitCastExpr>(Init)->getSubExpr();
-    }
-
+  case Expr::ExplicitCastExprClass: {
+    const Expr *SubExpr = cast<CastExpr>(Init)->getSubExpr();
     if (SubExpr->getType()->isArithmeticType())
       return CheckArithmeticConstantExpression(SubExpr);
 
@@ -1267,9 +1261,7 @@ bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
       }
     } else if (InitTy->isIntegralType()) {
       Expr* SubE = 0;
-      if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Init))
-        SubE = ICE->getSubExpr();
-      else if (CastExpr* CE = dyn_cast<CastExpr>(Init))
+      if (CastExpr* CE = dyn_cast<CastExpr>(Init))
         SubE = CE->getSubExpr();
       // Special check for pointer cast to int; we allow as an extension
       // an address constant cast to an integer if the integer
diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index bb18a4a6db..cac103a044 100644
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -1154,7 +1154,7 @@ ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty,
 
   if (CheckCastTypes(SourceRange(LParenLoc, RParenLoc), castType, castExpr))
     return true;
-  return new CastExpr(castType, castExpr, LParenLoc);
+  return new ExplicitCastExpr(castType, castExpr, LParenLoc);
 }
 
 /// Note that lex is not null here, even if this is the gnu "x ?: y" extension.