Extend AnyCall to handle callable declarations without the call expressions

[george.karpenkov]

Summary

That weakens inner invariants, but allows the class to be more generic, allowing usage in situations where the call expression is not known (or should not matter).

[rjmccall]

clang/include/clang/Analysis/AnyCall.h

23

"An instance of this class corresponds to a call. It may be a syntactically-concrete call, done as part of evaluating an expression, or it may be an abstract callee with no associated expression."

93

Destructors and constructors are subclasses of FunctionDecl and must be either checked for here or asserted against.

168

"its" and "asymmetry", and consider spelling out "asymmetry with the function and method cases above".

[rjmccall]

Thanks, LGTM.

clang/include/clang/Analysis/AnyCall.h

 #define LLVM_CLANG_ANALYSIS_ANY_CALL_H
 
 #include "clang/AST/Decl.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 
 namespace clang {
 
-/// An instance of this class corresponds to a 'callable' call.
+/// An instance of this class corresponds to a call.
+/// It might be a syntactically-concrete call, done as a part of evaluating an
+/// expression, or it may be an abstract callee with no associated expression.
 class AnyCall {
 public:
   enum Kind {
     /// A function, function pointer, or a C++ method call
     Function,
 
     /// A call to an Objective-C method
     ObjCMethod,
enum Kind {
     Allocator,
 
     /// A C++ deallocation function call (operator `delete`), via C++
     /// delete-expression
     Deallocator
   };
 
 private:
-  /// Call expression, remains null iff the call is an implicit destructor call.
+  /// Either expression or declaration (but not both at the same time)
+  /// can be null.
+
+  /// Call expression, is null when is not known (then declaration is non-null),
+  /// or for implicit destructor calls (when no expression exists.)
   const Expr *E = nullptr;
 
   /// Corresponds to a statically known declaration of the called function,
   /// or null if it is not known (e.g. for a function pointer).
   const Decl *D = nullptr;
   Kind K;
 
-  AnyCall(const Expr *E, const Decl *D, Kind K) : E(E), D(D), K(K) {}
-
 public:
   AnyCall(const CallExpr *CE) : E(CE) {
     D = CE->getCalleeDecl();
     K = (CE->getCallee()->getType()->getAs<BlockPointerType>()) ? Block
                                                                 : Function;
     if (D && ((K == Function && !isa<FunctionDecl>(D)) ||
               (K == Block && !isa<BlockDecl>(D))))
       D = nullptr;
   }
 
   AnyCall(const ObjCMessageExpr *ME)
       : E(ME), D(ME->getMethodDecl()), K(ObjCMethod) {}
 
   AnyCall(const CXXNewExpr *NE)
       : E(NE), D(NE->getOperatorNew()), K(Allocator) {}
 
   AnyCall(const CXXDeleteExpr *NE)
       : E(NE), D(NE->getOperatorDelete()), K(Deallocator) {}
 
   AnyCall(const CXXConstructExpr *NE)
       : E(NE), D(NE->getConstructor()), K(Constructor) {}
 
+  AnyCall(const CXXDestructorDecl *D) : E(nullptr), D(D), K(Destructor) {}
+
+  AnyCall(const CXXConstructorDecl *D) : E(nullptr), D(D), K(Constructor) {}
+
+  AnyCall(const ObjCMethodDecl *D) : E(nullptr), D(D), K(ObjCMethod) {}
+
+  AnyCall(const FunctionDecl *D) : E(nullptr), D(D) {
+    if (isa<CXXConstructorDecl>(D)) {
+      K = Constructor;
+    } else if (isa <CXXDestructorDecl>(D)) {
+      K = Destructor;
+    } else {
+      K = Function;
+    }
+
+  }
+
   /// If {@code E} is a generic call (to ObjC method /function/block/etc),
   /// return a constructed {@code AnyCall} object. Return None otherwise.
   static Optional<AnyCall> forExpr(const Expr *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);
     } else if (const auto *CXCE = dyn_cast<CXXConstructExpr>(E)) {
       return AnyCall(CXCE);
     } else {
       return None;
     }
   }
 
-  static AnyCall forDestructorCall(const CXXDestructorDecl *D) {
-    return AnyCall(/*E=*/nullptr, D, Destructor);
+  /// If {@code D} is a callable (Objective-C method or a function), return
+  /// a constructed {@code AnyCall} object. Return None otherwise.
+  // FIXME: block support.
+  static Optional<AnyCall> forDecl(const Decl *D) {
+    if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
+      return AnyCall(FD);
+    } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
+      return AnyCall(MD);
+    }
+    return None;
   }
 
   /// \returns formal parameters for direct calls (including virtual calls)
   ArrayRef<ParmVarDecl *> parameters() const {
     if (!D)
       return None;
 
     if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
       return FD->parameters();
     } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
       return MD->parameters();
-    } else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D)) {
-      return CD->parameters();
     } else if (const auto *BD = dyn_cast<BlockDecl>(D)) {
       return BD->parameters();
     } else {
       return None;
     }
   }
 
   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(); }
 
   QualType getReturnType(ASTContext &Ctx) const {
     switch (K) {
     case Function:
-    case Block:
+      if (E)
         return cast<CallExpr>(E)->getCallReturnType(Ctx);
+      return cast<FunctionDecl>(D)->getReturnType();
     case ObjCMethod:
+      if (E)
         return cast<ObjCMessageExpr>(E)->getCallReturnType(Ctx);
+      return cast<ObjCMethodDecl>(D)->getReturnType();
+    case Block:
+      // FIXME: BlockDecl does not know its return type,
+      // hence the asymmetry with the function and method cases above.
+      return cast<CallExpr>(E)->getCallReturnType(Ctx);
     case Destructor:
     case Constructor:
     case Allocator:
     case Deallocator:
       return cast<FunctionDecl>(D)->getReturnType();
     }
   }
 

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

 }
 
 const static RetainSummary *getSummary(RetainSummaryManager &Summaries,
                                        const CallEvent &Call,
                                        QualType ReceiverType) {
   const Expr *CE = Call.getOriginExpr();
   AnyCall C =
       CE ? *AnyCall::forExpr(CE)
-         : AnyCall::forDestructorCall(cast<CXXDestructorDecl>(Call.getDecl()));
+         : AnyCall(cast<CXXDestructorDecl>(Call.getDecl()));
   return Summaries.getSummary(C, Call.hasNonZeroCallbackArg(),
                               isReceiverUnconsumedSelf(Call), ReceiverType);
 }
 
 void RetainCountChecker::checkPostCall(const CallEvent &Call,
                                        CheckerContext &C) const {
   RetainSummaryManager &Summaries = getSummaryManager(C);