[analyzer][NFC] Add partial specializations for ProgramStateTraits

[steakhal]

Summary

Also, specialize it for enums.

[martong]

Nice!

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

278–279

How is it different than the partial specialization for integral types? Could we have the 2 contracted?

[steakhal]

• host common implementation

[martong]

LGTM!

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

290–293

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

 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H
 
 #include "llvm/ADT/ImmutableList.h"
 #include "llvm/ADT/ImmutableMap.h"
 #include "llvm/ADT/ImmutableSet.h"
 #include "llvm/Support/Allocator.h"
 #include <cstdint>
+#include <type_traits>
 
 namespace clang {
 namespace ento {
 
-  template <typename T> struct ProgramStatePartialTrait;
+template <typename T, typename Enable = void> struct ProgramStatePartialTrait;
 
-  /// Declares a program state trait for type \p Type called \p Name, and
-  /// introduce a type named \c NameTy.
-  /// The macro should not be used inside namespaces.
-  #define REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, Type) \
-    namespace { \
-      class Name {}; \
-      using Name ## Ty = Type; \
-    } \
-    namespace clang { \
-    namespace ento { \
-      template <> \
-      struct ProgramStateTrait<Name> \
-        : public ProgramStatePartialTrait<Name ## Ty> { \
-        static void *GDMIndex() { static int Index; return &Index; } \
-      }; \
-    } \
-    }
+#define REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, Type)                           \
+  namespace {                                                                  \
+  class Name {};                                                               \
+  using Name##Ty = Type;                                                       \
+  }                                                                            \
+  namespace clang {                                                            \
+  namespace ento {                                                             \
+  template <>                                                                  \
+  struct ProgramStateTrait<Name> : public ProgramStatePartialTrait<Name##Ty> { \
+    static void *GDMIndex() {                                                  \
+      static int Index;                                                        \
+      return &Index;                                                           \
+    }                                                                          \
+  };                                                                           \
+  }                                                                            \
 
   /// Declares a factory for objects of type \p Type in the program state
   /// manager. The type must provide a ::Factory sub-class. Commonly used for
   /// ImmutableMap, ImmutableSet, ImmutableList. The macro should not be used
   /// inside namespaces.
   #define REGISTER_FACTORY_WITH_PROGRAMSTATE(Type) \
     namespace clang { \
     namespace ento { \
static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
       return new typename data_type::Factory(Alloc);
     }
 
     static void DeleteContext(void *Ctx) {
       delete (typename data_type::Factory *) Ctx;
     }
   };
 
-  // Partial specialization for bool.
-  template <> struct ProgramStatePartialTrait<bool> {
-    using data_type = bool;
-
-    static data_type MakeData(void *const *p) {
-      return p ? (data_type) (uintptr_t) *p
-               : data_type();
-    }
-
-    static void *MakeVoidPtr(data_type d) {
-      return (void *) (uintptr_t) d;
-    }
-  };
-
-  // Partial specialization for unsigned.
-  template <> struct ProgramStatePartialTrait<unsigned> {
-    using data_type = unsigned;
-
-    static data_type MakeData(void *const *p) {
-      return p ? (data_type) (uintptr_t) *p
-               : data_type();
-    }
-
-    static void *MakeVoidPtr(data_type d) {
-      return (void *) (uintptr_t) d;
-    }
-  };
-
-  // Partial specialization for void*.
-  template <> struct ProgramStatePartialTrait<void *> {
-    using data_type = void *;
-
-    static data_type MakeData(void *const *p) {
-      return p ? *p
-               : data_type();
-    }
-
-    static void *MakeVoidPtr(data_type d) {
-      return d;
-    }
+  template <typename T> struct DefaultProgramStatePartialTraitImpl {
+    using data_type = T;
+    static T MakeData(void *const *P) { return P ? (T)(uintptr_t)*P : T{}; }
+    static void *MakeVoidPtr(T D) { return (void *)(uintptr_t)D; }
   };
 
-  // Partial specialization for const void *.
-  template <> struct ProgramStatePartialTrait<const void *> {
-    using data_type = const void *;
+  // Partial specialization for integral types.
+  template <typename T>
+  struct ProgramStatePartialTrait<T,
+                                  std::enable_if_t<std::is_integral<T>::value>>
+      : DefaultProgramStatePartialTraitImpl<T> {};
 
-    static data_type MakeData(void *const *p) {
-      return p ? *p : data_type();
-    }
+  // Partial specialization for enums.
+  template <typename T>
+  struct ProgramStatePartialTrait<T, std::enable_if_t<std::is_enum<T>::value>>
+      : DefaultProgramStatePartialTraitImpl<T> {};
 
-    static void *MakeVoidPtr(data_type d) {
-      return const_cast<void *>(d);
-    }
-  };
+  // Partial specialization for pointers.
+  template <typename T>
+  struct ProgramStatePartialTrait<T *, void>
+      : DefaultProgramStatePartialTraitImpl<T *> {};
 
 } // namespace ento
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_PROGRAMSTATETRAIT_H

clang/lib/StaticAnalyzer/Checkers/cert/InvalidPtrChecker.cpp

 };
 
 } // namespace
 
 // Set of memory regions that were invalidated
 REGISTER_SET_WITH_PROGRAMSTATE(InvalidMemoryRegions, const MemRegion *)
 
 // Stores the region of the environment pointer of 'main' (if present).
-// Note: This pointer has type 'const MemRegion *', however the trait is only
-// specialized to 'const void*' and 'void*'
-REGISTER_TRAIT_WITH_PROGRAMSTATE(EnvPtrRegion, const void *)
+REGISTER_TRAIT_WITH_PROGRAMSTATE(EnvPtrRegion, const MemRegion *)
 
 // Stores key-value pairs, where key is function declaration and value is
 // pointer to memory region returned by previous call of this function
 REGISTER_MAP_WITH_PROGRAMSTATE(PreviousCallResultMap, const FunctionDecl *,
                                const MemRegion *)
 
 void InvalidPtrChecker::EnvpInvalidatingCall(const CallEvent &Call,
                                              CheckerContext &C) const {
   StringRef FunctionName = Call.getCalleeIdentifier()->getName();
   ProgramStateRef State = C.getState();
-  const auto *Reg = State->get<EnvPtrRegion>();
-  if (!Reg)
+  const MemRegion *SymbolicEnvPtrRegion = State->get<EnvPtrRegion>();
+  if (!SymbolicEnvPtrRegion)
     return;
-  const auto *SymbolicEnvPtrRegion =
-      reinterpret_cast<const MemRegion *>(const_cast<const void *>(Reg));
 
   State = State->add<InvalidMemoryRegions>(SymbolicEnvPtrRegion);
 
   const NoteTag *Note =
       C.getNoteTag([SymbolicEnvPtrRegion, FunctionName](
                        PathSensitiveBugReport &BR, llvm::raw_ostream &Out) {
         if (!BR.isInteresting(SymbolicEnvPtrRegion))
           return;
if (!FD || FD->param_size() != 3 || !FD->isMain())
     return;
 
   ProgramStateRef State = C.getState();
   const MemRegion *EnvpReg =
       State->getRegion(FD->parameters()[2], C.getLocationContext());
 
   // Save the memory region pointed by the environment pointer parameter of
   // 'main'.
-  State = State->set<EnvPtrRegion>(
-      reinterpret_cast<void *>(const_cast<MemRegion *>(EnvpReg)));
-  C.addTransition(State);
+  C.addTransition(State->set<EnvPtrRegion>(EnvpReg));
 }
 
 // Check if invalidated region is being dereferenced.
 void InvalidPtrChecker::checkLocation(SVal Loc, bool isLoad, const Stmt *S,
                                       CheckerContext &C) const {
   ProgramStateRef State = C.getState();
 
   // Ignore memory operations involving 'non-invalidated' locations.