Index: include/llvm/Support/Casting.h
===================================================================
--- include/llvm/Support/Casting.h
+++ include/llvm/Support/Casting.h
@@ -67,51 +67,24 @@
   static inline bool doit(const From &) { return true; }
 };
 
-template <typename To, typename From> struct isa_impl_cl {
-  static inline bool doit(const From &Val) {
-    return isa_impl<To, From>::doit(Val);
-  }
-};
+template <typename To, typename From, typename = void> struct isa_impl_cl {};
 
-template <typename To, typename From> struct isa_impl_cl<To, const From> {
+template <typename To, typename From>
+struct isa_impl_cl<To, From,
+                   enable_if_t<!is_dereferenceable<From>::value>> {
+  using FromTy = typename std::remove_const<From>::type;
   static inline bool doit(const From &Val) {
-    return isa_impl<To, From>::doit(Val);
+    return isa_impl<To, FromTy>::doit(Val);
   }
 };
 
 template <typename To, typename From>
-struct isa_impl_cl<To, const std::unique_ptr<From>> {
-  static inline bool doit(const std::unique_ptr<From> &Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl_cl<To, From>::doit(*Val);
-  }
-};
-
-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> {
-  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*> {
-  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> {
-  static inline bool doit(const From *Val) {
+struct isa_impl_cl<To, From, enable_if_t<is_dereferenceable<From>::value>> {
+  using FromTy =
+      typename std::remove_const<dereferenced_type_t<From>>::type;
+  static inline bool doit(const From &Val) {
     assert(Val && "isa<> used on a null pointer");
-    return isa_impl<To, From>::doit(*Val);
+    return isa_impl<To, FromTy>::doit(*Val);
   }
 };
 
Index: include/llvm/Support/type_traits.h
===================================================================
--- include/llvm/Support/type_traits.h
+++ include/llvm/Support/type_traits.h
@@ -104,6 +104,30 @@
   using type = typename add_const_past_pointer<T>::type;
 };
 
+template <typename T, typename = decltype((void)*std::declval<T>(),
+                                          (void)(std::declval<T>() && true))>
+std::true_type is_dereferenceable_test(const T &);
+std::false_type is_dereferenceable_test(...);
+
+template <typename T>
+using is_dereferenceable = decltype(is_dereferenceable_test(std::declval<T>()));
+
+template <bool Cond>
+using enable_if_t = typename std::enable_if<Cond>::type;
+
+template <typename T>
+using decay_t = typename std::decay<T>::type;
+
+template <typename F, typename = void> struct dereferenced_type;
+
+template <typename F>
+struct dereferenced_type<F, enable_if_t<is_dereferenceable<F>::value>> {
+  using type = decay_t<decltype(*std::declval<F>())>;
+};
+
+template <typename F>
+using dereferenced_type_t = typename dereferenced_type<F>::type;
+
 } // end namespace llvm
 
 // If the compiler supports detecting whether a class is final, define
Index: unittests/Support/Casting.cpp
===================================================================
--- unittests/Support/Casting.cpp
+++ unittests/Support/Casting.cpp
@@ -11,6 +11,7 @@
 #include "llvm/IR/User.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/ADT/Optional.h"
 #include "gtest/gtest.h"
 #include <cstdlib>
 
@@ -281,6 +282,12 @@
   EXPECT_TRUE(BP != nullptr);
 }
 
+TEST(CastingTest, DereferencableIsA) {
+  std::shared_ptr<Derived> DShared = std::make_shared<Derived>();
+  EXPECT_TRUE(isa<Base>(DShared));
+  llvm::Optional<Derived> DOpt;
+  EXPECT_TRUE(isa<Base>(DOpt));
+}
 
 // This test verifies that the inferred upcast takes precedence over an
 // explicitly written one. This is important because it verifies that the