Fix try-catch for sure

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 843 matching lines @@
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 RawArray* Parser::EvaluateMetadata() {
-  if (CurrentToken() != Token::kAT) {
-    ErrorMsg("Metadata character '@' expected");
-  }
+  CheckToken(Token::kAT, "Metadata character '@' expected");
   GrowableObjectArray& meta_values =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
     intptr_t expr_pos = TokenPos();
     if (!IsIdentifier()) {
       ExpectIdentifier("identifier expected");
     }
     AstNode* expr = NULL;
     if ((LookaheadToken(1) == Token::kLPAREN) ||
@@ skipping 806 matching lines @@
     ParseFormalParameters(allow_explicit_default_values,
                           evaluate_metadata,
                           params);
     if (params->has_optional_positional_parameters ||
         params->has_optional_named_parameters) {
       // Parse optional parameters.
       ParseFormalParameters(allow_explicit_default_values,
                             evaluate_metadata,
                             params);
       if (params->has_optional_positional_parameters) {
-        if (CurrentToken() != Token::kRBRACK) {
-          ErrorMsg("',' or ']' expected");
-        }
+        CheckToken(Token::kRBRACK, "',' or ']' expected");
       } else {
-        if (CurrentToken() != Token::kRBRACE) {
-          ErrorMsg("',' or '}' expected");
-        }
+        CheckToken(Token::kRBRACE, "',' or '}' expected");
       }
       ConsumeToken();  // ']' or '}'.
     }
     if ((CurrentToken() != Token::kRPAREN) &&
         !params->has_optional_positional_parameters &&
         !params->has_optional_named_parameters) {
       ErrorMsg("',' or ')' expected");
     }
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
 }
 
 
 String& Parser::ParseNativeDeclaration() {
   TRACE_PARSER("ParseNativeDeclaration");
   ASSERT(IsLiteral("native"));
   ConsumeToken();
-  if (CurrentToken() != Token::kSTRING) {
-    ErrorMsg("string literal expected");
-  }
+  CheckToken(Token::kSTRING, "string literal expected");
   String& native_name = *CurrentLiteral();
   ConsumeToken();
   return native_name;
 }
 
 
 // Resolve and return the dynamic function of the given name in the superclass.
 // If it is not found, and resolve_getter is true, try to resolve a getter of
 // the same name. If it is still not found, return noSuchMethod and
 // set is_no_such_method to true..
@@ skipping 380 matching lines @@
   ConsumeToken();
   const Class& super_class = Class::Handle(cls.SuperClass());
   ASSERT(!super_class.IsNull());
   String& ctor_name = String::Handle(super_class.Name());
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_name = String::Concat(ctor_name,
                                *ExpectIdentifier("constructor name expected"));
   }
-  if (CurrentToken() != Token::kLPAREN) {
-    ErrorMsg("parameter list expected");
-  }
+  CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super class constructor.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
   // Second implicit parameter is the construction phase. We optimistically
   // assume that we can execute both the super initializer and the super
   // constructor body. We may later change this to only execute the
   // super initializer.
   AstNode* phase_parameter =
@@ skipping 238 matching lines @@
   const intptr_t call_pos = TokenPos();
   ConsumeToken();
   String& ctor_name = String::Handle(cls.Name());
 
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_name = String::Concat(ctor_name,
                                *ExpectIdentifier("constructor name expected"));
   }
-  if (CurrentToken() != Token::kLPAREN) {
-    ErrorMsg("parameter list expected");
-  }
+  CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // 'this' parameter is the first argument to constructor.
   AstNode* implicit_argument = new LoadLocalNode(call_pos, receiver);
   arguments->Add(implicit_argument);
   // Construction phase parameter is second argument.
   LocalVariable* phase_param = LookupPhaseParameter();
   ASSERT(phase_param != NULL);
   AstNode* phase_argument = new LoadLocalNode(call_pos, phase_param);
   arguments->Add(phase_argument);
@@ skipping 599 matching lines @@
 void Parser::SkipInitializers() {
   ASSERT(CurrentToken() == Token::kCOLON);
   do {
     ConsumeToken();  // Colon or comma.
     if (CurrentToken() == Token::kSUPER) {
       ConsumeToken();
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         ExpectIdentifier("identifier expected");
       }
-      if (CurrentToken() != Token::kLPAREN) {
-        ErrorMsg("'(' expected");
-      }
+      CheckToken(Token::kLPAREN);
       SkipToMatchingParenthesis();
     } else {
       SkipIf(Token::kTHIS);
       SkipIf(Token::kPERIOD);
       ExpectIdentifier("identifier expected");
       ExpectToken(Token::kASSIGN);
       SetAllowFunctionLiterals(false);
       SkipExpr();
       SetAllowFunctionLiterals(true);
     }
@@ skipping 190 matching lines @@
       ConsumeToken();  // Colon.
       ExpectToken(Token::kTHIS);
       String& redir_name = String::ZoneHandle(
           String::Concat(members->class_name(), Symbols::Dot()));
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         redir_name = String::Concat(redir_name,
             *ExpectIdentifier("constructor name expected"));
       }
       method->redirect_name = &redir_name;
-      if (CurrentToken() != Token::kLPAREN) {
-        ErrorMsg("'(' expected");
-      }
+      CheckToken(Token::kLPAREN);
       SkipToMatchingParenthesis();
     } else {
       SkipInitializers();
     }
   }
 
   // Only constructors can redirect to another method.
   ASSERT((method->redirect_name == NULL) || method->IsConstructor());
 
   intptr_t method_end_pos = TokenPos();
@@ skipping 446 matching lines @@
     *member.name = String::Concat(*member.name, Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       member.dict_name = ExpectIdentifier("identifier expected");
       *member.name = String::Concat(*member.name, *member.dict_name);
     }
     // Ensure that names are symbols.
     *member.name = Symbols::New(*member.name);
 
-    if (CurrentToken() != Token::kLPAREN) {
-      ErrorMsg("left parenthesis expected");
-    }
+    CheckToken(Token::kLPAREN);
   } else if ((CurrentToken() == Token::kGET) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     member.kind = RawFunction::kGetterFunction;
     member.name_pos = this->TokenPos();
     member.name = ExpectIdentifier("identifier expected");
     // If the result type was not specified, it will be set to DynamicType.
   } else if ((CurrentToken() == Token::kSET) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON))  {
     ConsumeToken();
     member.kind = RawFunction::kSetterFunction;
     member.name_pos = this->TokenPos();
     member.name = ExpectIdentifier("identifier expected");
-    if (CurrentToken() != Token::kLPAREN) {
-      ErrorMsg("'(' expected");
-    }
+    CheckToken(Token::kLPAREN);
     // The grammar allows a return type, so member.type is not always NULL here.
     // If no return type is specified, the return type of the setter is dynamic.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(Type::DynamicType());
     }
   } else if ((CurrentToken() == Token::kOPERATOR) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
@@ skipping 212 matching lines @@
     const Class& orig_class = Class::Cast(obj);
     ASSERT(!orig_class.is_finalized());
     orig_class.set_patch_class(cls);
     cls.set_is_patch();
   }
   pending_classes.Add(cls, Heap::kOld);
 
   if (is_mixin_declaration) {
     ExpectSemicolon();
   } else {
-    if (CurrentToken() != Token::kLBRACE) {
-      ErrorMsg("{ expected");
-    }
+    CheckToken(Token::kLBRACE);
     SkipBlock();
     ExpectToken(Token::kRBRACE);
   }
 }
 
 
 void Parser::ParseClassDefinition(const Class& cls) {
   TRACE_PARSER("ParseClassDefinition");
   set_current_class(cls);
   is_top_level_ = true;
@@ skipping 143 matching lines @@
   const intptr_t type_pos = TokenPos();
   AbstractType& type =
       AbstractType::Handle(ParseType(ClassFinalizer::kResolveTypeParameters));
   if (type.IsTypeParameter()) {
     ErrorMsg(type_pos,
              "class '%s' may not extend type parameter '%s'",
              class_name.ToCString(),
              String::Handle(type.UserVisibleName()).ToCString());
   }
 
-  if (CurrentToken() != Token::kWITH) {
-    ErrorMsg("mixin application 'with Type' expected");
-  }
+  CheckToken(Token::kWITH, "mixin application 'with Type' expected");
   type = ParseMixins(type);
 
   mixin_application.set_super_type(type);
   mixin_application.set_is_synthesized_class();
 
   // This mixin application typedef needs an implicit constructor, but it is
   // too early to call 'AddImplicitConstructor(mixin_application)' here,
   // because this class should be lazily compiled.
   if (CurrentToken() == Token::kIMPLEMENTS) {
     ParseInterfaceList(mixin_application);
@@ skipping 96 matching lines @@
   // Parse the type parameters of the function type.
   ParseTypeParameters(function_type_alias);
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
   if (!result_type.IsNull()) {
     ResolveTypeFromClass(function_type_alias,
                          ClassFinalizer::kResolveTypeParameters,
                          &result_type);
   }
   // Parse the formal parameters of the function type.
-  if (CurrentToken() != Token::kLPAREN) {
-    ErrorMsg("formal parameter list expected");
-  }
+  CheckToken(Token::kLPAREN, "formal parameter list expected");
   ParamList func_params;
 
   // Add implicit closure object parameter.
   func_params.AddFinalParameter(
       TokenPos(),
       &Symbols::ClosureParameter(),
       &Type::ZoneHandle(Type::DynamicType()));
 
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, false, &func_params);
@@ skipping 405 matching lines @@
     ErrorMsg(name_pos, "missing '%s' cannot be patched", func_name.ToCString());
   }
   String& accessor_name = String::Handle(Field::GetterName(func_name));
   if (library_.LookupLocalObject(accessor_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined as getter",
              func_name.ToCString());
   }
   // A setter named x= may co-exist with a function named x, thus we do
   // not need to check setters.
 
-  if (CurrentToken() != Token::kLPAREN) {
-    ErrorMsg("'(' expected");
-  }
+  CheckToken(Token::kLPAREN);
   const intptr_t function_pos = TokenPos();
   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) {
@@ skipping 236 matching lines @@
   }
 }
 
 
 void Parser::ParseLibraryImportExport() {
   bool is_import = (CurrentToken() == Token::kIMPORT);
   bool is_export = (CurrentToken() == Token::kEXPORT);
   ASSERT(is_import || is_export);
   const intptr_t import_pos = TokenPos();
   ConsumeToken();
-  if (CurrentToken() != Token::kSTRING) {
-    ErrorMsg("library url expected");
-  }
+  CheckToken(Token::kSTRING, "library url expected");
   AstNode* url_literal = ParseStringLiteral(false);
   ASSERT(url_literal->IsLiteralNode());
   ASSERT(url_literal->AsLiteralNode()->literal().IsString());
   const String& url = String::Cast(url_literal->AsLiteralNode()->literal());
   if (url.Length() == 0) {
     ErrorMsg("library url expected");
   }
   String& prefix = String::Handle();
   if (is_import && (CurrentToken() == Token::kAS)) {
     ConsumeToken();
@@ skipping 68 matching lines @@
   } else {
     ASSERT(is_export);
     library_.AddExport(ns);
   }
 }
 
 
 void Parser::ParseLibraryPart() {
   const intptr_t source_pos = TokenPos();
   ConsumeToken();  // Consume "part".
-  if (CurrentToken() != Token::kSTRING) {
-    ErrorMsg("url expected");
-  }
+  CheckToken(Token::kSTRING, "url expected");
   AstNode* url_literal = ParseStringLiteral(false);
   ASSERT(url_literal->IsLiteralNode());
   ASSERT(url_literal->AsLiteralNode()->literal().IsString());
   const String& url = String::Cast(url_literal->AsLiteralNode()->literal());
   ExpectSemicolon();
   const String& canon_url = String::CheckedHandle(
       CallLibraryTagHandler(Dart_kCanonicalizeUrl, source_pos, url));
   CallLibraryTagHandler(Dart_kSourceTag, source_pos, canon_url);
 }
 
@@ skipping 45 matching lines @@
     ParseLibraryPart();
     rewind_pos = TokenPos();
     metadata_pos = SkipMetadata();
   }
   SetPosition(rewind_pos);
 }
 
 
 void Parser::ParsePartHeader() {
   SkipMetadata();
-  if (CurrentToken() != Token::kPART) {
-    ErrorMsg("'part of' expected");
-  }
+  CheckToken(Token::kPART, "'part of' expected");
   ConsumeToken();
   if (!IsLiteral("of")) {
     ErrorMsg("'part of' expected");
   }
   ConsumeToken();
   // The VM is not required to check that the library name matches the
   // name of the current library, so we ignore it.
   ExpectIdentifier("library name expected");
   while (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
@@ skipping 489 matching lines @@
     if (previous_pos >= 0) {
       ASSERT(!script_.IsNull());
       intptr_t line_number;
       script_.GetTokenLocation(previous_pos, &line_number, NULL);
       ErrorMsg(name_pos,
                "identifier '%s' previously used in line %" Pd "",
                function_name->ToCString(),
                line_number);
     }
   }
-
-  if (CurrentToken() != Token::kLPAREN) {
-    ErrorMsg("'(' expected");
-  }
+  CheckToken(Token::kLPAREN);
 
   // Check whether we have parsed this closure function before, in a previous
   // compilation. If so, reuse the function object, else create a new one
   // and register it in the current class.
   // Note that we cannot share the same closure function between the closurized
   // and non-closurized versions of the same parent function.
   Function& function = Function::ZoneHandle();
   bool is_new_closure = false;
   // TODO(hausner): There could be two different closures at the given
   // function_pos, one enclosed in a closurized function and one enclosed in the
@@ skipping 1227 matching lines @@
 
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
 
   // Now parse the 'try' block.
   OpenBlock();
-  Block* current_try_block = current_block_;
-  PushTryBlock(current_try_block);
+  PushTryBlock(current_block_);
   ExpectToken(Token::kLBRACE);
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
   if ((CurrentToken() != Token::kCATCH) && !IsLiteral("on") &&
       (CurrentToken() != Token::kFINALLY)) {
     ErrorMsg("catch or finally clause expected");
   }
 
@@ skipping 14 matching lines @@
   bool needs_stacktrace = false;
   while ((CurrentToken() == Token::kCATCH) || IsLiteral("on")) {
     const intptr_t catch_pos = TokenPos();
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
     if (IsLiteral("on")) {
       ConsumeToken();
       exception_param.type = &AbstractType::ZoneHandle(
           ParseType(ClassFinalizer::kCanonicalize));
     } else {
-      exception_param.type =
-          &AbstractType::ZoneHandle(Type::DynamicType());
+      exception_param.type = &AbstractType::ZoneHandle(Type::DynamicType());
     }
     if (CurrentToken() == Token::kCATCH) {
       ConsumeToken();  // Consume the 'catch'.
       ExpectToken(Token::kLPAREN);
       exception_param.token_pos = TokenPos();
       exception_param.var = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
         // TODO(hausner): Make implicit type be StackTrace, not dynamic.
         stack_trace_param.type =
             &AbstractType::ZoneHandle(Type::DynamicType());
         stack_trace_param.token_pos = TokenPos();
         stack_trace_param.var = ExpectIdentifier("identifier expected");
       }
       ExpectToken(Token::kRPAREN);
     }
 
-    // Parse the individual catch handler code and add an unconditional
-    // JUMP to the end of the try block.
-    ExpectToken(Token::kLBRACE);
+    // Create a block containing the catch clause parameters and
+    // the following code:
+    // 1) Store exception object and stack trace object into user-defined
+    //    variables (as needed).
+    // 2) Nested block with source code from catch clause block.
+    // 3) unconditional JUMP to the end of the try block.

[regis, 2013/11/06 21:59:55]

Upper-case u.

[hausner, 2013/11/06 22:07:11]

Done.

     OpenBlock();
     AddCatchParamsToScope(exception_param,
                           stack_trace_param,
                           current_block_->scope);
 
     if (exception_param.var != NULL) {
       // Generate code to load the exception object (:exception_var) into
       // the exception variable specified in this block.
       LocalVariable* var = LookupLocalScope(*exception_param.var);
       ASSERT(var != NULL);
@@ skipping 14 matching lines @@
           new StoreLocalNode(catch_pos, trace,
                              new LoadLocalNode(catch_pos, catch_trace_var)));
       current_block_->statements->Add(
           new InstanceCallNode(
               catch_pos,
               new LoadLocalNode(catch_pos, trace),
               Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
               no_args));
     }
 
-    ParseStatementSequence();  // Parse the catch handler code.
+    // Add nested block with user-defined code.
+    CheckToken(Token::kLBRACE);
+    current_block_->statements->Add(ParseNestedStatement(false, NULL));
+
+    // Add unconditional jump to end of catch clause list.
     current_block_->statements->Add(
         new JumpNode(catch_pos, Token::kCONTINUE, end_catch_label));
-    SequenceNode* catch_handler = CloseBlock();
-    ExpectToken(Token::kRBRACE);
+
+    SequenceNode* catch_clause = CloseBlock();
 
     const bool is_bad_type = exception_param.type->IsMalformed() ||
                              exception_param.type->IsMalbounded();
     if (!is_bad_type && !exception_param.type->IsDynamicType()) {
       // Has a type specification that is not malformed or malbounded.
-      // Now form an 'if type check' as an exception type exists in the
-      // catch specifier.
+      // Now form an 'if type check' to guard the catch handler code.
       if (!exception_param.type->IsInstantiated() &&
           (current_block_->scope->function_level() > 0)) {
         // Make sure that the instantiator is captured.
         CaptureInstantiator();
       }
       TypeNode* exception_type = new TypeNode(catch_pos, *exception_param.type);
       AstNode* exception_var = new LoadLocalNode(catch_pos, catch_excp_var);
       if (!exception_type->type().IsInstantiated()) {
         EnsureExpressionTemp();
       }
       AstNode* type_cond_expr = new ComparisonNode(
           catch_pos, Token::kIS, exception_var, exception_type);
       current_block_->statements->Add(
-          new IfNode(catch_pos, type_cond_expr, catch_handler, NULL));
+          new IfNode(catch_pos, type_cond_expr, catch_clause, NULL));
 
       // Do not add uninstantiated types (e.g. type parameter T or
       // generic type List<T>), since the debugger won't be able to
       // instantiate it when walking the stack.
       // This means that the debugger is not able to determine whether
       // an exception is caught if the catch clause uses generic types.
       // It will report the exception as uncaught when in fact it might
       // be caught and handled when we unwind the stack.
       if (exception_param.type->IsInstantiated()) {
         handler_types.Add(*exception_param.type);
       }
     } else {
       if (is_bad_type) {
         current_block_->statements->Add(ThrowTypeError(catch_pos,
                                                        *exception_param.type));
         // We still add the dead code below to satisfy the code generator.
       }
-      // No exception type exists in the catch specifier so execute the
+      // No exception type exists in the catch clause so execute the
       // catch handler code unconditionally.
-      current_block_->statements->Add(catch_handler);
+      current_block_->statements->Add(catch_clause);
       generic_catch_seen = true;
       // This catch clause will handle all exceptions. We can safely forget
       // all previous catch clause types.
       handler_types.SetLength(0);
       handler_types.Add(*exception_param.type);
     }
   }
+
   SequenceNode* catch_handler_list = CloseBlock();
   TryBlocks* inner_try_block = PopTryBlock();
   const intptr_t try_index = inner_try_block->try_index();
   TryBlocks* outer_try_block = try_blocks_list_;
   const intptr_t outer_try_index = (outer_try_block != NULL)
       ? outer_try_block->try_index()
       : CatchClauseNode::kInvalidTryIndex;
 
   // Finally parse the 'finally' block.
   SequenceNode* finally_block = NULL;
@@ skipping 401 matching lines @@
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
 void Parser::Unimplemented(const char* msg) {
   ErrorMsg(TokenPos(), "%s", msg);
 }
 
 
+void Parser::CheckToken(Token::Kind token_expected, const char* msg) {
+  if (CurrentToken() != token_expected) {
+    if (msg != NULL) {
+      ErrorMsg("%s", msg);
+    } else {
+      ErrorMsg("'%s' expected", Token::Str(token_expected));
+    }
+  }
+}
+
+
 void Parser::ExpectToken(Token::Kind token_expected) {
   if (CurrentToken() != token_expected) {
     ErrorMsg("'%s' expected", Token::Str(token_expected));
   }
   ConsumeToken();
 }
 
 
 void Parser::ExpectSemicolon() {
   if (CurrentToken() != Token::kSEMICOLON) {
@@ skipping 781 matching lines @@
                               arguments->NodeAt(0),
                               arguments->NodeAt(1));
   }
   return new StaticCallNode(call_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver, const String& func_name) {
   TRACE_PARSER("ParseInstanceCall");
   const intptr_t call_pos = TokenPos();
-  if (CurrentToken() != Token::kLPAREN) {
-    ErrorMsg(call_pos, "left parenthesis expected");
-  }
+  CheckToken(Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return new InstanceCallNode(call_pos, receiver, func_name, arguments);
 }
 
 
 AstNode* Parser::ParseClosureCall(AstNode* closure) {
   TRACE_PARSER("ParseClosureCall");
   const intptr_t call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   EnsureSavedCurrentContext();
@@ skipping 1053 matching lines @@
   }
   return resolved;
 }
 
 
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseType");
-  if (CurrentToken() != Token::kIDENT) {
-    ErrorMsg("type name expected");
-  }
+  CheckToken(Token::kIDENT, "type name expected");
   QualIdent type_name;
   if (finalization == ClassFinalizer::kIgnore) {
     if (!is_top_level_ && (current_block_ != NULL)) {
       // Add the library prefix or type class name to the list of referenced
       // names of this scope, even if the type is ignored.
       current_block_->scope->AddReferencedName(TokenPos(), *CurrentLiteral());
     }
     SkipQualIdent();
   } else {
     ParseQualIdent(&type_name);
@@ skipping 596 matching lines @@
   // is a named constructor. Note that ParseType() above will not consume it as
   // part of a misinterpreted qualified identifier, because only a valid library
   // prefix is accepted as qualifier.
   String* named_constructor = NULL;
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
-  if (CurrentToken() != Token::kLPAREN) {
-    ErrorMsg("'(' expected");
-  }
+  CheckToken(Token::kLPAREN);
   intptr_t call_pos = TokenPos();
   ArgumentListNode* arguments = ParseActualParameters(NULL, is_const);
 
   // Parsing is complete, so we can return a throw in case of a malformed type
   // or report a compile-time error if the constructor is const.
   if (type.IsMalformed()) {
     if (is_const) {
       const Error& error = Error::Handle(type.malformed_error());
       ErrorMsg(error);
     }
@@ skipping 846 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart