Add implicit return; at end of functions with a return values list, closes #70

Author: hsutter

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

@@ -2,7 +2,7 @@
 f: () -> (ri : int = 0) = {
     pred := :(e:_) -> bool = { return e == 1; };
     ri = 42;
-    return;
+    // "return;" is implicit"
 }
 
 g: () -> (ri : int) = {

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

@@ -27,7 +27,7 @@ struct g__ret {
 #line 3 "pure2-look-up-parameter-across-unnamed-function.cpp2"
     auto pred { [](auto const& e) -> bool{return e == 1; } }; 
     ri = 42;
-    return  { std::move(ri) }; 
+    return  { std::move(ri) }; // "return;" is implicit"
 }
 
 [[nodiscard]] auto g() -> g__ret{

source/cppfront.cpp

@@ -727,7 +727,7 @@ class cppfront
             try
             {
                 for (auto const& [line, entry] : tokens.get_map()) {
-                    if (!parser.parse(entry)) {
+                    if (!parser.parse(entry, tokens.get_generated())) {
                         errors.emplace_back(
                             source_position(line, 0),
                             "parse failed for section starting here"

source/lex.h

@@ -21,6 +21,7 @@
 #include "load.h"
 #include <map>
 #include <climits>
+#include <deque>
 
 
 namespace cpp2 {
@@ -204,6 +205,18 @@ class token
     {
     }
 
+    token(
+        char const*     sz,
+        source_position pos,
+        lexeme          type
+    )
+      : start   {sz}
+      , count   {as<int16_t>(std::strlen(sz))}
+      , pos     {pos  }
+      , lex_type{type }
+    {
+    }
+
     operator std::string_view() const
     {
         assert (start);
@@ -867,17 +880,20 @@ class tokens
 {
     std::vector<error>& errors;
 
-    //  All non-comment tokens go here, which will be parsed in the parser
+    //  All non-comment source tokens go here, which will be parsed in the parser
     std::map<lineno_t, std::vector<token>> grammar_map;
 
-    //  All comment tokens go here, which are applied in the lexer
+    //  All comment source tokens go here, which are applied in the lexer
     //
     //  We could put all the tokens in the same map, but that would mean the
     //  parsing logic would have to remember to skip comments everywhere...
     //  simpler to keep comments separate, at the smaller cost of traversing
     //  a second token stream when lowering to Cpp1 to re-interleave comments
     std::vector<comment> comments;
 
+    //  All generated tokens go here
+    std::deque<token> generated_tokens;
+
 public:
     //-----------------------------------------------------------------------
     //  Constructor
@@ -957,6 +973,15 @@ class tokens
     }
 
 
+    //-----------------------------------------------------------------------
+    //  get_generated: Access the generated tokens
+    //
+    auto get_generated() -> auto&
+    {
+        return generated_tokens;
+    }
+
+
     //-----------------------------------------------------------------------
     //  debug_print
     //

source/parse.h

@@ -1250,7 +1250,8 @@ class parser
     };
 
     //  Used only for the duration of each parse() call
-    std::vector<token> const* tokens_ = nullptr;
+    std::vector<token> const* tokens_           = nullptr;
+    std::deque<token> *       generated_tokens_ = nullptr;
     int pos = 0;
 
 public:
@@ -1277,12 +1278,14 @@ class parser
     //  sections in a TU to build the whole TU's parse tree
     //
     auto parse(
-        std::vector<token> const& tokens
+        std::vector<token> const& tokens,
+        std::deque<token>&        generated_tokens
     )
         -> bool
     {
         //  Generate parse tree for this section as if a standalone TU
         tokens_ = &tokens;
+        generated_tokens_ = &generated_tokens;
         pos     = 0;
         auto tu = translation_unit();
 
@@ -3042,6 +3045,31 @@ class parser
             }
         }
 
+        //  If this is a function with a list of multiple/named return values
+        if (auto func = std::get_if<declaration_node::function>(&n->type);
+            func && (*func)->returns.index() == function_type_node::list)
+        {
+            assert (n->initializer && n->initializer->statement.index() == statement_node::compound);
+            auto& body = std::get<statement_node::compound>(n->initializer->statement);
+
+            //  If the function body's end doesn't already have "return" as the last statement
+            //  then generate "return;" as the last statement
+            if (body->statements.empty() || body->statements.back()->statement.index() != statement_node::return_)
+            {
+                auto pos = body->statements.back()->position();
+                ++pos.lineno;
+                generated_tokens_->emplace_back( "return", pos, lexeme::Keyword);
+
+                auto ret = std::make_unique<return_statement_node>();
+                ret->identifier = &generated_tokens_->back();
+
+                auto stmt = std::make_unique<statement_node>();
+                stmt->statement = std::move(ret);
+
+                body->statements.push_back(std::move(stmt));
+            }
+        }
+
         n->decl_end = peek(-1)->position();
         return n;
     }