Add a new expression node, CXXOperatorCallExpr, which expresses a
function call created in response to the use of operator syntax that
resolves to an overloaded operator in C++, e.g., "str1 +
str2" that resolves to std::operator+(str1, str2)". We now build a
CXXOperatorCallExpr in C++ when we pick an overloaded operator. (But
only for binary operators, where we actually implement overloading)
I decided *not* to refactor the current CallExpr to make it abstract
(with FunctionCallExpr and CXXOperatorCallExpr as derived
classes). Doing so would allow us to make CXXOperatorCallExpr a little
bit smaller, at the cost of making the argument and callee accessors
virtual. We won't know if this is going to be a win until we can parse
lots of C++ code to determine how much memory we'll save by making
this change vs. the performance penalty due to the extra virtual
calls.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@59306 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/AST/StmtSerialization.cpp b/lib/AST/StmtSerialization.cpp
index 667f597..268922e 100644
--- a/lib/AST/StmtSerialization.cpp
+++ b/lib/AST/StmtSerialization.cpp
@@ -53,7 +53,7 @@
return BreakStmt::CreateImpl(D, C);
case CallExprClass:
- return CallExpr::CreateImpl(D, C);
+ return CallExpr::CreateImpl(D, C, CallExprClass);
case CaseStmtClass:
return CaseStmt::CreateImpl(D, C);
@@ -198,6 +198,9 @@
// C++
//==--------------------------------------==//
+ case CXXOperatorCallExprClass:
+ return CXXOperatorCallExpr::CreateImpl(D, C, CXXOperatorCallExprClass);
+
case CXXDefaultArgExprClass:
return CXXDefaultArgExpr::CreateImpl(D, C);
@@ -361,14 +364,14 @@
S.BatchEmitOwnedPtrs(NumArgs+1, SubExprs);
}
-CallExpr* CallExpr::CreateImpl(Deserializer& D, ASTContext& C) {
+CallExpr* CallExpr::CreateImpl(Deserializer& D, ASTContext& C, StmtClass SC) {
QualType t = QualType::ReadVal(D);
SourceLocation L = SourceLocation::ReadVal(D);
unsigned NumArgs = D.ReadInt();
Stmt** SubExprs = new Stmt*[NumArgs+1];
D.BatchReadOwnedPtrs(NumArgs+1, SubExprs, C);
- return new CallExpr(SubExprs,NumArgs,t,L);
+ return new CallExpr(SC, SubExprs,NumArgs,t,L);
}
void CaseStmt::EmitImpl(Serializer& S) const {