Output formatting improvements - remove a lot of the extra-space injection

Author: hsutter

regression-tests/test-results/mixed-as-for-variant-20-types.cpp

@@ -15,19 +15,19 @@ struct X { operator int() const { return I; } };
 [[nodiscard]] auto main() -> int{
 
     std::variant<X<0>,X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>,X<9>,X<10>,X<11>,X<12>,X<13>,X<14>,X<15>,X<16>,X<17>,X<18>,X<19>> v {
-                                                                                            X<0>()}; 
+                    X<0>()}; 
 
     // lvalue reference
-    v = X< 0>(); std::cout << "v as X< 0> = " + cpp2::to_string(int(cpp2::as_<X<0>>(v))) << std::endl;
-    v = X< 1>(); std::cout << "v as X< 1> = " + cpp2::to_string(int(cpp2::as_<X<1>>(v))) << std::endl;
-    v = X< 2>(); std::cout << "v as X< 2> = " + cpp2::to_string(int(cpp2::as_<X<2>>(v))) << std::endl;
-    v = X< 3>(); std::cout << "v as X< 3> = " + cpp2::to_string(int(cpp2::as_<X<3>>(v))) << std::endl;
-    v = X< 4>(); std::cout << "v as X< 4> = " + cpp2::to_string(int(cpp2::as_<X<4>>(v))) << std::endl;
-    v = X< 5>(); std::cout << "v as X< 5> = " + cpp2::to_string(int(cpp2::as_<X<5>>(v))) << std::endl;
-    v = X< 6>(); std::cout << "v as X< 6> = " + cpp2::to_string(int(cpp2::as_<X<6>>(v))) << std::endl;
-    v = X< 7>(); std::cout << "v as X< 7> = " + cpp2::to_string(int(cpp2::as_<X<7>>(v))) << std::endl;
-    v = X< 8>(); std::cout << "v as X< 8> = " + cpp2::to_string(int(cpp2::as_<X<8>>(v))) << std::endl;
-    v = X< 9>(); std::cout << "v as X< 9> = " + cpp2::to_string(int(cpp2::as_<X<9>>(v))) << std::endl;
+    v = X<0>(); std::cout << "v as X< 0> = " + cpp2::to_string(int(cpp2::as_<X<0>>(v))) << std::endl;
+    v = X<1>(); std::cout << "v as X< 1> = " + cpp2::to_string(int(cpp2::as_<X<1>>(v))) << std::endl;
+    v = X<2>(); std::cout << "v as X< 2> = " + cpp2::to_string(int(cpp2::as_<X<2>>(v))) << std::endl;
+    v = X<3>(); std::cout << "v as X< 3> = " + cpp2::to_string(int(cpp2::as_<X<3>>(v))) << std::endl;
+    v = X<4>(); std::cout << "v as X< 4> = " + cpp2::to_string(int(cpp2::as_<X<4>>(v))) << std::endl;
+    v = X<5>(); std::cout << "v as X< 5> = " + cpp2::to_string(int(cpp2::as_<X<5>>(v))) << std::endl;
+    v = X<6>(); std::cout << "v as X< 6> = " + cpp2::to_string(int(cpp2::as_<X<6>>(v))) << std::endl;
+    v = X<7>(); std::cout << "v as X< 7> = " + cpp2::to_string(int(cpp2::as_<X<7>>(v))) << std::endl;
+    v = X<8>(); std::cout << "v as X< 8> = " + cpp2::to_string(int(cpp2::as_<X<8>>(v))) << std::endl;
+    v = X<9>(); std::cout << "v as X< 9> = " + cpp2::to_string(int(cpp2::as_<X<9>>(v))) << std::endl;
     v = X<10>(); std::cout << "v as X<10> = " + cpp2::to_string(int(cpp2::as_<X<10>>(v))) << std::endl;
     v = X<11>(); std::cout << "v as X<11> = " + cpp2::to_string(int(cpp2::as_<X<11>>(v))) << std::endl;
     v = X<12>(); std::cout << "v as X<12> = " + cpp2::to_string(int(cpp2::as_<X<12>>(v))) << std::endl;
@@ -40,16 +40,16 @@ struct X { operator int() const { return I; } };
     v = X<19>(); std::cout << "v as X<19> = " + cpp2::to_string(int(cpp2::as_<X<19>>(v))) << std::endl;
 
     // const lvalue reference
-    v = X< 0>(); std::cout << "as_const(v) as X< 0> = " + cpp2::to_string(int(cpp2::as_<X<0>>(std::as_const(v)))) << std::endl;
-    v = X< 1>(); std::cout << "as_const(v) as X< 1> = " + cpp2::to_string(int(cpp2::as_<X<1>>(std::as_const(v)))) << std::endl;
-    v = X< 2>(); std::cout << "as_const(v) as X< 2> = " + cpp2::to_string(int(cpp2::as_<X<2>>(std::as_const(v)))) << std::endl;
-    v = X< 3>(); std::cout << "as_const(v) as X< 3> = " + cpp2::to_string(int(cpp2::as_<X<3>>(std::as_const(v)))) << std::endl;
-    v = X< 4>(); std::cout << "as_const(v) as X< 4> = " + cpp2::to_string(int(cpp2::as_<X<4>>(std::as_const(v)))) << std::endl;
-    v = X< 5>(); std::cout << "as_const(v) as X< 5> = " + cpp2::to_string(int(cpp2::as_<X<5>>(std::as_const(v)))) << std::endl;
-    v = X< 6>(); std::cout << "as_const(v) as X< 6> = " + cpp2::to_string(int(cpp2::as_<X<6>>(std::as_const(v)))) << std::endl;
-    v = X< 7>(); std::cout << "as_const(v) as X< 7> = " + cpp2::to_string(int(cpp2::as_<X<7>>(std::as_const(v)))) << std::endl;
-    v = X< 8>(); std::cout << "as_const(v) as X< 8> = " + cpp2::to_string(int(cpp2::as_<X<8>>(std::as_const(v)))) << std::endl;
-    v = X< 9>(); std::cout << "as_const(v) as X< 9> = " + cpp2::to_string(int(cpp2::as_<X<9>>(std::as_const(v)))) << std::endl;
+    v = X<0>(); std::cout << "as_const(v) as X< 0> = " + cpp2::to_string(int(cpp2::as_<X<0>>(std::as_const(v)))) << std::endl;
+    v = X<1>(); std::cout << "as_const(v) as X< 1> = " + cpp2::to_string(int(cpp2::as_<X<1>>(std::as_const(v)))) << std::endl;
+    v = X<2>(); std::cout << "as_const(v) as X< 2> = " + cpp2::to_string(int(cpp2::as_<X<2>>(std::as_const(v)))) << std::endl;
+    v = X<3>(); std::cout << "as_const(v) as X< 3> = " + cpp2::to_string(int(cpp2::as_<X<3>>(std::as_const(v)))) << std::endl;
+    v = X<4>(); std::cout << "as_const(v) as X< 4> = " + cpp2::to_string(int(cpp2::as_<X<4>>(std::as_const(v)))) << std::endl;
+    v = X<5>(); std::cout << "as_const(v) as X< 5> = " + cpp2::to_string(int(cpp2::as_<X<5>>(std::as_const(v)))) << std::endl;
+    v = X<6>(); std::cout << "as_const(v) as X< 6> = " + cpp2::to_string(int(cpp2::as_<X<6>>(std::as_const(v)))) << std::endl;
+    v = X<7>(); std::cout << "as_const(v) as X< 7> = " + cpp2::to_string(int(cpp2::as_<X<7>>(std::as_const(v)))) << std::endl;
+    v = X<8>(); std::cout << "as_const(v) as X< 8> = " + cpp2::to_string(int(cpp2::as_<X<8>>(std::as_const(v)))) << std::endl;
+    v = X<9>(); std::cout << "as_const(v) as X< 9> = " + cpp2::to_string(int(cpp2::as_<X<9>>(std::as_const(v)))) << std::endl;
     v = X<10>(); std::cout << "as_const(v) as X<10> = " + cpp2::to_string(int(cpp2::as_<X<10>>(std::as_const(v)))) << std::endl;
     v = X<11>(); std::cout << "as_const(v) as X<11> = " + cpp2::to_string(int(cpp2::as_<X<11>>(std::as_const(v)))) << std::endl;
     v = X<12>(); std::cout << "as_const(v) as X<12> = " + cpp2::to_string(int(cpp2::as_<X<12>>(std::as_const(v)))) << std::endl;
@@ -62,16 +62,16 @@ struct X { operator int() const { return I; } };
     v = X<19>(); std::cout << "as_const(v) as X<19> = " + cpp2::to_string(int(cpp2::as_<X<19>>(std::as_const(v)))) << std::endl;
 
     // rvalue reference
-    v = X< 0>(); std::cout << "move(v) as X< 0> = " + cpp2::to_string(int(cpp2::as_<X<0>>((std::move(v))))) << std::endl;
-    v = X< 1>(); std::cout << "move(v) as X< 1> = " + cpp2::to_string(int(cpp2::as_<X<1>>((std::move(v))))) << std::endl;
-    v = X< 2>(); std::cout << "move(v) as X< 2> = " + cpp2::to_string(int(cpp2::as_<X<2>>((std::move(v))))) << std::endl;
-    v = X< 3>(); std::cout << "move(v) as X< 3> = " + cpp2::to_string(int(cpp2::as_<X<3>>((std::move(v))))) << std::endl;
-    v = X< 4>(); std::cout << "move(v) as X< 4> = " + cpp2::to_string(int(cpp2::as_<X<4>>((std::move(v))))) << std::endl;
-    v = X< 5>(); std::cout << "move(v) as X< 5> = " + cpp2::to_string(int(cpp2::as_<X<5>>((std::move(v))))) << std::endl;
-    v = X< 6>(); std::cout << "move(v) as X< 6> = " + cpp2::to_string(int(cpp2::as_<X<6>>((std::move(v))))) << std::endl;
-    v = X< 7>(); std::cout << "move(v) as X< 7> = " + cpp2::to_string(int(cpp2::as_<X<7>>((std::move(v))))) << std::endl;
-    v = X< 8>(); std::cout << "move(v) as X< 8> = " + cpp2::to_string(int(cpp2::as_<X<8>>((std::move(v))))) << std::endl;
-    v = X< 9>(); std::cout << "move(v) as X< 9> = " + cpp2::to_string(int(cpp2::as_<X<9>>((std::move(v))))) << std::endl;
+    v = X<0>(); std::cout << "move(v) as X< 0> = " + cpp2::to_string(int(cpp2::as_<X<0>>((std::move(v))))) << std::endl;
+    v = X<1>(); std::cout << "move(v) as X< 1> = " + cpp2::to_string(int(cpp2::as_<X<1>>((std::move(v))))) << std::endl;
+    v = X<2>(); std::cout << "move(v) as X< 2> = " + cpp2::to_string(int(cpp2::as_<X<2>>((std::move(v))))) << std::endl;
+    v = X<3>(); std::cout << "move(v) as X< 3> = " + cpp2::to_string(int(cpp2::as_<X<3>>((std::move(v))))) << std::endl;
+    v = X<4>(); std::cout << "move(v) as X< 4> = " + cpp2::to_string(int(cpp2::as_<X<4>>((std::move(v))))) << std::endl;
+    v = X<5>(); std::cout << "move(v) as X< 5> = " + cpp2::to_string(int(cpp2::as_<X<5>>((std::move(v))))) << std::endl;
+    v = X<6>(); std::cout << "move(v) as X< 6> = " + cpp2::to_string(int(cpp2::as_<X<6>>((std::move(v))))) << std::endl;
+    v = X<7>(); std::cout << "move(v) as X< 7> = " + cpp2::to_string(int(cpp2::as_<X<7>>((std::move(v))))) << std::endl;
+    v = X<8>(); std::cout << "move(v) as X< 8> = " + cpp2::to_string(int(cpp2::as_<X<8>>((std::move(v))))) << std::endl;
+    v = X<9>(); std::cout << "move(v) as X< 9> = " + cpp2::to_string(int(cpp2::as_<X<9>>((std::move(v))))) << std::endl;
     v = X<10>(); std::cout << "move(v) as X<10> = " + cpp2::to_string(int(cpp2::as_<X<10>>((std::move(v))))) << std::endl;
     v = X<11>(); std::cout << "move(v) as X<11> = " + cpp2::to_string(int(cpp2::as_<X<11>>((std::move(v))))) << std::endl;
     v = X<12>(); std::cout << "move(v) as X<12> = " + cpp2::to_string(int(cpp2::as_<X<12>>((std::move(v))))) << std::endl;

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

@@ -18,14 +18,14 @@ auto insert_at(cpp2::in<int> where, cpp2::in<int> val) -> void;
 #line 5 "mixed-captures-in-expressions-and-postconditions.cpp2"
 [[nodiscard]] auto main() -> int{
     std::vector<std::string> vec {
-               "hello", "2022"}; 
+            "hello", "2022"}; 
 
     std::string y {"\n"}; 
-    auto callback {[_0 = (&y)](auto const& x) -> void{std::cout << x << *cpp2::assert_not_null(_0);}}; 
+    auto callback {[_0 = (&y)](auto const& x) -> void{std::cout << x << *cpp2::assert_not_null(_0); }}; 
 
-    std::ranges::for_each( vec, callback );
+    std::ranges::for_each(vec, callback);
     y = "-ish\n";
-    std::ranges::for_each( std::move(vec), std::move(callback));
+    std::ranges::for_each(std::move(vec), std::move(callback));
 }
 
 std::vector<int> vec {}; 

regression-tests/test-results/mixed-forwarding.cpp

@@ -38,16 +38,16 @@ auto use(auto const& x) -> void{}
 auto apply_implicit_forward(auto&& t) -> void
 requires (std::is_same_v<CPP2_TYPEOF(t), std::pair<X,X>>)
 #line 16 "mixed-forwarding.cpp2"
-                                                     {
+{
     copy_from(t.first);             // copies
     copy_from(CPP2_FORWARD(t).second);// moves
 }
 auto apply_explicit_forward(auto&& t) -> void
 requires (std::is_same_v<CPP2_TYPEOF(t), std::pair<X,X>>)
 #line 20 "mixed-forwarding.cpp2"
-                                                     {
-    copy_from(        CPP2_FORWARD(t).first);// moves
-    copy_from(        CPP2_FORWARD(t).second);// moves
+{
+    copy_from(CPP2_FORWARD(t).first);// moves
+    copy_from(CPP2_FORWARD(t).second);// moves
 }
 
 [[nodiscard]] auto main() -> int{

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

@@ -17,18 +17,18 @@
 #line 7 "mixed-function-expression-and-std-for-each.cpp2"
 [[nodiscard]] auto main() -> int{
     std::vector<std::string> vec {
-               "hello", "2022"}; 
+            "hello", "2022"}; 
     std::span view {vec}; 
 
     //  Passing a function expression
     std::for_each(
         CPP2_UFCS_0(begin, view), 
         CPP2_UFCS_0(end, view), 
-        [](auto& x ) -> void { x += "-ish"; }
+        [](auto& x) -> void { x += "-ish";  }
     );
 
     //  Initializating from a function expression
-    auto callback {[](auto& x) -> void { x += " maybe"; }}; 
+    auto callback {[](auto& x) -> void { x += " maybe";  }}; 
     std::for_each(
         CPP2_UFCS_0(begin, view), 
         CPP2_UFCS_0(end, view), 

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

@@ -18,15 +18,15 @@
 #line 8 "mixed-function-expression-and-std-ranges-for-each-with-capture.cpp2"
 [[nodiscard]] auto main() -> int{
     std::vector<std::string> vec {
-               "hello", "2022"}; 
+            "hello", "2022"}; 
     std::span view {vec}; 
 
     auto y {"\n"}; 
     std::ranges::for_each
-        ( view, [_0 = std::move(y)](auto const& x) -> void{std::cout << x << _0;});
+        (view, [_0 = std::move(y)](auto const& x) -> void{std::cout << x << _0; });
 
-    auto callback {[](auto& x) -> void { x += "-ish"; }}; 
-    std::ranges::for_each( view, std::move(callback));
+    auto callback {[](auto& x) -> void { x += "-ish";  }}; 
+    std::ranges::for_each(view, std::move(callback));
 
     for ( auto const& cpp2_range = view;  auto const& str : cpp2_range ) 
         std::cout << str << "\n";

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

@@ -18,14 +18,14 @@
 #line 8 "mixed-function-expression-and-std-ranges-for-each.cpp2"
 [[nodiscard]] auto main() -> int{
     std::vector<std::string> vec {
-               "hello", "2022"}; 
+            "hello", "2022"}; 
     std::span view {vec}; 
 
     std::ranges::for_each
-        ( view, [](auto const& x) -> void{std::cout << x << "\n";});
+        (view, [](auto const& x) -> void{std::cout << x << "\n"; });
 
-    auto callback {[](auto& x) -> void { x += "-ish"; }}; 
-    std::ranges::for_each( view, std::move(callback));
+    auto callback {[](auto& x) -> void { x += "-ish";  }}; 
+    std::ranges::for_each(view, std::move(callback));
 
     for ( auto const& cpp2_range = view;  auto const& str : cpp2_range ) 
         std::cout << str << "\n";

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

@@ -18,16 +18,16 @@
 #line 8 "mixed-function-expression-with-pointer-capture.cpp2"
 [[nodiscard]] auto main() -> int{
     std::vector<std::string> vec {
-               "hello", "2023"}; 
+            "hello", "2023"}; 
     std::span view {vec}; 
 
     std::string y {"\n"}; 
-    std::ranges::for_each( view, [_0 = (&y)](auto const& x) -> void{
+    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);
-    } );
+    });
 
-    auto callback {[](auto& x) -> void { x += "-ish"; }}; 
-    std::ranges::for_each( view, std::move(callback));
+    auto callback {[](auto& x) -> void { x += "-ish";  }}; 
+    std::ranges::for_each(view, std::move(callback));
 
     for ( auto const& cpp2_range = view;  auto const& str : cpp2_range ) 
         std::cout << str << "\n";

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

@@ -18,15 +18,15 @@
 #line 8 "mixed-function-expression-with-repeated-capture.cpp2"
 [[nodiscard]] auto main() -> int{
     std::vector<std::string> vec {
-               "hello", "2022"}; 
+            "hello", "2022"}; 
     std::span view {vec}; 
 
     auto y {"\n"}; 
     std::ranges::for_each
-        ( view, [_0 = std::move(y)](auto const& x) -> void{std::cout << _0 << x << _0;});
+        (view, [_0 = std::move(y)](auto const& x) -> void{std::cout << _0 << x << _0; });
 
-    auto callback {[](auto& x) -> void { x += "-ish"; }}; 
-    std::ranges::for_each( view, std::move(callback));
+    auto callback {[](auto& x) -> void { x += "-ish";  }}; 
+    std::ranges::for_each(view, std::move(callback));
 
     for ( auto const& cpp2_range = view;  auto const& str : cpp2_range ) 
         std::cout << str << "\n";

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

@@ -35,8 +35,8 @@ bool flip_a_coin() {
 
     if (flip_a_coin()) {
         x.construct("xyzzy");
-    } else {
-        fill(&    x, "plugh", 40 ); // note: constructs x!
+    }else {
+        fill(&x, "plugh", 40);      // note: constructs x!
     }
     print_decorated(std::move(x.value()));
 }
@@ -53,5 +53,5 @@ auto fill(
     x.construct(CPP2_UFCS(substr, value, 0, count));
 }
 
-auto print_decorated(auto const& x) -> void { std::cout << ">> [" << x << "]\n"; }
+auto print_decorated(auto const& x) -> void { std::cout << ">> [" << x << "]\n";  }
 

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

@@ -31,8 +31,8 @@ auto print_decorated(auto const& x) -> void;
 
     if (flip_a_coin()) {
         x.construct("xyzzy");
-    } else {
-        fill(&    x, "plugh", 40 ); // note: constructs x!
+    }else {
+        fill(&x, "plugh", 40);      // note: constructs x!
     }
     print_decorated(std::move(x.value()));
 }
@@ -49,9 +49,9 @@ auto fill(
     x.construct(CPP2_UFCS(substr, value, 0, count));
 }
 
-auto print_decorated(auto const& x) -> void { std::cout << ">> [" << x << "]\n"; }
+auto print_decorated(auto const& x) -> void { std::cout << ">> [" << x << "]\n";  }
 
 // for test determinism, force "xyzzy" branch
 // the standard mandates that std::mt19937()() == 3499211612
-[[nodiscard]] auto flip_a_coin() -> bool { return std::mt19937()() % 2==0; }
+[[nodiscard]] auto flip_a_coin() -> bool { return std::mt19937()() % 2==0;  }
 

regression-tests/test-results/mixed-inspect-templates.cpp

@@ -26,9 +26,9 @@ struct my_type {};
     return [&] () -> std::string { auto&& __expr = v;
         if (cpp2::is<std::vector>(__expr)) { if constexpr( requires{"std::vector";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::vector")),std::string> ) return "std::vector"; else return std::string{}; else return std::string{}; }
         else if (cpp2::is<std::array>(__expr)) { if constexpr( requires{"std::array";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::array")),std::string> ) return "std::array"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<std::variant>(__expr)) { if constexpr( requires{"std::variant";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::variant")),std::string> ) return "std::variant"; else return std::string{}; else return std::string{}; }
+        else  if (cpp2::is<std::variant>(__expr)) { if constexpr( requires{"std::variant";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::variant")),std::string> ) return "std::variant"; else return std::string{}; else return std::string{}; }
         else if (cpp2::is<my_type>(__expr)) { if constexpr( requires{"my_type";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("my_type")),std::string> ) return "my_type"; else return std::string{}; else return std::string{}; }
-        else return "unknown"; }
+        else  return "unknown"; }
     (); 
 }
 

regression-tests/test-results/mixed-inspect-values-2.cpp

@@ -32,8 +32,8 @@ constexpr auto empty = [](auto&& x){
 
     std::cout << [&] () -> std::string { auto&& __expr = i;
         if (cpp2::is(__expr, (less_than(10)))) { if constexpr( requires{"i less than 10";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i less than 10")),std::string> ) return "i less than 10"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, in(11, 20))) { if constexpr( requires{"i is between 11 and 20";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i is between 11 and 20")),std::string> ) return "i is between 11 and 20"; else return std::string{}; else return std::string{}; }
-        else return "i is out of our interest"; }
+        else  if (cpp2::is(__expr, in(11, 20))) { if constexpr( requires{"i is between 11 and 20";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i is between 11 and 20")),std::string> ) return "i is between 11 and 20"; else return std::string{}; else return std::string{}; }
+        else  return "i is out of our interest"; }
     () << std::endl;
 
     if (cpp2::is(i, (less_than(20)))) {