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

Expr
  -> CastExpr
     -> ExplicitCastExpr
     -> ImplicitCastExpr 

llvm-svn: 54955

10 files changed, 34 insertions, 84 deletions

diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
index e78c3599f6f..a3efab637dd 100644
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/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/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 3fae5c90aae..8ba27f01334 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/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/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp
index abcab9cfd32..5b4c0ec7ce3 100644
--- a/clang/lib/AST/StmtPrinter.cpp
+++ b/clang/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/clang/lib/AST/StmtSerialization.cpp b/clang/lib/AST/StmtSerialization.cpp
index 99ca10d5be4..9859846292e 100644
--- a/clang/lib/AST/StmtSerialization.cpp
+++ b/clang/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/clang/lib/Analysis/Environment.cpp b/clang/lib/Analysis/Environment.cpp
index dd5caef7f08..7f6fbd30513 100644
--- a/clang/lib/Analysis/Environment.cpp
+++ b/clang/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/clang/lib/Analysis/GRExprEngine.cpp b/clang/lib/Analysis/GRExprEngine.cpp
index 896f473df8a..18c5a5825ec 100644
--- a/clang/lib/Analysis/GRExprEngine.cpp
+++ b/clang/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/clang/lib/CodeGen/CGExprConstant.cpp b/clang/lib/CodeGen/CGExprConstant.cpp
index ea60cbb1b04..fe9b5c95135 100644
--- a/clang/lib/CodeGen/CGExprConstant.cpp
+++ b/clang/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/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index a8782c16e0b..e5e80db2bef 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/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/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 906255e87ff..5a1ad50cd2e 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/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/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index bb18a4a6db3..cac103a0447 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/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.