[AST] [NFC] Introduce an abstract superclass for CallExpr | CXXConstructExpr | ObjCMessageExpr

[george.karpenkov]

Summary

Cf. http://clang-developers.42468.n3.nabble.com/Superclass-for-CallExpr-CXXConstructExpr-ObjCMessageExpr-td4061069.html for discussion.

[rsmith]

clang/include/clang/AST/Expr.h

2280–2285

Replace with using Expr::Expr;?

2292–2316

Don't use virtual functions here; we don't want to pay for a vtable in each CallExpr. Instead, make these non-virtual functions that dispatch based on the actual type (using dyn_cast / isa).

2305–2309

If we want to guarantee that the arguments are contiguous, I don't think there's any need to expose getArgs here; new code should use arguments instead. (Also the return type of getArgs is wrong resulting in a violation of the aliasing rules -- another reason to avoid it.)

2311

This setter should not be in the abstract interface. (It probably shouldn't be in the subtypes either.)

[george.karpenkov]

clang/include/clang/AST/Expr.h

2292–2316

Ah right, I was wondering whether it would be acceptable while writing this.
Any protips on avoiding 6-lines boilerplate on every single method here?
One way would be just to let the abstract superclass handle the arguments.

[george.karpenkov]

@rsmith i hope i'm on the right track here.

It would be nice to throw out all the 10+ methods argument-getter and just use an ArrayRef, but it's a larger/scarier diff.
Also caching constructed ArrayRef doesn't work, as different parts of the codebase mutate expressions after construction =/

[rsmith]

clang/include/clang/AST/Expr.h

2387

This is a violation of the aliasing rules that we're trying to move away from (it's why we have the ExprIterator / ConstExprIterator classes rather than using ArrayRef here). Can we keep using the iterator_range<arg_iterator> approach?

[george.karpenkov]

clang/include/clang/AST/Expr.h

2387

Right, I see now.
Keeping iterator ranges requires having ~10 getters, with 6 lines of boilerplate code each for doing RTTI. Do you have other suggestions?

[NoQ]

I realized that some of the motivating examples behind this patch also require uniform support for CXXNewExpr's placement arguments, otherwise we'd still have to duplicate code. And those have slightly different syntax, so it won't be a transparent change anymore (though it might be possible to avoid breaking the API by providing duplicate methods).

[george.karpenkov]

@rjmccall do you think you would have any suggestions on what can be done here?
The currently proposed version would have a non-virtual superclass which would use RTTI to dispatch to the generic parametersX methods.
That would require duplicating around 7 lines of boilerplate RTTI-dispatch code per each getter, and there are about 6 of them.

[rjmccall]

In D49005#1180482, @george.karpenkov wrote:

@rjmccall do you think you would have any suggestions on what can be done here?
The currently proposed version would have a non-virtual superclass which would use RTTI to dispatch to the generic parametersX methods.
That would require duplicating around 7 lines of boilerplate RTTI-dispatch code per each getter, and there are about 6 of them.

Er, by RTTI you mean just switching on getStmtClass()?

I'm not really opposed to this change in general, but I wonder if it's really the right way of achieving its goal, which appears to just be to make it easier to recognize user-level calls in the AST. Would it be better to just have a dedicated CallVisitor class that gets notified about all the different options, i.e. CallExpr, ObjCMessageExpr, CXXConstructExpr, operator new calls, and so on?

[george.karpenkov]

Er, by RTTI you mean just switching on getStmtClass()?

As far as I understand yes, basically doing dyn_cast myself as opposed to using virtual dispatch.

Would it be better to just have a dedicated CallVisitor class that gets notified about all the different options, i.e. CallExpr, ObjCMessageExpr, CXXConstructExpr, operator new calls, and so on?

We sort of have it in the analyzer, cf. CallEvent. A lot of code still ends up being duplicated/or worse, not general enough.

[rjmccall]

In D49005#1180740, @george.karpenkov wrote:

Er, by RTTI you mean just switching on getStmtClass()?

As far as I understand yes, basically doing dyn_cast myself as opposed to using virtual dispatch.

Would it be better to just have a dedicated CallVisitor class that gets notified about all the different options, i.e. CallExpr, ObjCMessageExpr, CXXConstructExpr, operator new calls, and so on?

We sort of have it in the analyzer, cf. CallEvent. A lot of code still ends up being duplicated/or worse, not general enough.

CallEvent looks like a good API to me. What do you think would become easier about it if you had this superclass? Or do people just not use CallEvent enough?

[george.karpenkov]

@rjmccall It's not sufficient.

1. It requires context, which is not always available (that's the biggest problem).
2. It can be too verbose - need to create a temporary object just when a simple isa/dyn_cast should suffice

For needed use cases: e.g. consider the duplication required in https://reviews.llvm.org/D48249

[rjmccall]

In D49005#1181488, @george.karpenkov wrote:

@rjmccall It's not sufficient.

1. It requires context, which is not always available (that's the biggest problem).
2. It can be too verbose - need to create a temporary object just when a simple isa/dyn_cast should suffice

Okay, so you want an AST CallSite equivalent that just a failable constructor/factory? Something with the basic interface of ApplySite in Swift SIL:

https://github.com/apple/swift/blob/463a46704694ef27680f27095c05f1b901e07b80/include/swift/SIL/SILInstruction.h#L7501

Because this superclass gets you, like, 10% of the way there, and then will never ever get you any closer.

[george.karpenkov]

@rjmccall Sorry, I'm not quite sure what do you mean.
All the cases we have seen in the analyzer so far (and we have seen quite a lot) would have been solved by having generic arguments().
What currently ends up happening is that in the best case the good is duplicated, and in the worst case, the code does not handle unexpected types of calls correctly (objc-message-send instead of a function call)

[rjmccall]

In D49005#1182915, @george.karpenkov wrote:

@rjmccall Sorry, I'm not quite sure what do you mean.
All the cases we have seen in the analyzer so far (and we have seen quite a lot) would have been solved by having generic arguments().
What currently ends up happening is that in the best case the good is duplicated, and in the worst case, the code does not handle unexpected types of calls correctly (objc-message-send instead of a function call)

Well, part of what I'm saying is that if you're willing to break away from the assumption that this is an abstract base class of various Expr classes, and instead just make it a separate class that just has its own convenient testing operations when you're starting with an Expr*, you can actually model calls that aren't just expressions with the same abstractions. Like you can have a CallSite that refers to the call to operator new in a CXXNewExpr, or to an implicit destructor call, or whatever.

clang/include/clang/AST/Expr.h

   child_range children() {
     return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
   }
   const_child_range children() const {
     return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
   }
 };
 
+/// Abstract interface for CallExpr, ObjCMessageExpr and CXXConstructExpr.
+class AbstractCallExpr : public Expr {
+public:
+  using Expr::Expr;
+
+  ArrayRef<Expr *> arguments() const;
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() >= firstAbstractCallExprConstant
+      && T->getStmtClass() <= lastAbstractCallExprConstant;
+  }
+};
+
 /// CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
 /// CallExpr itself represents a normal function call, e.g., "f(x, 2)",
 /// while its subclasses may represent alternative syntax that (semantically)
 /// results in a function call. For example, CXXOperatorCallExpr is
 /// a subclass for overloaded operator calls that use operator syntax, e.g.,
 /// "str1 + str2" to resolve to a function call.
-class CallExpr : public Expr {
+class CallExpr : public AbstractCallExpr {
   enum { FN=0, PREARGS_START=1 };
   Stmt **SubExprs;
   unsigned NumArgs;
   SourceLocation RParenLoc;
 
   void updateDependenciesFromArg(Expr *Arg);
 
 protected:
   // These versions of the constructor are for derived classes.
   CallExpr(const ASTContext &C, StmtClass SC, Expr *fn,
            ArrayRef<Expr *> preargs, ArrayRef<Expr *> args, QualType t,
            ExprValueKind VK, SourceLocation rparenloc);
   CallExpr(const ASTContext &C, StmtClass SC, Expr *fn, ArrayRef<Expr *> args,
            QualType t, ExprValueKind VK, SourceLocation rparenloc);
   CallExpr(const ASTContext &C, StmtClass SC, unsigned NumPreArgs,
            EmptyShell Empty);
 
   Stmt *getPreArg(unsigned i) {
     assert(i < getNumPreArgs() && "Prearg access out of range!");
     return SubExprs[PREARGS_START+i];
   }
   const Stmt *getPreArg(unsigned i) const {
     assert(i < getNumPreArgs() && "Prearg access out of range!");
     return SubExprs[PREARGS_START+i];
   }
   void setPreArg(unsigned i, Stmt *PreArg) {
     assert(i < getNumPreArgs() && "Prearg access out of range!");
     SubExprs[PREARGS_START+i] = PreArg;

     SubExprs[Arg+getNumPreArgs()+PREARGS_START] = ArgExpr;
   }
 
   /// setNumArgs - This changes the number of arguments present in this call.
   /// Any orphaned expressions are deleted by this, and any new operands are set
   /// to null.
   void setNumArgs(const ASTContext& C, unsigned NumArgs);
 
-  typedef ExprIterator arg_iterator;
-  typedef ConstExprIterator const_arg_iterator;
-  typedef llvm::iterator_range<arg_iterator> arg_range;
-  typedef llvm::iterator_range<const_arg_iterator> arg_const_range;
-
-  arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
-  arg_const_range arguments() const {
-    return arg_const_range(arg_begin(), arg_end());
-  }
-
-  arg_iterator arg_begin() { return SubExprs+PREARGS_START+getNumPreArgs(); }
-  arg_iterator arg_end() {
-    return SubExprs+PREARGS_START+getNumPreArgs()+getNumArgs();
-  }
-  const_arg_iterator arg_begin() const {
-    return SubExprs+PREARGS_START+getNumPreArgs();
-  }
-  const_arg_iterator arg_end() const {
-    return SubExprs+PREARGS_START+getNumPreArgs()+getNumArgs();
+  ArrayRef<Expr *> getArgsRef() const {
+    return ArrayRef<Expr *>(
+      reinterpret_cast<Expr **>(&(SubExprs[PREARGS_START + getNumPreArgs()])),
+      NumArgs);
   }
 
   /// This method provides fast access to all the subexpressions of
   /// a CallExpr without going through the slower virtual child_iterator
   /// interface.  This provides efficient reverse iteration of the
   /// subexpressions.  This is currently used for CFG construction.
   ArrayRef<Stmt*> getRawSubExprs() {
     return llvm::makeArrayRef(SubExprs,

clang/include/clang/AST/ExprCXX.h

     return T->getStmtClass() == CXXBindTemporaryExprClass;
   }
 
   // Iterators
   child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
 };
 
 /// Represents a call to a C++ constructor.
-class CXXConstructExpr : public Expr {
+class CXXConstructExpr : public AbstractCallExpr {
 public:
   enum ConstructionKind {
     CK_Complete,
     CK_NonVirtualBase,
     CK_VirtualBase,
     CK_Delegating
   };
 

                    bool ListInitialization,
                    bool StdInitListInitialization,
                    bool ZeroInitialization,
                    ConstructionKind ConstructKind,
                    SourceRange ParenOrBraceRange);
 
   /// Construct an empty C++ construction expression.
   CXXConstructExpr(StmtClass SC, EmptyShell Empty)
-      : Expr(SC, Empty), NumArgs(0), Elidable(false),
+      : AbstractCallExpr(SC, Empty), NumArgs(0), Elidable(false),
         HadMultipleCandidates(false), ListInitialization(false),
         ZeroInitialization(false), ConstructKind(0) {}
 
 public:
   friend class ASTStmtReader;
 
   /// Construct an empty C++ construction expression.
   explicit CXXConstructExpr(EmptyShell Empty)

     assert(Arg < NumArgs && "Arg access out of range!");
     return cast<Expr>(Args[Arg]);
   }
   const Expr *getArg(unsigned Arg) const {
     assert(Arg < NumArgs && "Arg access out of range!");
     return cast<Expr>(Args[Arg]);
   }
 
+  ArrayRef<Expr *> getArgsRef() const {
+    return ArrayRef<Expr *>(reinterpret_cast<Expr **>(Args), NumArgs);
+  }
+
   /// Set the specified argument.
   void setArg(unsigned Arg, Expr *ArgExpr) {
     assert(Arg < NumArgs && "Arg access out of range!");
     Args[Arg] = ArgExpr;
   }
 
   SourceLocation getLocStart() const LLVM_READONLY;
   SourceLocation getLocEnd() const LLVM_READONLY;

   llvm::iterator_range<arg_iterator> placement_arguments() {
     return llvm::make_range(placement_arg_begin(), placement_arg_end());
   }
 
   llvm::iterator_range<const_arg_iterator> placement_arguments() const {
     return llvm::make_range(placement_arg_begin(), placement_arg_end());
   }
 
+  ArrayRef<Expr *> placement_arguments_ref() const {
+    return ArrayRef<Expr *>(
+        reinterpret_cast<Expr **>(SubExprs + Array + hasInitializer()),
+        getNumPlacementArgs());
+  }
+
   arg_iterator placement_arg_begin() {
     return SubExprs + Array + hasInitializer();
   }
   arg_iterator placement_arg_end() {
     return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
   }
   const_arg_iterator placement_arg_begin() const {
     return SubExprs + Array + hasInitializer();

clang/include/clang/AST/ExprObjC.h

 ///
 /// All four kinds of message sends are modeled by the ObjCMessageExpr
 /// class, and can be distinguished via \c getReceiverKind(). Example:
 ///
 /// The "void *" trailing objects are actually ONE void * (the
 /// receiver pointer), and NumArgs Expr *. But due to the
 /// implementation of children(), these must be together contiguously.
 class ObjCMessageExpr final
-    : public Expr,
+    : public AbstractCallExpr,
       private llvm::TrailingObjects<ObjCMessageExpr, void *, SourceLocation> {
   /// Stores either the selector that this message is sending
   /// to (when \c HasMethod is zero) or an \c ObjCMethodDecl pointer
   /// referring to the method that we type-checked against.
   uintptr_t SelectorOrMethod = 0;
 
   enum { NumArgsBitWidth = 16 };
 
class ObjCMessageExpr final
   /// the location of the 'super' keyword.
   SourceLocation SuperLoc;
 
   /// The source locations of the open and close square
   /// brackets ('[' and ']', respectively).
   SourceLocation LBracLoc, RBracLoc;
 
   ObjCMessageExpr(EmptyShell Empty, unsigned NumArgs)
-      : Expr(ObjCMessageExprClass, Empty), Kind(0), HasMethod(false),
+      : AbstractCallExpr(ObjCMessageExprClass, Empty), Kind(0), HasMethod(false),
         IsDelegateInitCall(false), IsImplicit(false), SelLocsKind(0) {
     setNumArgs(NumArgs);
   }
 
   ObjCMessageExpr(QualType T, ExprValueKind VK,
                   SourceLocation LBracLoc,
                   SourceLocation SuperLoc,
                   bool IsInstanceSuper,
public:
   const_arg_iterator arg_begin() const { 
     return reinterpret_cast<Stmt const * const*>(getArgs()); 
   }
 
   const_arg_iterator arg_end() const { 
     return reinterpret_cast<Stmt const * const*>(getArgs() + NumArgs); 
   }
 
+  /// Return a reference to the arguments of this message expression not
+  /// including the receiver.
+  ArrayRef<Expr *> getArgsRef() const {
+    return ArrayRef<Expr *>(
+      const_cast<ObjCMessageExpr*>(this)->getArgs(), NumArgs);
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCMessageExprClass;
   }
 };
 
 /// ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
 /// (similar in spirit to MemberExpr).
 class ObjCIsaExpr : public Expr {

clang/include/clang/Basic/StmtNodes.td

 def CXXForRangeStmt : Stmt;
 
 // C++ Coroutines TS statements
 def CoroutineBodyStmt : Stmt;
 def CoreturnStmt : Stmt;
 
 // Expressions
 def Expr : Stmt<1>;
+def AbstractCallExpr : DStmt<Expr, 1>;
 def PredefinedExpr : DStmt<Expr>;
 def DeclRefExpr : DStmt<Expr>;
 def IntegerLiteral : DStmt<Expr>;
 def FixedPointLiteral : DStmt<Expr>;
 def FloatingLiteral : DStmt<Expr>;
 def ImaginaryLiteral : DStmt<Expr>;
 def StringLiteral : DStmt<Expr>;
 def CharacterLiteral : DStmt<Expr>;
 def ParenExpr : DStmt<Expr>;
 def UnaryOperator : DStmt<Expr>;
 def OffsetOfExpr : DStmt<Expr>;
 def UnaryExprOrTypeTraitExpr : DStmt<Expr>;
 def ArraySubscriptExpr : DStmt<Expr>;
 def OMPArraySectionExpr : DStmt<Expr>;
-def CallExpr : DStmt<Expr>;
+def CallExpr : DStmt<AbstractCallExpr>;
 def MemberExpr : DStmt<Expr>;
 def CastExpr : DStmt<Expr, 1>;
 def BinaryOperator : DStmt<Expr>;
 def CompoundAssignOperator : DStmt<BinaryOperator>;
 def AbstractConditionalOperator : DStmt<Expr, 1>;
 def ConditionalOperator : DStmt<AbstractConditionalOperator>;
 def BinaryConditionalOperator : DStmt<AbstractConditionalOperator>;
 def ImplicitCastExpr : DStmt<CastExpr>;

 def CXXStdInitializerListExpr : DStmt<Expr>;
 def CXXNewExpr : DStmt<Expr>;
 def CXXDeleteExpr : DStmt<Expr>;
 def CXXPseudoDestructorExpr : DStmt<Expr>;
 def TypeTraitExpr : DStmt<Expr>;
 def ArrayTypeTraitExpr : DStmt<Expr>;
 def ExpressionTraitExpr : DStmt<Expr>;
 def DependentScopeDeclRefExpr : DStmt<Expr>;
-def CXXConstructExpr : DStmt<Expr>;
+def CXXConstructExpr : DStmt<AbstractCallExpr>;
 def CXXInheritedCtorInitExpr : DStmt<Expr>;
 def CXXBindTemporaryExpr : DStmt<Expr>;
 def ExprWithCleanups : DStmt<Expr>;
 def CXXTemporaryObjectExpr : DStmt<CXXConstructExpr>;
 def CXXUnresolvedConstructExpr : DStmt<Expr>;
 def CXXDependentScopeMemberExpr : DStmt<Expr>;
 def OverloadExpr : DStmt<Expr, 1>;
 def UnresolvedLookupExpr : DStmt<OverloadExpr>;

 def CoyieldExpr : DStmt<CoroutineSuspendExpr>;
 
 // Obj-C Expressions.
 def ObjCStringLiteral : DStmt<Expr>;
 def ObjCBoxedExpr : DStmt<Expr>;
 def ObjCArrayLiteral : DStmt<Expr>;
 def ObjCDictionaryLiteral : DStmt<Expr>;
 def ObjCEncodeExpr : DStmt<Expr>;
-def ObjCMessageExpr : DStmt<Expr>;
+def ObjCMessageExpr : DStmt<AbstractCallExpr>;
 def ObjCSelectorExpr : DStmt<Expr>;
 def ObjCProtocolExpr : DStmt<Expr>;
 def ObjCIvarRefExpr : DStmt<Expr>;
 def ObjCPropertyRefExpr : DStmt<Expr>;
 def ObjCIsaExpr : DStmt<Expr>;
 def ObjCIndirectCopyRestoreExpr : DStmt<Expr>;
 def ObjCBoolLiteralExpr : DStmt<Expr>;
 def ObjCSubscriptRefExpr : DStmt<Expr>;

clang/lib/AST/Expr.cpp

   case UO_Minus: return OO_Minus;
   case UO_Not: return OO_Tilde;
   case UO_LNot: return OO_Exclaim;
   case UO_Coawait: return OO_Coawait;
   default: return OO_None;
   }
 }
 
+ArrayRef<Expr *> AbstractCallExpr::arguments() const {
+  if (auto CE = dyn_cast<CallExpr>(this))
+    return CE->getArgsRef();
+  if (auto ME = dyn_cast<ObjCMessageExpr>(this))
+    return ME->getArgsRef();
+  if (auto CXXCE = dyn_cast<CXXConstructExpr>(this))
+    return CXXCE->getArgsRef();
+  llvm_unreachable("Unexpected child class");
+}
 
 //===----------------------------------------------------------------------===//
 // Postfix Operators.
 //===----------------------------------------------------------------------===//
 
 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, Expr *fn,
                    ArrayRef<Expr *> preargs, ArrayRef<Expr *> args, QualType t,
                    ExprValueKind VK, SourceLocation rparenloc)
-    : Expr(SC, t, VK, OK_Ordinary, fn->isTypeDependent(),
+    : AbstractCallExpr(SC, t, VK, OK_Ordinary, fn->isTypeDependent(),
            fn->isValueDependent(), fn->isInstantiationDependent(),
            fn->containsUnexpandedParameterPack()),
       NumArgs(args.size()) {
 
   unsigned NumPreArgs = preargs.size();
   SubExprs = new (C) Stmt *[args.size()+PREARGS_START+NumPreArgs];
   SubExprs[FN] = fn;
   for (unsigned i = 0; i != NumPreArgs; ++i) {

     : CallExpr(C, CallExprClass, fn, ArrayRef<Expr *>(), args, t, VK, rparenloc) {
 }
 
 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, EmptyShell Empty)
     : CallExpr(C, SC, /*NumPreArgs=*/0, Empty) {}
 
 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, unsigned NumPreArgs,
                    EmptyShell Empty)
-  : Expr(SC, Empty), SubExprs(nullptr), NumArgs(0) {
+  : AbstractCallExpr(SC, Empty), SubExprs(nullptr), NumArgs(0) {
   // FIXME: Why do we allocate this?
   SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs]();
   CallExprBits.NumPreArgs = NumPreArgs;
 }
 
 void CallExpr::updateDependenciesFromArg(Expr *Arg) {
   if (Arg->isTypeDependent())
     ExprBits.TypeDependent = true;

clang/lib/AST/ExprCXX.cpp

CXXConstructExpr *CXXConstructExpr::Create(const ASTContext &C, QualType T,
   return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc,
                                   Ctor, Elidable, Args,
                                   HadMultipleCandidates, ListInitialization,
                                   StdInitListInitialization,
                                   ZeroInitialization, ConstructKind,
                                   ParenOrBraceRange);
 }
 
-CXXConstructExpr::CXXConstructExpr(const ASTContext &C, StmtClass SC,
-                                   QualType T, SourceLocation Loc,
-                                   CXXConstructorDecl *Ctor,
-                                   bool Elidable,
-                                   ArrayRef<Expr*> Args,
-                                   bool HadMultipleCandidates,
-                                   bool ListInitialization,
-                                   bool StdInitListInitialization,
-                                   bool ZeroInitialization,
-                                   ConstructionKind ConstructKind,
-                                   SourceRange ParenOrBraceRange)
-    : Expr(SC, T, VK_RValue, OK_Ordinary,
-           T->isDependentType(), T->isDependentType(),
-           T->isInstantiationDependentType(),
+CXXConstructExpr::CXXConstructExpr(
+    const ASTContext &C, StmtClass SC, QualType T, SourceLocation Loc,
+    CXXConstructorDecl *Ctor, bool Elidable, ArrayRef<Expr *> Args,
+    bool HadMultipleCandidates, bool ListInitialization,
+    bool StdInitListInitialization, bool ZeroInitialization,
+    ConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
+    : AbstractCallExpr(SC, T, VK_RValue, OK_Ordinary, T->isDependentType(),
+                       T->isDependentType(), T->isInstantiationDependentType(),
                        T->containsUnexpandedParameterPack()),
       Constructor(Ctor), Loc(Loc), ParenOrBraceRange(ParenOrBraceRange),
       NumArgs(Args.size()), Elidable(Elidable),
       HadMultipleCandidates(HadMultipleCandidates),
       ListInitialization(ListInitialization),
       StdInitListInitialization(StdInitListInitialization),
       ZeroInitialization(ZeroInitialization), ConstructKind(ConstructKind) {
   if (NumArgs) {
     this->Args = new (C) Stmt*[Args.size()];

clang/lib/AST/ExprObjC.cpp

 ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK,
                                  SourceLocation LBracLoc,
                                  SourceLocation SuperLoc, bool IsInstanceSuper,
                                  QualType SuperType, Selector Sel,
                                  ArrayRef<SourceLocation> SelLocs,
                                  SelectorLocationsKind SelLocsK,
                                  ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
                                  SourceLocation RBracLoc, bool isImplicit)
-    : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
+    : AbstractCallExpr(ObjCMessageExprClass, T, VK, OK_Ordinary,
                        /*TypeDependent=*/false, /*ValueDependent=*/false,
                        /*InstantiationDependent=*/false,
                        /*ContainsUnexpandedParameterPack=*/false),
       SelectorOrMethod(
           reinterpret_cast<uintptr_t>(Method ? Method : Sel.getAsOpaquePtr())),
       Kind(IsInstanceSuper ? SuperInstance : SuperClass),
       HasMethod(Method != nullptr), IsDelegateInitCall(false),
       IsImplicit(isImplicit), SuperLoc(SuperLoc), LBracLoc(LBracLoc),
       RBracLoc(RBracLoc) {
   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
   setReceiverPointer(SuperType.getAsOpaquePtr());
 }
 
 ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK,
                                  SourceLocation LBracLoc,
                                  TypeSourceInfo *Receiver, Selector Sel,
                                  ArrayRef<SourceLocation> SelLocs,
                                  SelectorLocationsKind SelLocsK,
                                  ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
                                  SourceLocation RBracLoc, bool isImplicit)
-    : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(),
-           T->isDependentType(), T->isInstantiationDependentType(),
+    : AbstractCallExpr(ObjCMessageExprClass, T, VK, OK_Ordinary,
+                       T->isDependentType(), T->isDependentType(),
+                       T->isInstantiationDependentType(),
                        T->containsUnexpandedParameterPack()),
       SelectorOrMethod(
           reinterpret_cast<uintptr_t>(Method ? Method : Sel.getAsOpaquePtr())),
       Kind(Class), HasMethod(Method != nullptr), IsDelegateInitCall(false),
       IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) {
   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
   setReceiverPointer(Receiver);
 }
 
 ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK,
                                  SourceLocation LBracLoc, Expr *Receiver,
                                  Selector Sel, ArrayRef<SourceLocation> SelLocs,
                                  SelectorLocationsKind SelLocsK,
                                  ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
                                  SourceLocation RBracLoc, bool isImplicit)
-    : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
+    : AbstractCallExpr(ObjCMessageExprClass, T, VK, OK_Ordinary,
                        Receiver->isTypeDependent(), Receiver->isTypeDependent(),
                        Receiver->isInstantiationDependent(),
                        Receiver->containsUnexpandedParameterPack()),
       SelectorOrMethod(
           reinterpret_cast<uintptr_t>(Method ? Method : Sel.getAsOpaquePtr())),
       Kind(Instance), HasMethod(Method != nullptr), IsDelegateInitCall(false),
       IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) {
   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
   setReceiverPointer(Receiver);
 }