Try lifetimebound

Author: danakj

subspace/CMakeLists.txt

@@ -73,6 +73,7 @@ target_sources(subspace PUBLIC
     "macros/compiler.h"
     "macros/eval_macro.h"
     "macros/for_each.h"
+    "macros/lifetimebound.h"
     "macros/no_unique_address.h"
     "macros/nonnull.h"
     "macros/remove_parens.h"

subspace/fn/fn_defn.h

@@ -17,6 +17,7 @@
 #include <stdint.h>
 
 #include "subspace/fn/callable.h"
+#include "subspace/macros/lifetimebound.h"
 #include "subspace/mem/addressof.h"
 #include "subspace/mem/forward.h"
 #include "subspace/mem/never_value.h"
@@ -85,6 +86,14 @@ concept FunctionPointer =
       { (*f)(args...) } -> std::convertible_to<R>;
     };
 
+template <class T>
+concept IsFunctionPointer = std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>;
+
+template <class F>
+concept ConvertsToFunctionPointer = requires(F f) {
+  { +f } -> IsFunctionPointer;
+};
+
 template <class F, class R, class... Args>
 concept CallableMut =
     !FunctionPointer<F, R, Args...> && requires(F & f, Args... args) {
@@ -127,7 +136,7 @@ concept CallableConst =
 template <class R, class... CallArgs>
 class [[sus_trivial_abi]] Fn<R(CallArgs...)> {
  public:
-  /// Construction from a function pointer or captureless lambda.
+  /// Construction from a function pointer.
   ///
   /// #[doc.overloads=ctor.fnpointer]
   template <__private::FunctionPointer<R, CallArgs...> F>
@@ -137,16 +146,28 @@ class [[sus_trivial_abi]] Fn<R(CallArgs...)> {
     invoke_ = &__private::Invoker<F>::template fnptr_call_const<R, CallArgs...>;
   }
 
-  /// Construction from a capturing lambda or other callable object.
+  /// Construction from a non-capturing lambda.
   ///
   /// #[doc.overloads=ctor.lambda]
   template <__private::CallableMut<R, CallArgs...> F>
+    requires(__private::ConvertsToFunctionPointer<F>)
   constexpr Fn(F&& object) noexcept {
     storage_.object = ::sus::mem::addressof(object);
     invoke_ = &__private::Invoker<
         std::remove_reference_t<F>>::template object_call_const<R, CallArgs...>;
   }
 
+  /// Construction from a capturing lambda or other callable object.
+  ///
+  /// #[doc.overloads=ctor.lambda]
+  template <__private::CallableMut<R, CallArgs...> F>
+    requires(!__private::ConvertsToFunctionPointer<F>)
+  constexpr Fn(F&& object sus_lifetimebound) noexcept {
+    storage_.object = ::sus::mem::addressof(object);
+    invoke_ = &__private::Invoker<
+        std::remove_reference_t<F>>::template object_call_const<R, CallArgs...>;
+  }
+
   ~Fn() noexcept = default;
 
   constexpr Fn(Fn&& o) noexcept

subspace/fn/fn_unittest.cc

@@ -494,4 +494,9 @@ TEST(Fn, CallsCorrectOverload) {
   EXPECT_EQ(mut_calls, 2);
 }
 
+TEST(Fn, Lvalue) {
+  Fn<void()> f([]() {});
+  Fn<void()> g([i = 1]() { (void)i; });
+}
+
 }  // namespace

subspace/macros/lifetimebound.h

@@ -0,0 +1,19 @@
+// Copyright 2023 Google LLC
+//
+// 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
+//
+//     https://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 "subspace/macros/compiler.h"
+
+#define sus_lifetimebound sus_if_clang([[clang::lifetimebound]])