Only do deferred init for function local objects, closes #59

Extend declaration parsing to track parent decls/scopes
And require a non-local object to have an initializer

Author: hsutter

source/cppfront.cpp

@@ -2598,7 +2598,16 @@ class cppfront
             else {
                 //  If there isn't an initializer, use cpp2::deferred_init<T>
                 if (!n.initializer) {
-                    printer.print_cpp2( "cpp2::deferred_init<", n.position() );
+                    if (n.parent_scope && n.parent_scope->is(declaration_node::function)) {
+                        printer.print_cpp2( "cpp2::deferred_init<", n.position() );
+                    }
+                    else {
+                        errors.emplace_back(
+                            n.position(),
+                            "a non-local object must have an initializer"
+                        );
+                        return;
+                    }
                 }
                 printer.preempt_position(n.position());
                 emit( *type );

source/parse.h

@@ -912,6 +912,10 @@ struct declaration_node
     std::unique_ptr<statement_node> initializer;
     capture_group                   captures;
 
+    declaration_node*               parent_scope = nullptr;
+
+    declaration_node(declaration_node* parent) : parent_scope{parent} { }
+
     //  Shorthand for common query
     //
     auto is(active a) const
@@ -1171,6 +1175,23 @@ class parser
         }
     };
 
+    //  Keep a stack of currently active declarations (still being parsed)
+    std::vector<declaration_node*> current_declarations = { nullptr };
+
+    struct current_declarations_stack_guard {
+        parser* pars;
+        current_declarations_stack_guard(parser* p, declaration_node* decl)
+            : pars{p}
+        {
+            assert(p);
+            assert(decl);
+            pars->current_declarations.push_back(decl);
+        }
+        ~current_declarations_stack_guard() {
+            pars->current_declarations.pop_back();
+        }
+    };
+
     //  Used only for the duration of each parse() call
     std::vector<token> const* tokens_ = nullptr;
     int pos = 0;
@@ -2856,14 +2877,16 @@ class parser
         }
         next();
 
-        auto n = std::make_unique<declaration_node>();
+        auto n = std::make_unique<declaration_node>( current_declarations.back() );
         n->pos = start;
         auto guard =
             captures_allowed
             ? make_unique<capture_groups_stack_guard>(this, &n->captures)
             : std::unique_ptr<capture_groups_stack_guard>()
             ;
 
+        auto guard2 = current_declarations_stack_guard(this, n.get());
+
         //  Next is an an optional type
 
         //  It could be a function type, declaring a function

source/sema.h

@@ -319,7 +319,7 @@ class sema
                     o << "*** " << sym.identifier->position().to_string()
                       << " DEFINITE LAST "
                       << (use->is_forward ? "FORWARDING" : "POTENTIALLY MOVING")
-                      << "USE OF ";
+                      << " USE OF ";
                 }
 
                 if (is_definite_initialization(sym.identifier)) {
@@ -372,7 +372,7 @@ class sema
         //  Helpers for readability
 
         //  It's an uninitialized variable (incl. named return values) if it's
-        //  a variable with no initializer and that isn't a parameter
+        //  a local variable with no initializer and that isn't a parameter
         //
         auto is_uninitialized_variable_decl = [&](symbol const& s)
             -> declaration_sym const*
@@ -381,7 +381,13 @@ class sema
                 assert (sym);
                 if (sym->start && !sym->initializer && !(sym->parameter && sym->parameter->pass != passing_style::out)) {
                     assert (sym->declaration->is(declaration_node::active::object));
-                    return sym;
+                    //  Must be in function scope
+                    if (sym->declaration->parent_scope && sym->declaration->parent_scope->is(declaration_node::function)) {
+                        return sym;
+                    }
+                    else {
+                        return {};
+                    }
                 }
             }
             return {};
@@ -401,7 +407,13 @@ class sema
                     )
                    )
                 {
-                    return sym;
+                    //  Must be in function scope
+                    if (sym->declaration->parent_scope && sym->declaration->parent_scope->is(declaration_node::function)) {
+                        return sym;
+                    }
+                    else {
+                        return {};
+                    }
                 }
             }
             return {};