Introduce newline tokens into the token stream.

runtime/vm/parser.cc

 // Copyright (c) 2012, 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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 1333 matching lines @@
 
   ReturnNode* return_node = new ReturnNode(token_pos, closure_call);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::SkipBlock() {
   ASSERT(CurrentToken() == Token::kLBRACE);
   GrowableArray<Token::Kind> token_stack(8);
+  // Adding the first kLBRACE here, because it will be consumed in the loop
+  // right away.
+  token_stack.Add(CurrentToken());
   const intptr_t block_start_pos = TokenPos();
   bool is_match = true;
   bool unexpected_token_found = false;
   Token::Kind token;
   intptr_t token_pos;
   do {
+    ConsumeToken();
     token = CurrentToken();
     token_pos = TokenPos();
     switch (token) {
       case Token::kLBRACE:
       case Token::kLPAREN:
       case Token::kLBRACK:
         token_stack.Add(token);
         break;
       case Token::kRBRACE:
         is_match = token_stack.RemoveLast() == Token::kLBRACE;
         break;
       case Token::kRPAREN:
         is_match = token_stack.RemoveLast() == Token::kLPAREN;
         break;
       case Token::kRBRACK:
         is_match = token_stack.RemoveLast() == Token::kLBRACK;
         break;
       case Token::kEOS:
         unexpected_token_found = true;
         break;
       default:
         // nothing.
         break;
     }
-    ConsumeToken();
   } while (!token_stack.is_empty() && is_match && !unexpected_token_found);
   if (!is_match) {
     ErrorMsg(token_pos, "unbalanced '%s'", Token::Str(token));
   } else if (unexpected_token_found) {
     ErrorMsg(block_start_pos, "unterminated block");
   }
 }
 
 
 void Parser::ParseFormalParameter(bool allow_explicit_default_value,
@@ skipping 1503 matching lines @@
                                function_name,
                                NULL,   // No arguments.
                                func.is_static() ?
                                    InvocationMirror::kStatic :
                                    InvocationMirror::kDynamic,
                                InvocationMirror::kMethod));
     end_token_pos = TokenPos();
   } else {
     UnexpectedToken();
   }
+
   ASSERT(func.end_token_pos() == func.token_pos() ||
          func.end_token_pos() == end_token_pos);
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   return CloseBlock();
 }
 
@@ skipping 263 matching lines @@
       ErrorMsg(method->name_pos,
                "const constructor or factory '%s' may not have a function body",
                method->name->ToCString());
     }
     if (method->redirect_name != NULL) {
       ErrorMsg(method->name_pos,
                "Constructor with redirection may not have a function body");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
+      method_end_pos = TokenPos();
+      ExpectToken(Token::kRBRACE);
     } else {
       ConsumeToken();
       SkipExpr();
+      method_end_pos = TokenPos();
       ExpectSemicolon();
     }
-    method_end_pos = TokenPos() - 1;
   } else if (IsLiteral("native")) {
     if (method->has_abstract) {
       ErrorMsg(method->name_pos,
                "abstract method '%s' may not have a function body",
                method->name->ToCString());
     } else if (method->IsFactoryOrConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
                "const constructor or factory '%s' may not be native",
                method->name->ToCString());
     }
@@ skipping 609 matching lines @@
   }
   pending_classes.Add(cls, Heap::kOld);
   if (metadata_pos >= 0) {
     library_.AddClassMetadata(cls, metadata_pos);
   }
 
   if (CurrentToken() != Token::kLBRACE) {
     ErrorMsg("{ expected");
   }
   SkipBlock();
+  ExpectToken(Token::kRBRACE);
 }
 
 
 void Parser::ParseClassDefinition(const Class& cls) {
   TRACE_PARSER("ParseClassDefinition");
   set_current_class(cls);
   is_top_level_ = true;
   String& class_name = String::Handle(cls.Name());
   const intptr_t class_pos = TokenPos();
   ClassDesc members(cls, class_name, false, class_pos);
@@ skipping 738 matching lines @@
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
   intptr_t function_end_pos = function_pos;
   if (is_external) {
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
-    function_end_pos = TokenPos() - 1;
+    function_end_pos = TokenPos();
+    ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else {
@@ skipping 107 matching lines @@
              is_getter ? "getter" : "setter",
              field_name->ToCString());
   }
 
   intptr_t accessor_end_pos = accessor_pos;
   if (is_external) {
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
-    accessor_end_pos = TokenPos() - 1;
+    accessor_end_pos = TokenPos();
+    ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
   } else {
@@ skipping 5424 matching lines @@
     ExpectIdentifier("function name expected");
   }
   if (CurrentToken() == Token::kLPAREN) {
     const bool allow_explicit_default_values = true;
     ParamList params;
     params.skipped = true;
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
   }
   if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
+    ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
 
 // Skips function/method/constructor/getter/setter preambles until the formal
 // parameter list. It is enough to skip the tokens, since we have already
 // previously parsed the function.
@@ skipping 275 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart