[analyzer][NFC] Introduce CallDescriptionSets

[steakhal]

Summary

Sometimes we only want to decide if some function is called, and we
don't care which of the set.
This CallDescriptionSet will have the same behavior, except
instead of lookup() returning a pointer to the mapped value,
the contains() returns bool.
Internally, it uses the CallDescriptionMap<bool> for implementing the
behavior. It is preferred, to reuse the generic
CallDescriptionMap::lookup() logic, instead of duplicating it.
The generic version might be improved by implementing a hash lookup or
something along those lines.

[martong]

I was thinking about that perhaps a higher level of abstraction would be useful.
Something like.

auto FM = FunctionMatcher{"foo", "bar"};
//....
if (FM.matches(CallEvent))
  //...

using FunctionMatcher = CallDescriptionMap<void>;

?

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

123

Could you please add some documentation that this could be used if the user only want to decide if some function is called/matched?

[steakhal]

In D113589#3127664, @martong wrote:

I was thinking about that perhaps a higher level of abstraction would be useful.
Something like.

auto FM = FunctionMatcher{"foo", "bar"};
//....
if (FM.matches(CallEvent))
  //...

using FunctionMatcher = CallDescriptionMap<void>;

I don't know. I don't really want to introduce yet another entity. They do the same basically. You can convince me though.

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

123

Great point! I'll.

[Szelethus]

I recognize the problem, but don't agree with the solution: this is a CallDescriptionSet at this point, not a CallDescriptionMap. Also, I just don't think this is the place to use template specialization, nor do I think we should keep the function name lookup, if we only care about whether the call is in the set or not.

[steakhal]

• define the CallDescriptionSet class, by wrapping a CallDescriptionMap
• add doc comments about the class

[steakhal]

In D113589#3131051, @Szelethus wrote:

I recognize the problem, but don't agree with the solution: this is a CallDescriptionSet at this point, not a CallDescriptionMap. Also, I just don't think this is the place to use template specialization, nor do I think we should keep the function name lookup, if we only care about whether the call is in the set or not.

You are right! Fixed by now.

[martong]

Very good! LGTM!

[Szelethus]

LGTM!

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

public:
   /// It's false, if and only if we expect a single identifier, such as
   /// `getenv`. It's true for `std::swap`, or `my::detail::container::data`.
   bool hasQualifiedNameParts() const { return QualifiedName.size() > 1; }
 };
 
 /// An immutable map from CallDescriptions to arbitrary data. Provides a unified
 /// way for checkers to react on function calls.
 template <typename T> class CallDescriptionMap {
+  friend class CallDescriptionSet;
+
   // Some call descriptions aren't easily hashable (eg., the ones with qualified
   // names in which some sections are omitted), so let's put them
   // in a simple vector and use linear lookup.
   // TODO: Implement an actual map for fast lookup for "hashable" call
   // descriptions (eg., the ones for C functions that just match the name).
   std::vector<std::pair<CallDescription, T>> LinearMap;
 
 public:
LLVM_NODISCARD const T *lookup(const CallEvent &Call) const {
     for (const std::pair<CallDescription, T> &I : LinearMap)
       if (Call.isCalled(I.first))
         return &I.second;
 
     return nullptr;
   }
 };
 
+/// An immutable set of CallDescriptions.
+/// Checkers can efficiently decide if a given CallEvent matches any
+/// CallDescription in the set.
+class CallDescriptionSet {
+  CallDescriptionMap<bool /*unused*/> Impl = {};
+
+public:
+  CallDescriptionSet(std::initializer_list<CallDescription> &&List);
+
+  CallDescriptionSet(const CallDescriptionSet &) = delete;
+  CallDescriptionSet &operator=(const CallDescription &) = delete;
+
+  LLVM_NODISCARD bool contains(const CallEvent &Call) const;
+};
+
 } // namespace ento
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CALLDESCRIPTION_H

clang/lib/StaticAnalyzer/Core/CallDescription.cpp

 }
 
 /// 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) {}
+
+ento::CallDescriptionSet::CallDescriptionSet(
+    std::initializer_list<CallDescription> &&List) {
+  Impl.LinearMap.reserve(List.size());
+  for (const CallDescription &CD : List)
+    Impl.LinearMap.push_back({CD, /*unused*/ true});
+}
+
+bool ento::CallDescriptionSet::contains(const CallEvent &Call) const {
+  return static_cast<bool>(Impl.lookup(Call));
+}