[analyzer][NFC] Use enum for CallDescription flags

[steakhal]

Summary

Yeah, let's prefer a slightly stronger type representing this.

[steakhal]

According to my comparative measurement, the whole change stack did not introduce any space and time overhead to the baseline. No reports changed. No crashes were introduced.
I tested about 12 projects or so.

[steakhal]

rebase

[martong]

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

38

The comment above is off now as that should go for CDF_MaybeBuiltin.
Also could you please add a menaningful comment for what CDF_None represents?

[steakhal]

• move the CDF_None above the comment block

[steakhal]

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

38

FIxed by now. Although I'm not sure we need to elaborate none.

[martong]

LGTM

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

 
 namespace clang {
 class IdentifierInfo;
 } // namespace clang
 
 namespace clang {
 namespace ento {
 
-enum CallDescriptionFlags : int {
+enum CallDescriptionFlags : unsigned {
+  CDF_None = 0,
+
   /// Describes a C standard function that is sometimes implemented as a macro
   /// that expands to a compiler builtin with some __builtin prefix.
   /// The builtin may as well have a few extra arguments on top of the requested
   /// number of arguments.
   CDF_MaybeBuiltin = 1 << 0,
 };
 
 /// 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;
   using MaybeUInt = Optional<unsigned>;
 
public:
   /// @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(int Flags, ArrayRef<const char *> QualifiedName,
+  CallDescription(CallDescriptionFlags Flags,
+                  ArrayRef<const char *> QualifiedName,
                   MaybeUInt RequiredArgs = None,
                   MaybeUInt RequiredParams = None);
 
   /// Construct a CallDescription with default flags.
   CallDescription(ArrayRef<const char *> QualifiedName,
                   MaybeUInt RequiredArgs = None,
                   MaybeUInt RequiredParams = None);
 

clang/lib/StaticAnalyzer/Checkers/ContainerModeling.cpp

public:
   using NoItParamFn = void (ContainerModeling::*)(CheckerContext &, SVal,
                                                   const Expr *) const;
   using OneItParamFn = void (ContainerModeling::*)(CheckerContext &, SVal,
                                                    SVal) const;
   using TwoItParamFn = void (ContainerModeling::*)(CheckerContext &, SVal, SVal,
                                                    SVal) const;
 
   CallDescriptionMap<NoItParamFn> NoIterParamFunctions = {
-    {{0, "clear", 0},
-     &ContainerModeling::handleClear},
-    {{0, "assign", 2},
-     &ContainerModeling::handleAssign},
-    {{0, "push_back", 1},
-     &ContainerModeling::handlePushBack},
-    {{0, "emplace_back", 1},
-     &ContainerModeling::handlePushBack},
-    {{0, "pop_back", 0},
-     &ContainerModeling::handlePopBack},
-    {{0, "push_front", 1},
-     &ContainerModeling::handlePushFront},
-    {{0, "emplace_front", 1},
-     &ContainerModeling::handlePushFront},
-    {{0, "pop_front", 0},
-     &ContainerModeling::handlePopFront},
+      {{"clear", 0}, &ContainerModeling::handleClear},
+      {{"assign", 2}, &ContainerModeling::handleAssign},
+      {{"push_back", 1}, &ContainerModeling::handlePushBack},
+      {{"emplace_back", 1}, &ContainerModeling::handlePushBack},
+      {{"pop_back", 0}, &ContainerModeling::handlePopBack},
+      {{"push_front", 1}, &ContainerModeling::handlePushFront},
+      {{"emplace_front", 1}, &ContainerModeling::handlePushFront},
+      {{"pop_front", 0}, &ContainerModeling::handlePopFront},
   };
-                                                          
   CallDescriptionMap<OneItParamFn> OneIterParamFunctions = {
-    {{0, "insert", 2},
-     &ContainerModeling::handleInsert},
-    {{0, "emplace", 2},
-     &ContainerModeling::handleInsert},
-    {{0, "erase", 1},
-     &ContainerModeling::handleErase},
-    {{0, "erase_after", 1},
-     &ContainerModeling::handleEraseAfter},
+      {{"insert", 2}, &ContainerModeling::handleInsert},
+      {{"emplace", 2}, &ContainerModeling::handleInsert},
+      {{"erase", 1}, &ContainerModeling::handleErase},
+      {{"erase_after", 1}, &ContainerModeling::handleEraseAfter},
   };
-                                                          
   CallDescriptionMap<TwoItParamFn> TwoIterParamFunctions = {
-    {{0, "erase", 2},
-     &ContainerModeling::handleErase},
-    {{0, "erase_after", 2},
-     &ContainerModeling::handleEraseAfter},
+      {{"erase", 2}, &ContainerModeling::handleErase},
+      {{"erase_after", 2}, &ContainerModeling::handleEraseAfter},
   };
-                                                          
 };
 
 bool isBeginCall(const FunctionDecl *Func);
 bool isEndCall(const FunctionDecl *Func);
 bool hasSubscriptOperator(ProgramStateRef State, const MemRegion *Reg);
 bool frontModifiable(ProgramStateRef State, const MemRegion *Reg);
 bool backModifiable(ProgramStateRef State, const MemRegion *Reg);
 SymbolRef getContainerBegin(ProgramStateRef State, const MemRegion *Cont);

clang/lib/StaticAnalyzer/Checkers/DebugContainerModeling.cpp

class DebugContainerModeling
   void analyzerContainerBegin(const CallExpr *CE, CheckerContext &C) const;
   void analyzerContainerEnd(const CallExpr *CE, CheckerContext &C) const;
   ExplodedNode *reportDebugMsg(llvm::StringRef Msg, CheckerContext &C) const;
 
   typedef void (DebugContainerModeling::*FnCheck)(const CallExpr *,
                                                  CheckerContext &) const;
 
   CallDescriptionMap<FnCheck> Callbacks = {
-    {{0, "clang_analyzer_container_begin", 1},
+      {{"clang_analyzer_container_begin", 1},
        &DebugContainerModeling::analyzerContainerBegin},
-    {{0, "clang_analyzer_container_end", 1},
+      {{"clang_analyzer_container_end", 1},
        &DebugContainerModeling::analyzerContainerEnd},
   };
 
 public:
   DebugContainerModeling();
 
   bool evalCall(const CallEvent &Call, CheckerContext &C) const;
 };
 

clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp

class DebugIteratorModeling
   void analyzerIteratorContainer(const CallExpr *CE, CheckerContext &C) const;
   void analyzerIteratorValidity(const CallExpr *CE, CheckerContext &C) const;
   ExplodedNode *reportDebugMsg(llvm::StringRef Msg, CheckerContext &C) const;
 
   typedef void (DebugIteratorModeling::*FnCheck)(const CallExpr *,
                                                  CheckerContext &) const;
 
   CallDescriptionMap<FnCheck> Callbacks = {
-    {{0, "clang_analyzer_iterator_position", 1},
+      {{"clang_analyzer_iterator_position", 1},
        &DebugIteratorModeling::analyzerIteratorPosition},
-    {{0, "clang_analyzer_iterator_container", 1},
+      {{"clang_analyzer_iterator_container", 1},
        &DebugIteratorModeling::analyzerIteratorContainer},
-    {{0, "clang_analyzer_iterator_validity", 1},
+      {{"clang_analyzer_iterator_validity", 1},
        &DebugIteratorModeling::analyzerIteratorValidity},
   };
 
 public:
   DebugIteratorModeling();
 
   bool evalCall(const CallEvent &Call, CheckerContext &C) const;
 };
 

clang/lib/StaticAnalyzer/Core/CallDescription.cpp

static MaybeUInt readRequiredParams(MaybeUInt RequiredArgs,
                                     MaybeUInt RequiredParams) {
   if (RequiredParams)
     return RequiredParams;
   if (RequiredArgs)
     return RequiredArgs;
   return None;
 }
 
-ento::CallDescription::CallDescription(int Flags,
+ento::CallDescription::CallDescription(CallDescriptionFlags Flags,
                                        ArrayRef<const char *> QualifiedName,
                                        MaybeUInt RequiredArgs /*= None*/,
                                        MaybeUInt RequiredParams /*= None*/)
     : 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,
                                        MaybeUInt RequiredArgs /*= None*/,
                                        MaybeUInt RequiredParams /*= None*/)
-    : CallDescription(0, QualifiedName, RequiredArgs, RequiredParams) {}
+    : CallDescription(CDF_None, QualifiedName, RequiredArgs, RequiredParams) {}
 
 bool ento::CallDescription::matches(const CallEvent &Call) const {
   // FIXME: Add ObjC Message support.
   if (Call.getKind() == CE_ObjCMessage)
     return false;
 
   const auto *FD = dyn_cast_or_null<FunctionDecl>(Call.getDecl());
   if (!FD)