[analyzer][NFC] Use idiomatic classof instead of isKind

[steakhal]

Summary

• Rename isKind() to classof() to follow the llvm style RTTI.
• Take SVal by-value instead of reference.
• Mark classof public.

[martong]

LGTM

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

 
 public:
   explicit SVal() = default;
 
   /// Convert to the specified SVal type, asserting that this SVal is of
   /// the desired type.
   template<typename T>
   T castAs() const {
-    assert(T::isKind(*this));
+    assert(T::classof(*this));
     return *static_cast<const T *>(this);
   }
 
   /// Convert to the specified SVal type, returning None if this SVal is
   /// not of the desired type.
   template<typename T>
   Optional<T> getAs() const {
-    if (!T::isKind(*this))
+    if (!T::classof(*this))
       return None;
     return *static_cast<const T *>(this);
   }
 
   unsigned getRawKind() const { return Kind; }
   BaseKind getBaseKind() const { return (BaseKind) (Kind & BaseMask); }
   unsigned getSubKind() const { return Kind >> BaseBits; }
 
   // This method is required for using SVal in a FoldingSetNode.  It
   // extracts a unique signature for this SVal object.
   void Profile(llvm::FoldingSetNodeID &ID) const {
     ID.AddInteger((unsigned) getRawKind());
     ID.AddPointer(Data);
   }
 
-  bool operator==(const SVal &R) const {
+  bool operator==(SVal R) const {
     return getRawKind() == R.getRawKind() && Data == R.Data;
   }
 
-  bool operator!=(const SVal &R) const {
-    return !(*this == R);
-  }
+  bool operator!=(SVal R) const { return !(*this == R); }
 
   bool isUnknown() const {
     return getRawKind() == UnknownValKind;
   }
 
   bool isUndef() const {
     return getRawKind() == UndefinedValKind;
   }
inline raw_ostream &operator<<(raw_ostream &os, clang::ento::SVal V) {
   V.dumpToStream(os);
   return os;
 }
 
 class UndefinedVal : public SVal {
 public:
   UndefinedVal() : SVal(UndefinedValKind) {}
 
+  static bool classof(SVal V) { return V.getBaseKind() == UndefinedValKind; }
+
 private:
   friend class SVal;
-
-  static bool isKind(const SVal& V) {
-    return V.getBaseKind() == UndefinedValKind;
-  }
 };
 
 class DefinedOrUnknownSVal : public SVal {
 public:
   // We want calling these methods to be a compiler error since they are
   // tautologically false.
   bool isUndef() const = delete;
   bool isValid() const = delete;
 
+  static bool classof(SVal V) { return !V.isUndef(); }
+
 protected:
   DefinedOrUnknownSVal() = default;
   explicit DefinedOrUnknownSVal(const void *d, bool isLoc, unsigned ValKind)
       : SVal(d, isLoc, ValKind) {}
   explicit DefinedOrUnknownSVal(BaseKind k, void *D = nullptr) : SVal(k, D) {}
 
 private:
   friend class SVal;
-
-  static bool isKind(const SVal& V) {
-    return !V.isUndef();
-  }
 };
 
 class UnknownVal : public DefinedOrUnknownSVal {
 public:
   explicit UnknownVal() : DefinedOrUnknownSVal(UnknownValKind) {}
 
+  static bool classof(SVal V) { return V.getBaseKind() == UnknownValKind; }
+
 private:
   friend class SVal;
-
-  static bool isKind(const SVal &V) {
-    return V.getBaseKind() == UnknownValKind;
-  }
 };
 
 class DefinedSVal : public DefinedOrUnknownSVal {
 public:
   // We want calling these methods to be a compiler error since they are
   // tautologically true/false.
   bool isUnknown() const = delete;
   bool isUnknownOrUndef() const = delete;
   bool isValid() const = delete;
 
+  static bool classof(SVal V) { return !V.isUnknownOrUndef(); }
+
 protected:
   DefinedSVal() = default;
   explicit DefinedSVal(const void *d, bool isLoc, unsigned ValKind)
       : DefinedOrUnknownSVal(d, isLoc, ValKind) {}
 
 private:
   friend class SVal;
-
-  static bool isKind(const SVal& V) {
-    return !V.isUnknownOrUndef();
-  }
 };
 
 /// Represents an SVal that is guaranteed to not be UnknownVal.
 class KnownSVal : public SVal {
   friend class SVal;
-
   KnownSVal() = default;
 
-  static bool isKind(const SVal &V) {
-    return !V.isUnknown();
-  }
-
 public:
   KnownSVal(const DefinedSVal &V) : SVal(V) {}
   KnownSVal(const UndefinedVal &V) : SVal(V) {}
+  static bool classof(SVal V) { return !V.isUnknown(); }
 };
 
 class NonLoc : public DefinedSVal {
 protected:
   NonLoc() = default;
   explicit NonLoc(unsigned SubKind, const void *d)
       : DefinedSVal(d, false, SubKind) {}
 
 public:
   void dumpToStream(raw_ostream &Out) const;
 
   static bool isCompoundType(QualType T) {
     return T->isArrayType() || T->isRecordType() ||
            T->isAnyComplexType() || T->isVectorType();
   }
 
+  static bool classof(SVal V) { return V.getBaseKind() == NonLocKind; }
+
 private:
   friend class SVal;
-
-  static bool isKind(const SVal& V) {
-    return V.getBaseKind() == NonLocKind;
-  }
 };
 
 class Loc : public DefinedSVal {
 protected:
   Loc() = default;
   explicit Loc(unsigned SubKind, const void *D)
       : DefinedSVal(const_cast<void *>(D), true, SubKind) {}
 
 public:
   void dumpToStream(raw_ostream &Out) const;
 
   static bool isLocType(QualType T) {
     return T->isAnyPointerType() || T->isBlockPointerType() ||
            T->isReferenceType() || T->isNullPtrType();
   }
 
+  static bool classof(SVal V) { return V.getBaseKind() == LocKind; }
+
 private:
   friend class SVal;
-
-  static bool isKind(const SVal& V) {
-    return V.getBaseKind() == LocKind;
-  }
 };
 
 //==------------------------------------------------------------------------==//
 //  Subclasses of NonLoc.
 //==------------------------------------------------------------------------==//
 
 namespace nonloc {
 
public:
   SymbolRef getSymbol() const {
     return (const SymExpr *) Data;
   }
 
   bool isExpression() const {
     return !isa<SymbolData>(getSymbol());
   }
 
-private:
-  friend class SVal;
-
-  static bool isKind(const SVal& V) {
-    return V.getBaseKind() == NonLocKind &&
-           V.getSubKind() == SymbolValKind;
+  static bool classof(SVal V) {
+    return V.getBaseKind() == NonLocKind && V.getSubKind() == SymbolValKind;
   }
 
-  static bool isKind(const NonLoc& V) {
-    return V.getSubKind() == SymbolValKind;
-  }
+  static bool classof(NonLoc V) { return V.getSubKind() == SymbolValKind; }
+
+private:
+  friend class SVal;
 };
 
 /// Value representing integer constant.
 class ConcreteInt : public NonLoc {
 public:
   explicit ConcreteInt(const llvm::APSInt& V) : NonLoc(ConcreteIntKind, &V) {}
 
   const llvm::APSInt& getValue() const {
     return *static_cast<const llvm::APSInt *>(Data);
   }
 
   // Transfer functions for unary operations on ConcreteInts.
   ConcreteInt evalComplement(SValBuilder &svalBuilder) const;
 
   ConcreteInt evalMinus(SValBuilder &svalBuilder) const;
 
+  static bool classof(SVal V) {
+    return V.getBaseKind() == NonLocKind && V.getSubKind() == ConcreteIntKind;
+  }
+
+  static bool classof(NonLoc V) { return V.getSubKind() == ConcreteIntKind; }
+
 private:
   friend class SVal;
-
   ConcreteInt() = default;
-
-  static bool isKind(const SVal& V) {
-    return V.getBaseKind() == NonLocKind &&
-           V.getSubKind() == ConcreteIntKind;
-  }
-
-  static bool isKind(const NonLoc& V) {
-    return V.getSubKind() == ConcreteIntKind;
-  }
 };
 
 class LocAsInteger : public NonLoc {
   friend class ento::SValBuilder;
 
   explicit LocAsInteger(const std::pair<SVal, uintptr_t> &data)
       : NonLoc(LocAsIntegerKind, &data) {
     // We do not need to represent loc::ConcreteInt as LocAsInteger,
public:
   }
 
   unsigned getNumBits() const {
     const std::pair<SVal, uintptr_t> *D =
       static_cast<const std::pair<SVal, uintptr_t> *>(Data);
     return D->second;
   }
 
+  static bool classof(SVal V) {
+    return V.getBaseKind() == NonLocKind && V.getSubKind() == LocAsIntegerKind;
+  }
+
+  static bool classof(NonLoc V) { return V.getSubKind() == LocAsIntegerKind; }
+
 private:
   friend class SVal;
-
   LocAsInteger() = default;
-
-  static bool isKind(const SVal& V) {
-    return V.getBaseKind() == NonLocKind &&
-           V.getSubKind() == LocAsIntegerKind;
-  }
-
-  static bool isKind(const NonLoc& V) {
-    return V.getSubKind() == LocAsIntegerKind;
-  }
 };
 
 class CompoundVal : public NonLoc {
   friend class ento::SValBuilder;
 
   explicit CompoundVal(const CompoundValData* D) : NonLoc(CompoundValKind, D) {}
 
 public:
   const CompoundValData* getValue() const {
     return static_cast<const CompoundValData *>(Data);
   }
 
   using iterator = llvm::ImmutableList<SVal>::iterator;
 
   iterator begin() const;
   iterator end() const;
 
-private:
-  friend class SVal;
-
-  CompoundVal() = default;
-
-  static bool isKind(const SVal& V) {
+  static bool classof(SVal V) {
     return V.getBaseKind() == NonLocKind && V.getSubKind() == CompoundValKind;
   }
 
-  static bool isKind(const NonLoc& V) {
-    return V.getSubKind() == CompoundValKind;
-  }
+  static bool classof(NonLoc V) { return V.getSubKind() == CompoundValKind; }
+
+private:
+  friend class SVal;
+  CompoundVal() = default;
 };
 
 class LazyCompoundVal : public NonLoc {
   friend class ento::SValBuilder;
 
   explicit LazyCompoundVal(const LazyCompoundValData *D)
       : NonLoc(LazyCompoundValKind, D) {}
 
 public:
   const LazyCompoundValData *getCVData() const {
     return static_cast<const LazyCompoundValData *>(Data);
   }
 
   const void *getStore() const;
   const TypedValueRegion *getRegion() const;
 
-private:
-  friend class SVal;
-
-  LazyCompoundVal() = default;
-
-  static bool isKind(const SVal& V) {
+  static bool classof(SVal V) {
     return V.getBaseKind() == NonLocKind &&
            V.getSubKind() == LazyCompoundValKind;
   }
 
-  static bool isKind(const NonLoc& V) {
+  static bool classof(NonLoc V) {
     return V.getSubKind() == LazyCompoundValKind;
   }
+
+private:
+  friend class SVal;
+  LazyCompoundVal() = default;
 };
 
 /// Value representing pointer-to-member.
 ///
 /// This value is qualified as NonLoc because neither loading nor storing
 /// operations are applied to it. Instead, the analyzer uses the L-value coming
 /// from pointer-to-member applied to an object.
 /// This SVal is represented by a NamedDecl which can be a member function
const AdjustedDecl *getDeclAs() const {
     return dyn_cast_or_null<AdjustedDecl>(getDecl());
   }
 
   using iterator = llvm::ImmutableList<const CXXBaseSpecifier *>::iterator;
 
   iterator begin() const;
   iterator end() const;
 
-private:
-  friend class SVal;
-
-  PointerToMember() = default;
-  explicit PointerToMember(const PTMDataType D)
-      : NonLoc(PointerToMemberKind, D.getOpaqueValue()) {}
-
-  static bool isKind(const SVal& V) {
+  static bool classof(SVal V) {
     return V.getBaseKind() == NonLocKind &&
            V.getSubKind() == PointerToMemberKind;
   }
 
-  static bool isKind(const NonLoc& V) {
+  static bool classof(NonLoc V) {
     return V.getSubKind() == PointerToMemberKind;
   }
+
+private:
+  friend class SVal;
+
+  PointerToMember() = default;
+  explicit PointerToMember(const PTMDataType D)
+      : NonLoc(PointerToMemberKind, D.getOpaqueValue()) {}
 };
 
 } // namespace nonloc
 
 //==------------------------------------------------------------------------==//
 //  Subclasses of Loc.
 //==------------------------------------------------------------------------==//
 
 namespace loc {
 
 class GotoLabel : public Loc {
 public:
   explicit GotoLabel(const LabelDecl *Label) : Loc(GotoLabelKind, Label) {
     assert(Label);
   }
 
   const LabelDecl *getLabel() const {
     return static_cast<const LabelDecl *>(Data);
   }
 
-private:
-  friend class SVal;
-
-  GotoLabel() = default;
-
-  static bool isKind(const SVal& V) {
+  static bool classof(SVal V) {
     return V.getBaseKind() == LocKind && V.getSubKind() == GotoLabelKind;
   }
 
-  static bool isKind(const Loc& V) {
-    return V.getSubKind() == GotoLabelKind;
-  }
+  static bool classof(Loc V) { return V.getSubKind() == GotoLabelKind; }
+
+private:
+  friend class SVal;
+  GotoLabel() = default;
 };
 
 class MemRegionVal : public Loc {
 public:
   explicit MemRegionVal(const MemRegion* r) : Loc(MemRegionValKind, r) {
     assert(r);
   }
 
public:
   bool operator==(const MemRegionVal &R) const {
     return getRegion() == R.getRegion();
   }
 
   bool operator!=(const MemRegionVal &R) const {
     return getRegion() != R.getRegion();
   }
 
+  static bool classof(SVal V) {
+    return V.getBaseKind() == LocKind && V.getSubKind() == MemRegionValKind;
+  }
+
+  static bool classof(Loc V) { return V.getSubKind() == MemRegionValKind; }
+
 private:
   friend class SVal;
-
   MemRegionVal() = default;
-
-  static bool isKind(const SVal& V) {
-    return V.getBaseKind() == LocKind &&
-           V.getSubKind() == MemRegionValKind;
-  }
-
-  static bool isKind(const Loc& V) {
-    return V.getSubKind() == MemRegionValKind;
-  }
 };
 
 class ConcreteInt : public Loc {
 public:
   explicit ConcreteInt(const llvm::APSInt& V) : Loc(ConcreteIntKind, &V) {}
 
   const llvm::APSInt &getValue() const {
     return *static_cast<const llvm::APSInt *>(Data);
   }
 
+  static bool classof(SVal V) {
+    return V.getBaseKind() == LocKind && V.getSubKind() == ConcreteIntKind;
+  }
+
+  static bool classof(Loc V) { return V.getSubKind() == ConcreteIntKind; }
+
 private:
   friend class SVal;
-
   ConcreteInt() = default;
-
-  static bool isKind(const SVal& V) {
-    return V.getBaseKind() == LocKind &&
-           V.getSubKind() == ConcreteIntKind;
-  }
-
-  static bool isKind(const Loc& V) {
-    return V.getSubKind() == ConcreteIntKind;
-  }
 };
 
 } // namespace loc
-
 } // namespace ento
-
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALS_H