[analyzer] CallDescription: Improve array management.

[NoQ]

Summary

CallDescription constructor now accepts an ArrayRef<const char *>, instead of two different constructors for StringRef and std::vector<StringRef>.

This allows us to write an init-list of a vector of CallDescription objects as:

vector<CallDescription> V = {
  { { "foo" }, 1 },
  { { "q1", "q2", "bar" }, 2 },
  ...
};

achieving uniformity between unqualified and qualified descriptions, while still allowing the old syntax of { "foo", 1 } (without braces around "foo"). Previously { { "foo" }, 1 } wouldn't have compiled, because the compiler was unable to figure out which constructor to call (because {} are allowed to be omitted or added indefinitely as a redundancy).

As a cost of that, i had to switch from StringRefs to raw pointers, because you can't automatically convert an initializer-list of C strings to an ArrayRef of StringRefs. But that doesn't seem bad, because StringRefs aren't that much different from raw pointers, and in practice only static strings will be used.

Also squash a mutable copy of that array.

[george.karpenkov]

Strictly speaking those two seem like completely unrelated changes , right?

[NoQ]

Yeah, i guess i should've split those up.

Well, i had to fix the other code when i fixed the first code, because it contains a hardcoded duplicate of the vector type. So i decided to fix it in a slightly more intelligent manner.

[MTC]

Thank you for digging in to delete that meaningless constructor, NoQ! And sorry for my technology debt : ).

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

 /// arguments and the name of the function.
 class CallDescription {
   friend CallEvent;
 
   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<StringRef> QualifiedName;
+  std::vector<const char *> QualifiedName;
   unsigned RequiredArgs;
 
 public:
   const static unsigned NoArgRequirement = std::numeric_limits<unsigned>::max();
 
   /// Constructs a CallDescription object.
   ///
-  /// @param QualifiedName The list of the qualified names of the function that
-  /// will be matched. It does not require the user to provide the full list of
-  /// the qualified name. The more details provided, the more accurate the
-  /// matching.
+  /// @param QualifiedName The list of the name qualifiers of the function that
+  /// will be matched. The user is allowed to skip any of the qualifiers.
+  /// 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(std::vector<StringRef> QualifiedName,
+  CallDescription(ArrayRef<const char *> QualifiedName,
                   unsigned RequiredArgs = NoArgRequirement)
       : QualifiedName(QualifiedName), RequiredArgs(RequiredArgs) {}
 
-  /// Constructs a CallDescription object.
-  ///
-  /// @param FuncName The name of the function that will be matched.
-  ///
-  /// @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(StringRef FuncName, unsigned RequiredArgs = NoArgRequirement)
-      : CallDescription(std::vector<StringRef>({FuncName}), NoArgRequirement) {
-  }
-
   /// Get the name of the function that this object matches.
   StringRef getFunctionName() const { return QualifiedName.back(); }
 };
 
 template<typename T = CallEvent>
 class CallEventRef : public IntrusiveRefCntPtr<const T> {
 public:
   CallEventRef(const T *Call) : IntrusiveRefCntPtr<const T>(Call) {}

lib/StaticAnalyzer/Core/CallEvent.cpp

bool CallEvent::isCalled(const CallDescription &CD) const {
   if (!II || II != CD.II)
     return false;
 
   const Decl *D = getDecl();
   // If CallDescription provides prefix names, use them to improve matching
   // accuracy.
   if (CD.QualifiedName.size() > 1 && D) {
     const DeclContext *Ctx = D->getDeclContext();
-    std::vector<StringRef> QualifiedName = CD.QualifiedName;
-    QualifiedName.pop_back();
+    // See if we'll be able to match them all.
+    size_t NumUnmatched = CD.QualifiedName.size() - 1;
     for (; Ctx && isa<NamedDecl>(Ctx); Ctx = Ctx->getParent()) {
+      if (NumUnmatched == 0)
+        break;
+
       if (const auto *ND = dyn_cast<NamespaceDecl>(Ctx)) {
-        if (!QualifiedName.empty() && ND->getName() == QualifiedName.back())
-          QualifiedName.pop_back();
+        if (ND->getName() == CD.QualifiedName[NumUnmatched - 1])
+          --NumUnmatched;
         continue;
       }
 
       if (const auto *RD = dyn_cast<RecordDecl>(Ctx)) {
-        if (!QualifiedName.empty() && RD->getName() == QualifiedName.back())
-          QualifiedName.pop_back();
+        if (RD->getName() == CD.QualifiedName[NumUnmatched - 1])
+          --NumUnmatched;
         continue;
       }
     }
 
-    if (!QualifiedName.empty())
+    if (NumUnmatched > 0)
       return false;
   }
 
   return (CD.RequiredArgs == CallDescription::NoArgRequirement ||
           CD.RequiredArgs == getNumArgs());
 }
 
 SVal CallEvent::getArgSVal(unsigned Index) const {