Read/write a CXXOperatorCallExpr from/to PCH files.

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

diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 6a1046e6d03feec8ada649439134e342b129bb32..1fc35ba8d548149e2dbfcc50683016418f803495 100644 (file)
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -955,7 +955,7 @@ public:
            SourceLocation rparenloc);
   
   /// \brief Build an empty call expression.
-  CallExpr(ASTContext &C, EmptyShell Empty);
+  CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty);
 
   ~CallExpr() {}
   

diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h
index 6956e58c8253d23c2073fd223e0190381a9bc7f7..176786601719fbda0d48b5a69dae35807f04f693 100644 (file)
--- a/include/clang/AST/ExprCXX.h
+++ b/include/clang/AST/ExprCXX.h
@@ -51,10 +51,14 @@ public:
                       SourceLocation operatorloc)
     : CallExpr(C, CXXOperatorCallExprClass, fn, args, numargs, t, operatorloc),
       Operator(Op) {}
+  explicit CXXOperatorCallExpr(ASTContext& C, EmptyShell Empty) : 
+    CallExpr(C, CXXOperatorCallExprClass, Empty) { }
+  
 
   /// getOperator - Returns the kind of overloaded operator that this
   /// expression refers to.
   OverloadedOperatorKind getOperator() const { return Operator; }
+  void setOperator(OverloadedOperatorKind Kind) { Operator = Kind; }
 
   /// getOperatorLoc - Returns the location of the operator symbol in
   /// the expression. When @c getOperator()==OO_Call, this is the

diff --git a/include/clang/Frontend/PCHBitCodes.h b/include/clang/Frontend/PCHBitCodes.h
index 2f687e5d9814ca53b9051769218d9d3d34c61a8b..b6155431c3b0b82d9fec8481e0d16051809d05a3 100644 (file)
--- a/include/clang/Frontend/PCHBitCodes.h
+++ b/include/clang/Frontend/PCHBitCodes.h
@@ -648,7 +648,12 @@ namespace clang {
       /// \brief An ObjCAtSynchronizedStmt record.      
       STMT_OBJC_AT_SYNCHRONIZED,
       /// \brief An ObjCAtThrowStmt record.      
-      STMT_OBJC_AT_THROW
+      STMT_OBJC_AT_THROW,
+
+      // C++
+
+      /// \brief An CXXOperatorCallExpr record.      
+      EXPR_CXX_OPERATOR_CALL
     };
 
     /// \brief The kinds of designators that can occur in a

diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 2c65179f9575c028bdcd52b57932d684b0f79313..39a90418f3d18ec4ec9581584fd75ae90ae5c336 100644 (file)
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -213,8 +213,8 @@ CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs,
   RParenLoc = rparenloc;
 }
 
-CallExpr::CallExpr(ASTContext &C, EmptyShell Empty) 
-  : Expr(CallExprClass, Empty), SubExprs(0), NumArgs(0) { 
+CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty) 
+  : Expr(SC, Empty), SubExprs(0), NumArgs(0) { 
   SubExprs = new (C) Stmt*[1];
 }
 

diff --git a/lib/Frontend/PCHReaderStmt.cpp b/lib/Frontend/PCHReaderStmt.cpp
index eccb53bf8189df798d75db0e05d9ba2a2e9dd78a..5681b675a2d5dfad91e170a59865a226d80c6344 100644 (file)
--- a/lib/Frontend/PCHReaderStmt.cpp
+++ b/lib/Frontend/PCHReaderStmt.cpp
@@ -111,6 +111,8 @@ namespace {
     unsigned VisitObjCAtTryStmt(ObjCAtTryStmt *);
     unsigned VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
     unsigned VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
+
+    unsigned VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
   };
 }
 
@@ -816,6 +818,15 @@ unsigned PCHStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
   return 1;
 }
 
+//===----------------------------------------------------------------------===//
+// C++ Expressions and Statements
+
+unsigned PCHStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  unsigned num = VisitCallExpr(E);
+  E->setOperator((OverloadedOperatorKind)Record[Idx++]);
+  return num;
+}
+
 
 // Within the bitstream, expressions are stored in Reverse Polish
 // Notation, with each of the subexpressions preceding the
@@ -983,7 +994,7 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) {
       break;
 
     case pch::EXPR_CALL:
-      S = new (Context) CallExpr(*Context, Empty);
+      S = new (Context) CallExpr(*Context, Stmt::CallExprClass, Empty);
       break;
 
     case pch::EXPR_MEMBER:
@@ -1113,6 +1124,10 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) {
     case pch::STMT_OBJC_AT_THROW:
       S = new (Context) ObjCAtThrowStmt(Empty);
       break;
+      
+    case pch::EXPR_CXX_OPERATOR_CALL:
+      S = new (Context) CXXOperatorCallExpr(*Context, Empty);
+      break;
     }
 
     // We hit a STMT_STOP, so we're done with this expression.

diff --git a/lib/Frontend/PCHWriterStmt.cpp b/lib/Frontend/PCHWriterStmt.cpp
index 5235326e9ffd41dbe5161a3fe6ada12ae1a70ca6..ae606b6b411d03de14abf2b8ee99758d1414c357 100644 (file)
--- a/lib/Frontend/PCHWriterStmt.cpp
+++ b/lib/Frontend/PCHWriterStmt.cpp
@@ -105,6 +105,9 @@ namespace {
     void VisitObjCAtTryStmt(ObjCAtTryStmt *);
     void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
     void VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
+
+    // C++ Statements    
+    void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
   };
 }
 
@@ -745,6 +748,16 @@ void PCHStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
   Code = pch::STMT_OBJC_AT_THROW;
 }
 
+//===----------------------------------------------------------------------===//
+// C++ Expressions and Statements.
+//===----------------------------------------------------------------------===//
+
+void PCHStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+  VisitCallExpr(E);
+  Record.push_back(E->getOperator());
+  Code = pch::EXPR_CXX_OPERATOR_CALL;
+}
+
 //===----------------------------------------------------------------------===//
 // PCHWriter Implementation
 //===----------------------------------------------------------------------===//