Enable UFCS in initializers of global variables, closes #314

The `[&]` introducer is required for the UFCS lambda in case it's invoked in a deeply nested context, but then the `[&]` is illegal when it's outside a function (initializing a namespace scope object)

Author: hsutter

include/cpp2util.h

@@ -672,6 +672,45 @@ class out {
 }(PARAM1)
 
 
+//  But for non-local lambdas [&] is not allowed
+
+#define CPP2_UFCS_NONLOCAL(FUNCNAME,PARAM1,...) \
+[](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+    if constexpr (requires{ std::forward<decltype(obj)>(obj).FUNCNAME(std::forward<decltype(params)>(params)...); }) { \
+        return std::forward<decltype(obj)>(obj).FUNCNAME(std::forward<decltype(params)>(params)...); \
+    } else { \
+        return FUNCNAME(std::forward<decltype(obj)>(obj), std::forward<decltype(params)>(params)...); \
+    } \
+}(PARAM1, __VA_ARGS__)
+
+#define CPP2_UFCS_0_NONLOCAL(FUNCNAME,PARAM1) \
+[](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+    if constexpr (requires{ std::forward<decltype(obj)>(obj).FUNCNAME(); }) { \
+        return std::forward<decltype(obj)>(obj).FUNCNAME(); \
+    } else { \
+        return FUNCNAME(std::forward<decltype(obj)>(obj)); \
+    } \
+}(PARAM1)
+
+#define CPP2_UFCS_TEMPLATE_NONLOCAL(FUNCNAME,TEMPARGS,PARAM1,...) \
+[](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+    if constexpr (requires{ std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(params)>(params)...); }) { \
+        return std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(params)>(params)...); \
+    } else { \
+        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(obj)>(obj), std::forward<decltype(params)>(params)...); \
+    } \
+}(PARAM1, __VA_ARGS__)
+
+#define CPP2_UFCS_TEMPLATE_0_NONLOCAL(FUNCNAME,TEMPARGS,PARAM1) \
+[](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+    if constexpr (requires{ std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); }) { \
+        return std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); \
+    } else { \
+        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(obj)>(obj)); \
+    } \
+}(PARAM1)
+
+
 //-----------------------------------------------------------------------
 //
 //  is and as

regression-tests/pure2-ufcs-member-access-and-chaining.cpp2

@@ -30,4 +30,8 @@ fun: () -> (i:int) = {
 
 get_i: (r:_) -> int = {
     return r.i;
-}
+}
+
+//  And a test for non-local UFCS, which shouldn't do a [&] capture
+f: (x)->int = 0;
+y: int = 0.f();

regression-tests/test-results/pure2-ufcs-member-access-and-chaining.cpp

@@ -24,6 +24,10 @@ struct fun__ret {
 #line 31 "pure2-ufcs-member-access-and-chaining.cpp2"
 [[nodiscard]] auto get_i(auto const& r) -> int;
 
+#line 35 "pure2-ufcs-member-access-and-chaining.cpp2"
+//  And a test for non-local UFCS, which shouldn't do a [&] capture
+[[nodiscard]] auto f(auto const& x) -> int;
+extern int y;
 //=== Cpp2 function definitions =================================================
 
 #line 1 "pure2-ufcs-member-access-and-chaining.cpp2"
@@ -63,3 +67,7 @@ struct fun__ret {
     return r.i; 
 }
 
+#line 36 "pure2-ufcs-member-access-and-chaining.cpp2"
+[[nodiscard]] auto f(auto const& x) -> int { return 0;  }
+int y {CPP2_UFCS_0_NONLOCAL(f, 0)}; 
+

source/cppfront.cpp

@@ -2250,9 +2250,11 @@ class cppfront
         if (
             !current_functions.empty()
             && current_functions.back().decl->is_function_with_this()
+            && !current_functions.back().decl->parent_is_namespace()
             )
         {
-            //  Note: & is needed because a nested UFCS might be viewed as trying to capture 'this'
+            //  Note: & is needed (when allowed, not at namespace scope) because a
+            //  nested UFCS might be viewed as trying to capture 'this'
             lambda_intro += "&";
             ++num_captures;
         }
@@ -2737,8 +2739,11 @@ class cppfront
             {
                 auto funcname = print_to_string(*i->id_expr);
 
+                //  First, build the UFCS macro name
+
                 auto ufcs_string = std::string("CPP2_UFCS");
 
+                //  If there are template arguments, use the _TEMPLATE version
                 if (i->id_expr->template_args_count() > 0) {
                     ufcs_string += "_TEMPLATE";
                     // we need to replace "fun<int,long,double>" to "fun, (<int,long,double>)" to be able to generate
@@ -2748,11 +2753,31 @@ class cppfront
                     assert(funcname.back() == '>');
                     funcname += ')';
                 }
+
                 //  If there are no additional arguments, use the _0 version
                 if (args.value().text_chunks.empty()) {
                     ufcs_string += "_0";
                 }
 
+                //  If we're in an object declaration (i.e., initializer)
+                //  at namespace scope, use the _NONLOCAL version
+                //
+                //  Note: If there are other cases where code could execute
+                //  in a non-local scope where a capture-default for the UFCS
+                //  lambda would not be allowed, then add them here
+                if (
+                    current_declarations.back()->is_namespace()
+                    || (
+                        current_declarations.back()->is_object()
+                        && current_declarations.back()->parent_is_namespace()
+                        )
+                    )
+                {
+                    ufcs_string += "_NONLOCAL";
+                }
+
+                //  Second, emit the UFCS argument list
+
                 prefix.emplace_back(ufcs_string + "(" + funcname + ", ", args.value().open_pos );
                 suffix.emplace_back(")", args.value().close_pos );
                 if (!args.value().text_chunks.empty()) {

source/parse.h

@@ -1714,7 +1714,7 @@ struct declaration_node
     auto parent_is_namespace() const -> bool
         { return !parent_declaration || parent_declaration->type.index() == a_namespace; }
     auto parent_is_alias    () const -> bool
-        { return !parent_declaration || parent_declaration->type.index() == an_alias;    }
+        { return  parent_declaration && parent_declaration->type.index() == an_alias;    }
 
     enum which {
         functions = 1,