[BUG] Return-by broken by "return expression list" support

[JohelEGP]

Title: Return-by broken by ab29f19.

That's my guess.

Minimal reproducer (https://cpp2.godbolt.org/z/Yh95zcrT1):

f: (forward x) -> forward _ = (forward x);
g: (forward x) -> forward _ = { return (forward x); }
main: () = { }

Commands:

cppfront -clean-cpp1 main.cpp2
clang++17 -std=c++2b -stdlib=libc++ -lc++abi -I . main.cpp

Expected result:

[[nodiscard]] auto f(auto&& x) -> auto&& { return CPP2_FORWARD(x);  }
[[nodiscard]] auto g(auto&& x) -> auto&&{return CPP2_FORWARD(x); }

Actual result and error:

[[nodiscard]] auto f(auto&& x) -> auto&& { return { CPP2_FORWARD(x) };  }
[[nodiscard]] auto g(auto&& x) -> auto&&{return { CPP2_FORWARD(x) }; }

Cpp2 lowered to Cpp1.

#include "cpp2util.h"


[[nodiscard]] auto f(auto&& x) -> auto&&;
[[nodiscard]] auto g(auto&& x) -> auto&&;
auto main() -> int;

[[nodiscard]] auto f(auto&& x) -> auto&& { return { CPP2_FORWARD(x) };  }
[[nodiscard]] auto g(auto&& x) -> auto&&{return { CPP2_FORWARD(x) }; }
auto main() -> int{}

main.cpp2:1:51: error: cannot deduce return type from initializer list
[[nodiscard]] auto f(auto&& x) -> auto&& { return { CPP2_FORWARD(x) };  }
                                                  ^~~~~~~~~~~~~~~~~~~
main.cpp2:2:49: error: cannot deduce return type from initializer list
[[nodiscard]] auto g(auto&& x) -> auto&&{return { CPP2_FORWARD(x) }; }
                                                ^~~~~~~~~~~~~~~~~~~
2 errors generated.

[JohelEGP]

Suggested resolution: #408 (comment).

Old suggestion.

 //G prefix-expression:
 //G     postfix-expression
 //G     prefix-operator prefix-expression
+//G     parameter-direction prefix-expression
 //GTODO     await-expression
 //GTODO     'sizeof' '(' type-id ')'
 //GTODO     'sizeof' '...' ( identifier ')'
 //GTODO     'alignof' '(' type-id ')'
 //GTODO     throws-expression

[JohelEGP]

I think that'd make the parameter-directions in expression-list redundant.

 //G expression-list:
-//G     parameter-direction? expression
-//G     expression-list ',' parameter-direction? expression
+//G     expression
+//G     expression-list ',' expression

This change would also make it so that
parentheses are required around a passed-by binary expression.
That's a plus, as a conventional binary expression should require no pass-by.
E.g., f(move a + b); -> f(move (a + b));.

This is probably necessary, anyways.

EDIT: Rereading #77 (comment), forward already works like a prefix operator: https://cpp2.godbolt.org/z/a1eeMvWhK.

[JohelEGP]

I just noticed this, to replace #408 (comment).

 //G prefix-operator:
 //G     one of  '!' '-' '+'
-//GT     parameter-direction
+//G     parameter-direction

[JohelEGP]

An alternative to the general solution above:

 //G return-statement:
-//G     return expression? ';'
+//G     return parameter-direction? expression? ';'

But the general solution is more useful.
There are more unparenthesized arguments in Cpp1 and Cpp2, like in a = b.

[hsutter]

Thanks! Got here from #487 -- for now I think the right fix is to not emit { } on deduced returns, which can change the type. We still want the { } on non-deduced returns I think. Anyway, the coming commit should fix this problem, and if there's more we can look at it again with new examples.