[analyzer] CallDescriptionMap: Support CXXOperatorCallExpr

[Charusso]

Summary

-

[NoQ]

clang/lib/StaticAnalyzer/Core/CallEvent.cpp

379

We still need to check the qualified name in this case. Eg., { "std", "unique_ptr", OO_Deref } and { "std", "shared_ptr", OO_Deref } may require different handling.

[NoQ]

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

1236–1240

Given the other comment, i suggest introducing the following overload: (ArrayRef<const char *> QualifiedName, OverloadedOperatorKind OOKind, Optional<unsigned> RequiredArgs = None, Optional<size_t> RequiredParams = None). Such overload is nice to read because the entire section that describes the name of the function stays together.

Let's not touch the overload with Flags for now because currently none of the flags apply to operators. We get there when we get there.

[Szelethus]

Mind that Signature in StdLibraryFunctionsChecker aims to achieve precise function call matching as well, and at the moment its a bit ahead. Some discussions can be found in D77410, D81745 and https://bugs.llvm.org/show_bug.cgi?id=46253.

[NoQ]

In D81059#2128437, @Szelethus wrote:

Mind that Signature in StdLibraryFunctionsChecker aims to achieve precise function call matching as well, and at the moment its a bit ahead. Some discussions can be found in D77410, D81745 and https://bugs.llvm.org/show_bug.cgi?id=46253.

As of now that one is entirely about signatures; this patch is mostly about function names. We should absolutely merge the signature work from StdLibraryFunctionsChecker into CallDescriptionMap and then convert StdLibraryFunctionsChecker to use CallDescriptionMap. But it shouldn't block this patch from landing in any way.

[Szelethus]

Well said!

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

public:
 
   /// Returns true if the CallEvent is a call to a function that matches
   /// the CallDescription.
   ///
   /// Note that this function is not intended to be used to match Obj-C method
   /// calls.
   bool isCalled(const CallDescription &CD) const;
 
+  /// \returns Whether the \p CD describing the same number of arguments and
+  ///          parameters of the current call.
+  bool isEqualArgsAndParams(const CallDescription &CD) const;
+
   /// Returns true whether the CallEvent is any of the CallDescriptions supplied
   /// as a parameter.
   template <typename FirstCallDesc, typename... CallDescs>
   bool isCalled(const FirstCallDesc &First, const CallDescs &... Rest) const {
     return isCalled(First) || isCalled(Rest...);
   }
 
   /// Returns a source range for the entire call, suitable for
class CallDescription {
 
   mutable IdentifierInfo *II = nullptr;
   mutable bool IsLookupDone = false;
   // The list of the qualified names used to identify the specified CallEvent,
   // e.g. "{a, b}" represent the qualified names, like "a::b".
   std::vector<const char *> QualifiedName;
   Optional<unsigned> RequiredArgs;
   Optional<size_t> RequiredParams;
+  Optional<OverloadedOperatorKind> OOKind;
   int Flags;
 
   // A constructor helper.
   static Optional<size_t> readRequiredParams(Optional<unsigned> RequiredArgs,
                                              Optional<size_t> RequiredParams) {
     if (RequiredParams)
       return RequiredParams;
     if (RequiredArgs)
public:
   /// For example, {"std", "basic_string", "c_str"} would match both
   /// std::basic_string<...>::c_str() and std::__1::basic_string<...>::c_str().
   ///
   /// @param RequiredArgs The number of arguments that is expected to match a
   /// call. Omit this parameter to match every occurrence of call with a given
   /// name regardless the number of arguments.
   CallDescription(int Flags, ArrayRef<const char *> QualifiedName,
                   Optional<unsigned> RequiredArgs = None,
-                  Optional<size_t> RequiredParams = None)
+                  Optional<size_t> RequiredParams = None,
+                  Optional<OverloadedOperatorKind> OOKind = None)
       : QualifiedName(QualifiedName), RequiredArgs(RequiredArgs),
         RequiredParams(readRequiredParams(RequiredArgs, RequiredParams)),
-        Flags(Flags) {}
+        OOKind(OOKind), Flags(Flags) {}
 
   /// Construct a CallDescription with default flags.
   CallDescription(ArrayRef<const char *> QualifiedName,
                   Optional<unsigned> RequiredArgs = None,
                   Optional<size_t> RequiredParams = None)
       : CallDescription(0, QualifiedName, RequiredArgs, RequiredParams) {}
 
+  /// Construct for CXXOperatorCallExpr using OverloadedOperatorKind.
+  CallDescription(OverloadedOperatorKind OOKind,
+                  Optional<unsigned> RequiredArgs = None,
+                  Optional<size_t> RequiredParams = None)
+      : CallDescription(0, "", RequiredArgs, RequiredParams, OOKind) {}
+
   /// Get the name of the function that this object matches.
   StringRef getFunctionName() const { return QualifiedName.back(); }
 };
 
 /// An immutable map from CallDescriptions to arbitrary data. Provides a unified
 /// way for checkers to react on function calls.
 template <typename T> class CallDescriptionMap {
   // Some call descriptions aren't easily hashable (eg., the ones with qualified

clang/lib/StaticAnalyzer/Core/CallEvent.cpp

ProgramPoint CallEvent::getProgramPoint(bool IsPreVisit,
   assert(D && "Cannot get a program point without a statement or decl");
 
   SourceLocation Loc = getSourceRange().getBegin();
   if (IsPreVisit)
     return PreImplicitCall(D, Loc, getLocationContext(), Tag);
   return PostImplicitCall(D, Loc, getLocationContext(), Tag);
 }
 
+bool CallEvent::isEqualArgsAndParams(const CallDescription &CD) const {
+  return (!CD.RequiredArgs || CD.RequiredArgs == getNumArgs()) &&
+         (!CD.RequiredParams || CD.RequiredParams == parameters().size());
+}
+
 bool CallEvent::isCalled(const CallDescription &CD) const {
   // FIXME: Add ObjC Message support.
   if (getKind() == CE_ObjCMessage)
     return false;
 
   if (!getDecl())
     return false;
 
   if (CD.Flags & CDF_MaybeBuiltin) {
     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(getDecl()))
       return CheckerContext::isCLibraryFunction(FD, CD.getFunctionName()) &&
              (!CD.RequiredArgs || CD.RequiredArgs <= getNumArgs()) &&
              (!CD.RequiredParams || CD.RequiredParams <= parameters().size());
     return false;
   }
 
+  if (CD.OOKind) {
+    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(getDecl()))
+      if (*CD.OOKind == FD->getOverloadedOperator())
+        return isEqualArgsAndParams(CD);
+
+    return false;
+  }
+
   if (!CD.IsLookupDone) {
     CD.IsLookupDone = true;
     CD.II = &getState()->getStateManager().getContext().Idents.get(
         CD.getFunctionName());
   }
 
   if (const IdentifierInfo *II = getCalleeIdentifier()) {
     if (II != CD.II)
for (; Ctx && isa<NamedDecl>(Ctx); Ctx = Ctx->getParent()) {
         continue;
       }
     }
 
     if (NumUnmatched > 0)
       return false;
   }
 
-  return (!CD.RequiredArgs || CD.RequiredArgs == getNumArgs()) &&
-         (!CD.RequiredParams || CD.RequiredParams == parameters().size());
+  return isEqualArgsAndParams(CD);
 }
 
 SVal CallEvent::getArgSVal(unsigned Index) const {
   const Expr *ArgE = getArgExpr(Index);
   if (!ArgE)
     return UnknownVal();
   return getSVal(ArgE);
 }

clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp

EXPECT_TRUE(tooling::runToolOnCode(
       "  typedef basic_string<char> string;"
       "}}"
       "void foo() {"
       "  using namespace std;"
       "  std::string s;"
       "}"));
 }
 
+TEST(CallDescriptionMap, CXXOperatorCallExpr) {
+  EXPECT_TRUE(tooling::runToolOnCode(
+      std::unique_ptr<CallDescriptionAction>(new CallDescriptionAction({
+          {OO_Plus, false},
+          {OO_GreaterGreater, true},
+      })),
+      "namespace std {"
+      "  template <typename CharT> class basic_istream{};"
+      "  template <typename CharT>"
+      "  basic_istream<CharT> &operator>>(basic_istream<CharT> &st, CharT *ch);"
+      "  typedef basic_istream<char> istream;"
+      "  extern istream cin;"
+      "}"
+      "void foo() {"
+      "  using namespace std;"
+      "  char buf[13];"
+      "  std::cin >> buf;"
+      "}"));
+}
+
+TEST(CallDescriptionMap, CXXOperatorCallExprArgumentCount) {
+  EXPECT_TRUE(tooling::runToolOnCode(
+      std::unique_ptr<CallDescriptionAction>(new CallDescriptionAction({
+          {{OO_GreaterGreater, 1}, false},
+          {{OO_GreaterGreater, 2}, true},
+      })),
+      "namespace std {"
+      "  template <typename CharT> class basic_istream{};"
+      "  template <typename CharT>"
+      "  basic_istream<CharT> &operator>>(basic_istream<CharT> &st, CharT *ch);"
+      "  typedef basic_istream<char> istream;"
+      "  extern istream cin;"
+      "}"
+      "void foo() {"
+      "  using namespace std;"
+      "  char buf[13];"
+      "  std::cin >> buf;"
+      "}"));
+}
+
 } // namespace
 } // namespace ento
 } // namespace clang