[llvm][analyzer][NFC] Introduce SFINAE for specializing FoldingSetTraits

[martong]

LGTM!

[steakhal]

• rebase

[bzcheeseman]

llvm/include/llvm/ADT/FoldingSet.h

260

supernit: I generally prefer named template parameters - can call it something like Enable?

834

supernit - the default type of std::enable_if_t is void so you don't need to specify it :)

[steakhal]

• Named SFINAE type parameter.
• Using default return value of enable_if_t

llvm/include/llvm/ADT/FoldingSet.h

260

Thanks!

834

Awesome!

clang/include/clang/Basic/SourceLocation.h

 #include <cassert>
 #include <cstdint>
 #include <string>
 #include <utility>
 
 namespace llvm {
 
 class FoldingSetNodeID;
-template <typename T> struct FoldingSetTrait;
+template <typename T, typename> struct FoldingSetTrait;
 
 } // namespace llvm
 
 namespace clang {
 
 class SourceManager;
 
 /// An opaque identifier used by SourceManager which refers to a

 /// In addition, one bit of SourceLocation is used for quick access to the
 /// information whether the location is in a file or a macro expansion.
 ///
 /// It is important that this type remains small. It is currently 32 bits wide.
 class SourceLocation {
   friend class ASTReader;
   friend class ASTWriter;
   friend class SourceManager;
-  friend struct llvm::FoldingSetTrait<SourceLocation>;
+  friend struct llvm::FoldingSetTrait<SourceLocation, void>;
 
 public:
   using UIntTy = uint32_t;
   using IntTy = int32_t;
 
 private:
   UIntTy ID = 0;
 
template <> struct DenseMapInfo<clang::SourceLocation, void> {
     }
 
     static bool isEqual(clang::SourceLocation LHS, clang::SourceLocation RHS) {
       return LHS == RHS;
     }
   };
 
   // Allow calling FoldingSetNodeID::Add with SourceLocation object as parameter
-  template <> struct FoldingSetTrait<clang::SourceLocation> {
+  template <> struct FoldingSetTrait<clang::SourceLocation, void> {
     static void Profile(const clang::SourceLocation &X, FoldingSetNodeID &ID);
   };
 
 } // namespace llvm
 
 #endif // LLVM_CLANG_BASIC_SOURCELOCATION_H

clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp

enum SelfFlagEnum {
   SelfFlag_None = 0x0,
   /// Value came from 'self'.
   SelfFlag_Self    = 0x1,
   /// Value came from the result of an initializer (e.g. [super init]).
   SelfFlag_InitRes = 0x2
 };
 }
 
-REGISTER_MAP_WITH_PROGRAMSTATE(SelfFlag, SymbolRef, unsigned)
+REGISTER_MAP_WITH_PROGRAMSTATE(SelfFlag, SymbolRef, SelfFlagEnum)
 REGISTER_TRAIT_WITH_PROGRAMSTATE(CalledInit, bool)
 
 /// A call receiving a reference to 'self' invalidates the object that
 /// 'self' contains. This keeps the "self flags" assigned to the 'self'
 /// object before the call so we can assign them to the new object that 'self'
 /// points to after the call.
 REGISTER_TRAIT_WITH_PROGRAMSTATE(PreCallSelfFlags, SelfFlagEnum)
 
 static SelfFlagEnum getSelfFlags(SVal val, ProgramStateRef state) {
   if (SymbolRef sym = val.getAsSymbol())
-    if (const unsigned *attachedFlags = state->get<SelfFlag>(sym))
-      return (SelfFlagEnum)*attachedFlags;
+    if (const SelfFlagEnum *attachedFlags = state->get<SelfFlag>(sym))
+      return *attachedFlags;
   return SelfFlag_None;
 }
 
 static SelfFlagEnum getSelfFlags(SVal val, CheckerContext &C) {
   return getSelfFlags(val, C.getState());
 }
 
 static void addSelfFlag(ProgramStateRef state, SVal val,
                         SelfFlagEnum flag, CheckerContext &C) {
   // We tag the symbol that the SVal wraps.
   if (SymbolRef sym = val.getAsSymbol()) {
-    state = state->set<SelfFlag>(sym, getSelfFlags(val, state) | flag);
+    state = state->set<SelfFlag>(sym,
+                                 SelfFlagEnum(getSelfFlags(val, state) | flag));
     C.addTransition(state);
   }
 }
 
 static bool hasSelfFlag(SVal val, SelfFlagEnum flag, CheckerContext &C) {
   return getSelfFlags(val, C) & flag;
 }
 

 void ObjCSelfInitChecker::checkPostCall(const CallEvent &CE,
                                         CheckerContext &C) const {
   // FIXME: A callback should disable checkers at the start of functions.
   if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
                                  C.getCurrentAnalysisDeclContext()->getDecl())))
     return;
 
   ProgramStateRef state = C.getState();
-  SelfFlagEnum prevFlags = (SelfFlagEnum)state->get<PreCallSelfFlags>();
+  SelfFlagEnum prevFlags = state->get<PreCallSelfFlags>();
   if (!prevFlags)
     return;
   state = state->remove<PreCallSelfFlags>();
 
   unsigned NumArgs = CE.getNumArgs();
   for (unsigned i = 0; i < NumArgs; ++i) {
     SVal argV = CE.getArgSVal(i);
     if (isSelfVar(argV, C)) {
if ((isSelfVar(loc, C)) &&
     C.addTransition(State);
   }
 }
 
 void ObjCSelfInitChecker::printState(raw_ostream &Out, ProgramStateRef State,
                                      const char *NL, const char *Sep) const {
   SelfFlagTy FlagMap = State->get<SelfFlag>();
   bool DidCallInit = State->get<CalledInit>();
-  SelfFlagEnum PreCallFlags = (SelfFlagEnum)State->get<PreCallSelfFlags>();
+  SelfFlagEnum PreCallFlags = State->get<PreCallSelfFlags>();
 
   if (FlagMap.isEmpty() && !DidCallInit && !PreCallFlags)
     return;
 
   Out << Sep << NL << *this << " :" << NL;
 
   if (DidCallInit)
     Out << "  An init method has been called." << NL;

llvm/include/llvm/ADT/FoldingSet.h

 
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/Support/Allocator.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <type_traits>
 #include <utility>
 
 namespace llvm {
 
 /// This folding set used for two purposes:
 ///   1. Given information about a node we want to create, look up the unique
 ///      instance of the node in the set.  If the node already exists, return
 ///      it, otherwise return the bucket it should be inserted into.

 };
 
 /// FoldingSetTrait - This trait class is used to define behavior of how
 /// to "profile" (in the FoldingSet parlance) an object of a given type.
 /// The default behavior is to invoke a 'Profile' method on an object, but
 /// through template specialization the behavior can be tailored for specific
 /// types.  Combined with the FoldingSetNodeWrapper class, one can add objects
 /// to FoldingSets that were not originally designed to have that behavior.
-template<typename T> struct FoldingSetTrait
-  : public DefaultFoldingSetTrait<T> {};
+template <typename T, typename = /*For SFINAE*/ void>
+struct FoldingSetTrait : public DefaultFoldingSetTrait<T> {};
 
 /// DefaultContextualFoldingSetTrait - Like DefaultFoldingSetTrait, but
 /// for ContextualFoldingSets.
 template<typename T, typename Ctx>
 struct DefaultContextualFoldingSetTrait {
   static void Profile(T &X, FoldingSetNodeID &ID, Ctx Context) {
     X.Profile(ID, Context);
   }

 struct FoldingSetTrait<std::pair<T1, T2>> {
   static inline void Profile(const std::pair<T1, T2> &P,
                              FoldingSetNodeID &ID) {
     ID.Add(P.first);
     ID.Add(P.second);
   }
 };
 
+template <typename T>
+struct FoldingSetTrait<
+    T, typename std::enable_if_t<std::is_enum<T>::value, void>> {
+  static void Profile(const T &X, FoldingSetNodeID &ID) {
+    ID.AddInteger(static_cast<typename std::underlying_type_t<T>>(X));
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_ADT_FOLDINGSET_H

llvm/include/llvm/CodeGen/SelectionDAG.h

 class DIExpression;
 class DILabel;
 class DIVariable;
 class Function;
 class Pass;
 class Type;
 template <class GraphType> struct GraphTraits;
 template <typename T, unsigned int N> class SmallSetVector;
-template <typename T> struct FoldingSetTrait;
+template <typename T, typename> struct FoldingSetTrait;
 class AAResults;
 class BlockAddress;
 class BlockFrequencyInfo;
 class Constant;
 class ConstantFP;
 class ConstantInt;
 class DataLayout;
 struct fltSemantics;