Remove abstract expression kinds from the StmtClass enum. Update a few users

appropriately.  Call out a few missing cases in the expression mangler.

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

diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 7f3c5cde38937028dfb4446f9a68f796587ebfbc..f192b6f156190f0edcd4e2f41fb1ffb7ecd0c7a9 100644 (file)
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -1748,7 +1748,7 @@ public:
 
   static bool classof(const Stmt *T) {
     StmtClass SC = T->getStmtClass();
-    if (SC >= ExplicitCastExprClass && SC <= CStyleCastExprClass)
+    if (SC >= CStyleCastExprClass && SC <= CStyleCastExprClass)
       return true;
     if (SC >= CXXNamedCastExprClass && SC <= CXXFunctionalCastExprClass)
       return true;

diff --git a/include/clang/AST/Stmt.h b/include/clang/AST/Stmt.h
index d2001d977113d14095e69a2d436a35dadf965269..94caa6faad660e8086daa35d481448e345edb521 100644 (file)
--- a/include/clang/AST/Stmt.h
+++ b/include/clang/AST/Stmt.h
@@ -102,6 +102,7 @@ public:
 #define LAST_STMT(CLASS) lastStmtConstant = CLASS##Class,
 #define FIRST_EXPR(CLASS) firstExprConstant = CLASS##Class,
 #define LAST_EXPR(CLASS) lastExprConstant = CLASS##Class
+#define ABSTRACT_EXPR(CLASS, PARENT)
 #include "clang/AST/StmtNodes.def"
 };
 private:

diff --git a/include/clang/AST/StmtNodes.def b/include/clang/AST/StmtNodes.def
index 301d6baf54dc01baa87f54fe6c368c4d6ad348d1..ec6149e55f11c841f249e47b437b6c0d5aa622f0 100644 (file)
--- a/include/clang/AST/StmtNodes.def
+++ b/include/clang/AST/StmtNodes.def
@@ -68,8 +68,7 @@ STMT(CXXTryStmt  , Stmt)
 LAST_STMT(CXXTryStmt)
 
 // Expressions.
-ABSTRACT_EXPR(Expr                  , Stmt)
-FIRST_EXPR(Expr)
+ABSTRACT_EXPR(Expr         , Stmt)
 EXPR(PredefinedExpr        , Expr)
 EXPR(DeclRefExpr           , Expr)
 EXPR(IntegerLiteral        , Expr)
@@ -83,12 +82,12 @@ EXPR(SizeOfAlignOfExpr     , Expr)
 EXPR(ArraySubscriptExpr    , Expr)
 EXPR(CallExpr              , Expr)
 EXPR(MemberExpr            , Expr)
-EXPR(CastExpr              , Expr)
+ABSTRACT_EXPR(CastExpr     , Expr)
 EXPR(BinaryOperator        , Expr)
 EXPR(CompoundAssignOperator, BinaryOperator)
 EXPR(ConditionalOperator   , Expr)
 EXPR(ImplicitCastExpr      , CastExpr)
-EXPR(ExplicitCastExpr      , CastExpr)
+ABSTRACT_EXPR(ExplicitCastExpr, CastExpr)
 EXPR(CStyleCastExpr        , ExplicitCastExpr)
 EXPR(CompoundLiteralExpr   , Expr)
 EXPR(ExtVectorElementExpr  , Expr)
@@ -153,6 +152,7 @@ EXPR(ShuffleVectorExpr    , Expr)
 EXPR(BlockExpr            , Expr)
 EXPR(BlockDeclRefExpr     , Expr)
 
+FIRST_EXPR(PredefinedExpr)
 LAST_EXPR(BlockDeclRefExpr)
 
 #undef ABSTRACT_EXPR

diff --git a/include/clang/AST/StmtVisitor.h b/include/clang/AST/StmtVisitor.h
index 3a525507dad33879f7a17ec0cc250844ba4a2ab5..4986f08ac1246ec6352beac3c9fb296a84402d93 100644 (file)
--- a/include/clang/AST/StmtVisitor.h
+++ b/include/clang/AST/StmtVisitor.h
@@ -105,6 +105,7 @@ public:
     // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
     switch (S->getStmtClass()) {
     default: assert(0 && "Unknown stmt kind!");
+#define ABSTRACT_EXPR(CLASS, PARENT)
 #define STMT(CLASS, PARENT)                              \
     case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
 #include "clang/AST/StmtNodes.def"

diff --git a/include/clang/Checker/PathSensitive/CheckerVisitor.def b/include/clang/Checker/PathSensitive/CheckerVisitor.def
index 7ec27efe51995d60ceb18c0b763f138b911ac1ee..2edc4a37b7ebad6a76b55c88929e6266a9a33a08 100644 (file)
--- a/include/clang/Checker/PathSensitive/CheckerVisitor.def
+++ b/include/clang/Checker/PathSensitive/CheckerVisitor.def
@@ -22,7 +22,6 @@
 PREVISIT(ArraySubscriptExpr, Stmt)
 PREVISIT(BinaryOperator, Stmt)
 PREVISIT(CallExpr, Stmt)
-PREVISIT(CastExpr, Stmt)
 PREVISIT(CXXOperatorCallExpr, CallExpr)
 PREVISIT(DeclStmt, Stmt)
 PREVISIT(ObjCMessageExpr, Stmt)

diff --git a/include/clang/Checker/PathSensitive/CheckerVisitor.h b/include/clang/Checker/PathSensitive/CheckerVisitor.h
index 913a6c75bccb80f21cb986b57499b3fe35624ed7..72f0ae1375e892540019f8de5ead616023d393fe 100644 (file)
--- a/include/clang/Checker/PathSensitive/CheckerVisitor.h
+++ b/include/clang/Checker/PathSensitive/CheckerVisitor.h
@@ -42,7 +42,6 @@ public:
         return;
 
       case Stmt::ImplicitCastExprClass:
-      case Stmt::ExplicitCastExprClass:
       case Stmt::CStyleCastExprClass:
         static_cast<ImplClass*>(this)->PreVisitCastExpr(C,
                                                static_cast<const CastExpr*>(S));
@@ -82,16 +81,18 @@ break;
 
   void PreVisitStmt(CheckerContext &C, const Stmt *S) {}
   void PostVisitStmt(CheckerContext &C, const Stmt *S) {}
+
+  void PreVisitCastExpr(CheckerContext &C, const CastExpr *E) {
+    static_cast<ImplClass*>(this)->PreVisitStmt(C, E);
+  }
   
 #define PREVISIT(NAME, FALLBACK) \
 void PreVisit ## NAME(CheckerContext &C, const NAME* S) {\
-  PreVisit ## FALLBACK(C, S);\
+  static_cast<ImplClass*>(this)->PreVisit ## FALLBACK(C, S);\
 }
-#include "clang/Checker/PathSensitive/CheckerVisitor.def"
-      
 #define POSTVISIT(NAME, FALLBACK) \
 void PostVisit ## NAME(CheckerContext &C, const NAME* S) {\
-  PostVisit ## FALLBACK(C, S);\
+  static_cast<ImplClass*>(this)->PostVisit ## FALLBACK(C, S);\
 }
 #include "clang/Checker/PathSensitive/CheckerVisitor.def"
 };

diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index cf78c66a8d3ca06174e64ac1603c326930c575eb..50ddc9156a9697dad524b037cb3b8aedb8cb6d8d 100644 (file)
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -1616,7 +1616,6 @@ static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) {
   case Expr::BlockExprClass:
   case Expr::BlockDeclRefExprClass:
   case Expr::NoStmtClass:
-  case Expr::ExprClass:
     return ICEDiag(2, E->getLocStart());
 
   case Expr::GNUNullExprClass:
@@ -1812,9 +1811,7 @@ static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) {
     }
     }
   }
-  case Expr::CastExprClass:
   case Expr::ImplicitCastExprClass:
-  case Expr::ExplicitCastExprClass:
   case Expr::CStyleCastExprClass:
   case Expr::CXXFunctionalCastExprClass:
   case Expr::CXXNamedCastExprClass:

diff --git a/lib/AST/Stmt.cpp b/lib/AST/Stmt.cpp
index ce97387ee36f42a75716885d58b767577b8d4c66..a0830997dcdd577464e7bc829c413279f83e3c1f 100644 (file)
--- a/lib/AST/Stmt.cpp
+++ b/lib/AST/Stmt.cpp
@@ -35,6 +35,7 @@ static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
 
   // Intialize the table on the first use.
   Initialized = true;
+#define ABSTRACT_EXPR(CLASS, PARENT)
 #define STMT(CLASS, PARENT) \
   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS;    \
   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Size = sizeof(CLASS);

diff --git a/lib/CodeGen/Mangle.cpp b/lib/CodeGen/Mangle.cpp
index 93b9a8fbc7e087f8ad1150223d358d1ce6104b96..4f84edd908bf5e47eea7d2d85f1591e986003f54 100644 (file)
--- a/lib/CodeGen/Mangle.cpp
+++ b/lib/CodeGen/Mangle.cpp
@@ -1056,21 +1056,38 @@ void CXXNameMangler::mangleIntegerLiteral(QualType T,
 
 void CXXNameMangler::mangleExpression(const Expr *E) {
   // <expression> ::= <unary operator-name> <expression>
-       //              ::= <binary operator-name> <expression> <expression>
-       //              ::= <trinary operator-name> <expression> <expression> <expression>
-  //              ::= cl <expression>* E               # call
+  //              ::= <binary operator-name> <expression> <expression>
+  //              ::= <trinary operator-name> <expression> <expression> <expression>
+  //              ::= cl <expression>* E            # call
   //              ::= cv <type> expression           # conversion with one argument
   //              ::= cv <type> _ <expression>* E # conversion with a different number of arguments
-  //              ::= st <type>                        # sizeof (a type)
+  //              ::= st <type>                             # sizeof (a type)
   //              ::= at <type>                      # alignof (a type)
   //              ::= <template-param>
   //              ::= <function-param>
   //              ::= sr <type> <unqualified-name>                   # dependent name
   //              ::= sr <type> <unqualified-name> <template-args>   # dependent template-id
   //              ::= sZ <template-param>                            # size of a parameter pack
-       //              ::= <expr-primary>
+  //              ::= <expr-primary>
   switch (E->getStmtClass()) {
-  default: assert(false && "Unhandled expression kind!");
+  default:
+    llvm_unreachable("unexpected statement kind");
+    break;
+
+  case Expr::CallExprClass:
+    // FIXME: implement
+    llvm_unreachable("mangling not implemented for calls");
+    break;
+
+  case Expr::CXXConstructExprClass:
+    // FIXME: implement
+    llvm_unreachable("mangling not implemented for construct exprs");
+    break;    
+
+  case Expr::SizeOfAlignOfExprClass:
+    // FIXME: implement
+    llvm_unreachable("mangling not implemented for sizeof/alignof");
+    break;
 
   case Expr::UnaryOperatorClass: {
     const UnaryOperator *UO = cast<UnaryOperator>(E);

diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h
index b23a69860b7351c33aab50ee073fa1f80bdd702d..1938e3dfb5973610c25e23adbe81edf31170666c 100644 (file)
--- a/lib/Sema/TreeTransform.h
+++ b/lib/Sema/TreeTransform.h
@@ -1684,6 +1684,7 @@ Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) {
 
   // Transform expressions by calling TransformExpr.
 #define STMT(Node, Parent)
+#define ABSTRACT_EXPR(Node, Parent)
 #define EXPR(Node, Parent) case Stmt::Node##Class:
 #include "clang/AST/StmtNodes.def"
     {
@@ -1707,6 +1708,7 @@ Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
   switch (E->getStmtClass()) {
     case Stmt::NoStmtClass: break;
 #define STMT(Node, Parent) case Stmt::Node##Class: break;
+#define ABSTRACT_EXPR(Node, Parent)
 #define EXPR(Node, Parent)                                              \
     case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
 #include "clang/AST/StmtNodes.def"
@@ -3827,13 +3829,6 @@ TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
                                         FirstQualifierInScope);
 }
 
-template<typename Derived>
-Sema::OwningExprResult
-TreeTransform<Derived>::TransformCastExpr(CastExpr *E) {
-  assert(false && "Cannot transform abstract class");
-  return SemaRef.Owned(E->Retain());
-}
-
 template<typename Derived>
 Sema::OwningExprResult
 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
@@ -3897,13 +3892,6 @@ TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
   return getDerived().TransformExpr(E->getSubExprAsWritten());
 }
 
-template<typename Derived>
-Sema::OwningExprResult
-TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E) {
-  assert(false && "Cannot transform abstract class");
-  return SemaRef.Owned(E->Retain());
-}
-
 template<typename Derived>
 Sema::OwningExprResult
 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {

diff --git a/tools/CIndex/CXCursor.cpp b/tools/CIndex/CXCursor.cpp
index 03b050db31305cb446ba1e619d29b308782eb2b7..ec1477eb8a275586cc740ced0a35380c1c541e32 100644 (file)
--- a/tools/CIndex/CXCursor.cpp
+++ b/tools/CIndex/CXCursor.cpp
@@ -115,7 +115,6 @@ CXCursor cxcursor::MakeCXCursor(Stmt *S, Decl *Parent, ASTUnit *TU) {
     K = CXCursor_UnexposedStmt;
     break;
       
-  case Stmt::ExprClass:
   case Stmt::PredefinedExprClass:        
   case Stmt::IntegerLiteralClass:        
   case Stmt::FloatingLiteralClass:       
@@ -126,12 +125,10 @@ CXCursor cxcursor::MakeCXCursor(Stmt *S, Decl *Parent, ASTUnit *TU) {
   case Stmt::UnaryOperatorClass:         
   case Stmt::SizeOfAlignOfExprClass:     
   case Stmt::ArraySubscriptExprClass:    
-  case Stmt::CastExprClass:              
   case Stmt::BinaryOperatorClass:        
   case Stmt::CompoundAssignOperatorClass:
   case Stmt::ConditionalOperatorClass:   
   case Stmt::ImplicitCastExprClass:
-  case Stmt::ExplicitCastExprClass:
   case Stmt::CStyleCastExprClass:
   case Stmt::CompoundLiteralExprClass:   
   case Stmt::ExtVectorElementExprClass: