Enable generic out parameters, removes temporary alpha limitation

Feature: Code like `f: (out x: _) = { x = 42; }` now works, and can work with any type that is constructible from the rhs (here `42`)... see the new regression test for an example

Step toward self-hosting: Start including `cpp2util.h` in cppfront itself... and add (and use) unconditional `final_action`/`finally`

Usability: nicer diagnostics for if/else that forgot the required `{` `}` around the body

Also: closes #260

Author: hsutter

.gitignore

@@ -22,3 +22,5 @@
 *.vsidx
 *.lock
 .editorconfig
+*.xml
+*.sarif

include/cpp2util.h

@@ -546,9 +546,9 @@ class out {
     bool called_construct_ = false;
 
 public:
-    out(T*                 t) noexcept :  t{ t}, has_t{true}      { Default.expects( t); }
-    out(deferred_init<T>* dt) noexcept : dt{dt}, has_t{false}     { Default.expects(dt); }
-    out(out<T>*           ot) noexcept : ot{ot}, has_t{ot->has_t} { Default.expects(ot);
+    out(T*                 t_) noexcept :  t{ t_}, has_t{true}       { Default.expects( t); }
+    out(deferred_init<T>* dt_) noexcept : dt{dt_}, has_t{false}      { Default.expects(dt); }
+    out(out<T>*           ot_) noexcept : ot{ot_}, has_t{ot_->has_t} { Default.expects(ot);
         if (has_t) {  t = ot->t;  }
         else       { dt = ot->dt; }
     }
@@ -1280,6 +1280,39 @@ template <class F>
 }
 
 
+//
+//  Same, but clean up also on exceptional paths
+//
+
+template <class F>
+class final_action
+{
+public:
+    explicit final_action(const F& ff) noexcept : f{ff} { }
+    explicit final_action(F&& ff) noexcept : f{std::move(ff)} { }
+
+    ~final_action() noexcept { f(); }
+
+    final_action(final_action&& that) noexcept
+        : f(std::move(that.f)), invoke(std::exchange(that.invoke, false))
+    { }
+
+    final_action  (final_action const&) = delete;
+    void operator=(final_action const&) = delete;
+    void operator=(final_action&&)      = delete;
+
+private:
+    F f;
+    bool invoke = true;
+};
+
+template <class F>
+[[nodiscard]] auto finally(F&& f) noexcept
+{
+    return final_action<std::remove_cvref_t<F>>{std::forward<F>(f)};
+}
+
+
 //-----------------------------------------------------------------------
 //
 //  to_string for string interpolation

regression-tests/mixed-parameter-passing-generic-out.cpp2

@@ -0,0 +1,23 @@
+#include <iostream>
+
+struct X {
+    X(int) { }
+};
+auto operator<<(std::ostream& o, X const&) -> std::ostream& {
+    o << "exxxx";
+    return o;
+}
+
+f: (out x: _) = {
+    x = 42;
+}
+
+main: ()->int = {
+    a: int;
+    f(out a);
+    std::cout << a << "\n";
+
+    b: X;
+    f(out b);
+    std::cout << b << "\n";
+}

regression-tests/test-results/clang-12/mixed-parameter-passing-generic-out.cpp.execution

@@ -0,0 +1,2 @@
+42
+exxxx

regression-tests/test-results/clang-12/mixed-parameter-passing-generic-out.cpp.output

@@ -0,0 +1,2 @@
+42
+exxxx

regression-tests/test-results/gcc-10/mixed-parameter-passing-generic-out.cpp.execution

@@ -0,0 +1,40 @@
+
+#line 1 "mixed-parameter-passing-generic-out.cpp2"
+#include <iostream>
+
+struct X {
+    X(int) { }
+};
+auto operator<<(std::ostream& o, X const&) -> std::ostream& {
+    o << "exxxx";
+    return o;
+}
+
+#include "cpp2util.h"
+
+
+#line 11 "mixed-parameter-passing-generic-out.cpp2"
+auto f(auto* x_) -> void;
+#line 15 "mixed-parameter-passing-generic-out.cpp2"
+[[nodiscard]] auto main() -> int;
+
+//=== Cpp2 definitions ==========================================================
+
+#line 10 "mixed-parameter-passing-generic-out.cpp2"
+
+auto f(auto* x_) -> void{
+    auto x = cpp2::out(x_); 
+#line 12 "mixed-parameter-passing-generic-out.cpp2"
+    x.construct(42);
+}
+
+[[nodiscard]] auto main() -> int{
+    cpp2::deferred_init<int> a; 
+    f(&   a);
+    std::cout << std::move(a.value()) << "\n";
+
+    cpp2::deferred_init<X> b; 
+    f(&   b);
+    std::cout << std::move(b.value()) << "\n";
+}
+

regression-tests/test-results/gcc-10/mixed-parameter-passing-generic-out.cpp.output

@@ -0,0 +1,2 @@
+mixed-parameter-passing-generic-out.cpp2... ok (mixed Cpp1/Cpp2, Cpp2 code passes safety checks)
+

regression-tests/test-results/mixed-parameter-passing-generic-out.cpp

@@ -1,3 +1,3 @@
-Microsoft (R) C/C++ Optimizing Compiler Version 19.34.31937 for x86
+Microsoft (R) C/C++ Optimizing Compiler Version 19.34.31942 for x86
 Copyright (C) Microsoft Corporation.  All rights reserved.
 

regression-tests/test-results/mixed-parameter-passing-generic-out.cpp2.output

@@ -0,0 +1,2 @@
+42
+exxxx

regression-tests/test-results/msvc-2022/MSVC-version.output

@@ -0,0 +1 @@
+mixed-parameter-passing-generic-out.cpp

regression-tests/test-results/msvc-2022/mixed-parameter-passing-generic-out.cpp.execution

@@ -14,7 +14,8 @@
 #ifdef _MSC_VER
 #pragma warning(disable: 4456)
 #endif
-//#include "../include/cpp2util.h"
+
+#include "../include/cpp2util.h"
 
 
 //===========================================================================
@@ -226,15 +227,15 @@ struct String
 //
 template<typename T>
     requires std::is_same_v<T, std::string>
-auto as(bool b) -> T
+auto __as(bool b) -> T
 {
     return b ? "true" : "false";
 }
 
 
 //  Explicit cast
 template<typename T>
-auto as(auto x) -> T {
+auto __as(auto x) -> T {
     return T(x);
 }
 
@@ -247,7 +248,7 @@ auto strip_path(std::string const& file) -> std::string
     while (i >= 0 && file[i] != '\\' && file[i] != '/') {
         --i;
     }
-    return {file, as<size_t>(i+1)};
+    return {file, __as<size_t>(i+1)};
 }
 
 
@@ -379,9 +380,9 @@ class cmdline_processor
             }
 
             for (auto& flag : flags) {
-                auto length_to_match = std::max(flag.unique_prefix, as<int>(arg->text.length())-1);
+                auto length_to_match = std::max(flag.unique_prefix, __as<int>(arg->text.length())-1);
                 if (flag.opt_out && arg->text.ends_with("-")) {
-                    length_to_match = std::max(flag.unique_prefix, as<int>(arg->text.length())-2);
+                    length_to_match = std::max(flag.unique_prefix, __as<int>(arg->text.length())-2);
                 }
 
                 //  Allow a switch to start with either - or /

regression-tests/test-results/msvc-2022/mixed-parameter-passing-generic-out.cpp.output

@@ -49,7 +49,7 @@ auto pad(int padding) -> std::string_view
 
     return {
         indent_str.c_str(),
-        as<size_t>( std::min( padding, as<int>(std::ssize(indent_str))) )
+        __as<size_t>( std::min( padding, __as<int>(std::ssize(indent_str))) )
     };
 }
 
@@ -746,6 +746,12 @@ class cppfront
     };
     std::vector<arg_info> current_args  = { {} };
 
+    struct function_info {
+        std::vector<std::string> prolog = {};
+        std::vector<std::string> epilog = {};
+    };
+    std::vector<function_info> current_function = { {} };
+
     //  For lowering
     //
     positional_printer printer;
@@ -1878,6 +1884,10 @@ class cppfront
         return (pointer_declarators_cnt + addr_cnt - deref_cnt) > 0;
     }
 
+    auto is_pointer_declaration(udt_type_node const*, int, int) -> bool {
+        return false;
+    }
+
     auto is_pointer_declaration(declaration_sym const* decl, int deref_cnt, int addr_cnt) -> bool {
         if (!decl) {
             return false;
@@ -2741,6 +2751,9 @@ class cppfront
         auto unqid = std::get_if<type_id_node::unqualified>(&type_id.id);
         auto is_wildcard = unqid && *(*unqid)->identifier == "_";
 
+        assert( n.declaration->identifier );
+        auto identifier     = print_to_string( *n.declaration->identifier );
+
         //  First any prefix
         if (!returns && !is_wildcard)
         {
@@ -2758,7 +2771,15 @@ class cppfront
             break;case passing_style::in     : printer.print_cpp2( "auto const&", n.position() );
             break;case passing_style::copy   : printer.print_cpp2( "auto",        n.position() );
             break;case passing_style::inout  : printer.print_cpp2( "auto&",       n.position() );
-            break;case passing_style::out    : printer.print_cpp2( "auto&",       n.position() ); // TODO: support out<auto> via rewrite to template param
+
+            //  For generic out parameters, we take a pointer to anything with paramater named "identifier_"
+            //  and then generate the out<> as a stack local with the expected name "identifier"
+            break;case passing_style::out    : printer.print_cpp2( "auto*",       n.position() );
+                                               current_function.back().prolog.push_back(
+                                                   "auto " + identifier + " = cpp2::out(" + identifier + "_); "
+                                               );
+                                               identifier += "_";
+
             break;case passing_style::move   : printer.print_cpp2( "auto&&",      n.position() );
             break;case passing_style::forward: printer.print_cpp2( "auto&&",      n.position() );
             break;default: ;
@@ -2798,8 +2819,7 @@ class cppfront
             }
         }
 
-        printer.print_cpp2( " ", n.declaration->identifier->position() );
-        emit( *n.declaration->identifier );
+        printer.print_cpp2( " " + identifier, n.declaration->identifier->position());
 
         if (!returns && n.declaration->initializer) {
             printer.print_cpp2( " = ", n.declaration->initializer->position() );
@@ -3015,7 +3035,12 @@ class cppfront
         }
 
         //  Function
-        if (n.is(declaration_node::function))
+        if (n.is(declaration_node::udt_type))
+        {
+        }
+
+        //  Function
+        else if (n.is(declaration_node::function))
         {
             //  Start fresh (there may be one spurious leftover
             //  requires-condition created during the declarations pass)
@@ -3024,8 +3049,11 @@ class cppfront
             auto& func = std::get<declaration_node::function>(n.type);
             assert(func);
 
+            current_function.push_back({});
+            auto guard = finally([&]{ current_function.pop_back(); });
+
             //  If this is at expression scope, we can't emit "[[nodiscard]] auto name"
-            //  so print the provided intro instead, which will be a lambda-capture-list
+            //  so print the provided intro instead, which will be a Cpp1 lambda-introducer
             if (capture_intro != "") {
                 assert (!n.identifier);
                 printer.print_cpp2(capture_intro, n.position());
@@ -3061,15 +3089,12 @@ class cppfront
             //  Function body
             assert( n.initializer );
 
-            auto function_return_locals = std::vector<std::string>{};
-            auto function_epilog        = std::vector<std::string>{};
-
             for (auto&& c : func->contracts) {
                 auto print = std::string();
                 printer.emit_to_string(&print);
                 emit(*c);
                 printer.emit_to_string();
-                function_return_locals.push_back(print);
+                current_function.back().prolog.push_back(print);
             }
 
             if (func->returns.index() == function_type_node::list)
@@ -3122,18 +3147,18 @@ class cppfront
                         loc += init;
                     }
                     loc += ";";
-                    function_return_locals.push_back(loc);
+                    current_function.back().prolog.push_back(loc);
                 }
             }
 
-            //function_epilog.push_back("/*EPILOG-TEST*/");
+            //current_function.back().epilog.push_back("/*EPILOG-TEST*/");
 
             printer.preempt_position_push( n.equal_sign );
 
             // TODO: something like this to get rid of extra blank lines
             //       inside the start of bodies of functions that have
             //       multiple contracts
-            //printer.skip_lines( std::ssize(function_return_locals) );
+            //printer.skip_lines( std::ssize(current_function.back().prolog) );
 
             //  If processing the parameters generated any requires conditions,
             //  emit them here
@@ -3150,7 +3175,7 @@ class cppfront
             emit(
                 *n.initializer,
                 true, func->position(), n.identifier && func->returns.index() == function_type_node::empty,
-                function_return_locals, function_epilog, n.position().colno
+                current_function.back().prolog, current_function.back().epilog, n.position().colno
             );
 
             printer.preempt_position_pop();

source/common.h

@@ -125,7 +125,7 @@ auto close_paren_type(lexeme l) -> lexeme {
 
 template<typename T>
     requires std::is_same_v<T, std::string>
-auto as(lexeme l) -> std::string
+auto __as(lexeme l) -> std::string
 {
     switch (l) {
     break;case lexeme::SlashEq:             return "SlashEq";
@@ -233,7 +233,7 @@ class token
         lexeme          type
     )
       : start   {sz}
-      , count   {as<int16_t>(std::strlen(sz))}
+      , count   {__as<int16_t>(std::strlen(sz))}
       , pos     {pos  }
       , lex_type{type }
     {
@@ -262,7 +262,7 @@ class token
             return text;
         }
         else {
-            return as<std::string>(lex_type) + std::string(": ") + text;
+            return __as<std::string>(lex_type) + std::string(": ") + text;
         }
     }
 
@@ -883,7 +883,7 @@ auto lex_line(
                     comments.push_back({
                         comment::comment_kind::line_comment,
                         {lineno, i},
-                        {lineno, as<colno_t>(std::ssize(line))},
+                        {lineno, __as<colno_t>(std::ssize(line))},
                         std::string(&line[i], std::ssize(line) - i)
                         });
                     in_comment = false;
@@ -1434,7 +1434,7 @@ class tokens
             for (auto const& token : entry) {
                 o << "    " << token << " (" << token.position().lineno
                     << "," << token.position().colno << ") "
-                    << as<std::string>(token.type()) << "\n";
+                    << __as<std::string>(token.type()) << "\n";
             }
 
         }
@@ -1452,7 +1452,7 @@ class tokens
         for (auto const& token : generated_tokens) {
             o << "    " << token << " (" << token.position().lineno
                 << "," << token.position().colno << ") "
-                << as<std::string>(token.type()) << "\n";
+                << __as<std::string>(token.type()) << "\n";
         }
 
         o << "--- Generated text\n";