Helper ast node sequences must not wrongly grab ownership of the enclosing

runtime/vm/parser.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 3588 matching lines @@
         (follower != Token::kIDENT) &&  // Variable name following a type.
         (follower != Token::kTHIS)) {  // Field parameter following a type.
       return Type::DynamicType();
     }
   }
   return ParseType(type_resolution);
 }
 
 
 // Returns ast nodes of the variable initialization, or NULL if variables
 // are not initialized. If several variables are declared and initialized,

[hausner, 2011/12/09 21:19:21]

This comment is outdated, since variables are now always initialized (possibly
implicitly). So NULL is never returned. Can you update it while you're working
in the neighborhood?

[regis, 2011/12/09 21:31:22]

Done.

 // the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   bool is_final = (CurrentToken() == Token::kFINAL);
   const AbstractType& type = AbstractType::ZoneHandle(
       ParseFinalVarOrType(kIsMandatory, kMustResolve));
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("identifier expected");
   }
 
   AstNode* initializers = ParseVariableDeclaration(type, is_final);
+  ASSERT(initializers != NULL);
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
     if (CurrentToken() != Token::kIDENT) {
       ErrorMsg("identifier expected after comma");
     }
-    AstNode* right = ParseVariableDeclaration(type, is_final);
-    if (right != NULL) {
-      if (initializers == NULL) {
-        initializers = right;
-      } else {
-        // We have a second initializer. Allocate a sequence node now.
-        SequenceNode* sequence = NodeAsSequenceNode(initializers->token_index(),
-                                                    initializers,
-                                                    current_block_->scope);
-        sequence->Add(right);
-        initializers = sequence;
-      }
-    }
+    // We have a second initializer. Allocate a sequence node now.
+    // The sequence does not own the current scope. Set its own scope to NULL.
+    SequenceNode* sequence = NodeAsSequenceNode(initializers->token_index(),
+                                                initializers,
+                                                NULL);
+    sequence->Add(ParseVariableDeclaration(type, is_final));
+    initializers = sequence;
   }
   return initializers;
 }
 
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
   AbstractType& result_type = AbstractType::Handle();
   const String* variable_name = NULL;
   const String* function_name = NULL;
@@ skipping 446 matching lines @@
   }
   return if_node;
 }
 
 
 CaseNode* Parser::ParseCaseClause(LocalVariable* switch_expr_value,
                                   SourceLabel* case_label) {
   TRACE_PARSER("ParseCaseStatement");
   bool default_seen = false;
   const intptr_t case_pos = token_index_;
-  SequenceNode* case_expressions =
-      new SequenceNode(case_pos, current_block_->scope);
+  // The case expressions node sequence does not own the enclosing scope.
+  SequenceNode* case_expressions = new SequenceNode(case_pos, NULL);
   while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
     if (CurrentToken() == Token::kCASE) {
       if (default_seen) {
         ErrorMsg("default clause must be last case");
       }
       ConsumeToken();  // Keyword case.
       const intptr_t expr_pos = token_index_;
       AstNode* expr = ParseExpr(kAllowConst);
       AstNode* switch_expr_load = new LoadLocalNode(case_pos,
                                                     *switch_expr_value);
@@ skipping 425 matching lines @@
     // Function literal in assert implies a call.
     condition =
         new ClosureCallNode(condition_pos,
                             condition,
                             new ArgumentListNode(condition_pos));
   }
   condition = new UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
   return new IfNode(condition_pos,
                     condition,
-                    NodeAsSequenceNode(condition_pos,
-                                       assert_throw,
-                                       current_block_->scope),
+                    NodeAsSequenceNode(condition_pos, assert_throw, NULL),
                     NULL);
 }
 
 
 struct CatchParamDesc {
   CatchParamDesc()
       : token_index(0), type(NULL), var(NULL), is_final(false) { }
   intptr_t token_index;
   const AbstractType* type;
   const String* var;
@@ skipping 787 matching lines @@
       || expr->IsStaticGetterNode()
       || expr->IsInstanceGetterNode()
       || expr->IsLoadIndexedNode();
 }
 
 
 AstNode* Parser::ParseExprList() {
   TRACE_PARSER("ParseExprList");
   AstNode* expressions = ParseExpr(kAllowConst);
   if (CurrentToken() == Token::kCOMMA) {
-    // Collect comma-separated expressions in a sequence node.
-    SequenceNode* list = new SequenceNode(token_index_, current_block_->scope);
+    // Collect comma-separated expressions in a non scope owning sequence node.
+    SequenceNode* list = new SequenceNode(token_index_, NULL);
     list->Add(expressions);
     while (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       AstNode* expr = ParseExpr(kAllowConst);
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
@@ skipping 2264 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart