test: regenerate regression tests

Author: JohelEGP

regression-tests/test-results/mixed-bounds-check.cpp

@@ -24,7 +24,7 @@
     std::set_terminate(std::abort);
 
     std::vector v {1, 2, 3, 4, 5, -999}; 
-    CPP2_UFCS_0(pop_back, v);
+    CPP2_UFCS(pop_back)(v);
     std::cout << cpp2::assert_in_bounds(std::move(v), 5) << "\n";
 }
 

regression-tests/test-results/mixed-bounds-safety-with-assert-2.cpp

@@ -38,7 +38,7 @@ auto add_42_to_subrange(auto& rng, cpp2::in<int> start, cpp2::in<int> end) -> vo
 auto add_42_to_subrange(auto& rng, cpp2::in<int> start, cpp2::in<int> end) -> void
 {
     cpp2::Bounds.expects(cpp2::cmp_less_eq(0,start), "");
-    cpp2::Bounds.expects(cpp2::cmp_less_eq(end,CPP2_UFCS_0(ssize, rng)), "");
+    cpp2::Bounds.expects(cpp2::cmp_less_eq(end,CPP2_UFCS(ssize)(rng)), "");
 
     auto count {0}; 
     for ( 

regression-tests/test-results/mixed-bounds-safety-with-assert.cpp

@@ -37,7 +37,7 @@ auto print_subrange(auto const& rng, cpp2::in<int> start, cpp2::in<int> end) ->
 
 auto print_subrange(auto const& rng, cpp2::in<int> start, cpp2::in<int> end) -> void{
     cpp2::Bounds.expects(cpp2::cmp_less_eq(0,start), "");
-    cpp2::Bounds.expects(cpp2::cmp_less_eq(end,CPP2_UFCS_0(ssize, rng)), "");
+    cpp2::Bounds.expects(cpp2::cmp_less_eq(end,CPP2_UFCS(ssize)(rng)), "");
 
     auto count {0}; 
     for ( 

regression-tests/test-results/mixed-captures-in-expressions-and-postconditions.cpp

@@ -45,9 +45,9 @@ auto insert_at(cpp2::in<int> where, cpp2::in<int> val) -> void
 
 #line 22 "mixed-captures-in-expressions-and-postconditions.cpp2"
 {
-    cpp2::Default.expects(cpp2::cmp_less_eq(0,where) && cpp2::cmp_less_eq(where,CPP2_UFCS_0(ssize, vec)), "");
-    auto post_21_5 = cpp2::finally_success([_0 = CPP2_UFCS_0(ssize, vec)]{cpp2::Default.expects(CPP2_UFCS_0(ssize, vec) == _0 + 1, "");} );
+    cpp2::Default.expects(cpp2::cmp_less_eq(0,where) && cpp2::cmp_less_eq(where,CPP2_UFCS(ssize)(vec)), "");
+    auto post_21_5 = cpp2::finally_success([_0 = CPP2_UFCS(ssize)(vec)]{cpp2::Default.expects(CPP2_UFCS(ssize)(vec) == _0 + 1, "");} );
 #line 23 "mixed-captures-in-expressions-and-postconditions.cpp2"
-    static_cast<void>(CPP2_UFCS(insert, vec, CPP2_UFCS_0(begin, vec) + where, val));
+    static_cast<void>(CPP2_UFCS(insert)(vec, CPP2_UFCS(begin)(vec) + where, val));
 }
 

regression-tests/test-results/mixed-fixed-type-aliases.cpp

@@ -45,6 +45,6 @@ auto test(auto const& x) -> void{
     test(std::move(z));
 
     for ( auto const& arg : args ) 
-        std::cout << CPP2_UFCS_0(filename, std::filesystem::path(arg)) << "\n";
+        std::cout << CPP2_UFCS(filename)(std::filesystem::path(arg)) << "\n";
 }
 

regression-tests/test-results/mixed-function-expression-and-std-for-each.cpp

@@ -30,16 +30,16 @@
 
     //  Passing a function expression
     std::for_each(
-        CPP2_UFCS_0(begin, view), 
-        CPP2_UFCS_0(end, view), 
+        CPP2_UFCS(begin)(view), 
+        CPP2_UFCS(end)(view), 
         [](auto& x) -> void { x += "-ish";  }
     );
 
     //  Initializing from a function expression
     auto callback {[](auto& x) -> void { x += " maybe";  }}; 
     std::for_each(
-        CPP2_UFCS_0(begin, view), 
-        CPP2_UFCS_0(end, view), 
+        CPP2_UFCS(begin)(view), 
+        CPP2_UFCS(end)(view), 
         std::move(callback)
     );
 

regression-tests/test-results/mixed-function-expression-with-pointer-capture.cpp

@@ -31,7 +31,7 @@
 
     std::string y {"\n"}; 
     std::ranges::for_each(view, [_0 = (&y)](auto const& x) -> void{
-        std::cout << CPP2_UFCS_0(c_str, (*cpp2::assert_not_null((_0)))) << x << *cpp2::assert_not_null(_0);
+        std::cout << CPP2_UFCS(c_str)((*cpp2::assert_not_null((_0)))) << x << *cpp2::assert_not_null(_0);
     });
 
     auto callback {[](auto& x) -> void { x += "-ish";  }}; 

regression-tests/test-results/mixed-initialization-safety-3-contract-violation.cpp

@@ -59,9 +59,9 @@ auto fill(
     ) -> void
 
 {
-    cpp2::Default.expects(cpp2::cmp_greater_eq(CPP2_UFCS_0(ssize, value),count), "fill: value must contain at least count elements");
+    cpp2::Default.expects(cpp2::cmp_greater_eq(CPP2_UFCS(ssize)(value),count), "fill: value must contain at least count elements");
 #line 25 "mixed-initialization-safety-3-contract-violation.cpp2"
-    x.construct(CPP2_UFCS(substr, value, 0, count));
+    x.construct(CPP2_UFCS(substr)(value, 0, count));
 }
 
 auto print_decorated(auto const& x) -> void { std::cout << ">> [" << x << "]\n";  }

regression-tests/test-results/mixed-initialization-safety-3.cpp

@@ -54,9 +54,9 @@ auto fill(
     ) -> void
 
 {
-    cpp2::Default.expects(cpp2::cmp_greater_eq(CPP2_UFCS_0(ssize, value),count), "fill: value must contain at least count elements");
+    cpp2::Default.expects(cpp2::cmp_greater_eq(CPP2_UFCS(ssize)(value),count), "fill: value must contain at least count elements");
 #line 23 "mixed-initialization-safety-3.cpp2"
-    x.construct(CPP2_UFCS(substr, value, 0, count));
+    x.construct(CPP2_UFCS(substr)(value, 0, count));
 }
 
 auto print_decorated(auto const& x) -> void { std::cout << ">> [" << x << "]\n";  }

regression-tests/test-results/mixed-lifetime-safety-and-null-contracts.cpp

@@ -34,7 +34,7 @@ auto call_my_framework(char const* msg) -> void;
 
 #line 6 "mixed-lifetime-safety-and-null-contracts.cpp2"
 [[nodiscard]] auto main() -> int{
-    CPP2_UFCS(set_handler, cpp2::Null, &call_my_framework);
+    CPP2_UFCS(set_handler)(cpp2::Null, &call_my_framework);
     try_pointer_stuff();
     std::cout << "done\n";
 }

regression-tests/test-results/mixed-postexpression-with-capture.cpp

@@ -40,9 +40,9 @@ auto insert_at(cpp2::in<int> where, cpp2::in<int> val) -> void
 
 #line 17 "mixed-postexpression-with-capture.cpp2"
 {
-    cpp2::Default.expects(cpp2::cmp_less_eq(0,where) && cpp2::cmp_less_eq(where,CPP2_UFCS_0(ssize, vec)), "");
-    auto post_16_5 = cpp2::finally_success([_0 = CPP2_UFCS_0(size, vec)]{cpp2::Default.expects(CPP2_UFCS_0(size, vec) == _0 + 1, "");} );
+    cpp2::Default.expects(cpp2::cmp_less_eq(0,where) && cpp2::cmp_less_eq(where,CPP2_UFCS(ssize)(vec)), "");
+    auto post_16_5 = cpp2::finally_success([_0 = CPP2_UFCS(size)(vec)]{cpp2::Default.expects(CPP2_UFCS(size)(vec) == _0 + 1, "");} );
 #line 18 "mixed-postexpression-with-capture.cpp2"
-    CPP2_UFCS(push_back, vec, val);
+    CPP2_UFCS(push_back)(vec, val);
 }
 

regression-tests/test-results/mixed-postfix-expression-custom-formatting.cpp

@@ -28,12 +28,12 @@ auto call([[maybe_unused]] auto const& param1, [[maybe_unused]] auto const& para
 
 [[nodiscard]] auto test(auto const& a) -> std::string{
     return call(a, 
-        ++*cpp2::assert_not_null(CPP2_UFCS(b, a, a.c)), "hello", /* polite
+        ++*cpp2::assert_not_null(CPP2_UFCS(b)(a, a.c)), "hello", /* polite
                           greeting
                           goes here */" there", 
-        CPP2_UFCS(e, a.d, ++CPP2_UFCS_0(g, *cpp2::assert_not_null(a.f)), // because f is foobar
-              CPP2_UFCS_0(i, a.h), 
-              CPP2_UFCS(j, a, a.k, a.l))
+        CPP2_UFCS(e)(a.d, ++CPP2_UFCS(g)(*cpp2::assert_not_null(a.f)), // because f is foobar
+              CPP2_UFCS(i)(a.h), 
+              CPP2_UFCS(j)(a, a.k, a.l))
         ); 
 }
 

regression-tests/test-results/mixed-string-interpolation.cpp

@@ -30,7 +30,7 @@ struct custom_struct_with_no_stringize_customization { } custom;
     std::cout << "a = " + cpp2::to_string(a) + ", b = " + cpp2::to_string(b) + "\n";
 
     b = 42;
-    std::cout << "a^2 + b = " + cpp2::to_string(a * std::move(a) + CPP2_UFCS_0(value, std::move(b))) + "\n";
+    std::cout << "a^2 + b = " + cpp2::to_string(a * std::move(a) + CPP2_UFCS(value)(std::move(b))) + "\n";
 
     std::string_view sv {"my string_view"}; 
     std::cout << "sv = " + cpp2::to_string(std::move(sv)) + "\n";

regression-tests/test-results/mixed-type-safety-1.cpp

@@ -55,7 +55,7 @@ auto print(cpp2::in<std::string> msg, cpp2::in<bool> b) -> void
     print( "1   is int? ", cpp2::is<int>(1));
 
     auto c {cpp2_new<Circle>()}; // safe by construction
-    Shape* s {CPP2_UFCS_0(get, c)}; // safe by Lifetime
+    Shape* s {CPP2_UFCS(get)(c)}; // safe by Lifetime
     print("\ns* is Shape?  ", cpp2::is<Shape>(*cpp2::assert_not_null(s)));
     print(  "s* is Circle? ", cpp2::is<Circle>(*cpp2::assert_not_null(s)));
     print(  "s* is Square? ", cpp2::is<Square>(*cpp2::assert_not_null(std::move(s))));

regression-tests/test-results/mixed-ufcs-multiple-template-arguments.cpp

@@ -39,6 +39,6 @@ struct X {
     std::cout << substr<4,8>(test_string) << "\n";
 
     X x {test_string}; 
-    std::cout << CPP2_UFCS_TEMPLATE_0(substr, (<4,8>), std::move(x)) << "\n";
+    std::cout << CPP2_UFCS_TEMPLATE(substr<4,8>)(std::move(x)) << "\n";
 }
 

regression-tests/test-results/pure2-bounds-safety-span.cpp

@@ -30,7 +30,7 @@ auto print_and_decorate(auto const& thing) -> void;
     std::span<std::string> s {words}; 
 
     auto i {0}; 
-    for( ; cpp2::cmp_less(i,CPP2_UFCS_0(ssize, s)); ++i ) {
+    for( ; cpp2::cmp_less(i,CPP2_UFCS(ssize)(s)); ++i ) {
         print_and_decorate(cpp2::assert_in_bounds(s, i));
     }
 }

regression-tests/test-results/pure2-bugfix-for-ufcs-arguments.cpp

@@ -31,7 +31,7 @@ template<typename T> [[nodiscard]] auto f(cpp2::in<t> o, auto const& x) -> cpp2:
 template<typename T, typename U> [[nodiscard]] auto f(cpp2::in<t> o, auto const& x, auto const& y) -> cpp2::i32;
 extern t m;
 extern t const n;
-template<typename T, typename U> auto static constexpr a = n;
+template<typename T, typename U> auto inline constexpr a = n;
 extern cpp2::i32 auto_21_1;
 extern cpp2::i32 auto_22_1;
 extern cpp2::i32 auto_23_1;

regression-tests/test-results/pure2-enum.cpp

@@ -232,7 +232,7 @@ inline CPP2_CONSTEXPR file_attributes file_attributes::none = 0;
 #line 28 "pure2-enum.cpp2"
 auto main() -> int{
     auto j {janus::past}; 
-    CPP2_UFCS_0(flip, j);
+    CPP2_UFCS(flip)(j);
     static_cast<void>(std::move(j));
 
     // x : skat_game = 9;               // error, can't construct skat_game from integer
@@ -244,8 +244,8 @@ auto main() -> int{
     // if x == 9 { }                    // error, can't compare skat_game and integer
     // if x == rgb::red { }             // error, can't compare skat_game and rgb color
 
-    std::cout << "x.to_string() is " + cpp2::to_string(CPP2_UFCS_0(to_string, x)) + "\n";
-    std::cout << "x2.to_string() is " + cpp2::to_string(CPP2_UFCS_0(to_string, std::move(x2))) + "\n";
+    std::cout << "x.to_string() is " + cpp2::to_string(CPP2_UFCS(to_string)(x)) + "\n";
+    std::cout << "x2.to_string() is " + cpp2::to_string(CPP2_UFCS(to_string)(std::move(x2))) + "\n";
 
     std::cout << "with if else: ";
     if (x == skat_game::diamonds) {     // ok, can compare two skat_games
@@ -277,41 +277,41 @@ auto main() -> int{
 
     x = skat_game::diamonds;        // ok, can assign one skat_game from another
 
-    std::cout << "file_attributes::cached.get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, file_attributes::cached)) + "\n";
-    std::cout << "file_attributes::current.get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, file_attributes::current)) + "\n";
-    std::cout << "file_attributes::obsolete.get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, file_attributes::obsolete)) + "\n";
-    std::cout << "file_attributes::cached_and_current.get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, file_attributes::cached_and_current)) + "\n";
+    std::cout << "file_attributes::cached.get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(file_attributes::cached)) + "\n";
+    std::cout << "file_attributes::current.get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(file_attributes::current)) + "\n";
+    std::cout << "file_attributes::obsolete.get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(file_attributes::obsolete)) + "\n";
+    std::cout << "file_attributes::cached_and_current.get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(file_attributes::cached_and_current)) + "\n";
 
     file_attributes f {file_attributes::cached_and_current}; 
     f &= file_attributes::cached | file_attributes::obsolete;
-    std::cout << "f. get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, f)) + "\n";
+    std::cout << "f. get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(f)) + "\n";
 
     auto f2 {file_attributes::cached}; 
-    std::cout << "f2.get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, f2)) + "\n";
+    std::cout << "f2.get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(f2)) + "\n";
 
-    std::cout << "f  is " << CPP2_UFCS_0(to_string, f) << "\n";
-    std::cout << "f2 is " << CPP2_UFCS_0(to_string, f2) << "\n";
+    std::cout << "f  is " << CPP2_UFCS(to_string)(f) << "\n";
+    std::cout << "f2 is " << CPP2_UFCS(to_string)(f2) << "\n";
 
-    CPP2_UFCS(clear, f2, f2);
-    std::cout << "f2 is " << CPP2_UFCS_0(to_string, f2) << "\n";
-    CPP2_UFCS(set, f2, file_attributes::cached);
-    std::cout << "f2 is " << CPP2_UFCS_0(to_string, f2) << "\n";
+    CPP2_UFCS(clear)(f2, f2);
+    std::cout << "f2 is " << CPP2_UFCS(to_string)(f2) << "\n";
+    CPP2_UFCS(set)(f2, file_attributes::cached);
+    std::cout << "f2 is " << CPP2_UFCS(to_string)(f2) << "\n";
 
-    std::cout << "f. get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, f)) + "\n";
-    std::cout << "f2.get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, f2)) + "\n";
+    std::cout << "f. get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(f)) + "\n";
+    std::cout << "f2.get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(f2)) + "\n";
 
     std::cout << "f  is (f2) is " + cpp2::to_string(cpp2::is(f, (f2))) + "\n";
     std::cout << "f2 is (f ) is " + cpp2::to_string(cpp2::is(f2, (f))) + "\n\n";
 
-    CPP2_UFCS(clear, f, f2);
-    CPP2_UFCS(set, f, file_attributes::current | f2);
+    CPP2_UFCS(clear)(f, f2);
+    CPP2_UFCS(set)(f, file_attributes::current | f2);
     f  |= file_attributes::obsolete;
     f2 |= file_attributes::current;
 
-    std::cout << "f  is " << CPP2_UFCS_0(to_string, f) << "\n";
-    std::cout << "f2 is " << CPP2_UFCS_0(to_string, f2) << "\n";
-    std::cout << "f. get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, f)) + "\n";
-    std::cout << "f2.get_raw_value() is " + cpp2::to_string(CPP2_UFCS_0(get_raw_value, f2)) + "\n";
+    std::cout << "f  is " << CPP2_UFCS(to_string)(f) << "\n";
+    std::cout << "f2 is " << CPP2_UFCS(to_string)(f2) << "\n";
+    std::cout << "f. get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(f)) + "\n";
+    std::cout << "f2.get_raw_value() is " + cpp2::to_string(CPP2_UFCS(get_raw_value)(f2)) + "\n";
     std::cout << "f  == f2   is " + cpp2::to_string(f  == f2  ) + "\n";
     std::cout << "f  is (f2) is " + cpp2::to_string(cpp2::is(f, (f2))) + "\n";
     std::cout << "f2 is (f ) is " + cpp2::to_string(cpp2::is(f2, (f))) + "\n";

regression-tests/test-results/pure2-initialization-safety-with-else-if.cpp

@@ -25,10 +25,10 @@ auto main(int const argc_, char** argv_) -> int{
     auto c {3}; 
     auto d {4}; 
 
-    if (CPP2_UFCS_0(size, args) == 3) {
+    if (CPP2_UFCS(size)(args) == 3) {
         p.construct(&a);
     }else {if (true) {
-        if (CPP2_UFCS_0(size, args) == 2) {
+        if (CPP2_UFCS(size)(args) == 2) {
             p.construct(&c);
         }else {if (cpp2::cmp_greater(std::move(b),0)) {
                 p.construct(&a);

regression-tests/test-results/pure2-inspect-expression-in-generic-function-multiple-types.cpp

@@ -29,7 +29,7 @@ auto test_generic(auto const& x, auto const& msg) -> void;
     test_generic(a,    "any");
     test_generic(o,    "optional<int>");
 
-    static_cast<void>(CPP2_UFCS_TEMPLATE(emplace, (<0>), v, 1));
+    static_cast<void>(CPP2_UFCS_TEMPLATE(emplace<0>)(v, 1));
     a = 2;
     o = 3;
     test_generic(42,   "int");

regression-tests/test-results/pure2-interpolation.cpp

@@ -59,9 +59,9 @@ auto const& x = item();
 
 #line 25 "pure2-interpolation.cpp2"
     {
-        std::cout << std::left << std::setw(20) << CPP2_UFCS_0(name, x) << " color " << std::left << std::setw(10) << CPP2_UFCS_0(color, x) << " price " << std::setw(10) << std::setprecision(3) << CPP2_UFCS_0(price, x) << " in stock = " << std::boolalpha << (cpp2::cmp_greater(CPP2_UFCS_0(count, x),0)) << "\n";
+        std::cout << std::left << std::setw(20) << CPP2_UFCS(name)(x) << " color " << std::left << std::setw(10) << CPP2_UFCS(color)(x) << " price " << std::setw(10) << std::setprecision(3) << CPP2_UFCS(price)(x) << " in stock = " << std::boolalpha << (cpp2::cmp_greater(CPP2_UFCS(count)(x),0)) << "\n";
 
-        std::cout << cpp2::to_string(CPP2_UFCS_0(name, x), "{:20}") + " color " + cpp2::to_string(CPP2_UFCS_0(color, x), "{:10}") + " price " + cpp2::to_string(CPP2_UFCS_0(price, x), "{: <10.2f}") + " in stock = " + cpp2::to_string(cpp2::cmp_greater(CPP2_UFCS_0(count, x),0)) + "\n";
+        std::cout << cpp2::to_string(CPP2_UFCS(name)(x), "{:20}") + " color " + cpp2::to_string(CPP2_UFCS(color)(x), "{:10}") + " price " + cpp2::to_string(CPP2_UFCS(price)(x), "{: <10.2f}") + " in stock = " + cpp2::to_string(cpp2::cmp_greater(CPP2_UFCS(count)(x),0)) + "\n";
     }
 }
 

regression-tests/test-results/pure2-intro-example-hello-2022.cpp

@@ -36,7 +36,7 @@ auto print_it(auto const& x, auto const& len) -> void;
 
 [[nodiscard]] auto decorate(auto& thing) -> int{
     thing = "[" + thing + "]";
-    return CPP2_UFCS_0(ssize, thing); 
+    return CPP2_UFCS(ssize)(thing); 
 }
 
 auto print_it(auto const& x, auto const& len) -> void { 

regression-tests/test-results/pure2-intro-example-three-loops.cpp

@@ -42,7 +42,7 @@ auto decorate_and_print(auto& thing) -> void{
     std::span<std::string> view {words}; 
 
     auto i {cpp2_new<int>(0)}; 
-    for( ; cpp2::cmp_less(*cpp2::assert_not_null(i),CPP2_UFCS_0(ssize, view)); ++*cpp2::assert_not_null(i) ) {
+    for( ; cpp2::cmp_less(*cpp2::assert_not_null(i),CPP2_UFCS(ssize)(view)); ++*cpp2::assert_not_null(i) ) {
         print(cpp2::assert_in_bounds(view, *cpp2::assert_not_null(i)));
     }
 

regression-tests/test-results/pure2-print.cpp

@@ -103,11 +103,11 @@ requires (true)
             if (cpp2::cmp_less(*cpp2::assert_not_null(p),0)) {
                 ret = -*cpp2::assert_not_null(std::move(p));
             }
-            ret += strlen(s) - 10 + CPP2_UFCS_0(strlen, std::move(s)) * (16 / (3 & 2)) % 3;
+            ret += strlen(s) - 10 + CPP2_UFCS(strlen)(std::move(s)) * (16 / (3 & 2)) % 3;
 
             std::map<int const,std::string> m {}; 
             cpp2::assert_in_bounds(m, 0) = cpp2::as_<std::string>("har");
-            ret -= CPP2_UFCS_0(length, h("x", m));
+            ret -= CPP2_UFCS(length)(h("x", m));
             static_cast<void>(std::move(m));
 
             return ret; 
@@ -117,24 +117,24 @@ requires (true)
 
 #line 32 "pure2-print.cpp2"
         {
-            cpp2::Default.expects(CPP2_UFCS_0(empty, m) == false || false, "");
-            cpp2::Bounds.expects([_0 = 0, _1 = CPP2_UFCS_0(ssize, m), _2 = 100]{ return cpp2::cmp_less(_0,_1) && cpp2::cmp_less(_1,_2); }() && true != false, "");
+            cpp2::Default.expects(CPP2_UFCS(empty)(m) == false || false, "");
+            cpp2::Bounds.expects([_0 = 0, _1 = CPP2_UFCS(ssize)(m), _2 = 100]{ return cpp2::cmp_less(_0,_1) && cpp2::cmp_less(_1,_2); }() && true != false, "");
 #line 33 "pure2-print.cpp2"
             auto a {[]() -> void{}}; 
             auto b {[]() -> void{}}; 
             auto c {[]() -> void{}}; 
 
-            for( ; CPP2_UFCS_0(empty, s); a() ) {break; }
+            for( ; CPP2_UFCS(empty)(s); a() ) {break; }
 
-            do {} while ( CPP2_UFCS_0(empty, s) && [&]{ b() ; return true; }() );
+            do {} while ( CPP2_UFCS(empty)(s) && [&]{ b() ; return true; }() );
 
             for ( [[maybe_unused]] auto const& param1 : m ) {
 #line 41 "pure2-print.cpp2"
              { do {goto CONTINUE_41_13; } while (false); c(); } CPP2_CONTINUE_BREAK(41_13) }
 
 #line 43 "pure2-print.cpp2"
-            if (cpp2::is(!(CPP2_UFCS_0(empty, s)), (true))) {std::move(a)(); }
-            else {if (!(CPP2_UFCS_0(empty, m))) {std::move(b)(); }
+            if (cpp2::is(!(CPP2_UFCS(empty)(s)), (true))) {std::move(a)(); }
+            else {if (!(CPP2_UFCS(empty)(m))) {std::move(b)(); }
             else {std::move(c)(); }}
 
             cpp2::Default.expects(true, "");
@@ -169,9 +169,9 @@ requires (true)
 
 #line 75 "pure2-print.cpp2"
         ::outer::mytype var {}; 
-        std::cout << CPP2_UFCS(g, var, 42) << "\n";
+        std::cout << CPP2_UFCS(g)(var, 42) << "\n";
 
-        std::cout << [&] () -> namespace_alias::string { auto&& _expr = CPP2_UFCS(g, std::move(var), 42);
+        std::cout << [&] () -> namespace_alias::string { auto&& _expr = CPP2_UFCS(g)(std::move(var), 42);
             if (cpp2::is(_expr, 43)) { if constexpr( requires{"forty-and-three";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("forty-and-three")),namespace_alias::string> ) return "forty-and-three"; else return namespace_alias::string{}; else return namespace_alias::string{}; }
             else return "default case"; }
         () << "\n";

regression-tests/test-results/pure2-stdio-with-raii.cpp

@@ -24,6 +24,6 @@
 [[nodiscard]] auto main() -> int{
     std::string s {"Fred"}; 
     auto myfile {cpp2::fopen("xyzzy", "w")}; 
-    static_cast<void>(CPP2_UFCS(fprintf, std::move(myfile), "Hello %s with UFCS!", CPP2_UFCS_0(c_str, std::move(s))));
+    static_cast<void>(CPP2_UFCS(fprintf)(std::move(myfile), "Hello %s with UFCS!", CPP2_UFCS(c_str)(std::move(s))));
 }
 

regression-tests/test-results/pure2-stdio.cpp

@@ -26,7 +26,7 @@
 [[nodiscard]] auto main() -> int{
     std::string s {"Fred"}; 
     auto myfile {fopen("xyzzy", "w")}; 
-    static_cast<void>(CPP2_UFCS(fprintf, myfile, "Hello %s with UFCS!", CPP2_UFCS_0(c_str, std::move(s))));
-    static_cast<void>(CPP2_UFCS_0(fclose, std::move(myfile)));
+    static_cast<void>(CPP2_UFCS(fprintf)(myfile, "Hello %s with UFCS!", CPP2_UFCS(c_str)(std::move(s))));
+    static_cast<void>(CPP2_UFCS(fclose)(std::move(myfile)));
 }