Disallow forward return of in or move parameter, addresses #248 comment

Addresses #248 (comment)

Author: hsutter

source/cppfront.cpp

@@ -2057,19 +2057,42 @@ class cppfront
         //
         if (n.expression)
         {
-            auto tok = n.expression->expr->get_postfix_expression_node()->expr->get_token();
-            if (
+            assert(!current_functions.empty());
+
+            //  If we're doing a forward return
+            if (auto tok = n.expression->expr->get_postfix_expression_node()->expr->get_token();
                 tok
-                && sema.get_declaration_of(*tok)
                 && !function_returns.empty()
                 && function_returns.back().pass == passing_style::forward
                 )
             {
-                errors.emplace_back(
-                    n.position(),
-                    "a 'forward' return type cannot return a local variable"
-                );
-                return;
+                //  Ensure we're not returning a local or an in/move parameter
+                auto is_parameter_name = current_functions.back().decl->has_parameter_named(*tok);
+                if (
+                    is_parameter_name
+                    && (
+                        current_functions.back().decl->has_in_parameter_named(*tok)
+                        || current_functions.back().decl->has_move_parameter_named(*tok)
+                        )
+                    )
+                {
+                    errors.emplace_back(
+                        n.position(),
+                        "a 'forward' return type cannot return an 'in' or 'move' parameter"
+                    );
+                    return;
+                }
+                else if (
+                    !is_parameter_name
+                    && sema.get_declaration_of(*tok)
+                    )
+                {
+                    errors.emplace_back(
+                        n.position(),
+                        "a 'forward' return type cannot return a local variable"
+                    );
+                    return;
+                }
             }
 
             emit(*n.expression);

source/parse.h

@@ -1415,13 +1415,27 @@ struct function_type_node
         return returns.index() != empty;
     }
 
-    auto has_out_parameter_named(std::string_view s) const
+    auto has_parameter_named(std::string_view s) const
+        -> bool
+    {
+        for (auto& param : parameters->parameters) {
+            if (param->has_name(s)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    auto has_parameter_with_name_and_pass(
+        std::string_view s,
+        passing_style    pass
+    ) const
         -> bool
     {
         for (auto& param : parameters->parameters) {
             if (
                 param->has_name(s)
-                && param->pass == passing_style::out
+                && param->pass == pass
                 )
             {
                 return true;
@@ -1430,6 +1444,24 @@ struct function_type_node
         return false;
     }
 
+    auto has_in_parameter_named(std::string_view s) const
+        -> bool
+    {
+        return has_parameter_with_name_and_pass(s, passing_style::in);
+    }
+
+    auto has_out_parameter_named(std::string_view s) const
+        -> bool
+    {
+        return has_parameter_with_name_and_pass(s, passing_style::out);
+    }
+
+    auto has_move_parameter_named(std::string_view s) const
+        -> bool
+    {
+        return has_parameter_with_name_and_pass(s, passing_style::move);
+    }
+
     //  Internals
     //
     auto position() const
@@ -1571,6 +1603,24 @@ struct declaration_node
             ;
     }
 
+    auto has_parameter_named(std::string_view s) const
+        -> bool
+    {
+        if (!is_function()) {
+            return false;
+        }
+        return std::get<a_function>(type)->has_parameter_named(s);
+    }
+
+    auto has_in_parameter_named(std::string_view s) const
+        -> bool
+    {
+        if (!is_function()) {
+            return false;
+        }
+        return std::get<a_function>(type)->has_in_parameter_named(s);
+    }
+
     auto has_out_parameter_named(std::string_view s) const
         -> bool
     {
@@ -1580,6 +1630,15 @@ struct declaration_node
         return std::get<a_function>(type)->has_out_parameter_named(s);
     }
 
+    auto has_move_parameter_named(std::string_view s) const
+        -> bool
+    {
+        if (!is_function()) {
+            return false;
+        }
+        return std::get<a_function>(type)->has_move_parameter_named(s);
+    }
+
     auto is_function () const -> bool
         { return type.index() == a_function;  }
     auto is_object   () const -> bool