[AST] AnyCall: Implement arguments().

[NoQ]

Summary

AnyCall is an interface provided by libAnalysis to polymorphically handle various call-like entities (function calls, Obj-C message expressions, block calls, constructor/destructor invocations, new/delete invocations, etc.) which aren't necessarily related in the AST class hierarchy.

This patch updates it to allow obtaining arguments of any call-like expression.

It also adds a couple of accessor functions in the AST in order to make this possible. The CXXDeleteExpr's getArgumentAddress() looks a bit weird out of context but we do seem to have a precedent (VarDecl::getInitAddress()).

[xazax.hun]

clang/include/clang/Analysis/AnyCall.h

170

As far as I remember CXXMemberCallExpr and CXXOperatorCallExpr having slightly different behavior with the former not including the implicit object argument in the argument list contrary to the latter. If that is the case, maybe this API should provide some uniformity, e.g. skipping the implicit object argument for CXXOperatorCallExpr (and potentially providing a separate function for getting the this/self). What do you think?

[NoQ]

clang/include/clang/Analysis/AnyCall.h

170

Excellent point yeah. And if we're going to do something so non-trivial it probably makes sense for me to start covering AnyCall with unittests.

clang/include/clang/AST/ExprCXX.h

unsigned getNumPlacementArgs() const {
     return CXXNewExprBits.NumPlacementArgs;
   }
 
   Expr **getPlacementArgs() {
     return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>() +
                                      placementNewArgsOffset());
   }
 
+  Expr *const *getPlacementArgs() const {
+    return reinterpret_cast<Expr *const *>(getTrailingObjects<Stmt *>() +
+                                           placementNewArgsOffset());
+  }
+
   Expr *getPlacementArg(unsigned I) {
     assert((I < getNumPlacementArgs()) && "Index out of range!");
     return getPlacementArgs()[I];
   }
   const Expr *getPlacementArg(unsigned I) const {
     return const_cast<CXXNewExpr *>(this)->getPlacementArg(I);
   }
 
bool doesUsualArrayDeleteWantSize() const {
     return CXXDeleteExprBits.UsualArrayDeleteWantsSize;
   }
 
   FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
 
   Expr *getArgument() { return cast<Expr>(Argument); }
   const Expr *getArgument() const { return cast<Expr>(Argument); }
 
+  /// Retrieve the address of the argument expression.
+  Stmt *const *getArgumentAddress() const { return &Argument; }
+
   /// Retrieve the type being destroyed.
   ///
   /// If the type being destroyed is a dependent type which may or may not
   /// be a pointer, return an invalid type.
   QualType getDestroyedType() const;
 
   SourceLocation getBeginLoc() const { return CXXDeleteExprBits.Loc; }
   SourceLocation getEndLoc() const LLVM_READONLY {

clang/include/clang/Analysis/AnyCall.h

AnyCall(const FunctionDecl *D) : E(nullptr), D(D) {
     } else {
       K = Function;
     }
 
   }
 
   /// If @c E is a generic call (to ObjC method /function/block/etc),
   /// return a constructed @c AnyCall object. Return None otherwise.
-  static Optional<AnyCall> forExpr(const Expr *E) {
+  static Optional<AnyCall> forExpr(const Stmt *E) {
     if (const auto *ME = dyn_cast<ObjCMessageExpr>(E)) {
       return AnyCall(ME);
     } else if (const auto *CE = dyn_cast<CallExpr>(E)) {
       return AnyCall(CE);
     } else if (const auto *CXNE = dyn_cast<CXXNewExpr>(E)) {
       return AnyCall(CXNE);
     } else if (const auto *CXDE = dyn_cast<CXXDeleteExpr>(E)) {
       return AnyCall(CXDE);
public:
   }
 
   using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;
   param_const_iterator param_begin() const { return parameters().begin(); }
   param_const_iterator param_end() const { return parameters().end(); }
   size_t param_size() const { return parameters().size(); }
   bool param_empty() const { return parameters().empty(); }
 
+  ArrayRef<const Expr *> arguments() const {
+    if (!E)
+      return None;
+
+    if (const auto *ME = dyn_cast<ObjCMessageExpr>(E)) {
+      return {ME->getArgs(), ME->getNumArgs()};
+    } else if (const auto *CE = dyn_cast<CallExpr>(E)) {
+      return {CE->getArgs(), CE->getNumArgs()};
+    } else if (const auto *CXNE = dyn_cast<CXXNewExpr>(E)) {
+      return {CXNE->getPlacementArgs(), CXNE->getNumPlacementArgs()};
+    } else if (const auto *CXDE = dyn_cast<CXXDeleteExpr>(E)) {
+      // The only argument is the object being deleted.
+      return {reinterpret_cast<Expr *const *>(CXDE->getArgumentAddress()), 1U};
+    } else if (const auto *CXCE = dyn_cast<CXXConstructExpr>(E)) {
+      return {CXCE->getArgs(), CXCE->getNumArgs()};
+    } else if (const auto *CXCIE = dyn_cast<CXXInheritedCtorInitExpr>(E)) {
+      // No argument expressions are synthesized in this case.
+      return None;
+    } else {
+      return None;
+    }
+  }
+
+  using arg_const_iterator = ArrayRef<const Expr *>::const_iterator;
+  arg_const_iterator arg_begin() const { return arguments().begin(); }
+  arg_const_iterator arg_end() const { return arguments().end(); }
+  size_t arg_size() const { return arguments().size(); }
+  bool arg_empty() const { return arguments().empty(); }
+
   QualType getReturnType(ASTContext &Ctx) const {
     switch (K) {
     case Function:
       if (E)
         return cast<CallExpr>(E)->getCallReturnType(Ctx);
       return cast<FunctionDecl>(D)->getReturnType();
     case ObjCMethod:
       if (E)