[analyzer][Casting] Support isa, cast, dyn_cast of SVals

[steakhal]

Summary

This change specializes the LLVM RTTI mechanism for SVals.
After this change, we can use the well-known isa, cast, dyn_cast.

Examples:

// SVal V = ...;
// Loc MyLoc = ...;

bool IsInteresting = isa<loc::MemRegionVal, loc::GotoLabel>(MyLoc);
auto MRV = cast<loc::MemRegionVal>(MyLoc);
Optional<loc::MemRegionVal> MaybeMRV = dyn_cast<loc::MemRegionVal>(V)

The current SVal::getAs and castAs member functions are redundant at
this point, but I believe that they are still handy.

The member function version is terse and reads left-to-right, which IMO
is a great plus. However, we should probably add a variadic isa member
function version to have the same casting API in both cases.

I'm not sure, shall I add tests?

Thanks for the extensive TMP help @bzcheeseman!

[bzcheeseman]

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

100–101

Is it worth refactoring this and getAs to use cast<T> and dyn_cast<T> as appropriate to avoid code duplication?

[steakhal]

Use cast and dyn_cast in castAs and getAs respecitvely.

[steakhal]

I had to fix the doCast to return To instead of Optional<To> to make it work.

[martong]

I'm not sure, shall I add tests?

Yes, please. Unit tests for dyn_cast and isa should be easy. However, I am not sure how to test cast for the failure cases.

[bzcheeseman]

In D125709#3518096, @steakhal wrote:

I had to fix the doCast to return To instead of Optional<To> to make it work.

That's fine (or it should be!), you could dereference the optional if you wanted to

[steakhal]

In D125709#3518242, @martong wrote:

I'm not sure, shall I add tests?

Yes, please. Unit tests for dyn_cast and isa should be easy. However, I am not sure how to test cast for the failure cases.

What if we were using the 'new' casting style at some places. If it compiles, it should be fine.
It feels weird to check stuff, only in static_asserts.

In D125709#3519033, @bzcheeseman wrote:

In D125709#3518096, @steakhal wrote:

I had to fix the doCast to return To instead of Optional<To> to make it work.

That's fine (or it should be!), you could dereference the optional if you wanted to

Currently, we expect that casts result in regular SVal objects, instead of pointer-like objects , thus this code to compile:
NonLoc N = llvm::cast<NonLoc>(V), where V is of type SVal. I believe that is why I decided to make that change.

[bzcheeseman]

In D125709#3519033, @bzcheeseman wrote:

In D125709#3518096, @steakhal wrote:

I had to fix the doCast to return To instead of Optional<To> to make it work.

That's fine (or it should be!), you could dereference the optional if you wanted to

Currently, we expect that casts result in regular SVal objects, instead of pointer-like objects , thus this code to compile:
NonLoc N = llvm::cast<NonLoc>(V), where V is of type SVal. I believe that is why I decided to make that change.

Makes sense, LGTM

[steakhal]

Thanks for your help @bzcheeseman!

[xazax.hun]

While not having tests might be OK, but I'd prefer to introduce at least a couple uses of the new facilities so existing tests cover them.

[steakhal]

• Added uses for dyn_cast and cast of the new specialization.

[steakhal]

In D125709#3519850, @xazax.hun wrote:

While not having tests might be OK, but I'd prefer to introduce at least a couple uses of the new facilities so existing tests cover them.

I've added a use of the new dyn_cast and cast free function specializations.

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

explicit SVal(const void *d, bool isLoc, unsigned ValKind)
       : Data(d), Kind((isLoc ? LocKind : NonLocKind) | (ValKind << BaseBits)) {}
 
   explicit SVal(BaseKind k, const void *D = nullptr) : Data(D), Kind(k) {}
 
 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::classof(*this));
-    return *static_cast<const T *>(this);
-  }
+  template <typename T> T castAs() const { return llvm::cast<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::classof(*this))
-      return None;
-    return *static_cast<const T *>(this);
+  template <typename T> Optional<T> getAs() const {
+    return llvm::dyn_cast<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.
public:
 
   static bool classof(Loc V) { return V.getSubKind() == ConcreteIntKind; }
 };
 
 } // namespace loc
 } // namespace ento
 } // namespace clang
 
+namespace llvm {
+template <typename To, typename From>
+struct CastInfo<
+    To, From,
+    std::enable_if_t<std::is_base_of<::clang::ento::SVal, From>::value>>
+    : public CastIsPossible<To, ::clang::ento::SVal> {
+  using Self = CastInfo<
+      To, From,
+      std::enable_if_t<std::is_base_of<::clang::ento::SVal, From>::value>>;
+  static bool isPossible(const From &V) {
+    return To::classof(*static_cast<const ::clang::ento::SVal *>(&V));
+  }
+  static Optional<To> castFailed() { return Optional<To>{}; }
+  static To doCast(const From &f) {
+    return *static_cast<const To *>(cast<::clang::ento::SVal>(&f));
+  }
+  static Optional<To> doCastIfPossible(const From &f) {
+    if (!Self::isPossible(f))
+      return Self::castFailed();
+    return doCast(f);
+  }
+};
+} // namespace llvm
+
 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALS_H

clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp

if (!(FD->getIdentifier() == ICreate || FD->getIdentifier() == IGetValue) ||
       CE->getNumArgs() != 3)
     return;
 
   // Get the value of the "theType" argument.
   SVal TheTypeVal = C.getSVal(CE->getArg(1));
 
   // FIXME: We really should allow ranges of valid theType values, and
   //   bifurcate the state appropriately.
-  Optional<nonloc::ConcreteInt> V = TheTypeVal.getAs<nonloc::ConcreteInt>();
+  Optional<nonloc::ConcreteInt> V = dyn_cast<nonloc::ConcreteInt>(TheTypeVal);
   if (!V)
     return;
 
   uint64_t NumberKind = V->getValue().getLimitedValue();
   Optional<uint64_t> OptCFNumberSize = GetCFNumberSize(Ctx, NumberKind);
 
   // FIXME: In some cases we can emit an error.
   if (!OptCFNumberSize)
if (const DeclStmt *DS = dyn_cast<DeclStmt>(Element)) {
     ElementLoc = State->getSVal(Element, LCtx).getAs<Loc>();
   }
 
   if (!ElementLoc)
     return State;
 
   // Go ahead and assume the value is non-nil.
   SVal Val = State->getSVal(*ElementLoc);
-  return State->assume(Val.castAs<DefinedOrUnknownSVal>(), true);
+  return State->assume(cast<DefinedOrUnknownSVal>(Val), true);
 }
 
 /// Returns NULL state if the collection is known to contain elements
 /// (or is known not to contain elements if the Assumption parameter is false.)
 static ProgramStateRef
 assumeCollectionNonEmpty(CheckerContext &C, ProgramStateRef State,
                          SymbolRef CollectionS, bool Assumption) {
   if (!State || !CollectionS)