Second try at additional nested block in functions.

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 528 matching lines @@
 
 
 struct TopLevel {
   TopLevel() : fields(4), functions(4) { }
 
   GrowableArray<Field*> fields;
   GrowableArray<Function*> functions;
 };
 
 
+static bool HasReturnNode(SequenceNode* seq) {
+  if (seq->length() == 0) {
+    return false;
+  } else if ((seq->length()) == 1 &&
+             (seq->NodeAt(seq->length() - 1)->IsSequenceNode())) {
+    return HasReturnNode(seq->NodeAt(seq->length() - 1)->AsSequenceNode());
+  } else {
+    return seq->NodeAt(seq->length() - 1)->IsReturnNode();
+  }
+}
+
+
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   Isolate* isolate = Isolate::Current();
   // Compilation can be nested, preserve the ast node id.
   const int prev_ast_node_id = isolate->ast_node_id();
   isolate->set_ast_node_id(0);
   ASSERT(parsed_function != NULL);
   const Function& func = parsed_function->function();
   const Class& cls = Class::Handle(func.owner());
   const Script& script = Script::Handle(cls.script());
   Parser parser(script, func, func.token_index());
@@ skipping 18 matching lines @@
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceSetter(func);
       break;
     case RawFunction::kConstImplicitGetter:
       node_sequence = parser.ParseStaticConstGetter(func);
       break;
     default:
       UNREACHABLE();
   }
 
-  if ((node_sequence->length() == 0) ||
-      !node_sequence->NodeAt(node_sequence->length() - 1)->IsReturnNode()) {
+  if (!HasReturnNode(node_sequence)) {
     // Add implicit return node.
     node_sequence->Add(new ReturnNode(parser.token_index_));
   }
   parsed_function->set_node_sequence(node_sequence);
 
   // The instantiator may be required at run time for generic type checks or
   // allocation of generic types.
   if (parser.IsInstantiatorRequired()) {
     // In the case of a local function, only set the instantiator if the
     // receiver was captured.
@@ skipping 1228 matching lines @@
     // The instantiator may be required at run time for generic type checks.
     if (IsInstantiatorRequired()) {
       // Make sure that the receiver of the enclosing instance function
       // (or implicit first parameter of an enclosing factory) is marked as
       // captured if type checks are enabled, because they may access the
       // receiver to instantiate types.
       CaptureReceiver();
     }
   }
 
+  OpenBlock();  // Open a nested scope for the outermost function block.
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     const intptr_t expr_pos = token_index_;
     AstNode* expr = ParseExpr(kAllowConst);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
   } else if (IsLiteral("native")) {
     ParseNativeFunctionBlock(&params, func);
   } else {
     UnexpectedToken();
   }
+  SequenceNode* body = CloseBlock();
+  current_block_->statements->Add(body);
   return CloseBlock();
 }
 
 
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
     ConsumeToken();
   }
 }
 
@@ skipping 5828 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart