[analyzer][NFC] CallDescription should own the qualified name parts

[steakhal]

Summary

Previously, CallDescription simply referred to the qualified name parts
by const char* pointers.
In the future, we might want to dynamically load and populate
CallDescriptionMaps, hence we will need the CallDescriptions to
actually own their qualified name parts.

[steakhal]

rebase

[NoQ]

Why though? Are you actually putting anything in there that isn't a static string literal?

[steakhal]

In D113593#3136435, @NoQ wrote:

Why though? Are you actually putting anything in there that isn't a static string literal?

If we plan in the future to dynamically populate CallDescriptionMaps then we will need owning semantics for CallDescriptions actually owning the qualified name parts.
Consider the GenericTaintChecker, which currently implements an ad-hoc function call matching just because of this.
Ideally, what we want is just parsing the config and populating the corresponding maps.
On the other hand, it could come in handy in the StdLibraryChecker as well, if we decide to hoist the DSL and let users specify their API in config files in a similar manner.

[martong]

LGTM!

[steakhal]

rebase

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

 
 /// This class represents a description of a function call using the number of
 /// arguments and the name of the function.
 class CallDescription {
   friend class CallEvent;
   mutable Optional<const IdentifierInfo *> II;
   // 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;
+  std::vector<std::string> QualifiedName;
   Optional<unsigned> RequiredArgs;
   Optional<size_t> RequiredParams;
   int Flags;
 
 public:
   /// Constructs a CallDescription object.
   ///
   /// @param QualifiedName The list of the name qualifiers of the function that

clang/lib/StaticAnalyzer/Core/CallDescription.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
+#include <iterator>
 
 using namespace llvm;
 using namespace clang;
 
 // A constructor helper.
 static Optional<size_t> readRequiredParams(Optional<unsigned> RequiredArgs,
                                            Optional<size_t> RequiredParams) {
   if (RequiredParams)
     return RequiredParams;
   if (RequiredArgs)
     return static_cast<size_t>(*RequiredArgs);
   return None;
 }
 
 ento::CallDescription::CallDescription(
     int Flags, ArrayRef<const char *> QualifiedName,
     Optional<unsigned> RequiredArgs /*= None*/,
     Optional<size_t> RequiredParams /*= None*/)
-    : QualifiedName(QualifiedName), RequiredArgs(RequiredArgs),
+    : RequiredArgs(RequiredArgs),
       RequiredParams(readRequiredParams(RequiredArgs, RequiredParams)),
       Flags(Flags) {
   assert(!QualifiedName.empty());
+  this->QualifiedName.reserve(QualifiedName.size());
+  llvm::copy(QualifiedName, std::back_inserter(this->QualifiedName));
 }
 
 /// Construct a CallDescription with default flags.
 ento::CallDescription::CallDescription(
     ArrayRef<const char *> QualifiedName,
     Optional<unsigned> RequiredArgs /*= None*/,
     Optional<size_t> RequiredParams /*= None*/)
     : CallDescription(0, QualifiedName, RequiredArgs, RequiredParams) {}