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

@@ -46,6 +46,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-enum.cpp

@@ -101,7 +101,7 @@ auto main() -> int;
     else {if (value == clubs) {ret = "clubs";}
     else {if (value == grand) {ret = "grand";}
     else {if (value == null) {ret = "null";}}}}}}
-if (CPP2_UFCS_0(empty, ret)) {ret = "(invalid skat_game enumerator value)";}
+if (CPP2_UFCS(empty)(ret)) {ret = "(invalid skat_game enumerator value)";}
 return ret; 
 }
 
@@ -122,7 +122,7 @@ std::string ret {};
 if (value == red) {ret = "red";}
 else {if (value == green) {ret = "green";}
 else {if (value == blue) {ret = "blue";}}}
-if (CPP2_UFCS_0(empty, ret)) {ret = "(invalid rgb enumerator value)";}
+if (CPP2_UFCS(empty)(ret)) {ret = "(invalid rgb enumerator value)";}
 return ret; 
 }
 
@@ -150,7 +150,7 @@ if ((value & current) == current) {ret += comma + "current";comma = ", ";}
 if ((value & obsolete) == obsolete) {ret += comma + "obsolete";comma = ", ";}
 if ((value & cached_and_current) == cached_and_current) {ret += comma + "cached_and_current";comma = ", ";}
 if (value == none) {ret += comma + "none";comma = ", ";}
-if (CPP2_UFCS_0(empty, ret)) {ret = "(invalid file_attributes enumerator value)";}
+if (CPP2_UFCS(empty)(ret)) {ret = "(invalid file_attributes enumerator value)";}
 return ret + ")"; 
 }
 
@@ -171,8 +171,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 << "using << prints " << x << "\n";
 
     std::cout << "with if else: ";
@@ -213,9 +213,9 @@ auto main() -> int{
     std::cout << "f  is " << f  << "\n";
     std::cout << "f2 is " << f2 << "\n";
 
-    CPP2_UFCS(clear, f2, f2);
+    CPP2_UFCS(clear)(f2, f2);
     std::cout << "f2 is " << f2 << "\n";
-    CPP2_UFCS(set, f2, file_attributes::cached);
+    CPP2_UFCS(set)(f2, file_attributes::cached);
     std::cout << "f2 is " << f2 << "\n";
 
     std::cout << "f  as int  is " + cpp2::to_string(cpp2::as_<int>(f)) + "\n";
@@ -224,8 +224,8 @@ auto main() -> int{
     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;
 

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-intro-example-hello-2022.cpp

@@ -36,7 +36,7 @@ auto println(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 println(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-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)));
 }
 

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

@@ -41,7 +41,7 @@ auto print(cpp2::in<std::string> msg, cpp2::in<bool> b) -> void;
 
     std::cout << "\n";
 
-    static_cast<void>(CPP2_UFCS_TEMPLATE(emplace, (<1>), v, 1));
+    static_cast<void>(CPP2_UFCS_TEMPLATE(emplace<1>)(v, 1));
     a = 2;
     o = 3;
     test_generic(42,   "int");

regression-tests/test-results/pure2-type-safety-2-with-inspect-expression.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, (<2>), v, 1));
+    static_cast<void>(CPP2_UFCS_TEMPLATE(emplace<2>)(v, 1));
     a = 2;
     o = 3;
     test_generic(42,   "int");

regression-tests/test-results/pure2-types-basics.cpp

@@ -191,19 +191,19 @@ namespace N {
 
 auto main() -> int{
     N::myclass x {1}; 
-    CPP2_UFCS(f, x, 53);
+    CPP2_UFCS(f)(x, 53);
     N::myclass::nested::g();
-    std::cout << "f1: " + cpp2::to_string(CPP2_UFCS(f1, x, 1, 1)) + "\n";
-    std::cout << "f2: " + cpp2::to_string(CPP2_UFCS(f2, x, 2, 2)) + "\n";
-    std::cout << "f3: " + cpp2::to_string(CPP2_UFCS_TEMPLATE_0(f3, (<3,3>), x)) + "\n";
-    std::cout << "f4: " + cpp2::to_string(CPP2_UFCS_TEMPLATE_0(f4, (<4,4>), x)) + "\n";
+    std::cout << "f1: " + cpp2::to_string(CPP2_UFCS(f1)(x, 1, 1)) + "\n";
+    std::cout << "f2: " + cpp2::to_string(CPP2_UFCS(f2)(x, 2, 2)) + "\n";
+    std::cout << "f3: " + cpp2::to_string(CPP2_UFCS_TEMPLATE(f3<3,3>)(x)) + "\n";
+    std::cout << "f4: " + cpp2::to_string(CPP2_UFCS_TEMPLATE(f4<4,4>)(x)) + "\n";
     N::myclass x2 {"abracadabra"}; 
     N::myclass x3 {}; 
     N::myclass x4 {1, "hair"}; 
 
     // Invoke the single-param operator=s as actual assignments
     std::cout << "x's state before assignments: ";
-    CPP2_UFCS_0(print, x);
+    CPP2_UFCS(print)(x);
     x = 84;
     x = "syzygy";
     x = 84;

regression-tests/test-results/pure2-types-down-upcast.cpp

@@ -77,18 +77,18 @@ auto func_const(cpp2::in<B> b) -> void{std::cout << "Call B const: " + cpp2::to_
 auto test_const_foo() -> void{
  A s {}; 
   A const* sC {&s}; 
-  CPP2_UFCS_0(const_foo, s);
-  CPP2_UFCS_0(const_foo, (*cpp2::assert_not_null(sC)));
- CPP2_UFCS_0(const_foo, (cpp2::as_<A>(s)));
-  CPP2_UFCS_0(const_foo, (cpp2::as_<A>(*cpp2::assert_not_null(sC))));
+  CPP2_UFCS(const_foo)(s);
+  CPP2_UFCS(const_foo)((*cpp2::assert_not_null(sC)));
+ CPP2_UFCS(const_foo)((cpp2::as_<A>(s)));
+  CPP2_UFCS(const_foo)((cpp2::as_<A>(*cpp2::assert_not_null(sC))));
   static_cast<void>(std::move(s));
   static_cast<void>(std::move(sC));
 }
 
 auto test_mut_foo() -> void{
  A s {}; 
-  CPP2_UFCS_0(mut_foo, s);
- CPP2_UFCS_0(mut_foo, (cpp2::as_<A>(s)));
+  CPP2_UFCS(mut_foo)(s);
+ CPP2_UFCS(mut_foo)((cpp2::as_<A>(s)));
   static_cast<void>(std::move(s));
 }
 

regression-tests/test-results/pure2-types-inheritance.cpp

@@ -132,18 +132,18 @@ namespace N {
 #line 38 "pure2-types-inheritance.cpp2"
 auto make_speak(cpp2::in<Human> h) -> void{
     std::cout << "-> [vcall: make_speak] ";
-    CPP2_UFCS_0(speak, h);
+    CPP2_UFCS(speak)(h);
 }
 
 auto do_work(cpp2::in<N::Machine<99>> m) -> void{
     std::cout << "-> [vcall: do_work] ";
-    CPP2_UFCS_0(work, m);
+    CPP2_UFCS(work)(m);
 }
 
 auto main() -> int{
     Cyborg c {"Parsnip"}; 
-    CPP2_UFCS_0(print, c);
-    CPP2_UFCS_0(make_speak, c);
-    CPP2_UFCS_0(do_work, std::move(c));
+    CPP2_UFCS(print)(c);
+    CPP2_UFCS(make_speak)(c);
+    CPP2_UFCS(do_work)(std::move(c));
 }