diff --git a/llvm/include/llvm/Support/Casting.h b/llvm/include/llvm/Support/Casting.h
--- a/llvm/include/llvm/Support/Casting.h
+++ b/llvm/include/llvm/Support/Casting.h
@@ -6,14 +6,15 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the isa<X>(), cast<X>(), dyn_cast<X>(), cast_or_null<X>(),
-// and dyn_cast_or_null<X>() templates.
+// This file defines the isa<X>(), cast<X>(), dyn_cast<X>(),
+// cast_if_present<X>(), and dyn_cast_if_present<X>() templates.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_CASTING_H
 #define LLVM_SUPPORT_CASTING_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
@@ -22,44 +23,133 @@
 
 namespace llvm {
 
+/// There are 3 components of LLVM's casting infrastructure you may want to take
+/// advantage of as the author of a new type. `isa`, `cast`, and `dyn_cast` (and
+/// their _if_present) variants. Their implementation should generally be opaque
+/// to most users who want to support simple casts, the most basic step needed
+/// to participate in the casting infrastructure is:
+///
+/// struct MyNewType {
+///   static bool classof(const MyOtherType *t) { return t->isMyNewType(); }
+/// };
+///
+/// From here, there are several more-advanced methods that can be used to
+/// customize the way casting is performed.
+///
+/// `isa` and `isa_and_present` rely on the `CastIsPossible` template. In order
+/// to provide custom behavior for `isa*` you should specialize this struct like
+/// so:
+///
+/// template<> CastIsPossible<MyNewType, MyOtherType> {
+///   static inline bool isPossible(const MyOtherType &ot) {
+///     return ot.isMyNewType();
+///   }
+/// }
+///
+/// `cast` is what we call an infallible cast. This distinction allows us to
+/// provide cast-only support for some types when we don't want to enable
+/// fallible casting (i.e. dyn_cast). Note that cast_if_present is a fallible
+/// cast! This is because if the value is not present, the failure type must be
+/// provided. If you want to provide custom behavior for `cast` you should
+/// specialize the `InfallibleCastTraits` struct like so:
+///
+/// template<> struct InfallibleCastTraits<MyNewType, MyOtherType> {
+///   using CastResultType = const MyNewType &;
+///   static inline CastResultType doCast(const MyOtherType &ot) {
+///     return (CastResultType)ot;
+///   }
+/// };
+///
+/// Fallible casts comprise the majority of casts performed - `cast_if_present`,
+/// `dyn_cast`, `dyn_cast_if_present` are all fallible casts. The way to
+/// customize the behavior for fallible casts is to specialize the struct
+/// `FallibleCastTraits` like so:
+///
+/// template<> struct FallibleCastTraits<MyNewType, MyOtherType> {
+///  using CastResultType = MyOptionalContainer<MyNewType>;
+///  static inline CastResultType doCast(const MyOtherType &f) {
+///    return MyNewType(f);
+///  }
+///  static inline CastResultType castFailed() { return CastResultType(); }
+///  static inline CastResultType doCastIfPossible(const MyOtherType &f) {
+///    if (!isPossible<MyNewType>(f))
+///      return castFailed();
+///    return doCast(f);
+///  }
+///};
+///
+/// Sometimes you don't need the full control provided by the
+/// (In/F)allibleCastTraits - you just need to say "here's how to tell if a
+/// value is present or not". In that case, there's another template you can
+/// specialize, `ValueIsPresent`, which is done like so:
+///
+/// template<typename T> struct ValueIsPresent<MyOptionalContainer<T>> {
+///   using UnwrappedType = T;
+///   static inline bool isPresent(const MyOptionalContainer<T> &t) { return
+///   t.hasAValue(); } static inline const T &unwrapValue(const T &t) { return
+///   t.getMyValue(); }
+/// };
+///
+/// Other times, you need full control over how a cast is performed. In that
+/// case, you should specialize the `CastInfo` struct for your type. We provide
+/// a set of basic/default cast traits that can be used to implement a custom
+/// `CastInfo` to reduce boilerplate, but to have full control simply implement
+/// the methods you want in your CastInfo specialization. You can specialize
+/// `CastInfo` like this:
+///
+/// template<> struct CastInfo<foo, bar> :
+///   // Provide a checked pointer cast from bar * to foo *
+///   public CheckedPointerCast<foo, bar *> {
+///     // And we want to only provide an infallible cast from value ref to
+///     // value ref (which we want to implement ourselves).
+///     using CastResultType = foo &;
+///     static inline CastResultType doCast(const bar &b) {
+///       return (foo &)b;
+///     }
+/// };
+
 //===----------------------------------------------------------------------===//
-//                          isa<x> Support Templates
+// simplify_type
 //===----------------------------------------------------------------------===//
 
-// Define a template that can be specialized by smart pointers to reflect the
-// fact that they are automatically dereferenced, and are not involved with the
-// template selection process...  the default implementation is a noop.
-//
-template<typename From> struct simplify_type {
+/// Define a template that can be specialized by smart pointers to reflect the
+/// fact that they are automatically dereferenced, and are not involved with the
+/// template selection process...  the default implementation is a noop.
+// TODO: rename this and/or replace it with other cast traits.
+template <typename From> struct simplify_type {
   using SimpleType = From; // The real type this represents...
 
   // An accessor to get the real value...
   static SimpleType &getSimplifiedValue(From &Val) { return Val; }
 };
 
-template<typename From> struct simplify_type<const From> {
+template <typename From> struct simplify_type<const From> {
   using NonConstSimpleType = typename simplify_type<From>::SimpleType;
-  using SimpleType =
-      typename add_const_past_pointer<NonConstSimpleType>::type;
+  using SimpleType = typename add_const_past_pointer<NonConstSimpleType>::type;
   using RetType =
       typename add_lvalue_reference_if_not_pointer<SimpleType>::type;
 
-  static RetType getSimplifiedValue(const From& Val) {
-    return simplify_type<From>::getSimplifiedValue(const_cast<From&>(Val));
+  static RetType getSimplifiedValue(const From &Val) {
+    return simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val));
   }
 };
 
+// TODO: add this namespace once everyone is switched to using the new
+//       interface.
+// namespace detail {
+
+//===----------------------------------------------------------------------===//
+// isa_impl
+//===----------------------------------------------------------------------===//
+
 // The core of the implementation of isa<X> is here; To and From should be
 // the names of classes.  This template can be specialized to customize the
 // implementation of isa<> without rewriting it from scratch.
-template <typename To, typename From, typename Enabler = void>
-struct isa_impl {
-  static inline bool doit(const From &Val) {
-    return To::classof(&Val);
-  }
+template <typename To, typename From, typename Enabler = void> struct isa_impl {
+  static inline bool doit(const From &Val) { return To::classof(&Val); }
 };
 
-/// Always allow upcasts, and perform no dynamic check for them.
+// Always allow upcasts, and perform no dynamic check for them.
 template <typename To, typename From>
 struct isa_impl<To, From, std::enable_if_t<std::is_base_of<To, From>::value>> {
   static inline bool doit(const From &) { return true; }
@@ -85,103 +175,78 @@
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, From*> {
+template <typename To, typename From> struct isa_impl_cl<To, From *> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, From*const> {
+template <typename To, typename From> struct isa_impl_cl<To, From *const> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, const From*> {
+template <typename To, typename From> struct isa_impl_cl<To, const From *> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, const From*const> {
+template <typename To, typename From>
+struct isa_impl_cl<To, const From *const> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template<typename To, typename From, typename SimpleFrom>
+template <typename To, typename From, typename SimpleFrom>
 struct isa_impl_wrap {
   // When From != SimplifiedType, we can simplify the type some more by using
   // the simplify_type template.
   static bool doit(const From &Val) {
     return isa_impl_wrap<To, SimpleFrom,
-      typename simplify_type<SimpleFrom>::SimpleType>::doit(
-                          simplify_type<const From>::getSimplifiedValue(Val));
+                         typename simplify_type<SimpleFrom>::SimpleType>::
+        doit(simplify_type<const From>::getSimplifiedValue(Val));
   }
 };
 
-template<typename To, typename FromTy>
+template <typename To, typename FromTy>
 struct isa_impl_wrap<To, FromTy, FromTy> {
   // When From == SimpleType, we are as simple as we are going to get.
   static bool doit(const FromTy &Val) {
-    return isa_impl_cl<To,FromTy>::doit(Val);
+    return isa_impl_cl<To, FromTy>::doit(Val);
   }
 };
 
-// isa<X> - Return true if the parameter to the template is an instance of one
-// of the template type arguments.  Used like this:
-//
-//  if (isa<Type>(myVal)) { ... }
-//  if (isa<Type0, Type1, Type2>(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);
-}
-
-template <typename First, typename Second, typename... Rest, typename Y>
-LLVM_NODISCARD inline bool isa(const Y &Val) {
-  return isa<First>(Val) || isa<Second, Rest...>(Val);
-}
-
-// isa_and_nonnull<X> - Functionally identical to isa, except that a null value
-// is accepted.
-//
-template <typename... 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
+// cast_retty + cast_retty_impl
 //===----------------------------------------------------------------------===//
 
-template<class To, class From> struct cast_retty;
+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.
-template<class To, class From> struct cast_retty_impl {
-  using ret_type = To &;       // Normal case, return Ty&
+template <class To, class From> struct cast_retty_impl {
+  using ret_type = To &; // Normal case, return Ty&
 };
-template<class To, class From> struct cast_retty_impl<To, const From> {
+template <class To, class From> struct cast_retty_impl<To, const From> {
   using ret_type = const To &; // Normal case, return Ty&
 };
 
-template<class To, class From> struct cast_retty_impl<To, From*> {
-  using ret_type = To *;       // Pointer arg case, return Ty*
+template <class To, class From> struct cast_retty_impl<To, From *> {
+  using ret_type = To *; // Pointer arg case, return Ty*
 };
 
-template<class To, class From> struct cast_retty_impl<To, const From*> {
+template <class To, class From> struct cast_retty_impl<To, const From *> {
   using ret_type = const To *; // Constant pointer arg case, return const Ty*
 };
 
-template<class To, class From> struct cast_retty_impl<To, const From*const> {
+template <class To, class From> struct cast_retty_impl<To, const From *const> {
   using ret_type = const To *; // Constant pointer arg case, return const Ty*
 };
 
@@ -195,187 +260,533 @@
   using ret_type = std::unique_ptr<ResultType>;
 };
 
-template<class To, class From, class SimpleFrom>
-struct cast_retty_wrap {
+template <class To, class From, class SimpleFrom> struct cast_retty_wrap {
   // When the simplified type and the from type are not the same, use the type
   // simplifier to reduce the type, then reuse cast_retty_impl to get the
   // resultant type.
   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
 };
 
-template<class To, class FromTy>
-struct cast_retty_wrap<To, FromTy, FromTy> {
+template <class To, class FromTy> struct cast_retty_wrap<To, FromTy, FromTy> {
   // When the simplified type is equal to the from type, use it directly.
-  using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
+  using ret_type = typename cast_retty_impl<To, FromTy>::ret_type;
 };
 
-template<class To, class From>
-struct cast_retty {
+template <class To, class From> struct cast_retty {
   using ret_type = typename cast_retty_wrap<
       To, From, typename simplify_type<From>::SimpleType>::ret_type;
 };
 
+//===----------------------------------------------------------------------===//
+// cast_convert_val
+//===----------------------------------------------------------------------===//
+
 // Ensure the non-simple values are converted using the simplify_type template
 // that may be specialized by smart pointers...
 //
-template<class To, class From, class SimpleFrom> struct cast_convert_val {
+template <class To, class From, class SimpleFrom> struct cast_convert_val {
   // This is not a simple type, use the template to simplify it...
-  static typename cast_retty<To, From>::ret_type doit(From &Val) {
+  static typename cast_retty<To, From>::ret_type doit(const From &Val) {
     return cast_convert_val<To, SimpleFrom,
-      typename simplify_type<SimpleFrom>::SimpleType>::doit(
-                          simplify_type<From>::getSimplifiedValue(Val));
+                            typename simplify_type<SimpleFrom>::SimpleType>::
+        doit(simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val)));
   }
 };
 
-template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
+template <class To, class FromTy> struct cast_convert_val<To, FromTy, FromTy> {
   // This _is_ a simple type, just cast it.
   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
-    typename cast_retty<To, FromTy>::ret_type Res2
-     = (typename cast_retty<To, FromTy>::ret_type)const_cast<FromTy&>(Val);
+    typename cast_retty<To, FromTy>::ret_type Res2 =
+        (typename cast_retty<To, FromTy>::ret_type) const_cast<FromTy &>(Val);
     return Res2;
   }
 };
 
+//===----------------------------------------------------------------------===//
+// is_simple_type
+//===----------------------------------------------------------------------===//
+
 template <class X> struct is_simple_type {
   static const bool value =
       std::is_same<X, typename simplify_type<X>::SimpleType>::value;
 };
 
-// cast<X> - Return the argument parameter cast to the specified type.  This
-// casting operator asserts that the type is correct, so it does not return null
-// on failure.  It does not allow a null argument (use cast_or_null for that).
-// It is typically used like this:
-//
-//  cast<Instruction>(myVal)->getParent()
-//
-template <class X, class Y>
-inline std::enable_if_t<!is_simple_type<Y>::value,
-                        typename cast_retty<X, const Y>::ret_type>
-cast(const Y &Val) {
-  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
-  return cast_convert_val<
-      X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
+// } // namespace detail
+
+//===----------------------------------------------------------------------===//
+// CastIsPossible
+//===----------------------------------------------------------------------===//
+
+/// This struct provides a way to check if a given cast is possible. It provides
+/// a static function called isPossible that is used to check if a cast can be
+/// performed. It should be overridden like this:
+///
+/// template<> struct CastIsPossible<foo, bar> {
+///   static inline bool isPossible(const bar &b) {
+///     return bar.isFoo();
+///   }
+/// };
+template <typename To, typename From, typename Enable = void>
+struct CastIsPossible {
+  static inline bool isPossible(const From &f) {
+    return isa_impl_wrap<
+        To, const From,
+        typename simplify_type<const From>::SimpleType>::doit(f);
+  }
+};
+
+// Needed for optional unwrapping. This could be implemented with isa_impl, but
+// we want to implement things in the new method and move old implementations
+// over. In fact, some of the isa_impl templates should be moved over to
+// CastIsPossible.
+template <typename To, typename From>
+struct CastIsPossible<To, Optional<From>> {
+  static inline bool isPossible(const Optional<From> &f) {
+    assert(f.hasValue() && "CastIsPossible::isPossible called on a nullopt!");
+    return isa_impl_wrap<
+        To, const From,
+        typename simplify_type<const From>::SimpleType>::doit(*f);
+  }
+};
+
+/// Helper function to make it easier to call CastIsPossible::isPossible.
+template <typename To, typename From> inline bool isPossible(const From &f) {
+  return CastIsPossible<To, From>::isPossible(f);
 }
 
-template <class X, class Y>
-inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
-  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
-  return cast_convert_val<X, Y,
-                          typename simplify_type<Y>::SimpleType>::doit(Val);
+//===----------------------------------------------------------------------===//
+// InfallibleCastTraits
+//===----------------------------------------------------------------------===//
+
+/// This struct provides the return type and method for performing an infallible
+/// cast. This is a cast that must be used with cast (and not dyn_cast) because
+/// it cannot fail. It should be overridden like this:
+///
+/// template<> struct InfallibleCastTraits<foo, bar> {
+///   using CastResultType = foo &;
+///   static inline foo &doCast(const bar &b) {
+///     return (foo &)(const_cast<bar &>(b));
+///   }
+/// };
+template <typename To, typename From, typename Enable = void>
+struct InfallibleCastTraits {
+  using CastResultType = typename cast_retty<To, From>::ret_type;
+  static inline CastResultType doCast(const From &f) {
+    return cast_convert_val<
+        To, From,
+        typename simplify_type<From>::SimpleType>::doit(const_cast<From &>(f));
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// FallibleCastTraits
+//===----------------------------------------------------------------------===//
+
+/// This struct provides the return type and method for performing a fallible
+/// cast. This is a cast that can be used with dyn_cast - for non-nullable types
+/// this cast returns an Optional<T> and for nullable types this cast returns T.
+/// It should be overridden like this:
+///
+/// template<> struct FallibleCastTraits<foo, bar> {
+///   using CastResultType = foo;
+///   static inline CastResultType doCast(const bar &b) {
+///     return foo(const_cast<bar &>(b));
+///   }
+///   static inline CastResultType castFailed() { return foo(); }
+///   static inline CastResultType doCastIfPossible(const bar &b) {
+///     if (!isPossible<foo>(b))
+///       return castFailed();
+///     return doCast(b);
+///   }
+/// };
+template <typename To, typename From, typename Enable = void>
+struct FallibleCastTraits {
+  using CastResultType = typename cast_retty<To, From>::ret_type;
+  static inline CastResultType doCast(const From &f) {
+    return cast_convert_val<
+        To, From,
+        typename simplify_type<From>::SimpleType>::doit(const_cast<From &>(f));
+  }
+
+  static inline CastResultType castFailed() { return CastResultType(nullptr); }
+
+  static inline CastResultType doCastIfPossible(const From &f) {
+    if (!isPossible<To>(f))
+      return castFailed();
+    return doCast(f);
+  }
+};
+
+/// If something is a pointer or constructible from nullptr, we consider it to
+/// be "nullable".
+template <class T>
+constexpr bool IsNullable = std::is_pointer<T>::value ||
+                            std::is_constructible<T, std::nullptr_t>::value;
+
+/// This is the non-nullable implementation for FallibleCastTraits that returns
+/// Optional<T>.
+template <typename To, typename From>
+struct FallibleCastTraits<To, From,
+                          std::enable_if_t<!IsNullable<std::remove_reference_t<
+                              typename cast_retty<To, From>::ret_type>>>> {
+  using InnerReturnType =
+      std::remove_reference_t<typename cast_retty<To, From>::ret_type>;
+  static_assert(
+      !std::is_pointer<InnerReturnType>::value,
+      "Optional<T *> must never be the deduced fallible cast result type.");
+  using CastResultType = Optional<InnerReturnType>;
+
+  static inline CastResultType doCast(const From &f) {
+    return cast_convert_val<
+        InnerReturnType, From,
+        typename simplify_type<From>::SimpleType>::doit(const_cast<From &>(f));
+  }
+
+  static inline CastResultType castFailed() { return CastResultType{}; }
+
+  static inline CastResultType doCastIfPossible(const From &f) {
+    if (!isPossible<To>(f))
+      return castFailed();
+    return doCast(f);
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// ValueIsPresent
+//===----------------------------------------------------------------------===//
+
+/// ValueIsPresent provides a way to check if a value is, well, present. For
+/// pointers, this is the equivalent of checking against nullptr, for Optionals
+/// this is the equivalent of checking hasValue(). It also provides a method for
+/// unwrapping a value (think dereferencing a pointer).
+
+// Generic values can't *not* be present.
+template <typename T, typename Enable = void> struct ValueIsPresent {
+  using UnwrappedType = T;
+  static inline bool isPresent(const T &t) { return true; }
+  static inline const T &unwrapValue(const T &t) { return t; }
+};
+
+// Optional provides its own way to check if something is present.
+template <typename T> struct ValueIsPresent<Optional<T>> {
+  using UnwrappedType = T;
+  static inline bool isPresent(const Optional<T> &t) { return t.hasValue(); }
+  static inline const T &unwrapValue(const Optional<T> &t) {
+    return t.getValue();
+  }
+};
+
+// If something is "nullable" then we just compare it to nullptr to see if it
+// exists.
+template <typename T>
+struct ValueIsPresent<T, std::enable_if_t<IsNullable<T>>> {
+  using UnwrappedType = T;
+  static inline bool isPresent(const T &t) { return t != nullptr; }
+  static inline const T &unwrapValue(const T &t) { return t; }
+};
+
+// Convenience function we can use to check if a value is present. Because of
+// simplify_type, we have to call it on the simplified type for now.
+template <typename T> inline bool isPresent(const T &t) {
+  return ValueIsPresent<typename simplify_type<T>::SimpleType>::isPresent(
+      simplify_type<T>::getSimplifiedValue(const_cast<T &>(t)));
 }
 
-template <class X, class Y>
-inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
-  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
-  return cast_convert_val<X, Y*,
-                          typename simplify_type<Y*>::SimpleType>::doit(Val);
+// Convenience function we can use to unwrap a value.
+template <typename T>
+inline const typename ValueIsPresent<T>::UnwrappedType &
+unwrapValue(const T &t) {
+  return ValueIsPresent<T>::unwrapValue(t);
 }
 
-template <class X, class Y>
-inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
-cast(std::unique_ptr<Y> &&Val) {
-  assert(isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!");
-  using ret_type = typename cast_retty<X, std::unique_ptr<Y>>::ret_type;
-  return ret_type(
-      cast_convert_val<X, Y *, typename simplify_type<Y *>::SimpleType>::doit(
-          Val.release()));
+//===----------------------------------------------------------------------===//
+// Cast Traits
+//===----------------------------------------------------------------------===//
+
+/// This cast trait is a composite of CastIsPossible and FallibleCastTraits.
+/// It provides the standard LLVM checked pointer cast.
+template <typename To, typename From>
+struct CheckedPointerCast : public CastIsPossible<To, From>,
+                            public FallibleCastTraits<To, From> {};
+
+/// This cast trait provides the standard LLVM support for infallible casts
+/// (i.e.. convert one reference to another). You cannot use dyn_cast on a cast
+/// that only uses this.
+template <typename To, typename From>
+struct InfallibleValueCast : public CastIsPossible<To, From>,
+                             public InfallibleCastTraits<To, From> {};
+
+/// This cast trait provides fallible value casting. The default behavior is
+/// that if the target type can be constructed from nullptr (i.e. nullable) then
+/// castFailed() returns the target type constructed with nullptr. Otherwise,
+/// the fallible cast will return an Optional<T> with an empty optional in the
+/// case of cast failure.
+template <typename To, typename From>
+struct FallibleValueCast : public CastIsPossible<To, From>,
+                           public FallibleCastTraits<To, From> {};
+
+/// For the specific case of constructing a value-typed object from a
+/// pointer-typed object, we implement FallibleCastTraits manually to handle
+/// this. Note that `To` must be nullable to use this cast trait.
+template <typename To, typename From>
+struct ValueFromPointerCast : public CastIsPossible<To, From> {
+  using CastResultType = To;
+
+  static inline To castFailed() { return To{nullptr}; }
+
+  static inline CastResultType doCast(const From *f) {
+    return CastResultType(const_cast<From *>(f));
+  }
+
+  static inline CastResultType doCastIfPossible(const From *f) {
+    if (!isPossible<To>(f))
+      return castFailed();
+    return doCast(f);
+  }
+};
+
+/// This cast trait provides std::unique_ptr casting. It has the semantics of
+/// moving the contents of the input unique_ptr into the output unique_ptr
+/// during the cast. It's also a good example of how to implement a move-only
+/// cast.
+template <typename To, typename From>
+struct UniquePtrCast : public CastIsPossible<To, From *>,
+                       public FallibleCastTraits<To, std::unique_ptr<From>> {
+  using Self = UniquePtrCast<To, From>;
+  using CastResultType = typename Self::CastResultType;
+
+  static inline CastResultType doCast(std::unique_ptr<From> &f) {
+    return CastResultType((typename CastResultType::element_type *)f.release());
+  }
+
+  static inline CastResultType doCast(std::unique_ptr<From> &&f) {
+    return CastResultType((typename CastResultType::element_type *)f.release());
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// CastInfo
+//===----------------------------------------------------------------------===//
+
+/// This is what is actually called by cast, dyn_cast, cast_if_present, and
+/// dyn_cast_if_present. For the default cases it combines the cast traits above
+/// to handle a range of cast cases. For the most control over how and when
+/// casting is performed, override this class with your specific types. You can
+/// override it like so:
+///
+/// template<> struct CastInfo<foo, bar> :
+///   // Provide a checked pointer cast from bar * to foo *
+///   public CheckedPointerCast<foo, bar *> {
+///     // And we want to only provide an infallible cast from value ref to
+///     // value ref (which we want to implement ourselves).
+///     using CastResultType = foo &;
+///     static inline CastResultType doCast(const bar &b) {
+///       return (foo &)b;
+///     }
+/// };
+
+template <typename To, typename From, bool Fallible = false,
+          typename Enable = void>
+struct CastInfo
+    : public std::conditional_t<Fallible, FallibleValueCast<To, From>,
+                                InfallibleValueCast<To, From>> {};
+
+template <typename To, typename From>
+struct CastInfo<To, From *> : public CheckedPointerCast<To, From *> {};
+
+template <typename To, typename From>
+struct CastInfo<To, std::unique_ptr<From>> : public UniquePtrCast<To, From> {};
+
+template <typename To, typename From>
+struct CastInfo<To, Optional<From>> : public FallibleValueCast<To, From> {};
+
+/// isa<X> - Return true if the parameter to the template is an instance of one
+/// of the template type arguments.  Used like this:
+///
+///  if (isa<Type>(myVal)) { ... }
+///  if (isa<Type0, Type1, Type2>(myVal)) { ... }
+template <typename To, typename From>
+LLVM_NODISCARD inline bool isa(const From &Val) {
+  return CastInfo<To, const From>::isPossible(Val);
 }
 
-// cast_or_null<X> - Functionally identical to cast, except that a null value is
-// accepted.
-//
-template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<
-    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
-cast_or_null(const Y &Val) {
-  if (!Val)
-    return nullptr;
-  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
-  return cast<X>(Val);
+template <typename First, typename Second, typename... Rest, typename From>
+LLVM_NODISCARD inline bool isa(const From &Val) {
+  return isa<First>(Val) || isa<Second, Rest...>(Val);
 }
 
-template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<!is_simple_type<Y>::value,
-                                       typename cast_retty<X, Y>::ret_type>
-cast_or_null(Y &Val) {
-  if (!Val)
-    return nullptr;
-  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
-  return cast<X>(Val);
+/// cast<X> - Return the argument parameter cast to the specified type.  This
+/// casting operator asserts that the type is correct, so it does not return
+/// null on failure.  It does not allow a null argument (use cast_if_present for
+/// that). It is typically used like this:
+///
+///  cast<Instruction>(myVal)->getParent()
+
+template <typename To, typename From>
+LLVM_NODISCARD inline typename CastInfo<To, const From>::CastResultType
+cast(const From &Val) {
+  return CastInfo<To, const From>::doCast(Val);
 }
 
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
-cast_or_null(Y *Val) {
-  if (!Val) return nullptr;
-  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
-  return cast<X>(Val);
+template <typename To, typename From>
+LLVM_NODISCARD inline typename CastInfo<To, From>::CastResultType
+cast(From &Val) {
+  return CastInfo<To, From>::doCast(Val);
 }
 
-template <class X, class Y>
-inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
-cast_or_null(std::unique_ptr<Y> &&Val) {
-  if (!Val)
-    return nullptr;
-  return cast<X>(std::move(Val));
+template <typename To, typename From>
+LLVM_NODISCARD inline typename CastInfo<To, From *>::CastResultType
+cast(From *Val) {
+  return CastInfo<To, From *>::doCast(Val);
 }
 
-// dyn_cast<X> - Return the argument parameter cast to the specified type.  This
-// casting operator returns null if the argument is of the wrong type, so it can
-// be used to test for a type as well as cast if successful.  This should be
-// used in the context of an if statement like this:
-//
-//  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
-//
+template <typename To, typename From>
+LLVM_NODISCARD inline
+    typename CastInfo<To, std::unique_ptr<From>>::CastResultType
+    cast(std::unique_ptr<From> &&Val) {
+  return CastInfo<To, std::unique_ptr<From>>::doCast(std::move(Val));
+}
 
-template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<
-    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
-dyn_cast(const Y &Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
+/// dyn_cast<X> - Return the argument parameter cast to the specified type. This
+/// casting operator returns null if the argument is of the wrong type, so it
+/// can be used to test for a type as well as cast if successful. The value
+/// passed in must be present, if not, use dyn_cast_if_present. This should be
+/// used in the context of an if statement like this:
+///
+///  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
+
+template <typename To, typename From>
+LLVM_NODISCARD inline typename CastInfo<To, const From, true>::CastResultType
+dyn_cast(const From &Val) {
+  return CastInfo<To, const From, true>::doCastIfPossible(Val);
 }
 
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
+template <typename To, typename From>
+LLVM_NODISCARD inline typename CastInfo<To, From, true>::CastResultType
+dyn_cast(From &Val) {
+  return CastInfo<To, From, true>::doCastIfPossible(Val);
 }
 
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
+template <typename To, typename From>
+LLVM_NODISCARD inline typename CastInfo<To, From *>::CastResultType
+dyn_cast(From *Val) {
+  return CastInfo<To, From *>::doCastIfPossible(Val);
 }
 
-// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
-// value is accepted.
-//
-template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<
-    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
-dyn_cast_or_null(const Y &Val) {
-  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
+template <typename To, typename From>
+LLVM_NODISCARD inline
+    typename CastInfo<To, std::unique_ptr<From>>::CastResultType
+    dyn_cast(std::unique_ptr<From> &&Val) {
+  return CastInfo<To, std::unique_ptr<From>>::doCastIfPossible(std::move(Val));
 }
 
+/// isa_and_present<X> - Functionally identical to isa, except that a null value
+/// is accepted.
+template <typename... X, class Y>
+LLVM_NODISCARD inline bool isa_and_present(const Y &Val) {
+  if (!isPresent(Val))
+    return false;
+  return isa<X...>(Val);
+}
+
+template <typename... X, class Y>
+LLVM_NODISCARD inline bool isa_and_nonnull(const Y &Val) {
+  return isa_and_present<X...>(Val);
+}
+
+/// cast_if_present<X> - Functionally identical to cast, except that a null
+/// value is accepted.
 template <class X, class Y>
-LLVM_NODISCARD inline std::enable_if_t<!is_simple_type<Y>::value,
-                                       typename cast_retty<X, Y>::ret_type>
-dyn_cast_or_null(Y &Val) {
-  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
+LLVM_NODISCARD inline auto cast_if_present(const Y &Val) {
+  if (!isPresent(Val))
+    return CastInfo<X, const Y, true>::castFailed();
+  assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!");
+  return cast<X>(unwrapValue(Val));
+}
+
+template <class X, class Y> LLVM_NODISCARD inline auto cast_if_present(Y &Val) {
+  if (!isPresent(Val))
+    return CastInfo<X, Y, true>::castFailed();
+  assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!");
+  return cast<X>(unwrapValue(Val));
+}
+
+template <class X, class Y> LLVM_NODISCARD inline auto cast_if_present(Y *Val) {
+  if (!isPresent(Val))
+    return CastInfo<X, Y *, true>::castFailed();
+  assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!");
+  return cast<X>(unwrapValue(Val));
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
-dyn_cast_or_null(Y *Val) {
-  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
+LLVM_NODISCARD inline auto cast_if_present(std::unique_ptr<Y> &&Val) {
+  if (!isPresent(Val))
+    return UniquePtrCast<X, Y>::castFailed();
+  return UniquePtrCast<X, Y>::doCast(std::move(Val));
+}
+
+// Provide a forwarding from cast_or_null to cast_if_present for current
+// users. This is deprecated and will be removed in a future patch, use
+// cast_if_present instead.
+template <class X, class Y> auto cast_or_null(const Y &Val) {
+  return cast_if_present<X>(Val);
+}
+
+template <class X, class Y> auto cast_or_null(Y &Val) {
+  return cast_if_present<X>(Val);
+}
+
+template <class X, class Y> auto cast_or_null(Y *Val) {
+  return cast_if_present<X>(Val);
+}
+
+template <class X, class Y> auto cast_or_null(std::unique_ptr<Y> &&Val) {
+  return cast_if_present<X>(std::move(Val));
+}
+
+/// dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a
+/// null (or none in the case of optionals) value is accepted.
+template <class X, class Y> auto dyn_cast_if_present(const Y &Val) {
+  if (!isPresent(Val))
+    return CastInfo<X, const Y, true>::castFailed();
+  return CastInfo<X, const Y, true>::doCastIfPossible(unwrapValue(Val));
+}
+
+template <class X, class Y> auto dyn_cast_if_present(Y &Val) {
+  if (!isPresent(Val))
+    return CastInfo<X, Y, true>::castFailed();
+  return CastInfo<X, Y, true>::doCastIfPossible(unwrapValue(Val));
+}
+
+template <class X, class Y> auto dyn_cast_if_present(Y *Val) {
+  if (!isPresent(Val))
+    return CastInfo<X, Y *>::castFailed();
+  return CastInfo<X, Y *>::doCastIfPossible(unwrapValue(Val));
+}
+
+// Forwards to dyn_cast_if_present to avoid breaking current users. This is
+// deprecated and will be removed in a future patch, use
+// cast_if_present instead.
+template <class X, class Y> auto dyn_cast_or_null(const Y &Val) {
+  return dyn_cast_if_present<X>(Val);
+}
+
+template <class X, class Y> auto dyn_cast_or_null(Y &Val) {
+  return dyn_cast_if_present<X>(Val);
+}
+
+template <class X, class Y> auto dyn_cast_or_null(Y *Val) {
+  return dyn_cast_if_present<X>(Val);
 }
 
-// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
-// taking ownership of the input pointer iff isa<X>(Val) is true.  If the
-// cast is successful, From refers to nullptr on exit and the casted value
-// is returned.  If the cast is unsuccessful, the function returns nullptr
-// and From is unchanged.
+/// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
+/// taking ownership of the input pointer iff isa<X>(Val) is true.  If the
+/// cast is successful, From refers to nullptr on exit and the casted value
+/// is returned.  If the cast is unsuccessful, the function returns nullptr
+/// and From is unchanged.
 template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &Val)
-    -> decltype(cast<X>(Val)) {
+LLVM_NODISCARD inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
+unique_dyn_cast(std::unique_ptr<Y> &Val) {
   if (!isa<X>(Val))
     return nullptr;
   return cast<X>(std::move(Val));
@@ -386,11 +797,11 @@
   return unique_dyn_cast<X, Y>(Val);
 }
 
-// dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast, except that
-// a null value is accepted.
+// unique_dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast,
+// except that a null value is accepted.
 template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &Val)
-    -> decltype(cast<X>(Val)) {
+LLVM_NODISCARD inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
+unique_dyn_cast_or_null(std::unique_ptr<Y> &Val) {
   if (!Val)
     return nullptr;
   return unique_dyn_cast<X, Y>(Val);
diff --git a/llvm/unittests/Support/Casting.cpp b/llvm/unittests/Support/Casting.cpp
--- a/llvm/unittests/Support/Casting.cpp
+++ b/llvm/unittests/Support/Casting.cpp
@@ -28,15 +28,13 @@
   struct foo *caz();
   struct foo *daz();
   struct foo *naz();
+
 private:
   bar(const bar &);
 };
 struct foo {
+  foo(const bar &) {}
   void ext() const;
-  /*  static bool classof(const bar *X) {
-    cerr << "Classof: " << X << "\n";
-    return true;
-    }*/
 };
 
 struct base {
@@ -54,26 +52,21 @@
   }
 };
 
+// Note for the future - please don't do this. isa_impl is an internal template
+// for the implementation of `isa` and should not be exposed this way.
+// Completely unrelated types *should* result in compiler errors if you try to
+// cast between them.
 template <typename T> struct isa_impl<foo, T> {
   static inline bool doit(const T &Val) { return false; }
 };
 
-foo *bar::baz() {
-    return cast<foo>(this);
-}
+foo *bar::baz() { return cast<foo>(this); }
 
-foo *bar::caz() {
-    return cast_or_null<foo>(this);
-}
+foo *bar::caz() { return cast_or_null<foo>(this); }
 
-foo *bar::daz() {
-    return dyn_cast<foo>(this);
-}
-
-foo *bar::naz() {
-    return dyn_cast_or_null<foo>(this);
-}
+foo *bar::daz() { return dyn_cast<foo>(this); }
 
+foo *bar::naz() { return dyn_cast_or_null<foo>(this); }
 
 bar *fub();
 
@@ -82,10 +75,54 @@
   static SimpleType getSimplifiedValue(foo &Val) { return 0; }
 };
 
-} // End llvm namespace
+struct T1 {};
 
-using namespace llvm;
+struct T2 {
+  T2(const T1 &x) {}
+  static bool classof(const T1 *x) { return true; }
+};
+
+// Provide a pointer cast and a fallible value cast.
+template <>
+struct CastInfo<T2, T1> : public CheckedPointerCast<T2, T1 *>,
+                          public FallibleValueCast<T2, T1> {};
+
+struct T3 {
+  T3(const T1 *x) : hasValue(x != nullptr) {}
+
+  static bool classof(const T1 *x) { return true; }
+  bool hasValue = false;
+};
 
+// T3 is convertible from a pointer to T1.
+template <> struct CastInfo<T3, T1 *> : public ValueFromPointerCast<T3, T1> {};
+
+struct T4 {
+  T4() : hasValue(false) {}
+  T4(const T3 &x) : hasValue(true) {}
+
+  static bool classof(const T3 *x) { return true; }
+  bool hasValue = false;
+};
+
+template <> struct ValueIsPresent<T3> {
+  using UnwrappedType = T3;
+  static inline bool isPresent(const T3 &t) { return t.hasValue; }
+  static inline const T3 &unwrapValue(const T3 &t) { return t; }
+};
+
+template <> struct FallibleCastTraits<T4, T3> {
+  using CastResultType = T4;
+  static inline CastResultType doCast(const T3 &t) { return T4(t); }
+  static inline CastResultType castFailed() { return CastResultType(); }
+  static inline CastResultType doCastIfPossible(const T3 &f) {
+    return doCast(f);
+  }
+};
+
+} // namespace llvm
+
+using namespace llvm;
 
 // Test the peculiar behavior of Use in simplify_type.
 static_assert(std::is_same<simplify_type<Use>::SimpleType, Value *>::value,
@@ -156,7 +193,7 @@
   EXPECT_NE(F12, null_foo);
   const foo *F13 = cast_or_null<foo>(B4);
   EXPECT_NE(F13, null_foo);
-  const foo *F14 = cast_or_null<foo>(fub());  // Shouldn't print.
+  const foo *F14 = cast_or_null<foo>(fub()); // Shouldn't print.
   EXPECT_EQ(F14, null_foo);
   foo *F15 = B1.caz();
   EXPECT_NE(F15, null_foo);
@@ -180,6 +217,8 @@
   EXPECT_NE(F5, null_foo);
 }
 
+// All these tests forward to dyn_cast_if_present, so they also provde an
+// effective test for its use cases.
 TEST(CastingTest, dyn_cast_or_null) {
   const foo *F1 = dyn_cast_or_null<foo>(B2);
   EXPECT_NE(F1, null_foo);
@@ -191,6 +230,43 @@
   EXPECT_EQ(F4, null_foo);
   foo *F5 = B1.naz();
   EXPECT_NE(F5, null_foo);
+  // dyn_cast_if_present should have exactly the same behavior as
+  // dyn_cast_or_null.
+  const foo *F6 = dyn_cast_if_present<foo>(B2);
+  EXPECT_EQ(F6, F2);
+}
+
+TEST(CastingTest, dyn_cast_value_types) {
+  T1 t1;
+  Optional<T2> t2 = dyn_cast<T2>(t1);
+  EXPECT_TRUE(t2.hasValue());
+
+  T2 *t2ptr = dyn_cast<T2>(&t1);
+  EXPECT_TRUE(t2ptr != nullptr);
+
+  T3 t3 = dyn_cast<T3>(&t1);
+  EXPECT_TRUE(t3.hasValue);
+}
+
+TEST(CastingTest, dyn_cast_if_present) {
+  Optional<T1> empty{};
+  Optional<T2> F1 = dyn_cast_if_present<T2>(empty);
+  EXPECT_FALSE(F1.hasValue());
+
+  T1 t1;
+  Optional<T2> F2 = dyn_cast_if_present<T2>(t1);
+  EXPECT_TRUE(F2.hasValue());
+
+  T1 *t1Null = nullptr;
+
+  // T3 should have hasValue == false because t1Null is nullptr.
+  T3 t3 = dyn_cast_if_present<T3>(t1Null);
+  EXPECT_FALSE(t3.hasValue);
+
+  // Now because of that, T4 should receive the castFailed implementation of its
+  // FallibleCastTraits, which default-constructs a T4, which has no value.
+  T4 t4 = dyn_cast_if_present<T4>(t3);
+  EXPECT_FALSE(t4.hasValue);
 }
 
 std::unique_ptr<derived> newd() { return std::make_unique<derived>(); }
@@ -227,6 +303,9 @@
 
   // Converting between unrelated types should fail.  The original value should
   // remain unchanged and it should return nullptr.
+  //
+  // Note that this is a very contrived test - most of the time we want a cast
+  // like this to emit a compiler error.
   auto F = unique_dyn_cast<foo>(D);
   ASSERT_EQ(nullptr, F);
   ASSERT_EQ(OrigD, D.get());
@@ -246,14 +325,14 @@
 }
 
 // These lines are errors...
-//foo *F20 = cast<foo>(B2);  // Yields const foo*
-//foo &F21 = cast<foo>(B3);  // Yields const foo&
-//foo *F22 = cast<foo>(B4);  // Yields const foo*
-//foo &F23 = cast_or_null<foo>(B1);
-//const foo &F24 = cast_or_null<foo>(B3);
+// foo *F20 = cast<foo>(B2);  // Yields const foo*
+// foo &F21 = cast<foo>(B3);  // Yields const foo&
+// foo *F22 = cast<foo>(B4);  // Yields const foo*
+// foo &F23 = cast_or_null<foo>(B1);
+// const foo &F24 = cast_or_null<foo>(B3);
 
 const bar *B2 = &B;
-}  // anonymous namespace
+} // anonymous namespace
 
 bar *llvm::fub() { return nullptr; }
 
@@ -286,16 +365,13 @@
   EXPECT_NE(BP, nullptr);
 }
 
-
 // This test verifies that the inferred upcast takes precedence over an
 // explicitly written one. This is important because it verifies that the
 // dynamic check gets optimized away.
 class UseInferredUpcast {
 public:
   int Dummy;
-  static bool classof(const UseInferredUpcast *) {
-    return false;
-  }
+  static bool classof(const UseInferredUpcast *) { return false; }
 };
 
 TEST(CastingTest, InferredUpcastTakesPrecedence) {
@@ -310,8 +386,8 @@
 // Test that we reject casts of temporaries (and so the illegal cast gets used).
 namespace TemporaryCast {
 struct pod {};
-IllegalCast *testIllegalCast() { return cast<foo>(pod()); }
-}
+// IllegalCast *testIllegalCast() { return cast<foo>(pod()); }
+} // namespace TemporaryCast
 
 namespace {
 namespace pointer_wrappers {
@@ -328,6 +404,7 @@
 
 class PTy {
   Base *B;
+
 public:
   PTy(Base *B) : B(B) {}
   explicit operator bool() const { return get(); }
@@ -339,14 +416,41 @@
 
 namespace llvm {
 
+template <> struct ValueIsPresent<pointer_wrappers::PTy> {
+  using UnwrappedType = pointer_wrappers::PTy;
+  static inline bool isPresent(const pointer_wrappers::PTy &P) {
+    return P.get() != nullptr;
+  }
+  static const UnwrappedType &unwrapValue(const pointer_wrappers::PTy &P) {
+    return P;
+  }
+};
+
+template <> struct ValueIsPresent<const pointer_wrappers::PTy> {
+  using UnwrappedType = pointer_wrappers::PTy;
+  static inline bool isPresent(const pointer_wrappers::PTy &P) {
+    return P.get() != nullptr;
+  }
+
+  static const UnwrappedType &unwrapValue(const pointer_wrappers::PTy &P) {
+    return P;
+  }
+};
+
 template <> struct simplify_type<pointer_wrappers::PTy> {
   typedef pointer_wrappers::Base *SimpleType;
+  static bool valueIsPresent(pointer_wrappers::PTy &P) {
+    return P.get() != nullptr;
+  }
   static SimpleType getSimplifiedValue(pointer_wrappers::PTy &P) {
     return P.get();
   }
 };
 template <> struct simplify_type<const pointer_wrappers::PTy> {
   typedef pointer_wrappers::Base *SimpleType;
+  static bool valueIsPresent(const pointer_wrappers::PTy &P) {
+    return P.get() != nullptr;
+  }
   static SimpleType getSimplifiedValue(const pointer_wrappers::PTy &P) {
     return P.get();
   }