New C++17 backport: folly::enable_shared_from_this

Summary:
C++14 has no direct means of creating a std::weak_ptr, one must always create a (temporary) std::shared_ptr first. C++17 adds weak_from_this() to std::enable_shared_from_this to avoid that overhead.
Alas code that is meant to compile under different language versions cannot rely on std::enable_shared_from_this::weak_from_this().
This new utility class uses SFINAE to call std::enable_shared_from_this<T>::weak_from_this() if available. Falls back to std::enable_shared_from_this<T>::shared_from_this() otherwise.
Use as a drop-in replacement for std::enable_shared_from_this where weak_from_this() is desired.

Reviewed By: yfeldblum

Differential Revision: D4616394

fbshipit-source-id: 73bf6cd8852d4a33478a9280cc69c81e7ea73423

folly/Memory.h

@@ -446,4 +446,93 @@ std::shared_ptr<T> allocate_shared(Allocator&& allocator, Args&&... args) {
  */
 template <class T> struct IsArenaAllocator : std::false_type { };
 
+/*
+ * folly::enable_shared_from_this
+ *
+ * To be removed once C++17 becomes a minimum requirement for folly.
+ */
+#if __cplusplus >= 201700L || \
+    __cpp_lib_enable_shared_from_this >= 201603L
+
+// Guaranteed to have std::enable_shared_from_this::weak_from_this(). Prefer
+// type alias over our own class.
+/* using override */ using std::enable_shared_from_this;
+
+#else
+
+/**
+ * Extends std::enabled_shared_from_this. Offers weak_from_this() to pre-C++17
+ * code. Use as drop-in replacement for std::enable_shared_from_this.
+ *
+ * C++14 has no direct means of creating a std::weak_ptr, one must always
+ * create a (temporary) std::shared_ptr first. C++17 adds weak_from_this() to
+ * std::enable_shared_from_this to avoid that overhead. Alas code that must
+ * compile under different language versions cannot call
+ * std::enable_shared_from_this::weak_from_this() directly. Hence this class.
+ *
+ * @example
+ *   class MyClass : public folly::enable_shared_from_this<MyClass> {};
+ *
+ *   int main() {
+ *     std::shared_ptr<MyClass> sp = std::make_shared<MyClass>();
+ *     std::weak_ptr<MyClass> wp = sp->weak_from_this();
+ *   }
+ */
+template <typename T>
+class enable_shared_from_this : public std::enable_shared_from_this<T> {
+public:
+  constexpr enable_shared_from_this() noexcept = default;
+
+  std::weak_ptr<T> weak_from_this() noexcept {
+    return weak_from_this_<T>(this);
+  }
+
+  std::weak_ptr<T const> weak_from_this() const noexcept {
+    return weak_from_this_<T>(this);
+  }
+
+private:
+  // Uses SFINAE to detect and call
+  // std::enable_shared_from_this<T>::weak_from_this() if available. Falls
+  // back to std::enable_shared_from_this<T>::shared_from_this() otherwise.
+  template <typename U>
+  auto weak_from_this_(std::enable_shared_from_this<U>* base_ptr)
+  noexcept -> decltype(base_ptr->weak_from_this()) {
+    return base_ptr->weak_from_this();
+  }
+
+  template <typename U>
+  auto weak_from_this_(std::enable_shared_from_this<U> const* base_ptr)
+  const noexcept -> decltype(base_ptr->weak_from_this()) {
+    return base_ptr->weak_from_this();
+  }
+
+  template <typename U>
+  std::weak_ptr<U> weak_from_this_(...) noexcept {
+    try {
+      return this->shared_from_this();
+    } catch (std::bad_weak_ptr const&) {
+      // C++17 requires that weak_from_this() on an object not owned by a
+      // shared_ptr returns an empty weak_ptr. Sadly, in C++14,
+      // shared_from_this() on such an object is undefined behavior, and there
+      // is nothing we can do to detect and handle the situation in a portable
+      // manner. But in case a compiler is nice enough to implement C++17
+      // semantics of shared_from_this() and throws a bad_weak_ptr, we catch it
+      // and return an empty weak_ptr.
+      return std::weak_ptr<U>{};
+    }
+  }
+
+  template <typename U>
+  std::weak_ptr<U const> weak_from_this_(...) const noexcept {
+    try {
+      return this->shared_from_this();
+    } catch (std::bad_weak_ptr const&) {
+      return std::weak_ptr<U const>{};
+    }
+  }
+};
+
+#endif
+
 }  // namespace folly

folly/test/MemoryTest.cpp

@@ -22,6 +22,7 @@
 #include <glog/logging.h>
 
 #include <type_traits>
+#include <utility>
 
 using namespace folly;
 
@@ -105,3 +106,48 @@ TEST(rebind_allocator, sanity_check) {
   s.reset();
   ASSERT_EQ(nullptr, s.get());
 }
+
+template <typename C>
+static void test_enable_shared_from_this(std::shared_ptr<C> sp) {
+  ASSERT_EQ(1l, sp.use_count());
+
+  // Test shared_from_this().
+  std::shared_ptr<C> sp2 = sp->shared_from_this();
+  ASSERT_EQ(sp, sp2);
+
+  // Test weak_from_this().
+  std::weak_ptr<C> wp = sp->weak_from_this();
+  ASSERT_EQ(sp, wp.lock());
+  sp.reset();
+  sp2.reset();
+  ASSERT_EQ(nullptr, wp.lock());
+
+  // Test shared_from_this() and weak_from_this() on object not owned by a
+  // shared_ptr. Undefined in C++14 but well-defined in C++17. Also known to
+  // work with libstdc++ >= 20150123. Feel free to add other standard library
+  // versions where the behavior is known.
+#if __cplusplus >= 201700L || \
+    __GLIBCXX__ >= 20150123L
+  C stack_resident;
+  ASSERT_THROW(stack_resident.shared_from_this(), std::bad_weak_ptr);
+  ASSERT_TRUE(stack_resident.weak_from_this().expired());
+#endif
+}
+
+TEST(enable_shared_from_this, compatible_with_std_enable_shared_from_this) {
+  // Compile-time compatibility.
+  class C_std : public std::enable_shared_from_this<C_std> {};
+  class C_folly : public folly::enable_shared_from_this<C_folly> {};
+  static_assert(
+    noexcept(std::declval<C_std>().shared_from_this()) ==
+    noexcept(std::declval<C_folly>().shared_from_this()), "");
+  static_assert(
+    noexcept(std::declval<C_std const>().shared_from_this()) ==
+    noexcept(std::declval<C_folly const>().shared_from_this()), "");
+  static_assert(noexcept(std::declval<C_folly>().weak_from_this()), "");
+  static_assert(noexcept(std::declval<C_folly const>().weak_from_this()), "");
+
+  // Runtime compatibility.
+  test_enable_shared_from_this(std::make_shared<C_folly>());
+  test_enable_shared_from_this(std::make_shared<C_folly const>());
+}