Take 2: Enable natural use of single named return value

This version works better for class types than the previous initial commit. For example:

    f: () -> (ret: int = 5)
        post (ret > ret$)
    = {
        ret += 1;
    }

    std::cout << f().ret + 2;   // use name, always worked
    std::cout << f() + 2;       // omit name, now works

Postconditions can freely refer to the named return value(s) without having to add special syntax to the postcondition grammar as Cpp1 is doing, because with the generalized named return value solution the names are just in scope and normally available

TODO: Still need to make postconditions evaluate before the explicit/implicit return (including before move from definite last use, not after) - if this int were a string, it would be moved-from-last-use and currently the postcondition would inspect an empty string, so just need to evaluate the postcondition right before returning

Author: hsutter

regression-tests/pure2-bugfix-for-name-lookup-and-value-decoration.cpp2

@@ -5,5 +5,5 @@ vals: () -> (i : int) = {
 
 main: () -> int = {
     v := vals();
-    v.i;
+    _ = v;
 }

regression-tests/pure2-look-up-parameter-across-unnamed-function.cpp2

@@ -15,5 +15,5 @@ g: () -> (ri : int) = {
 }
 
 main: ()->int = {
-    std::cout << f().ri + g().ri << "\n";
+    std::cout << f() + g() << "\n";
 }

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

@@ -3,11 +3,11 @@ main: () -> int = {
     _ = i.ufcs();
 
     j := fun();
-    _ = j.i.ufcs();
+    _ = j.ufcs();
 
-    _ = fun().i.ufcs();
+    _ = fun().ufcs();
 
-    k := fun().i;
+    k := fun();
     _ = k.ufcs();
 
     _ = get_i(j).ufcs();
@@ -16,7 +16,7 @@ main: () -> int = {
 
     res := (42).ufcs();
 
-    _ = (j.i).ufcs();
+    _ = (j).ufcs();
 
     42.no_return();
 
@@ -35,7 +35,7 @@ fun: () -> (i:int) = {
 }
 
 get_i: (r:_) -> int = {
-    return r.i;
+    return r;
 }
 
 //  And a test for non-local UFCS, which shouldn't do a [&] capture

regression-tests/test-results/clang-12/pure2-bugfix-for-name-lookup-and-value-decoration.cpp.output

@@ -1,4 +0,0 @@
-pure2-bugfix-for-name-lookup-and-value-decoration.cpp2:8:18: warning: expression result unused [-Wunused-value]
-    std::move(v).i;
-    ~~~~~~~~~~~~ ^
-1 warning generated.

regression-tests/test-results/pure2-bugfix-for-name-lookup-and-value-decoration.cpp

@@ -13,9 +13,7 @@
 
 #line 1 "pure2-bugfix-for-name-lookup-and-value-decoration.cpp2"
 
-struct vals_ret { int i; 
-operator auto() const { return i; }};
-
+using vals_ret = int;
 [[nodiscard]] auto vals() -> vals_ret;
 
 #line 6 "pure2-bugfix-for-name-lookup-and-value-decoration.cpp2"
@@ -28,11 +26,11 @@ operator auto() const { return i; }};
         cpp2::deferred_init<int> i;
 #line 2 "pure2-bugfix-for-name-lookup-and-value-decoration.cpp2"
     i.construct(42);
-    return  { std::move(i.value()) }; 
+    return std::move(i.value()); 
 }
 
 [[nodiscard]] auto main() -> int{
     auto v {vals()}; 
-    std::move(v).i;
+    static_cast<void>(std::move(v));
 }
 

regression-tests/test-results/pure2-look-up-parameter-across-unnamed-function.cpp

@@ -13,14 +13,10 @@
 
 #line 1 "pure2-look-up-parameter-across-unnamed-function.cpp2"
 
-struct f_ret { int ri; 
-operator auto() const { return ri; }};
-
+using f_ret = int;
 #line 2 "pure2-look-up-parameter-across-unnamed-function.cpp2"
 [[nodiscard]] auto f() -> f_ret;
-struct g_ret { int ri; 
-operator auto() const { return ri; }};
-
+using g_ret = int;
 
 
 #line 9 "pure2-look-up-parameter-across-unnamed-function.cpp2"
@@ -40,7 +36,7 @@ operator auto() const { return ri; }};
     auto pred {[](auto const& e) -> auto { return e == 1;  }}; 
     ri = 42;
     std::move(pred)(ri);
-    return  { std::move(ri) }; // "return;" is implicit"
+    return std::move(ri); // "return;" is implicit"
 }
 
 [[nodiscard]] auto g() -> g_ret{
@@ -50,10 +46,10 @@ operator auto() const { return ri; }};
     auto pred {[](auto const& e) -> auto { return e == 1;  }}; 
     ri.value() = 42;
     std::move(pred)(ri.value());
-    return  { std::move(ri.value()) }; 
+    return std::move(ri.value()); 
 }
 
 [[nodiscard]] auto main() -> int{
-    std::cout << f().ri + g().ri << "\n";
+    std::cout << f() + g() << "\n";
 }
 

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

@@ -18,9 +18,7 @@
 auto no_return([[maybe_unused]] auto const& unnamed_param_1) -> void;
 
 [[nodiscard]] auto ufcs(cpp2::in<int> i) -> int;
-struct fun_ret { int i; 
-operator auto() const { return i; }};
-
+using fun_ret = int;
 
 
 #line 32 "pure2-ufcs-member-access-and-chaining.cpp2"
@@ -43,11 +41,11 @@ extern int y;
     static_cast<void>(CPP2_UFCS_0(ufcs, std::move(i)));
 
     auto j {fun()}; 
-    static_cast<void>(CPP2_UFCS_0(ufcs, j.i));
+    static_cast<void>(CPP2_UFCS_0(ufcs, j));
 
-    static_cast<void>(CPP2_UFCS_0(ufcs, fun().i));
+    static_cast<void>(CPP2_UFCS_0(ufcs, fun()));
 
-    auto k {fun().i}; 
+    auto k {fun()}; 
     static_cast<void>(CPP2_UFCS_0(ufcs, std::move(k)));
 
     static_cast<void>(CPP2_UFCS_0(ufcs, get_i(j)));
@@ -56,7 +54,7 @@ extern int y;
 
     auto res {CPP2_UFCS_0(ufcs, (42))}; 
 
-    static_cast<void>(CPP2_UFCS_0(ufcs, (std::move(j).i)));
+    static_cast<void>(CPP2_UFCS_0(ufcs, (std::move(j))));
 
     CPP2_UFCS_0(no_return, 42);
 
@@ -73,11 +71,11 @@ auto no_return([[maybe_unused]] auto const& unnamed_param_1) -> void{}
         cpp2::deferred_init<int> i;
 #line 33 "pure2-ufcs-member-access-and-chaining.cpp2"
     i.construct(42);
-    return  { std::move(i.value()) }; 
+    return std::move(i.value()); 
 }
 
 [[nodiscard]] auto get_i(auto const& r) -> int{
-    return r.i; 
+    return r; 
 }
 
 #line 42 "pure2-ufcs-member-access-and-chaining.cpp2"

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.3.0   Build 8B15:1925
+cppfront compiler v0.3.0   Build 8B16:1224
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"8B15:1925"
+"8B16:1224"

source/to_cpp1.h

@@ -2376,9 +2376,17 @@ class cppfront
             && function_returns.back().param_list
             )
         {
-            //auto stmt = function_return_name + " { "; // we shouldn't need this with { } init
-            auto stmt = std::string(" { ");
             auto& parameters = function_returns.back().param_list->parameters;
+
+            auto stmt = std::string{};
+
+            //  Put braces only around multiple named returns, which are a struct
+            //  - single named returns are emitted as ordinary returns, and extra
+            //  { } would be legal but generate a noisy warning on some compilers
+            if (std::ssize(parameters) > 1) {
+                stmt += std::string(" { ");
+            }
+
             for (bool first = true; auto& param : parameters) {
                 if (!first) {
                     stmt += ", ";
@@ -2390,7 +2398,11 @@ class cppfront
                 emit(*param->declaration->identifier, true);
                 printer.emit_to_string();
             }
-            stmt += " }";
+
+            if (std::ssize(parameters) > 1) {
+                stmt += std::string(" }");
+            }
+
             printer.print_cpp2(stmt, n.position());
         }
 
@@ -4242,8 +4254,7 @@ class cppfront
     auto emit(
         parameter_declaration_list_node const& n,
         bool                                   is_returns            = false,
-        bool                                   is_template_parameter = false,
-        std::string                            extra_text            = ""
+        bool                                   is_template_parameter = false
     )
         -> void
     {
@@ -4281,7 +4292,7 @@ class cppfront
         }
 
         if (is_returns) {
-            printer.print_extra( extra_text + "};\n" );
+            printer.print_extra( "};\n" );
         }
         else {
             //  Position heuristic (aka hack): Avoid emitting extra whitespace before )
@@ -5315,23 +5326,34 @@ class cppfront
             auto& func = std::get<declaration_node::a_function>(n.type);
             assert(func);
 
-            if (func->returns.index() == function_type_node::list) {
+            if (func->returns.index() == function_type_node::list)
+            {
                 auto& r = std::get<function_type_node::list>(func->returns);
                 assert(r);
                 assert(std::ssize(r->parameters) > 0);
-                printer.print_extra( "\nstruct " );
-                printer.print_extra( *n.name() );
-                printer.print_extra( "_ret " );
 
-                auto extra = std::string{};
-                if (std::ssize(r->parameters) == 1) {
-                    assert (r->parameters[0]->declaration->name());
-                    extra += "\noperator auto() const { return "
-                        + r->parameters[0]->declaration->name()->to_string()
-                        + "; }";
-                }
+                auto func_name = n.name()->to_string();
 
-                emit(*r, true, false, extra);
+                //  If it's a single named value, emit it as an aonymous return value
+                if (std::ssize(r->parameters) == 1)
+                {
+                    printer.print_extra(
+                        "\nusing "
+                        + func_name + "_ret = "
+                        + r->parameters[0]->declaration->get_object_type()->to_string()
+                        + ";"
+                    );
+                }
+                //  Else just emit it as an ordinary struct
+                else
+                {
+                    printer.print_extra(
+                        "\nstruct "
+                        + n.name()->to_string()
+                        + "_ret "
+                    );
+                    emit(*r, true);
+                }
                 printer.print_extra( "\n" );
             }
         }