Split out folly::enable_shared_from_this from Memory.h

Summary:
This doesn't need to be in Memory.h and is one of the reasons Memory.h fails to compile with -fno-exceptions, so split it out

I include EnableSharedFromThis.h because I'm not sure how else to ensure backward compatibility any other way (and I have the macro so we can include Memory.h without including EnableSharedFromThis.h)

Reviewed By: yfeldblum

Differential Revision: D9385709

fbshipit-source-id: bf2c3a757ae4eefba69e6191309d64b347becf12

folly/Makefile.am

@@ -367,6 +367,7 @@ nobase_follyinclude_HEADERS = \
 	Memory.h \
 	memory/Arena.h \
 	memory/Arena-inl.h \
+	memory/EnableSharedFromThis.h \
 	memory/MallctlHelper.h \
 	memory/Malloc.h \
 	memory/ThreadCachedArena.h \

folly/Memory.h

@@ -690,92 +690,4 @@ template <typename Value, typename T>
 struct AllocatorHasDefaultObjectDestroy<std::allocator<Value>, T>
     : std::true_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/memory/EnableSharedFromThis.h

+/*
+ * Copyright 2013-present Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+
+namespace folly {
+
+/*
+ * 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/EnableSharedFromThisTest.cpp

+/*
+ * Copyright 2013-present Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/memory/EnableSharedFromThis.h>
+#include <folly/portability/GTest.h>
+
+using namespace folly;
+
+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>());
+}

folly/test/MemoryTest.cpp

@@ -324,52 +324,6 @@ TEST(AllocatorObjectLifecycleTraits, compiles) {
       !folly::AllocatorHasDefaultObjectDestroy<TestAlloc5<S>, S>::value, "");
 }
 
-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>());
-}
-
 template <typename T>
 struct ExpectingAlloc {
   using value_type = T;