Require definite first use initialization to be a standalone statement, closes #368

Author: hsutter

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.2.1   Build 8811:0910
+cppfront compiler v0.2.1   Build 8812:0920
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"8811:0910"
+"8812:0920"

source/parse.h

@@ -263,13 +263,19 @@ struct prefix_expression_node
 };
 
 
+struct expression_node;
+
+
 template<
     String   Name,
     typename Term
 >
 struct binary_expression_node
 {
-    std::unique_ptr<Term> expr;
+    std::unique_ptr<Term>  expr;
+    expression_node const* my_expression = {};
+
+    binary_expression_node();
 
     struct term
     {
@@ -280,6 +286,15 @@ struct binary_expression_node
 
     //  API
     //
+    auto is_standalone_expression() const
+        -> bool
+    {
+        return
+            my_expression
+            && my_expression->is_standalone_expression()
+            ;
+    }
+
     auto terms_size() const
         -> int
     {
@@ -437,12 +452,29 @@ struct assignment_expression_lhs_rhs {
 };
 
 
+struct expression_statement_node;
+
 struct expression_node
 {
+    static inline std::vector<expression_node*> current_expressions = {};
+
     std::unique_ptr<assignment_expression_node> expr;
+    int num_subexpressions = 0;
+    expression_statement_node const* my_statement = {};
+
+    expression_node();
 
     // API
     //
+    auto is_standalone_expression() const
+        -> bool;
+
+    auto subexpression_count() const
+        -> int
+    {
+        return num_subexpressions;
+    }
+
     auto is_identifier() const
         -> bool
     {
@@ -504,6 +536,17 @@ struct expression_node
 };
 
 
+template<
+    String   Name,
+    typename Term
+>
+binary_expression_node<Name, Term>::binary_expression_node() {
+    if (!expression_node::current_expressions.empty()) {
+        my_expression = expression_node::current_expressions.back();
+    }
+}
+
+
 enum class passing_style { in=0, copy, inout, out, move, forward, invalid };
 auto to_passing_style(token const& t) -> passing_style {
     if (t.type() == lexeme::Identifier) {
@@ -604,11 +647,20 @@ auto primary_expression_node::is_literal() const
 
 struct expression_statement_node
 {
+    static inline std::vector<expression_statement_node*> current_expression_statements = {};
+
     std::unique_ptr<expression_node> expr;
     bool has_semicolon = false;
 
     //  API
     //
+    auto subexpression_count() const
+        -> int
+    {
+        assert (expr);
+        return expr->subexpression_count();
+    }
+
     auto to_string() const
         -> std::string
     {
@@ -636,6 +688,24 @@ struct expression_statement_node
 };
 
 
+expression_node::expression_node()
+{
+    if (!expression_statement_node::current_expression_statements.empty()) {
+        my_statement = expression_statement_node::current_expression_statements.back();
+    }
+}
+
+
+auto expression_node::is_standalone_expression() const
+    -> bool
+{
+    return
+        my_statement
+        && my_statement->subexpression_count() == subexpression_count()
+        ;
+}
+
+
 struct capture {
     postfix_expression_node* capture_expr;
     std::string              cap_sym = {};
@@ -4275,6 +4345,10 @@ class parser
             return {};
         }
 
+        for (auto& e : expression_node::current_expressions) {
+            e->num_subexpressions += std::ssize(n->ops);
+        }
+
         return n;
     }
 
@@ -4621,7 +4695,7 @@ class parser
             );
 
             if (ret && ret->terms_size() > 1) {
-                error("assignment cannot be chained - instead of 'c = b = a;', write 'b = a; c = b;'");
+                error("assignment cannot be chained - instead of 'c = b = a;', write 'b = a; c = b;'", false);
                 return {};
             }
 
@@ -4635,7 +4709,7 @@ class parser
             );
 
             if (ret && ret->terms_size() > 1) {
-                error("assignment cannot be chained - instead of 'c = b = a;', write 'b = a; c = b;'");
+                error("assignment cannot be chained - instead of 'c = b = a;', write 'b = a; c = b;'", false);
                 return {};
             }
 
@@ -4651,6 +4725,11 @@ class parser
         -> std::unique_ptr<expression_node>
     {
         auto n = std::make_unique<expression_node>();
+
+        {
+        expression_node::current_expressions.push_back(n.get());
+        auto guard = finally([&]{ expression_node::current_expressions.pop_back(); });
+
         if (!(n->expr = assignment_expression(allow_angle_operators))) {
             return {};
         }
@@ -4663,7 +4742,11 @@ class parser
             error("'->' is not Cpp2 deference syntax - write '*.' instead");
             return {};
         }
+        }
 
+        for (auto& e : expression_node::current_expressions) {
+            ++e->num_subexpressions;
+        }
         return n;
     }
 
@@ -5127,6 +5210,10 @@ class parser
         -> std::unique_ptr<expression_statement_node>
     {
         auto n = std::make_unique<expression_statement_node>();
+
+        expression_statement_node::current_expression_statements.push_back(n.get());
+        auto guard = finally([&]{ expression_statement_node::current_expression_statements.pop_back(); });
+
         if (!(n->expr = expression())) {
             return {};
         }
@@ -7233,9 +7320,11 @@ class parse_tree_printer : printing_visitor
         o << pre(indent) << "literal" << "\n";
     }
 
-    auto start(expression_node const&, int indent) -> void
+    auto start(expression_node const& n, int indent) -> void
     {
-        o << pre(indent) << "expression\n";
+        o << pre(indent) << "expression - "
+            << n.num_subexpressions << " subexpressions, my_statement ["
+            << static_cast<void const*>(n.my_statement) << "]\n";
     }
 
     auto start(expression_list_node::term const&n, int indent) -> void
@@ -7272,9 +7361,9 @@ class parse_tree_printer : printing_visitor
         o << pre(indent) << Name.value << "-expression\n";
     }
 
-    auto start(expression_statement_node const&, int indent) -> void
+    auto start(expression_statement_node const& n, int indent) -> void
     {
-        o << pre(indent) << "expression-statement\n";
+        o << pre(indent) << "expression-statement - [" << static_cast<void const*>(&n) << "]\n";
     }
 
     auto start(postfix_expression_node const&, int indent) -> void

source/sema.h

@@ -62,14 +62,14 @@ struct declaration_sym {
 };
 
 struct identifier_sym {
-    bool assignment_to = false;
+    bool standalone_assignment_to = false;
     token const* identifier = {};
 
     identifier_sym(
         bool         a,
         token const* id
     )
-        : assignment_to{a}
+        : standalone_assignment_to{a}
         , identifier{id}
     { }
 
@@ -411,7 +411,7 @@ class sema
                     o << "*** " << sym.identifier->position().to_string()
                       << " DEFINITE INITIALIZATION OF ";
                 }
-                else if (sym.assignment_to) {
+                else if (sym.standalone_assignment_to) {
                     o << "*** assignment to ";
                 }
                 else {
@@ -737,7 +737,7 @@ class sema
                     //  If we're not inside a selection statement, we're at the top level --
                     //  just return true if it's an assignment to it, else return false
                     if (std::ssize(selection_stack) == 0) {
-                        if (sym.assignment_to) {
+                        if (sym.standalone_assignment_to) {
                             definite_initializations.push_back( sym.identifier );
                         }
                         else {
@@ -746,7 +746,7 @@ class sema
                                 "local variable " + name
                                     + " is used before it was initialized");
                         }
-                        return sym.assignment_to;
+                        return sym.standalone_assignment_to;
                     }
 
                     //  Else if we're inside a selection statement but still in the condition
@@ -755,7 +755,7 @@ class sema
                         //  If this is a top-level selection statement, handle it the same as
                         //  if we weren't an a selection statement
                         if (std::ssize(selection_stack) == 1) {
-                            if (sym.assignment_to) {
+                            if (sym.standalone_assignment_to) {
                                 definite_initializations.push_back( sym.identifier );
                             }
                             else {
@@ -764,14 +764,14 @@ class sema
                                     "local variable " + name
                                         + " is used in a condition before it was initialized");
                             }
-                            return sym.assignment_to;
+                            return sym.standalone_assignment_to;
                         }
                         //  Else we can skip the rest of this selection statement, and record
                         //  this as the result of the next outer selection statement's current branch
                         else {
                             selection_stack.pop_back();
                             assert (std::ssize(selection_stack.back().branches) > 0);
-                            selection_stack.back().branches.back().result = sym.assignment_to;
+                            selection_stack.back().branches.back().result = sym.standalone_assignment_to;
 
                             int this_depth = symbols[pos].depth;
                             while (symbols[pos + 1].depth >= this_depth) {
@@ -783,7 +783,7 @@ class sema
                     //  Else we're in a selection branch and can skip the rest of this branch
                     //  and record this as the result for the current branch
                     else {
-                        if (sym.assignment_to) {
+                        if (sym.standalone_assignment_to) {
                             definite_initializations.push_back( sym.identifier );
                         }
                         else {
@@ -792,7 +792,7 @@ class sema
                                 "local variable " + name
                                     + " is used in a branch before it was initialized");
                         }
-                        selection_stack.back().branches.back().result = sym.assignment_to;
+                        selection_stack.back().branches.back().result = sym.standalone_assignment_to;
 
                         //  The depth of this branch should always be the depth of
                         //  the current selection statement + 1
@@ -1450,13 +1450,13 @@ class sema
     //-----------------------------------------------------------------------
     //  Visitor functions
     //
-    int  scope_depth                   = 0;
-    bool started_assignment_expression = false;
-    bool started_postfix_expression    = false;
-    bool is_out_expression             = false;
-    bool inside_parameter_list         = false;
-    bool inside_returns_list           = false;
-    bool just_entered_for              = false;
+    int  scope_depth                              = 0;
+    bool started_standalone_assignment_expression = false;
+    bool started_postfix_expression               = false;
+    bool is_out_expression                        = false;
+    bool inside_parameter_list                    = false;
+    bool inside_returns_list                      = false;
+    bool just_entered_for                         = false;
     parameter_declaration_node const* inside_out_parameter = {};
 
     auto start(parameter_declaration_list_node const&, int) -> void
@@ -1588,10 +1588,10 @@ class sema
 
         //  If this is the first identifier since we started a new assignment,
         //  expression, then it's the left-hand side (target) of the assignment
-        else if (started_assignment_expression)
+        else if (started_standalone_assignment_expression)
         {
             symbols.emplace_back( scope_depth, identifier_sym( true, &t ) );
-            started_assignment_expression = false;
+            started_standalone_assignment_expression = false;   // we were the consumer for this information
         }
 
         //  If this is the first identifier since we saw an `out` expression,
@@ -1681,10 +1681,14 @@ class sema
 
     auto start(assignment_expression_node const& n, int)
     {
-        if (std::ssize(n.terms) > 0) {
+        if (
+            n.is_standalone_expression()
+            && std::ssize(n.terms) > 0
+            )
+        {
             assert (n.terms.front().op);
             if (n.terms.front().op->type() == lexeme::Assignment) {
-                started_assignment_expression = true;
+                started_standalone_assignment_expression = true;
             }
         }
     }