fix: constrain uses of nontype values as constants

Author: zhihaoy

include/std23/function_ref.h

@@ -145,9 +145,10 @@ class function_ref<Sig, R(Args...)> // freestanding
 
     template<auto f>
     constexpr function_ref(nontype_t<f>) noexcept
-        requires is_invocable_using<decltype(f)>
+        requires is_invocable_using<decltype((f))>
         : fptr_(
-              [](storage, _param_t<Args>... args) noexcept(noex) -> R {
+              [](storage, _param_t<Args>... args) noexcept(noex) -> R
+              {
                   return std23::invoke_r<R>(
                       f, static_cast<decltype(args)>(args)...);
               })
@@ -160,7 +161,7 @@ class function_ref<Sig, R(Args...)> // freestanding
     template<auto f, class U, class T = std::remove_reference_t<U>>
     constexpr function_ref(nontype_t<f>, U &&obj) noexcept
         requires(not std::is_rvalue_reference_v<U &&> and
-                 is_invocable_using<decltype(f), cvref<T>>)
+                 is_invocable_using<decltype((f)), cvref<T>>)
         : fptr_(
               [](storage this_, _param_t<Args>... args) noexcept(noex) -> R
               {
@@ -177,7 +178,7 @@ class function_ref<Sig, R(Args...)> // freestanding
 
     template<auto f, class T>
     constexpr function_ref(nontype_t<f>, cv<T> *obj) noexcept
-        requires is_invocable_using<decltype(f), decltype(obj)>
+        requires is_invocable_using<decltype((f)), decltype(obj)>
         : fptr_(
               [](storage this_, _param_t<Args>... args) noexcept(noex) -> R
               {

tests/function_ref/test_nontype.cpp

@@ -48,16 +48,17 @@ suite nttp_callable = []
                 expect(call({nontype<&A::data>, &a}) == 99_i);
             };
 
-            when("binding free function to object") = [&] {
-                expect(call({nontype<h>, a}) == free_function);
-            };
+            when("binding free function to object") = [&]
+            { expect(call({nontype<h>, a}) == free_function); };
 
-            when("binding closure to object") = [&] {
+            when("binding closure to object") = [&]
+            {
                 expect(call({nontype<[](A p) { return BODYN(p.data); }>, a}) ==
                        99_i);
             };
 
-            when("binding closure to pointer") = [&] {
+            when("binding closure to pointer") = [&]
+            {
                 expect(call({nontype<[](A *p) { return BODYN(p->data); }>,
                              &a}) == 99_i);
             };
@@ -71,3 +72,35 @@ suite nttp_callable = []
         };
     };
 };
+
+struct C_mut
+{
+    int operator()() { return BODYN(non_const); }
+};
+
+struct C_mut_A
+{
+    int operator()(A const &) { return 0; }
+};
+
+struct C_mut_pA
+{
+    int operator()(A *) { return 0; }
+};
+
+using T = function_ref<int()>;
+
+static_assert(std::is_constructible_v<T, nontype_t<C{}>>,
+              "nontype callable may have operator() overloaded on const");
+static_assert(not std::is_constructible_v<T, nontype_t<C_mut{}>>,
+              "nontype callable is called as a constant");
+
+static_assert(
+    std::is_constructible_v<T, nontype_t<[](A const &) { return 0; }>, A &>);
+static_assert(not std::is_constructible_v<T, nontype_t<C_mut_A{}>, A &>,
+              "nontype callable cannot potentially mutate its own state");
+static_assert(
+    std::is_constructible_v<T, nontype_t<[](A *) { return 0; }>, A *>);
+static_assert(
+    not std::is_constructible_v<T, nontype_t<C_mut_pA{}>, A *>,
+    "nontype callable cannot potentially mutate its own state (pointer form)");