[llvm] Add isa_and_nonnull

[hintonda]

Summary

Add new `isa_and_nonnull<>` operator that works just like
the `isa<>` operator, except that it allows for a null pointer as an
argument (which it then returns false).

The final name has not yet been determined, but a discussion can be
seen here: http://lists.llvm.org/pipermail/llvm-dev/2019-April/131555.html

[hubert.reinterpretcast]

llvm/docs/ProgrammersManual.rst

167 ↗

(On Diff #193803)

The name seems backwards. What does it mean to check "isa" on null? That question would not arise if the name was nonnull_and_isa.

[hintonda]

llvm/docs/ProgrammersManual.rst

167 ↗

(On Diff #193803)

Btw, there's been 4 naming comments so far, and each one is different. So, I hope we can come to a consensus soon. I originally thought isa_or_null was a good idea because it matches (cast|dyn_cast)_or_null, but since we're returning a bool and not a pointer, I no longer think that's a good name either.

So, I'm open to whatever is decided.

[lattner]

Patch LGTM. I think that the isa_and_nonnull name is the least bad of the options that I've heard, and if someone comes up with a better name, we can always rename it in the future. Thank you for updating the docs as well!

llvm/trunk/docs/ProgrammersManual.rst

``dyn_cast<>``:
 
   Note that the ``dyn_cast<>`` operator, like C++'s ``dynamic_cast<>`` or Java's
   ``instanceof`` operator, can be abused.  In particular, you should not use big
   chained ``if/then/else`` blocks to check for lots of different variants of
   classes.  If you find yourself wanting to do this, it is much cleaner and more
   efficient to use the ``InstVisitor`` class to dispatch over the instruction
   type directly.
 
+``isa_and_nonnull<>``:
+  The ``isa_and_nonnull<>`` operator works just like the ``isa<>`` operator,
+  except that it allows for a null pointer as an argument (which it then
+  returns false).  This can sometimes be useful, allowing you to combine several
+  null checks into one.
+
 ``cast_or_null<>``:
   The ``cast_or_null<>`` operator works just like the ``cast<>`` operator,
   except that it allows for a null pointer as an argument (which it then
   propagates).  This can sometimes be useful, allowing you to combine several
   null checks into one.
 
 ``dyn_cast_or_null<>``:
   The ``dyn_cast_or_null<>`` operator works just like the ``dyn_cast<>``

llvm/trunk/include/llvm/Support/Casting.h

 //
 //  if (isa<Type>(myVal)) { ... }
 //
 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
   return isa_impl_wrap<X, const Y,
                        typename simplify_type<const Y>::SimpleType>::doit(Val);
 }
 
+// isa_and_nonnull<X> - Functionally identical to isa, except that a null value
+// is accepted.
+//
+template <class X, class Y>
+LLVM_NODISCARD inline bool isa_and_nonnull(const Y &Val) {
+  if (!Val)
+    return false;
+  return isa<X>(Val);
+}
+
 //===----------------------------------------------------------------------===//
 //                          cast<x> Support Templates
 //===----------------------------------------------------------------------===//
 
 template<class To, class From> struct cast_retty;
 
 // Calculate what type the 'cast' function should return, based on a requested
 // type of To and a source type of From.

llvm/trunk/unittests/Support/Casting.cpp

 
 TEST(CastingTest, isa) {
   EXPECT_TRUE(isa<foo>(B1));
   EXPECT_TRUE(isa<foo>(B2));
   EXPECT_TRUE(isa<foo>(B3));
   EXPECT_TRUE(isa<foo>(B4));
 }
 
+TEST(CastingTest, isa_and_nonnull) {
+  EXPECT_TRUE(isa_and_nonnull<foo>(B2));
+  EXPECT_TRUE(isa_and_nonnull<foo>(B4));
+  EXPECT_FALSE(isa_and_nonnull<foo>(fub()));
+}
+
 TEST(CastingTest, cast) {
   foo &F1 = cast<foo>(B1);
   EXPECT_NE(&F1, null_foo);
   const foo *F3 = cast<foo>(B2);
   EXPECT_NE(F3, null_foo);
   const foo *F4 = cast<foo>(B2);
   EXPECT_NE(F4, null_foo);
   const foo &F5 = cast<foo>(B3);