Cleanup of error and warning reporting.

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
 #include "vm/native_arguments.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
+#include "vm/report.h"
 #include "vm/resolver.h"
 #include "vm/scanner.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/timer.h"
 #include "vm/zone.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
-DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
-DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
 DEFINE_FLAG(bool, warn_mixin_typedef, true, "Warning on legacy mixin typedef.");
 DECLARE_FLAG(bool, error_on_bad_type);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
@@ skipping 332 matching lines @@
   VMTagScope tagScope(isolate, VMTag::kCompileTopLevelTagId);
   Parser parser(script, library, 0);
   parser.ParseTopLevel();
 }
 
 
 void Parser::ComputeCurrentToken() {
   ASSERT(token_kind_ == Token::kILLEGAL);
   token_kind_ = tokens_iterator_.CurrentTokenKind();
   if (token_kind_ == Token::kERROR) {
-    ErrorMsg(TokenPos(), "%s", CurrentLiteral()->ToCString());
+    ReportError(TokenPos(), "%s", CurrentLiteral()->ToCString());
   }
 }
 
 
 Token::Kind Parser::LookaheadToken(int num_tokens) {
   CompilerStats::num_tokens_lookahead++;
   CompilerStats::num_token_checks++;
   return tokens_iterator_.LookaheadTokenKind(num_tokens);
 }
 
@@ skipping 12 matching lines @@
 }
 
 
 RawInteger* Parser::CurrentIntegerLiteral() const {
   literal_token_ ^= tokens_iterator_.CurrentToken();
   ASSERT(literal_token_.kind() == Token::kINTEGER);
   RawInteger* ri = Integer::RawCast(literal_token_.value());
   if (FLAG_throw_on_javascript_int_overflow) {
     const Integer& i = Integer::Handle(I, ri);
     if (i.CheckJavascriptIntegerOverflow()) {
-      ErrorMsg(TokenPos(),
-          "Integer literal does not fit in a Javascript integer: %s.",
-          i.ToCString());
+      ReportError(TokenPos(),
+                  "Integer literal does not fit in a Javascript integer: %s.",
+                  i.ToCString());
     }
   }
   return ri;
 }
 
 
 // A QualIdent is an optionally qualified identifier.
 struct QualIdent {
   QualIdent() {
     Clear();
@@ skipping 480 matching lines @@
     ConsumeToken();
     intptr_t expr_pos = TokenPos();
     if (!IsIdentifier()) {
       ExpectIdentifier("identifier expected");
     }
     // Reject expressions with deferred library prefix eagerly.
     Object& obj = Object::Handle(I,
                                  library_.LookupLocalObject(*CurrentLiteral()));
     if (!obj.IsNull() && obj.IsLibraryPrefix()) {
       if (LibraryPrefix::Cast(obj).is_deferred_load()) {
-        ErrorMsg("Metadata must be compile-time constant");
+        ReportError("Metadata must be compile-time constant");
       }
     }
     AstNode* expr = NULL;
     if ((LookaheadToken(1) == Token::kLPAREN) ||
         ((LookaheadToken(1) == Token::kPERIOD) &&
             (LookaheadToken(3) == Token::kLPAREN)) ||
         ((LookaheadToken(1) == Token::kPERIOD) &&
             (LookaheadToken(3) == Token::kPERIOD) &&
             (LookaheadToken(5) == Token::kLPAREN))) {
       expr = ParseNewOperator(Token::kCONST);
     } else {
       // Can be x, C.x, or L.C.x.
       expr = ParsePrimary();  // Consumes x, C or L.C.
       Class& cls = Class::Handle(I);
       if (expr->IsPrimaryNode()) {
         PrimaryNode* primary_node = expr->AsPrimaryNode();
         if (primary_node->primary().IsClass()) {
           // If the primary node referred to a class we are loading a
           // qualified static field.
           cls ^= primary_node->primary().raw();
         } else {
-          ErrorMsg(expr_pos, "Metadata expressions must refer to a const field "
-                             "or constructor");
+          ReportError(expr_pos,
+                      "Metadata expressions must refer to a const field "
+                      "or constructor");
         }
       }
       if (CurrentToken() == Token::kPERIOD) {
         // C.x or L.C.X.
         if (cls.IsNull()) {
-          ErrorMsg(expr_pos, "Metadata expressions must refer to a const field "
-                             "or constructor");
+          ReportError(expr_pos,
+                      "Metadata expressions must refer to a const field "
+                      "or constructor");
         }
         ConsumeToken();
         const intptr_t ident_pos = TokenPos();
         String* ident = ExpectIdentifier("identifier expected");
         const Field& field = Field::Handle(I, cls.LookupStaticField(*ident));
         if (field.IsNull()) {
-          ErrorMsg(ident_pos,
-                   "Class '%s' has no field '%s'",
-                   cls.ToCString(),
-                   ident->ToCString());
+          ReportError(ident_pos,
+                      "Class '%s' has no field '%s'",
+                      cls.ToCString(),
+                      ident->ToCString());
         }
         if (!field.is_const()) {
-          ErrorMsg(ident_pos,
-                   "Field '%s' of class '%s' is not const",
-                   ident->ToCString(),
-                   cls.ToCString());
+          ReportError(ident_pos,
+                      "Field '%s' of class '%s' is not const",
+                      ident->ToCString(),
+                      cls.ToCString());
         }
         expr = GenerateStaticFieldLookup(field, ident_pos);
       }
     }
     if (expr->EvalConstExpr() == NULL) {
-      ErrorMsg(expr_pos, "expression must be a compile-time constant");
+      ReportError(expr_pos, "expression must be a compile-time constant");
     }
     const Instance& val = EvaluateConstExpr(expr_pos, expr);
     meta_values.Add(val);
   }
   return Array::MakeArray(meta_values);
 }
 
 
 SequenceNode* Parser::ParseStaticFinalGetter(const Function& func) {
   TRACE_PARSER("ParseStaticFinalGetter");
@@ skipping 18 matching lines @@
   const intptr_t expr_pos = TokenPos();
   if (field.is_const()) {
     // We don't want to use ParseConstExpr() here because we don't want
     // the constant folding code to create, compile and execute a code
     // fragment to evaluate the expression. Instead, we just make sure
     // the static const field initializer is a constant expression and
     // leave the evaluation to the getter function.
     AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     // This getter will only be called once at compile time.
     if (expr->EvalConstExpr() == NULL) {
-      ErrorMsg(expr_pos, "initializer is not a valid compile-time constant");
+      ReportError(expr_pos, "initializer is not a valid compile-time constant");
     }
     ReturnNode* return_node = new ReturnNode(ident_pos, expr);
     current_block_->statements->Add(return_node);
   } else {
     // This getter may be called each time the static field is accessed.
     // The following generated code lazily initializes the field:
     // if (field.value === transition_sentinel) {
     //   field.value = null;
     //   throw("circular dependency in field initialization");
     // }
@@ skipping 474 matching lines @@
         break;
       case Token::kEOS:
         unexpected_token_found = true;
         break;
       default:
         // nothing.
         break;
     }
   } while (!token_stack.is_empty() && is_match && !unexpected_token_found);
   if (!is_match) {
-    ErrorMsg(token_pos, "unbalanced '%s'", Token::Str(token));
+    ReportError(token_pos, "unbalanced '%s'", Token::Str(token));
   } else if (unexpected_token_found) {
-    ErrorMsg(block_start_pos, "unterminated block");
+    ReportError(block_start_pos, "unterminated block");
   }
 }
 
 
 void Parser::ParseFormalParameter(bool allow_explicit_default_value,
                                   bool evaluate_metadata,
                                   ParamList* params) {
   TRACE_PARSER("ParseFormalParameter");
   ParamDesc parameter;
   bool var_seen = false;
@@ skipping 26 matching lines @@
     ConsumeToken();
     // This must later be changed to a closure type if we recognize
     // a closure/function type parameter. We check this at the end
     // of ParseFormalParameter.
     parameter.type = &Type::ZoneHandle(I, Type::VoidType());
   }
   if (parameter.type == NULL) {
     // At this point, we must see an identifier for the type or the
     // function parameter.
     if (!IsIdentifier()) {
-      ErrorMsg("parameter name or type expected");
+      ReportError("parameter name or type expected");
     }
     // We have not seen a parameter type yet, so we check if the next
     // identifier could represent a type before parsing it.
     Token::Kind follower = LookaheadToken(1);
     // We have an identifier followed by a 'follower' token.
     // We either parse a type or assume that no type is specified.
     if ((follower == Token::kLT) ||  // Parameterized type.
         (follower == Token::kPERIOD) ||  // Qualified class name of type.
         Token::IsIdentifier(follower) ||  // Parameter name following a type.
         (follower == Token::kTHIS)) {  // Field parameter following a type.
@@ skipping 19 matching lines @@
 
   // At this point, we must see an identifier for the parameter name.
   parameter.name_pos = TokenPos();
   parameter.name = ExpectIdentifier("parameter name expected");
   if (parameter.is_field_initializer) {
     params->has_field_initializer = true;
   }
 
   if (params->has_optional_named_parameters &&
       (parameter.name->CharAt(0) == '_')) {
-    ErrorMsg(parameter.name_pos, "named parameter must not be private");
+    ReportError(parameter.name_pos, "named parameter must not be private");
   }
 
   // Check for duplicate formal parameters.
   const intptr_t num_existing_parameters =
       params->num_fixed_parameters + params->num_optional_parameters;
   for (intptr_t i = 0; i < num_existing_parameters; i++) {
     ParamDesc& existing_parameter = (*params->parameters)[i];
     if (existing_parameter.name->Equals(*parameter.name)) {
-      ErrorMsg(parameter.name_pos, "duplicate formal parameter '%s'",
-               parameter.name->ToCString());
+      ReportError(parameter.name_pos, "duplicate formal parameter '%s'",
+                  parameter.name->ToCString());
     }
   }
 
   if (CurrentToken() == Token::kLPAREN) {
     // This parameter is probably a closure. If we saw the keyword 'var'
     // or 'final', a closure is not legal here and we ignore the
     // opening parens.
     if (!var_seen && !parameter.is_final) {
       // The parsed parameter type is actually the function result type.
       const AbstractType& result_type =
@@ skipping 58 matching lines @@
       ASSERT(!signature_type.IsMalbounded());
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
   }
 
   if ((CurrentToken() == Token::kASSIGN) || (CurrentToken() == Token::kCOLON)) {
     if ((!params->has_optional_positional_parameters &&
          !params->has_optional_named_parameters) ||
         !allow_explicit_default_value) {
-      ErrorMsg("parameter must not specify a default value");
+      ReportError("parameter must not specify a default value");
     }
     if (params->has_optional_positional_parameters) {
       ExpectToken(Token::kASSIGN);
     } else {
       ExpectToken(Token::kCOLON);
     }
     params->num_optional_parameters++;
     params->has_explicit_default_values = true;  // Also if explicitly NULL.
     if (is_top_level_) {
       // Skip default value parsing.
       SkipExpr();
     } else {
       const Object& const_value = ParseConstExpr()->literal();
       parameter.default_value = &const_value;
     }
   } else {
     if (params->has_optional_positional_parameters ||
         params->has_optional_named_parameters) {
       // Implicit default value is null.
       params->num_optional_parameters++;
       parameter.default_value = &Object::ZoneHandle();
     } else {
       params->num_fixed_parameters++;
       ASSERT(params->num_optional_parameters == 0);
     }
   }
   if (parameter.type->IsVoidType()) {
-    ErrorMsg("parameter '%s' may not be 'void'", parameter.name->ToCString());
+    ReportError("parameter '%s' may not be 'void'",
+                parameter.name->ToCString());
   }
   if (params->implicitly_final) {
     parameter.is_final = true;
   }
   params->parameters->Add(parameter);
 }
 
 
 // Parses a sequence of normal or optional formal parameters.
 void Parser::ParseFormalParameters(bool allow_explicit_default_values,
@@ skipping 43 matching lines @@
       if (params->has_optional_positional_parameters) {
         CheckToken(Token::kRBRACK, "',' or ']' expected");
       } else {
         CheckToken(Token::kRBRACE, "',' or '}' expected");
       }
       ConsumeToken();  // ']' or '}'.
     }
     if ((CurrentToken() != Token::kRPAREN) &&
         !params->has_optional_positional_parameters &&
         !params->has_optional_named_parameters) {
-      ErrorMsg("',' or ')' expected");
+      ReportError("',' or ')' expected");
     }
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
 }
 
 
 String& Parser::ParseNativeDeclaration() {
   TRACE_PARSER("ParseNativeDeclaration");
@@ skipping 10 matching lines @@
 // 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..
 RawFunction* Parser::GetSuperFunction(intptr_t token_pos,
                                       const String& name,
                                       ArgumentListNode* arguments,
                                       bool resolve_getter,
                                       bool* is_no_such_method) {
   const Class& super_class = Class::Handle(I, current_class().SuperClass());
   if (super_class.IsNull()) {
-    ErrorMsg(token_pos, "class '%s' does not have a superclass",
-             String::Handle(I, current_class().Name()).ToCString());
+    ReportError(token_pos, "class '%s' does not have a superclass",
+                String::Handle(I, current_class().Name()).ToCString());
   }
   Function& super_func = Function::Handle(I,
       Resolver::ResolveDynamicAnyArgs(super_class, name));
   if (!super_func.IsNull() &&
       !super_func.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     NULL)) {
     super_func = Function::null();
   } else if (super_func.IsNull() && resolve_getter) {
     const String& getter_name = String::ZoneHandle(I, Field::GetterName(name));
@@ skipping 150 matching lines @@
                          operator_function_name,
                          op_arguments,
                          kResolveGetter,
                          &is_no_such_method));
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
           super_pos, operator_function_name, *op_arguments, NULL, true);
     }
     super_op = new StaticCallNode(super_pos, super_operator, op_arguments);
   } else {
-    ErrorMsg(super_pos, "illegal super operator call");
+    ReportError(super_pos, "illegal super operator call");
   }
   return super_op;
 }
 
 
 AstNode* Parser::ParseSuperOperator() {
   TRACE_PARSER("ParseSuperOperator");
   AstNode* super_op = NULL;
   const intptr_t operator_pos = TokenPos();
 
@@ skipping 70 matching lines @@
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name,
                                        intptr_t field_pos) {
   TRACE_PARSER("ParseSuperFieldAccess");
   const Class& super_class = Class::ZoneHandle(I, current_class().SuperClass());
   if (super_class.IsNull()) {
-    ErrorMsg("class '%s' does not have a superclass",
-             String::Handle(I, current_class().Name()).ToCString());
+    ReportError("class '%s' does not have a superclass",
+                String::Handle(I, current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
   const String& getter_name =
       String::ZoneHandle(I, Field::GetterName(field_name));
   const Function& super_getter = Function::ZoneHandle(I,
       Resolver::ResolveDynamicAnyArgs(super_class, getter_name));
   if (super_getter.IsNull()) {
     const String& setter_name =
         String::ZoneHandle(I, Field::SetterName(field_name));
@@ skipping 62 matching lines @@
       // Add the constructor name 'n' to the super constructor.
       ctor_name = String::SubString(ctor_name, class_name.Length() + 1);
       super_ctor_name = String::Concat(super_ctor_name, ctor_name);
     }
   }
 
   // Resolve super constructor function and check arguments.
   const Function& super_ctor = Function::ZoneHandle(I,
       super_class.LookupConstructor(super_ctor_name));
   if (super_ctor.IsNull()) {
-      ErrorMsg(supercall_pos,
-               "unresolved implicit call to super constructor '%s()'",
-               String::Handle(I, super_class.Name()).ToCString());
+      ReportError(supercall_pos,
+                  "unresolved implicit call to super constructor '%s()'",
+                  String::Handle(I, super_class.Name()).ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
-    ErrorMsg(supercall_pos, "implicit call to non-const super constructor");
+    ReportError(supercall_pos, "implicit call to non-const super constructor");
   }
 
   String& error_message = String::Handle(I);
   if (!super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     &error_message)) {
-    ErrorMsg(supercall_pos,
-             "invalid arguments passed to super constructor '%s()': %s",
-             String::Handle(I, super_class.Name()).ToCString(),
-             error_message.ToCString());
+    ReportError(supercall_pos,
+                "invalid arguments passed to super constructor '%s()': %s",
+                String::Handle(I, super_class.Name()).ToCString(),
+                error_message.ToCString());
   }
   current_block_->statements->Add(
       new StaticCallNode(supercall_pos, super_ctor, arguments));
 }
 
 
 AstNode* Parser::ParseSuperInitializer(const Class& cls,
                                        LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
@@ skipping 24 matching lines @@
   arguments->Add(phase_parameter);
   // 'this' parameter must not be accessible to the other super call arguments.
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
 
   // Resolve the constructor.
   const Function& super_ctor = Function::ZoneHandle(I,
       super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull()) {
-    ErrorMsg(supercall_pos,
-             "super class constructor '%s' not found",
-             ctor_name.ToCString());
+    ReportError(supercall_pos,
+                "super class constructor '%s' not found",
+                ctor_name.ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
-    ErrorMsg(supercall_pos, "super constructor must be const");
+    ReportError(supercall_pos, "super constructor must be const");
   }
   String& error_message = String::Handle(I);
   if (!super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     &error_message)) {
-    ErrorMsg(supercall_pos,
-             "invalid arguments passed to super class constructor '%s': %s",
-             ctor_name.ToCString(),
-             error_message.ToCString());
+    ReportError(supercall_pos,
+                "invalid arguments passed to super class constructor '%s': %s",
+                ctor_name.ToCString(),
+                error_message.ToCString());
   }
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
 AstNode* Parser::ParseInitializer(const Class& cls,
                                   LocalVariable* receiver,
                                   GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializer");
   const intptr_t field_pos = TokenPos();
   if (CurrentToken() == Token::kTHIS) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
   }
   const String& field_name = *ExpectIdentifier("field name expected");
   ExpectToken(Token::kASSIGN);
 
   const bool saved_mode = SetAllowFunctionLiterals(false);
   // "this" must not be accessible in initializer expressions.
   receiver->set_invisible(true);
   AstNode* init_expr = ParseConditionalExpr();
   if (CurrentToken() == Token::kCASCADE) {
     init_expr = ParseCascades(init_expr);
   }
   receiver->set_invisible(false);
   SetAllowFunctionLiterals(saved_mode);
   if (current_function().is_const() && !init_expr->IsPotentiallyConst()) {
-    ErrorMsg(field_pos,
-             "initializer expression must be compile time constant.");
+    ReportError(field_pos,
+                "initializer expression must be compile time constant.");
   }
   Field& field = Field::ZoneHandle(I, cls.LookupInstanceField(field_name));
   if (field.IsNull()) {
-    ErrorMsg(field_pos, "unresolved reference to instance field '%s'",
-             field_name.ToCString());
+    ReportError(field_pos, "unresolved reference to instance field '%s'",
+                field_name.ToCString());
   }
   CheckDuplicateFieldInit(field_pos, initialized_fields, &field);
   AstNode* instance = new LoadLocalNode(field_pos, receiver);
   EnsureExpressionTemp();
   return new StoreInstanceFieldNode(field_pos, instance, field, init_expr);
 }
 
 
 void Parser::CheckFieldsInitialized(const Class& cls) {
   const Array& fields = Array::Handle(I, cls.fields());
@@ skipping 114 matching lines @@
 }
 
 
 void Parser::CheckDuplicateFieldInit(intptr_t init_pos,
                                     GrowableArray<Field*>* initialized_fields,
                                     Field* field) {
   ASSERT(!field->is_static());
   for (int i = 0; i < initialized_fields->length(); i++) {
     Field* initialized_field = (*initialized_fields)[i];
     if (initialized_field->raw() == field->raw()) {
-      ErrorMsg(init_pos,
-               "duplicate initialization for field %s",
-               String::Handle(I, field->name()).ToCString());
+      ReportError(init_pos,
+                  "duplicate initialization for field %s",
+                  String::Handle(I, field->name()).ToCString());
     }
   }
   initialized_fields->Add(field);
 }
 
 
 void Parser::ParseInitializers(const Class& cls,
                                LocalVariable* receiver,
                                GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializers");
   bool super_init_seen = false;
   if (CurrentToken() == Token::kCOLON) {
     do {
       ConsumeToken();  // Colon or comma.
       AstNode* init_statement;
       if (CurrentToken() == Token::kSUPER) {
         if (super_init_seen) {
-          ErrorMsg("duplicate call to super constructor");
+          ReportError("duplicate call to super constructor");
         }
         init_statement = ParseSuperInitializer(cls, receiver);
         super_init_seen = true;
       } else {
         init_statement = ParseInitializer(cls, receiver, initialized_fields);
       }
       current_block_->statements->Add(init_statement);
     } while (CurrentToken() == Token::kCOMMA);
   }
   if (!super_init_seen) {
@@ skipping 31 matching lines @@
   ASSERT(phase_param != NULL);
   AstNode* phase_argument = new LoadLocalNode(call_pos, phase_param);
   arguments->Add(phase_argument);
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
   // Resolve the constructor.
   const Function& redirect_ctor = Function::ZoneHandle(I,
       cls.LookupConstructor(ctor_name));
   if (redirect_ctor.IsNull()) {
-    ErrorMsg(call_pos, "constructor '%s' not found", ctor_name.ToCString());
+    ReportError(call_pos, "constructor '%s' not found", ctor_name.ToCString());
   }
   String& error_message = String::Handle(I);
   if (!redirect_ctor.AreValidArguments(arguments->length(),
                                        arguments->names(),
                                        &error_message)) {
-    ErrorMsg(call_pos,
-             "invalid arguments passed to constructor '%s': %s",
-             ctor_name.ToCString(),
-             error_message.ToCString());
+    ReportError(call_pos,
+                "invalid arguments passed to constructor '%s': %s",
+                ctor_name.ToCString(),
+                error_message.ToCString());
   }
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   ASSERT(func.Owner() == current_class().raw());
   const intptr_t ctor_pos = TokenPos();
@@ skipping 30 matching lines @@
       current_class().IsMixinApplication()) {
     // At this point we don't support forwarding constructors
     // that have optional parameters because we don't know the default
     // values of the optional parameters. We would have to compile the super
     // constructor to get the default values. Also, the spec is not clear
     // whether optional parameters are even allowed in this situation.
     // TODO(hausner): Remove this limitation if the language spec indeed
     // allows optional parameters.
     if (func.HasOptionalParameters()) {
       const Class& super_class = Class::Handle(I, current_class().SuperClass());
-      ErrorMsg(ctor_pos,
-               "cannot generate an implicit mixin application constructor "
-               "forwarding to a super class constructor with optional "
-               "parameters; add a constructor without optional parameters "
-               "to class '%s' that redirects to the constructor with optional "
-               "parameters and invoke it via super from a constructor of the "
-               "class extending the mixin application",
-               String::Handle(I, super_class.Name()).ToCString());
+      ReportError(ctor_pos,
+                  "cannot generate an implicit mixin application constructor "
+                  "forwarding to a super class constructor with optional "
+                  "parameters; add a constructor without optional parameters "
+                  "to class '%s' that redirects to the constructor with "
+                  "optional parameters and invoke it via super from a "
+                  "constructor of the class extending the mixin application",
+                  String::Handle(I, super_class.Name()).ToCString());
     }
 
     // Prepare user-defined arguments to be forwarded to super call.
     // The first user-defined argument is at position 2.
     forwarding_args = new ArgumentListNode(Scanner::kNoSourcePos);
     for (int i = 2; i < func.NumParameters(); i++) {
       LocalVariable* param = new LocalVariable(
           Scanner::kNoSourcePos,
           String::ZoneHandle(I, func.ParameterNameAt(i)),
           Type::ZoneHandle(I, Type::DynamicType()));
@@ skipping 16 matching lines @@
 
 
 void Parser::CheckRecursiveInvocation() {
   const GrowableObjectArray& pending_functions =
       GrowableObjectArray::Handle(I,
           I->object_store()->pending_functions());
   for (int i = 0; i < pending_functions.Length(); i++) {
     if (pending_functions.At(i) == current_function().raw()) {
       const String& fname =
           String::Handle(I, current_function().UserVisibleName());
-      ErrorMsg("circular dependency for function %s", fname.ToCString());
+      ReportError("circular dependency for function %s", fname.ToCString());
     }
   }
   ASSERT(!unregister_pending_function_);
   pending_functions.Add(current_function());
   unregister_pending_function_ = true;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter declaration
 // of function. Parse the formal parameters, initializers and code.
@@ skipping 76 matching lines @@
   if (params.has_field_initializer) {
     // First two parameters are implicit receiver and phase.
     ASSERT(params.parameters->length() >= 2);
     for (int i = 2; i < params.parameters->length(); i++) {
       ParamDesc& param = (*params.parameters)[i];
       if (param.is_field_initializer) {
         const String& field_name = *param.name;
         Field& field =
             Field::ZoneHandle(I, cls.LookupInstanceField(field_name));
         if (field.IsNull()) {
-          ErrorMsg(param.name_pos,
-                   "unresolved reference to instance field '%s'",
-                   field_name.ToCString());
+          ReportError(param.name_pos,
+                      "unresolved reference to instance field '%s'",
+                      field_name.ToCString());
         }
         if (is_redirecting_constructor) {
-          ErrorMsg(param.name_pos,
-                   "redirecting constructors may not have "
-                   "initializing formal parameters");
+          ReportError(param.name_pos,
+                      "redirecting constructors may not have "
+                      "initializing formal parameters");
         }
         CheckDuplicateFieldInit(param.name_pos, &initialized_fields, &field);
 
         if (!param.has_explicit_type) {
           const AbstractType& field_type =
               AbstractType::ZoneHandle(I, field.type());
           param.type = &field_type;
           // Parameter type was already set to dynamic when parsing the class
           // declaration: fix it.
           func.SetParameterTypeAt(i, field_type);
@@ skipping 137 matching lines @@
   }
 
   if (CurrentToken() == Token::kLBRACE) {
     // We checked in the top-level parse phase that a redirecting
     // constructor does not have a body.
     ASSERT(!is_redirecting_constructor);
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
-    ErrorMsg("constructors may not return a value");
+    ReportError("constructors may not return a value");
   } else if (IsLiteral("native")) {
-    ErrorMsg("native constructors not supported");
+    ReportError("native constructors not supported");
   } else if (CurrentToken() == Token::kSEMICOLON) {
     // Some constructors have no function body.
     ConsumeToken();
     if (func.is_external()) {
       // Body of an external method contains a single throw.
       const String& function_name = String::ZoneHandle(func.name());
       current_block_->statements->Add(
           ThrowNoSuchMethodError(TokenPos(),
                                  cls,
                                  function_name,
@@ skipping 98 matching lines @@
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
     ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
 
     // Check whether the function has any field initializer formal parameters,
     // which are not allowed in non-constructor functions.
     if (params.has_field_initializer) {
       for (int i = 0; i < params.parameters->length(); i++) {
         ParamDesc& param = (*params.parameters)[i];
         if (param.is_field_initializer) {
-          ErrorMsg(param.name_pos,
-                   "field initializer only allowed in constructors");
+          ReportError(param.name_pos,
+                      "field initializer only allowed in constructors");
         }
       }
     }
     // Populate function scope with the formal parameters.
     AddFormalParamsToScope(&params, current_block_->scope);
 
     if (FLAG_enable_type_checks &&
         (current_block_->scope->function_level() > 0)) {
       // We are parsing, but not compiling, a local function.
       // The instantiator may be required at run time for generic type checks.
@@ skipping 192 matching lines @@
 
 
 void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
   TRACE_PARSER("ParseMethodOrConstructor");
   ASSERT(CurrentToken() == Token::kLPAREN || method->IsGetter());
   ASSERT(method->type != NULL);
   ASSERT(method->name_pos > 0);
   ASSERT(current_member_ == method);
 
   if (method->has_var) {
-    ErrorMsg(method->name_pos, "keyword var not allowed for methods");
+    ReportError(method->name_pos, "keyword var not allowed for methods");
   }
   if (method->has_final) {
-    ErrorMsg(method->name_pos, "'final' not allowed for methods");
+    ReportError(method->name_pos, "'final' not allowed for methods");
   }
   if (method->has_abstract && method->has_static) {
-    ErrorMsg(method->name_pos,
-             "static method '%s' cannot be abstract",
-             method->name->ToCString());
-  }
+    ReportError(method->name_pos,
+                "static method '%s' cannot be abstract",
+                method->name->ToCString());
+     }
   if (method->has_const && !method->IsFactoryOrConstructor()) {
-    ErrorMsg(method->name_pos, "'const' not allowed for methods");
+    ReportError(method->name_pos, "'const' not allowed for methods");
   }
   if (method->has_abstract && method->IsFactoryOrConstructor()) {
-    ErrorMsg(method->name_pos, "constructor cannot be abstract");
+    ReportError(method->name_pos, "constructor cannot be abstract");
   }
   if (method->has_const && method->IsConstructor()) {
     current_class().set_is_const();
   }
 
   // Parse the formal parameters.
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values = true;
   const intptr_t formal_param_pos = TokenPos();
   method->params.Clear();
@@ skipping 47 matching lines @@
       method->name = &String::ZoneHandle(I, Field::GetterSymbol(*method->name));
     } else {
       ASSERT(method->IsSetter());
       expected_num_parameters = (method->has_static) ? 1 : 2;
       method->dict_name = &String::ZoneHandle(I,
           String::Concat(*method->name, Symbols::Equals()));
       method->name = &String::ZoneHandle(I, Field::SetterSymbol(*method->name));
     }
     if ((method->params.num_fixed_parameters != expected_num_parameters) ||
         (method->params.num_optional_parameters != 0)) {
-      ErrorMsg(method->name_pos, "illegal %s parameters",
-               method->IsGetter() ? "getter" : "setter");
+      ReportError(method->name_pos, "illegal %s parameters",
+                  method->IsGetter() ? "getter" : "setter");
     }
   }
 
   // Parse redirecting factory constructor.
   Type& redirection_type = Type::Handle(I);
   String& redirection_identifier = String::Handle(I);
   bool is_redirecting = false;
   if (method->IsFactory() && (CurrentToken() == Token::kASSIGN)) {
     // Default parameter values are disallowed in redirecting factories.
     if (method->params.has_explicit_default_values) {
-      ErrorMsg("redirecting factory '%s' may not specify default values "
-               "for optional parameters",
-               method->name->ToCString());
+      ReportError("redirecting factory '%s' may not specify default values "
+                  "for optional parameters",
+                  method->name->ToCString());
     }
     if (method->has_external) {
-      ErrorMsg(TokenPos(),
-               "external factory constructor '%s' may not have redirection",
-               method->name->ToCString());
+      ReportError(TokenPos(),
+                  "external factory constructor '%s' may not have redirection",
+                  method->name->ToCString());
     }
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     is_redirecting = true;
     const AbstractType& type = AbstractType::Handle(I,
         ParseType(ClassFinalizer::kResolveTypeParameters));
     if (!type.IsMalformed() && type.IsTypeParameter()) {
       // Replace the type with a malformed type and compile a throw when called.
       redirection_type = ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(I),  // No previous error.
           script_,
           type_pos,
           "factory '%s' may not redirect to type parameter '%s'",
           method->name->ToCString(),
           String::Handle(I, type.UserVisibleName()).ToCString());
     } else {
       // We handle malformed and malbounded redirection type at run time.
       redirection_type ^= type.raw();
     }
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor or factory.
       ConsumeToken();
       redirection_identifier = ExpectIdentifier("identifier expected")->raw();
     }
   } else if (CurrentToken() == Token::kCOLON) {
     // Parse initializers.
     if (!method->IsConstructor()) {
-      ErrorMsg("initializers only allowed on constructors");
+      ReportError("initializers only allowed on constructors");
     }
     if (method->has_external) {
-      ErrorMsg(TokenPos(),
-               "external constructor '%s' may not have initializers",
-               method->name->ToCString());
+      ReportError(TokenPos(),
+                  "external constructor '%s' may not have initializers",
+                  method->name->ToCString());
     }
     if ((LookaheadToken(1) == Token::kTHIS) &&
         ((LookaheadToken(2) == Token::kLPAREN) ||
          LookaheadToken(4) == Token::kLPAREN)) {
       // Redirected constructor: either this(...) or this.xxx(...).
       is_redirecting = true;
       if (method->params.has_field_initializer) {
         // Constructors that redirect to another constructor must not
         // initialize any fields using field initializer parameters.
-        ErrorMsg(formal_param_pos, "Redirecting constructor "
-                 "may not use field initializer parameters");
+        ReportError(formal_param_pos, "Redirecting constructor "
+                    "may not use field initializer parameters");
       }
       ConsumeToken();  // Colon.
       ExpectToken(Token::kTHIS);
       String& redir_name = String::ZoneHandle(I,
           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;
       CheckToken(Token::kLPAREN);
       SkipToMatchingParenthesis();
     } else {
       SkipInitializers();
     }
   }
 
   // Only constructors can redirect to another method.
   ASSERT((method->redirect_name == NULL) || method->IsConstructor());
 
   if (method->IsConstructor() &&
       method->has_external &&
       method->params.has_field_initializer) {
-    ErrorMsg(method->name_pos,
-             "external constructor '%s' may not have field initializers",
-             method->name->ToCString());
+    ReportError(method->name_pos,
+                "external constructor '%s' may not have field initializers",
+                method->name->ToCString());
   }
 
   intptr_t method_end_pos = TokenPos();
   if ((CurrentToken() == Token::kLBRACE) ||
       (CurrentToken() == Token::kARROW)) {
     if (method->has_abstract) {
-      ErrorMsg(TokenPos(),
-               "abstract method '%s' may not have a function body",
-               method->name->ToCString());
+      ReportError(TokenPos(),
+                  "abstract method '%s' may not have a function body",
+                  method->name->ToCString());
     } else if (method->has_external) {
-      ErrorMsg(TokenPos(),
-               "external %s '%s' may not have a function body",
-               method->IsFactoryOrConstructor() ? "constructor" : "method",
-               method->name->ToCString());
+      ReportError(TokenPos(),
+                  "external %s '%s' may not have a function body",
+                  method->IsFactoryOrConstructor() ? "constructor" : "method",
+                  method->name->ToCString());
     } else if (method->IsConstructor() && method->has_const) {
-      ErrorMsg(TokenPos(),
-               "const constructor '%s' may not have a function body",
-               method->name->ToCString());
+      ReportError(TokenPos(),
+                  "const constructor '%s' may not have a function body",
+                  method->name->ToCString());
     } else if (method->IsFactory() && method->has_const) {
-      ErrorMsg(TokenPos(),
-               "const factory '%s' may not have a function body",
-               method->name->ToCString());
+      ReportError(TokenPos(),
+                  "const 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");
+      ReportError(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();
     }
   } else if (IsLiteral("native")) {
     if (method->has_abstract) {
-      ErrorMsg(method->name_pos,
-               "abstract method '%s' may not have a function body",
-               method->name->ToCString());
+      ReportError(method->name_pos,
+                  "abstract method '%s' may not have a function body",
+                  method->name->ToCString());
     } else if (method->IsConstructor() && method->has_const) {
-      ErrorMsg(method->name_pos,
-               "const constructor '%s' may not be native",
-               method->name->ToCString());
+      ReportError(method->name_pos,
+                  "const constructor '%s' may not be native",
+                  method->name->ToCString());
     }
     if (method->redirect_name != NULL) {
-      ErrorMsg(method->name_pos,
-               "Constructor with redirection may not have a function body");
+      ReportError(method->name_pos,
+                  "Constructor with redirection may not have a function body");
     }
     ParseNativeDeclaration();
     method_end_pos = TokenPos();
     ExpectSemicolon();
     method->has_native = true;
   } else {
     // We haven't found a method body. Issue error if one is required.
     const bool must_have_body =
         method->has_static &&
         !method->has_external &&
         redirection_type.IsNull();
     if (must_have_body) {
-      ErrorMsg(method->name_pos,
-               "function body expected for method '%s'",
-               method->name->ToCString());
+      ReportError(method->name_pos,
+                  "function body expected for method '%s'",
+                  method->name->ToCString());
     }
 
     if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       if (!method->has_static &&
           !method->has_external &&
           !method->IsConstructor()) {
           // Methods, getters and setters without a body are
           // implicitly abstract.
         method->has_abstract = true;
       }
     } else {
       // Signature is not followed by semicolon or body. Issue an
       // appropriate error.
       const bool must_have_semicolon =
           (method->redirect_name != NULL) ||
           (method->IsConstructor() && method->has_const) ||
           method->has_external;
       if (must_have_semicolon) {
         ExpectSemicolon();
       } else {
-        ErrorMsg(method->name_pos,
-                 "function body or semicolon expected for method '%s'",
-                 method->name->ToCString());
+        ReportError(method->name_pos,
+                    "function body or semicolon expected for method '%s'",
+                    method->name->ToCString());
       }
     }
   }
 
   RawFunction::Kind function_kind;
   if (method->IsFactoryOrConstructor()) {
     function_kind = RawFunction::kConstructor;
   } else if (method->IsGetter()) {
     function_kind = RawFunction::kGetterFunction;
   } else if (method->IsSetter()) {
@@ skipping 49 matching lines @@
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA ||
          CurrentToken() == Token::kASSIGN);
   ASSERT(field->type != NULL);
   ASSERT(field->name_pos > 0);
   ASSERT(current_member_ == field);
   // All const fields are also final.
   ASSERT(!field->has_const || field->has_final);
 
   if (field->has_abstract) {
-    ErrorMsg("keyword 'abstract' not allowed in field declaration");
+    ReportError("keyword 'abstract' not allowed in field declaration");
   }
   if (field->has_external) {
-    ErrorMsg("keyword 'external' not allowed in field declaration");
+    ReportError("keyword 'external' not allowed in field declaration");
   }
   if (field->has_factory) {
-    ErrorMsg("keyword 'factory' not allowed in field declaration");
+    ReportError("keyword 'factory' not allowed in field declaration");
   }
   if (!field->has_static && field->has_const) {
-    ErrorMsg(field->name_pos, "instance field may not be 'const'");
+    ReportError(field->name_pos, "instance field may not be 'const'");
   }
   Function& getter = Function::Handle(I);
   Function& setter = Function::Handle(I);
   Field& class_field = Field::ZoneHandle(I);
   Instance& init_value = Instance::Handle(I);
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
     if (has_initializer) {
       ConsumeToken();
@@ skipping 11 matching lines @@
       // mode), the field value is reset and a kImplicitStaticFinalGetter is
       // created at finalization time.
       if (LookaheadToken(1) == Token::kSEMICOLON) {
         has_simple_literal = IsSimpleLiteral(*field->type, &init_value);
       }
       SkipExpr();
     } else {
       // Static const and static final fields must have an initializer.
       // Static const fields are implicitly final.
       if (field->has_static && field->has_final) {
-        ErrorMsg(field->name_pos,
-                 "static %s field '%s' must have an initializer expression",
-                 field->has_const ? "const" : "final",
-                 field->name->ToCString());
+        ReportError(field->name_pos,
+                    "static %s field '%s' must have an initializer expression",
+                    field->has_const ? "const" : "final",
+                    field->name->ToCString());
       }
     }
 
     // Create the field object.
     class_field = Field::New(*field->name,
                              field->has_static,
                              field->has_final,
                              field->has_const,
                              current_class(),
                              field->name_pos);
@@ skipping 101 matching lines @@
   } else if ((op == Token::kBIT_NOT) || (op == Token::kNEGATE)) {
     expected_num_parameters = 1;
   } else {
     expected_num_parameters = 2;
   }
   if ((member.params.num_optional_parameters > 0) ||
       member.params.has_optional_positional_parameters ||
       member.params.has_optional_named_parameters ||
       (member.params.num_fixed_parameters != expected_num_parameters)) {
     // Subtract receiver when reporting number of expected arguments.
-    ErrorMsg(member.name_pos, "operator %s expects %" Pd " argument(s)",
-        member.name->ToCString(), (expected_num_parameters - 1));
+    ReportError(member.name_pos, "operator %s expects %" Pd " argument(s)",
+                member.name->ToCString(), (expected_num_parameters - 1));
   }
 }
 
 
 void Parser::CheckMemberNameConflict(ClassDesc* members,
                                      MemberDesc* member) {
   const String& name = *member->DictName();
   if (name.Equals(members->class_name())) {
-    ErrorMsg(member->name_pos,
-             "%s '%s' conflicts with class name",
-             member->ToCString(),
-             name.ToCString());
+    ReportError(member->name_pos,
+                "%s '%s' conflicts with class name",
+                member->ToCString(),
+                name.ToCString());
   }
   if (members->clazz().LookupTypeParameter(name) != TypeParameter::null()) {
-    ErrorMsg(member->name_pos,
-             "%s '%s' conflicts with type parameter",
-             member->ToCString(),
-             name.ToCString());
+    ReportError(member->name_pos,
+                "%s '%s' conflicts with type parameter",
+                member->ToCString(),
+                name.ToCString());
   }
   for (int i = 0; i < members->members().length(); i++) {
     MemberDesc* existing_member = &members->members()[i];
     if (name.Equals(*existing_member->DictName())) {
-      ErrorMsg(member->name_pos,
-               "%s '%s' conflicts with previously declared %s",
-               member->ToCString(),
-               name.ToCString(),
-               existing_member->ToCString());
+      ReportError(member->name_pos,
+                  "%s '%s' conflicts with previously declared %s",
+                  member->ToCString(),
+                  name.ToCString(),
+                  existing_member->ToCString());
     }
   }
 }
 
 
 void Parser::ParseClassMemberDefinition(ClassDesc* members,
                                         intptr_t metadata_pos) {
   TRACE_PARSER("ParseClassMemberDefinition");
   MemberDesc member;
   current_member_ = &member;
@@ skipping 11 matching lines @@
   }
   if (CurrentToken() == Token::kCONST) {
     ConsumeToken();
     member.has_const = true;
   } else if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     member.has_final = true;
   }
   if (CurrentToken() == Token::kVAR) {
     if (member.has_const) {
-      ErrorMsg("identifier expected after 'const'");
+      ReportError("identifier expected after 'const'");
     }
     if (member.has_final) {
-      ErrorMsg("identifier expected after 'final'");
+      ReportError("identifier expected after 'final'");
     }
     ConsumeToken();
     member.has_var = true;
     // The member type is the 'dynamic' type.
     member.type = &Type::ZoneHandle(I, Type::DynamicType());
   } else if (CurrentToken() == Token::kFACTORY) {
     ConsumeToken();
     if (member.has_static) {
-      ErrorMsg("factory method cannot be explicitly marked static");
+      ReportError("factory method cannot be explicitly marked static");
     }
     member.has_factory = true;
     member.has_static = true;
     // The result type depends on the name of the factory method.
   }
   // Optionally parse a type.
   if (CurrentToken() == Token::kVOID) {
     if (member.has_var || member.has_factory) {
-      ErrorMsg("void not expected");
+      ReportError("void not expected");
     }
     ConsumeToken();
     ASSERT(member.type == NULL);
     member.type = &Type::ZoneHandle(I, Type::VoidType());
   } else if (CurrentToken() == Token::kIDENT) {
     // This is either a type name or the name of a method/constructor/field.
     if ((member.type == NULL) && !member.has_factory) {
       // We have not seen a member type yet, so we check if the next
       // identifier could represent a type before parsing it.
       Token::Kind follower = LookaheadToken(1);
@@ skipping 19 matching lines @@
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     member.name_pos = TokenPos();
     member.name = CurrentLiteral();  // Unqualified identifier.
     ConsumeToken();
     if (member.has_factory) {
       // The factory name may be qualified, but the first identifier must match
       // the name of the immediately enclosing class.
       if (!member.name->Equals(members->class_name())) {
-        ErrorMsg(member.name_pos, "factory name must be '%s'",
-                 members->class_name().ToCString());
+        ReportError(member.name_pos, "factory name must be '%s'",
+                    members->class_name().ToCString());
       }
     } else if (member.has_static) {
-      ErrorMsg(member.name_pos, "constructor cannot be static");
+      ReportError(member.name_pos, "constructor cannot be static");
     }
     if (member.type != NULL) {
-      ErrorMsg(member.name_pos, "constructor must not specify return type");
+      ReportError(member.name_pos, "constructor must not specify return type");
     }
     // Do not bypass class resolution by using current_class() directly, since
     // it may be a patch class.
     const Object& result_type_class = Object::Handle(I,
         UnresolvedClass::New(LibraryPrefix::Handle(I),
                              *member.name,
                              member.name_pos));
     // The type arguments of the result type are the type parameters of the
     // current class. Note that in the case of a patch class, they are copied
     // from the class being patched.
@@ skipping 40 matching lines @@
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(I, 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)) {
     ConsumeToken();
     if (!Token::CanBeOverloaded(CurrentToken())) {
-      ErrorMsg("invalid operator overloading");
+      ReportError("invalid operator overloading");
     }
     if (member.has_static) {
-      ErrorMsg("operator overloading functions cannot be static");
+      ReportError("operator overloading functions cannot be static");
     }
     member.operator_token = CurrentToken();
     member.has_operator = true;
     member.kind = RawFunction::kRegularFunction;
     member.name_pos = this->TokenPos();
     member.name =
         &String::ZoneHandle(I, Symbols::New(Token::Str(member.operator_token)));
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = TokenPos();
     ConsumeToken();
   } else {
-    ErrorMsg("identifier expected");
+    ReportError("identifier expected");
   }
 
   ASSERT(member.name != NULL);
   if (CurrentToken() == Token::kLPAREN || member.IsGetter()) {
     // Constructor or method.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(I, Type::DynamicType());
     }
     ASSERT(member.IsFactory() == member.has_factory);
     ParseMethodOrConstructor(members, &member);
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
     if (member.has_const) {
       // const fields are implicitly final.
       member.has_final = true;
     }
     if (member.type == NULL) {
       if (member.has_final) {
         member.type = &Type::ZoneHandle(I, Type::DynamicType());
       } else {
-        ErrorMsg("missing 'var', 'final', 'const' or type"
-                 " in field declaration");
+        ReportError("missing 'var', 'final', 'const' or type"
+                    " in field declaration");
       }
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   CheckMemberNameConflict(members, &member);
   members->AddMember(member);
 }
@@ skipping 19 matching lines @@
   String& class_name = *ExpectUserDefinedTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
   Class& cls = Class::Handle(I);
   TypeArguments& orig_type_parameters = TypeArguments::Handle(I);
   Object& obj = Object::Handle(I,
                                library_.LookupLocalObject(class_name));
   if (obj.IsNull()) {
     if (is_patch) {
-      ErrorMsg(classname_pos, "missing class '%s' cannot be patched",
-               class_name.ToCString());
+      ReportError(classname_pos, "missing class '%s' cannot be patched",
+                  class_name.ToCString());
     }
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
-      ErrorMsg(classname_pos, "'%s' is already defined",
-               class_name.ToCString());
+      ReportError(classname_pos, "'%s' is already defined",
+                  class_name.ToCString());
     }
     cls ^= obj.raw();
     if (is_patch) {
       // Preserve and reuse the original type parameters and bounds since the
       // ones defined in the patch class will not be finalized.
       orig_type_parameters = cls.type_parameters();
       // A patch class must be given the same name as the class it is patching,
       // otherwise the generic signature classes it defines will not match the
       // patched generic signature classes. Therefore, new signature classes
       // will be introduced and the original ones will not get finalized.
       cls = Class::New(class_name, script_, classname_pos);
       cls.set_library(library_);
     } else {
       // Not patching a class, but it has been found. This must be one of the
       // pre-registered classes from object.cc or a duplicate definition.
       if (!(cls.is_prefinalized() ||
             RawObject::IsTypedDataViewClassId(cls.id()))) {
-        ErrorMsg(classname_pos, "class '%s' is already defined",
-                 class_name.ToCString());
+        ReportError(classname_pos, "class '%s' is already defined",
+                    class_name.ToCString());
       }
       // Pre-registered classes need their scripts connected at this time.
       cls.set_script(script_);
       cls.set_token_pos(classname_pos);
     }
   }
   ASSERT(!cls.IsNull());
   ASSERT(cls.functions() == Object::empty_array().raw());
   set_current_class(cls);
   ParseTypeParameters(cls);
   if (is_patch) {
     // Check that the new type parameters are identical to the original ones.
     const TypeArguments& new_type_parameters =
         TypeArguments::Handle(I, cls.type_parameters());
     const int new_type_params_count =
         new_type_parameters.IsNull() ? 0 : new_type_parameters.Length();
     const int orig_type_params_count =
         orig_type_parameters.IsNull() ? 0 : orig_type_parameters.Length();
     if (new_type_params_count != orig_type_params_count) {
-      ErrorMsg(classname_pos,
-               "class '%s' must be patched with identical type parameters",
-               class_name.ToCString());
+      ReportError(classname_pos,
+                  "class '%s' must be patched with identical type parameters",
+                  class_name.ToCString());
     }
     TypeParameter& new_type_param = TypeParameter::Handle(I);
     TypeParameter& orig_type_param = TypeParameter::Handle(I);
     String& new_name = String::Handle(I);
     String& orig_name = String::Handle(I);
     AbstractType& new_bound = AbstractType::Handle(I);
     AbstractType& orig_bound = AbstractType::Handle(I);
     for (int i = 0; i < new_type_params_count; i++) {
       new_type_param ^= new_type_parameters.TypeAt(i);
       orig_type_param ^= orig_type_parameters.TypeAt(i);
       new_name = new_type_param.name();
       orig_name = orig_type_param.name();
       if (!new_name.Equals(orig_name)) {
-        ErrorMsg(new_type_param.token_pos(),
-                 "type parameter '%s' of patch class '%s' does not match "
-                 "original type parameter '%s'",
-                 new_name.ToCString(),
-                 class_name.ToCString(),
-                 orig_name.ToCString());
+        ReportError(new_type_param.token_pos(),
+                    "type parameter '%s' of patch class '%s' does not match "
+                    "original type parameter '%s'",
+                    new_name.ToCString(),
+                    class_name.ToCString(),
+                    orig_name.ToCString());
       }
       new_bound = new_type_param.bound();
       orig_bound = orig_type_param.bound();
       if (!new_bound.Equals(orig_bound)) {
-        ErrorMsg(new_type_param.token_pos(),
-                 "bound '%s' of type parameter '%s' of patch class '%s' does "
-                 "not match original type parameter bound '%s'",
-                 String::Handle(new_bound.UserVisibleName()).ToCString(),
-                 new_name.ToCString(),
-                 class_name.ToCString(),
-                 String::Handle(orig_bound.UserVisibleName()).ToCString());
+        ReportError(new_type_param.token_pos(),
+                    "bound '%s' of type parameter '%s' of patch class '%s' "
+                    "does not match original type parameter bound '%s'",
+                    String::Handle(new_bound.UserVisibleName()).ToCString(),
+                    new_name.ToCString(),
+                    class_name.ToCString(),
+                    String::Handle(orig_bound.UserVisibleName()).ToCString());
       }
     }
     cls.set_type_parameters(orig_type_parameters);
   }
 
   if (is_abstract) {
     cls.set_is_abstract();
   }
   if (metadata_pos >= 0) {
     library_.AddClassMetadata(cls, toplevel_class, metadata_pos);
   }
 
   const bool is_mixin_declaration = (CurrentToken() == Token::kASSIGN);
   if (is_mixin_declaration && is_patch) {
-    ErrorMsg(classname_pos,
-             "mixin application '%s' may not be a patch class",
-             class_name.ToCString());
+    ReportError(classname_pos,
+                "mixin application '%s' may not be a patch class",
+                class_name.ToCString());
   }
 
   AbstractType& super_type = Type::Handle(I);
   if ((CurrentToken() == Token::kEXTENDS) || is_mixin_declaration) {
     ConsumeToken();  // extends or =
     const intptr_t type_pos = TokenPos();
     super_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (super_type.IsMalformedOrMalbounded()) {
-      ErrorMsg(Error::Handle(I, super_type.error()));
+      ReportError(Error::Handle(I, super_type.error()));
     }
     if (super_type.IsDynamicType()) {
       // Unlikely here, since super type is not resolved yet.
-      ErrorMsg(type_pos,
-               "class '%s' may not extend 'dynamic'",
-               class_name.ToCString());
+      ReportError(type_pos,
+                  "class '%s' may not extend 'dynamic'",
+                  class_name.ToCString());
     }
     if (super_type.IsTypeParameter()) {
-      ErrorMsg(type_pos,
-               "class '%s' may not extend type parameter '%s'",
-               class_name.ToCString(),
-               String::Handle(I,
-                              super_type.UserVisibleName()).ToCString());
+      ReportError(type_pos,
+                  "class '%s' may not extend type parameter '%s'",
+                  class_name.ToCString(),
+                  String::Handle(I,
+                                 super_type.UserVisibleName()).ToCString());
     }
     // The class finalizer will check whether the super type is malbounded.
     if (is_mixin_declaration) {
       if (CurrentToken() != Token::kWITH) {
-        ErrorMsg("mixin application clause 'with type' expected");
+        ReportError("mixin application clause 'with type' expected");
       }
       cls.set_is_mixin_app_alias();
       cls.set_is_synthesized_class();
     }
     if (CurrentToken() == Token::kWITH) {
       super_type = ParseMixins(super_type);
     }
   } else {
     // No extends clause: implicitly extend Object, unless Object itself.
     if (!cls.IsObjectClass()) {
@@ skipping 68 matching lines @@
 
   if (cls.is_patch()) {
     // Apply the changes to the patched class looked up above.
     Object& obj = Object::Handle(I,
                                  library_.LookupLocalObject(class_name));
     // The patched class must not be finalized yet.
     const Class& orig_class = Class::Cast(obj);
     ASSERT(!orig_class.is_finalized());
     Error& error = Error::Handle(I);
     if (!orig_class.ApplyPatch(cls, &error)) {
-      AppendErrorMsg(error, class_pos, "applying patch failed");
+      Report::LongJumpF(error, script_, class_pos, "applying patch failed");
     }
   }
 }
 
 
 // Add an implicit constructor to the given class.
 void Parser::AddImplicitConstructor(const Class& cls) {
   // The implicit constructor is unnamed, has no explicit parameter.
   String& ctor_name = String::ZoneHandle(I, cls.Name());
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
@@ skipping 41 matching lines @@
     MemberDesc* member = &members[i];
     if (member->redirect_name == NULL) {
       continue;
     }
     GrowableArray<MemberDesc*> ctors;
     while ((member != NULL) && (member->redirect_name != NULL)) {
       ASSERT(member->IsConstructor());
       // Check whether we have already seen this member.
       for (int i = 0; i < ctors.length(); i++) {
         if (ctors[i] == member) {
-          ErrorMsg(member->name_pos,
-                   "cyclic reference in constructor redirection");
+          ReportError(member->name_pos,
+                      "cyclic reference in constructor redirection");
         }
       }
       // We haven't seen this member. Add it to the list and follow
       // the next redirection. If we can't find the constructor to
       // which the current one redirects, we ignore the unresolved
       // reference. We'll catch it later when the constructor gets
       // compiled.
       ctors.Add(member);
       member = class_desc->LookupMember(*member->redirect_name);
     }
   }
 }
 
 
 void Parser::ParseMixinAppAlias(
     const GrowableObjectArray& pending_classes,
     const Class& toplevel_class,
     intptr_t metadata_pos) {
   TRACE_PARSER("ParseMixinAppAlias");
   const intptr_t classname_pos = TokenPos();
   String& class_name = *ExpectUserDefinedTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("toplevel parsing mixin application alias class '%s'\n",
               class_name.ToCString());
   }
   const Object& obj = Object::Handle(I,
                                      library_.LookupLocalObject(class_name));
   if (!obj.IsNull()) {
-    ErrorMsg(classname_pos, "'%s' is already defined",
-             class_name.ToCString());
+    ReportError(classname_pos, "'%s' is already defined",
+                class_name.ToCString());
   }
   const Class& mixin_application =
       Class::Handle(I, Class::New(class_name, script_, classname_pos));
   mixin_application.set_is_mixin_app_alias();
   library_.AddClass(mixin_application);
   set_current_class(mixin_application);
   ParseTypeParameters(mixin_application);
 
   ExpectToken(Token::kASSIGN);
 
   if (CurrentToken() == Token::kABSTRACT) {
     mixin_application.set_is_abstract();
     ConsumeToken();
   }
 
   const intptr_t type_pos = TokenPos();
   AbstractType& type =
       AbstractType::Handle(I,
                            ParseType(ClassFinalizer::kResolveTypeParameters));
   if (type.IsTypeParameter()) {
-    ErrorMsg(type_pos,
-             "class '%s' may not extend type parameter '%s'",
-             class_name.ToCString(),
-             String::Handle(I, type.UserVisibleName()).ToCString());
+    ReportError(type_pos,
+                "class '%s' may not extend type parameter '%s'",
+                class_name.ToCString(),
+                String::Handle(I, type.UserVisibleName()).ToCString());
   }
 
   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 alias needs an implicit constructor, but it is
   // too early to call 'AddImplicitConstructor(mixin_application)' here,
@@ skipping 50 matching lines @@
 
 
 void Parser::ParseTypedef(const GrowableObjectArray& pending_classes,
                           const Class& toplevel_class,
                           intptr_t metadata_pos) {
   TRACE_PARSER("ParseTypedef");
   ExpectToken(Token::kTYPEDEF);
 
   if (IsMixinAppAlias()) {
     if (FLAG_warn_mixin_typedef) {
-      Warning("deprecated mixin application typedef");
+      ReportWarning(TokenPos(), "deprecated mixin application typedef");
     }
     ParseMixinAppAlias(pending_classes, toplevel_class, metadata_pos);
     return;
   }
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(I, Type::DynamicType());
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     // Type annotations in typedef are never ignored, even in production mode.
     // Wait until we have an owner class before resolving the result type.
     result_type = ParseType(ClassFinalizer::kDoNotResolve);
   }
 
   const intptr_t alias_name_pos = TokenPos();
   const String* alias_name =
       ExpectUserDefinedTypeIdentifier("function alias name expected");
 
   // Lookup alias name and report an error if it is already defined in
   // the library scope.
   const Object& obj = Object::Handle(I,
                                      library_.LookupLocalObject(*alias_name));
   if (!obj.IsNull()) {
-    ErrorMsg(alias_name_pos,
-             "'%s' is already defined", alias_name->ToCString());
+    ReportError(alias_name_pos,
+                "'%s' is already defined", alias_name->ToCString());
   }
 
   // Create the function type alias signature class. It will be linked to its
   // signature function after it has been parsed. The type parameters, in order
   // to be properly finalized, need to be associated to this signature class as
   // they are parsed.
   const Class& function_type_alias = Class::Handle(I,
       Class::NewSignatureClass(*alias_name,
                                Function::Handle(I),
                                script_,
@@ skipping 119 matching lines @@
 void Parser::SkipTypeArguments() {
   if (CurrentToken() == Token::kLT) {
     do {
       ConsumeToken();
       SkipType(false);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
-      ErrorMsg("right angle bracket expected");
+      ReportError("right angle bracket expected");
     }
   }
 }
 
 
 void Parser::SkipType(bool allow_void) {
   if (CurrentToken() == Token::kVOID) {
     if (!allow_void) {
-      ErrorMsg("'void' not allowed here");
+      ReportError("'void' not allowed here");
     }
     ConsumeToken();
   } else {
     ExpectIdentifier("type name expected");
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("name expected");
     }
     SkipTypeArguments();
   }
@@ skipping 14 matching lines @@
       ConsumeToken();
       const intptr_t metadata_pos = SkipMetadata();
       const intptr_t type_parameter_pos = TokenPos();
       String& type_parameter_name =
           *ExpectUserDefinedTypeIdentifier("type parameter expected");
       // Check for duplicate type parameters.
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i);
         existing_type_parameter_name = existing_type_parameter.name();
         if (existing_type_parameter_name.Equals(type_parameter_name)) {
-          ErrorMsg(type_parameter_pos, "duplicate type parameter '%s'",
-                   type_parameter_name.ToCString());
+          ReportError(type_parameter_pos, "duplicate type parameter '%s'",
+                      type_parameter_name.ToCString());
         }
       }
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         // A bound may refer to the owner of the type parameter it applies to,
         // i.e. to the class or interface currently being parsed.
         // Postpone resolution in order to avoid resolving the class and its
         // type parameters, as they are not fully parsed yet.
         type_parameter_bound = ParseType(ClassFinalizer::kDoNotResolve);
       } else {
         type_parameter_bound = I->object_store()->object_type();
       }
       type_parameter = TypeParameter::New(cls,
                                           index,
                                           type_parameter_name,
                                           type_parameter_bound,
                                           type_parameter_pos);
       type_parameters_array.Add(type_parameter);
       if (metadata_pos >= 0) {
         library_.AddTypeParameterMetadata(type_parameter, metadata_pos);
       }
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
-      ErrorMsg("right angle bracket expected");
+      ReportError("right angle bracket expected");
     }
     const TypeArguments& type_parameters =
         TypeArguments::Handle(I,
                               NewTypeArguments(type_parameters_array));
     cls.set_type_parameters(type_parameters);
     // Try to resolve the upper bounds, which will at least resolve the
     // referenced type parameters.
     const intptr_t num_types = type_parameters.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       type_parameter ^= type_parameters.TypeAt(i);
@@ skipping 20 matching lines @@
       // Map a malformed type argument to dynamic.
       if (type.IsMalformed()) {
         type = Type::DynamicType();
       }
       types.Add(type);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
-      ErrorMsg("right angle bracket expected");
+      ReportError("right angle bracket expected");
     }
     if (finalization != ClassFinalizer::kIgnore) {
       return NewTypeArguments(types);
     }
   }
   return TypeArguments::null();
 }
 
 
 // Parse interface list and add to class cls.
 void Parser::ParseInterfaceList(const Class& cls) {
   TRACE_PARSER("ParseInterfaceList");
   ASSERT(CurrentToken() == Token::kIMPLEMENTS);
   const GrowableObjectArray& all_interfaces =
       GrowableObjectArray::Handle(I, GrowableObjectArray::New());
   AbstractType& interface = AbstractType::Handle(I);
   // First get all the interfaces already implemented by class.
   Array& cls_interfaces = Array::Handle(I, cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
     interface ^= cls_interfaces.At(i);
     all_interfaces.Add(interface);
   }
   // Now parse and add the new interfaces.
   do {
     ConsumeToken();
     intptr_t interface_pos = TokenPos();
     interface = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (interface.IsTypeParameter()) {
-      ErrorMsg(interface_pos,
-               "type parameter '%s' may not be used in interface list",
-               String::Handle(I,
-                              interface.UserVisibleName()).ToCString());
+      ReportError(interface_pos,
+                  "type parameter '%s' may not be used in interface list",
+                  String::Handle(I, interface.UserVisibleName()).ToCString());
     }
     all_interfaces.Add(interface);
   } while (CurrentToken() == Token::kCOMMA);
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 RawAbstractType* Parser::ParseMixins(const AbstractType& super_type) {
   TRACE_PARSER("ParseMixins");
   ASSERT(CurrentToken() == Token::kWITH);
   const GrowableObjectArray& mixin_types =
       GrowableObjectArray::Handle(I, GrowableObjectArray::New());
   AbstractType& mixin_type = AbstractType::Handle(I);
   do {
     ConsumeToken();
     mixin_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (mixin_type.IsDynamicType()) {
       // The string 'dynamic' is not resolved yet at this point, but a malformed
       // type mapped to dynamic can be encountered here.
-      ErrorMsg(mixin_type.token_pos(), "illegal mixin of a malformed type");
+      ReportError(mixin_type.token_pos(), "illegal mixin of a malformed type");
     }
     if (mixin_type.IsTypeParameter()) {
-      ErrorMsg(mixin_type.token_pos(),
-               "mixin type '%s' may not be a type parameter",
-               String::Handle(I,
-                              mixin_type.UserVisibleName()).ToCString());
+      ReportError(mixin_type.token_pos(),
+                  "mixin type '%s' may not be a type parameter",
+                  String::Handle(I, mixin_type.UserVisibleName()).ToCString());
     }
     mixin_types.Add(mixin_type);
   } while (CurrentToken() == Token::kCOMMA);
   return MixinAppType::New(super_type,
       Array::Handle(I, Array::MakeArray(mixin_types)));
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_const = (CurrentToken() == Token::kCONST);
   // Const fields are implicitly final.
   const bool is_final = is_const || (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const AbstractType& type = AbstractType::ZoneHandle(I,
       ParseConstFinalVarOrType(ClassFinalizer::kResolveTypeParameters));
   Field& field = Field::Handle(I);
   Function& getter = Function::Handle(I);
   while (true) {
     const intptr_t name_pos = TokenPos();
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupLocalObject(var_name) != Object::null()) {
-      ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
+      ReportError(name_pos, "'%s' is already defined", var_name.ToCString());
     }
 
     // Check whether a getter or setter for this name exists. A const
     // or final field implies a setter which throws a NoSuchMethodError,
     // thus we need to check for conflicts with existing setters and
     // getters.
     String& accessor_name = String::Handle(I,
                                            Field::GetterName(var_name));
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
-      ErrorMsg(name_pos, "getter for '%s' is already defined",
-               var_name.ToCString());
+      ReportError(name_pos, "getter for '%s' is already defined",
+                  var_name.ToCString());
     }
     accessor_name = Field::SetterName(var_name);
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
-      ErrorMsg(name_pos, "setter for '%s' is already defined",
-               var_name.ToCString());
+      ReportError(name_pos, "setter for '%s' is already defined",
+                  var_name.ToCString());
     }
 
     field = Field::New(var_name, is_static, is_final, is_const,
                        current_class(), name_pos);
     field.set_type(type);
     field.set_value(Instance::Handle(I, Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (metadata_pos >= 0) {
       library_.AddFieldMetadata(field, metadata_pos);
@@ skipping 25 matching lines @@
         top_level->functions.Add(getter);
 
         // Create initializer function.
         if (!field.is_const()) {
           const Function& init_function = Function::ZoneHandle(I,
               Function::NewStaticInitializer(field));
           top_level->functions.Add(init_function);
         }
       }
     } else if (is_final) {
-      ErrorMsg(name_pos, "missing initializer for final or const variable");
+      ReportError(name_pos, "missing initializer for final or const variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
@@ skipping 27 matching lines @@
     if ((CurrentToken() == Token::kIDENT) &&
         (LookaheadToken(1) != Token::kLPAREN)) {
       result_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     }
   }
   const intptr_t name_pos = TokenPos();
   const String& func_name = *ExpectIdentifier("function name expected");
 
   bool found = library_.LookupLocalObject(func_name) != Object::null();
   if (found && !is_patch) {
-    ErrorMsg(name_pos, "'%s' is already defined", func_name.ToCString());
+    ReportError(name_pos, "'%s' is already defined", func_name.ToCString());
   } else if (!found && is_patch) {
-    ErrorMsg(name_pos, "missing '%s' cannot be patched", func_name.ToCString());
+    ReportError(name_pos, "missing '%s' cannot be patched",
+                func_name.ToCString());
   }
   String& accessor_name = String::Handle(I,
                                          Field::GetterName(func_name));
   if (library_.LookupLocalObject(accessor_name) != Object::null()) {
-    ErrorMsg(name_pos, "'%s' is already defined as getter",
-             func_name.ToCString());
+    ReportError(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.
 
   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);
 
@@ skipping 10 matching lines @@
     ConsumeToken();
     SkipExpr();
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
     function_end_pos = TokenPos();
     ExpectSemicolon();
     is_native = true;
   } else {
-    ErrorMsg("function block expected");
+    ReportError("function block expected");
   }
   Function& func = Function::Handle(I,
       Function::New(func_name,
                     RawFunction::kRegularFunction,
                     is_static,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     is_external,
                     is_native,
                     current_class(),
@@ skipping 66 matching lines @@
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
     accessor_name = Field::GetterSymbol(*field_name);
   } else {
     expected_num_parameters = 1;
     accessor_name = Field::SetterSymbol(*field_name);
   }
   if ((params.num_fixed_parameters != expected_num_parameters) ||
       (params.num_optional_parameters != 0)) {
-    ErrorMsg(name_pos, "illegal %s parameters",
-             is_getter ? "getter" : "setter");
+    ReportError(name_pos, "illegal %s parameters",
+                is_getter ? "getter" : "setter");
   }
 
   // Check whether this getter conflicts with a function or top-level variable
   // with the same name.
   if (is_getter &&
       (library_.LookupLocalObject(*field_name) != Object::null())) {
-    ErrorMsg(name_pos, "'%s' is already defined in this library",
-             field_name->ToCString());
+    ReportError(name_pos, "'%s' is already defined in this library",
+                field_name->ToCString());
   }
   // Check whether this setter conflicts with the implicit setter
   // of a top-level variable with the same name.
   if (!is_getter &&
       (library_.LookupLocalField(*field_name) != Object::null())) {
-    ErrorMsg(name_pos, "Variable '%s' is already defined in this library",
-             field_name->ToCString());
+    ReportError(name_pos, "Variable '%s' is already defined in this library",
+                field_name->ToCString());
   }
   bool found = library_.LookupLocalObject(accessor_name) != Object::null();
   if (found && !is_patch) {
-    ErrorMsg(name_pos, "%s for '%s' is already defined",
-             is_getter ? "getter" : "setter",
-             field_name->ToCString());
+    ReportError(name_pos, "%s for '%s' is already defined",
+                is_getter ? "getter" : "setter",
+                field_name->ToCString());
   } else if (!found && is_patch) {
-    ErrorMsg(name_pos, "missing %s for '%s' cannot be patched",
-             is_getter ? "getter" : "setter",
-             field_name->ToCString());
+    ReportError(name_pos, "missing %s for '%s' cannot be patched",
+                is_getter ? "getter" : "setter",
+                field_name->ToCString());
   }
 
   intptr_t accessor_end_pos = accessor_pos;
   bool is_native = false;
   if (is_external) {
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     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();
     is_native = true;
   } else {
-    ErrorMsg("function block expected");
+    ReportError("function block expected");
   }
   Function& func = Function::Handle(I,
       Function::New(accessor_name,
                     is_getter ? RawFunction::kGetterFunction :
                                 RawFunction::kSetterFunction,
                     is_static,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     is_external,
                     is_native,
@@ skipping 22 matching lines @@
                                          intptr_t token_pos,
                                          const String& url) {
   Dart_LibraryTagHandler handler = I->library_tag_handler();
   if (handler == NULL) {
     if (url.StartsWith(Symbols::DartScheme())) {
       if (tag == Dart_kCanonicalizeUrl) {
         return url.raw();
       }
       return Object::null();
     }
-    ErrorMsg(token_pos, "no library handler registered");
+    ReportError(token_pos, "no library handler registered");
   }
   // Block class finalization attempts when calling into the library
   // tag handler.
   I->BlockClassFinalization();
   Api::Scope api_scope(I);
   Dart_Handle result = handler(tag,
                                Api::NewHandle(I, library_.raw()),
                                Api::NewHandle(I, url.raw()));
   I->UnblockClassFinalization();
   if (Dart_IsError(result)) {
     // In case of an error we append an explanatory error message to the
     // error obtained from the library tag handler.
     Error& prev_error = Error::Handle(I);
     prev_error ^= Api::UnwrapHandle(result);
-    AppendErrorMsg(prev_error, token_pos, "library handler failed");
+    Report::LongJumpF(prev_error, script_, token_pos, "library handler failed");
   }
   if (tag == Dart_kCanonicalizeUrl) {
     if (!Dart_IsString(result)) {
-      ErrorMsg(token_pos, "library handler failed URI canonicalization");
+      ReportError(token_pos, "library handler failed URI canonicalization");
     }
   }
   return Api::UnwrapHandle(result);
 }
 
 
 void Parser::ParseLibraryName() {
   ASSERT(CurrentToken() == Token::kLIBRARY);
   ConsumeToken();
   String& lib_name = *ExpectIdentifier("library name expected");
   if (CurrentToken() == Token::kPERIOD) {
     while (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       lib_name = String::Concat(lib_name, Symbols::Dot());
       lib_name = String::Concat(lib_name,
           *ExpectIdentifier("malformed library name"));
     }
     lib_name = Symbols::New(lib_name);
   }
   library_.SetName(lib_name);
   ExpectSemicolon();
 }
 
 
 void Parser::ParseIdentList(GrowableObjectArray* names) {
   if (!IsIdentifier()) {
-    ErrorMsg("identifier expected");
+    ReportError("identifier expected");
   }
   while (IsIdentifier()) {
     names->Add(*CurrentLiteral());
     ConsumeToken();  // Identifier.
     if (CurrentToken() != Token::kCOMMA) {
       return;
     }
     ConsumeToken();  // Comma.
   }
 }
 
 
 void Parser::ParseLibraryImportExport(intptr_t metadata_pos) {
   bool is_import = (CurrentToken() == Token::kIMPORT);
   bool is_export = (CurrentToken() == Token::kEXPORT);
   ASSERT(is_import || is_export);
   const intptr_t import_pos = TokenPos();
   ConsumeToken();
   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");
+    ReportError("library url expected");
   }
   bool is_deferred_import = false;
   if (is_import && (IsLiteral("deferred"))) {
     is_deferred_import = true;
     ConsumeToken();
     CheckToken(Token::kAS, "'as' expected");
   }
   String& prefix = String::Handle(I);
   intptr_t prefix_pos = 0;
   if (is_import && (CurrentToken() == Token::kAS)) {
@@ skipping 58 matching lines @@
   if (metadata_pos >= 0) {
     ns.AddMetadata(metadata_pos, current_class());
   }
 
   if (is_import) {
     // Ensure that private dart:_ libraries are only imported into dart:
     // libraries.
     const String& lib_url = String::Handle(I, library_.url());
     if (canon_url.StartsWith(Symbols::DartSchemePrivate()) &&
         !lib_url.StartsWith(Symbols::DartScheme())) {
-      ErrorMsg(import_pos, "private library is not accessible");
+      ReportError(import_pos, "private library is not accessible");
     }
     if (prefix.IsNull() || (prefix.Length() == 0)) {
       ASSERT(!is_deferred_import);
       library_.AddImport(ns);
     } else {
       LibraryPrefix& library_prefix = LibraryPrefix::Handle(I);
       library_prefix = library_.LookupLocalLibraryPrefix(prefix);
       if (!library_prefix.IsNull()) {
         // Check that prefix names of deferred import clauses are
         // unique.
         if (!is_deferred_import && library_prefix.is_deferred_load()) {
-          ErrorMsg(prefix_pos,
-                   "prefix '%s' already used in a deferred import clause",
-                   prefix.ToCString());
+          ReportError(prefix_pos,
+                      "prefix '%s' already used in a deferred import clause",
+                      prefix.ToCString());
         }
         if (is_deferred_import) {
-          ErrorMsg(prefix_pos, "prefix of deferred import must be uniqe");
+          ReportError(prefix_pos, "prefix of deferred import must be uniqe");
         }
         library_prefix.AddImport(ns);
       } else {
         library_prefix =
             LibraryPrefix::New(prefix, ns, is_deferred_import, library_);
         library_.AddObject(library_prefix, prefix);
       }
     }
   } else {
     ASSERT(is_export);
@@ skipping 29 matching lines @@
   ASSERT(script_.kind() != RawScript::kSourceTag);
 
   // We may read metadata tokens that are part of the toplevel
   // declaration that follows the library definitions. Therefore, we
   // need to remember the position of the last token that was
   // successfully consumed.
   intptr_t rewind_pos = TokenPos();
   intptr_t metadata_pos = SkipMetadata();
   if (CurrentToken() == Token::kLIBRARY) {
     if (is_patch_source()) {
-      ErrorMsg("patch cannot override library name");
+      ReportError("patch cannot override library name");
     }
     ParseLibraryName();
     if (metadata_pos >= 0) {
       library_.AddLibraryMetadata(current_class(), metadata_pos);
     }
     rewind_pos = TokenPos();
     metadata_pos = SkipMetadata();
   }
   while ((CurrentToken() == Token::kIMPORT) ||
       (CurrentToken() == Token::kEXPORT)) {
@@ skipping 17 matching lines @@
   }
   SetPosition(rewind_pos);
 }
 
 
 void Parser::ParsePartHeader() {
   SkipMetadata();
   CheckToken(Token::kPART, "'part of' expected");
   ConsumeToken();
   if (!IsLiteral("of")) {
-    ErrorMsg("'part of' expected");
+    ReportError("'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();
     ExpectIdentifier("malformed library name");
   }
   ExpectSemicolon();
@@ skipping 153 matching lines @@
 // with the formal parameter types and names.
 void Parser::AddFormalParamsToFunction(const ParamList* params,
                                        const Function& func) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT((params->num_optional_parameters > 0) ==
          (params->has_optional_positional_parameters ||
           params->has_optional_named_parameters));
   if (!Utils::IsInt(16, params->num_fixed_parameters) ||
       !Utils::IsInt(16, params->num_optional_parameters)) {
     const Script& script = Script::Handle(Class::Handle(func.Owner()).script());
-    const Error& error = Error::Handle(LanguageError::NewFormatted(
-        Error::Handle(), script, func.token_pos(),
-        LanguageError::kError, Heap::kNew,
-        "too many formal parameters"));
-    ErrorMsg(error);
+    Report::MessageF(Report::kError, script, func.token_pos(),
+                     "too many formal parameters");
   }
   func.set_num_fixed_parameters(params->num_fixed_parameters);
   func.SetNumOptionalParameters(params->num_optional_parameters,
                                 params->has_optional_positional_parameters);
   const int num_parameters = params->parameters->length();
   ASSERT(num_parameters == func.NumParameters());
   func.set_parameter_types(Array::Handle(Array::New(num_parameters,
                                                     Heap::kOld)));
   func.set_parameter_names(Array::Handle(Array::New(num_parameters,
                                                     Heap::kOld)));
@@ skipping 11 matching lines @@
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT(scope != NULL);
   const int num_parameters = params->parameters->length();
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
     ASSERT(!is_top_level_ || param_desc.type->IsResolved());
     const String* name = param_desc.name;
     LocalVariable* parameter = new(I) LocalVariable(
         param_desc.name_pos, *name, *param_desc.type);
     if (!scope->InsertParameterAt(i, parameter)) {
-      ErrorMsg(param_desc.name_pos,
-               "name '%s' already exists in scope",
-               param_desc.name->ToCString());
+      ReportError(param_desc.name_pos,
+                  "name '%s' already exists in scope",
+                  param_desc.name->ToCString());
     }
     param_desc.var = parameter;
     if (param_desc.is_final) {
       parameter->set_is_final();
     }
     if (param_desc.is_field_initializer) {
       parameter->set_invisible(true);
     }
   }
 }
@@ skipping 11 matching lines @@
   // Parse the function name out.
   const intptr_t native_pos = TokenPos();
   const String& native_name = ParseNativeDeclaration();
 
   // Now resolve the native function to the corresponding native entrypoint.
   const int num_params = NativeArguments::ParameterCountForResolution(func);
   bool auto_setup_scope = true;
   NativeFunction native_function = NativeEntry::ResolveNative(
       library, native_name, num_params, &auto_setup_scope);
   if (native_function == NULL) {
-    ErrorMsg(native_pos,
-             "native function '%s' (%" Pd " arguments) cannot be found",
-             native_name.ToCString(), func.NumParameters());
+    ReportError(native_pos,
+                "native function '%s' (%" Pd " arguments) cannot be found",
+                native_name.ToCString(), func.NumParameters());
   }
   func.SetIsNativeAutoSetupScope(auto_setup_scope);
 
   // Now add the NativeBodyNode and return statement.
   Dart_NativeEntryResolver resolver = library.native_entry_resolver();
   bool is_bootstrap_native = Bootstrap::IsBootstapResolver(resolver);
   current_block_->statements->Add(new(I) ReturnNode(
       TokenPos(), new(I) NativeBodyNode(
           TokenPos(),
           Function::ZoneHandle(I, func.raw()),
@@ skipping 37 matching lines @@
   ASSERT(found);
 }
 
 
 AstNode* Parser::LoadReceiver(intptr_t token_pos) {
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
-    ErrorMsg(token_pos, "illegal implicit access to receiver 'this'");
+    ReportError(token_pos, "illegal implicit access to receiver 'this'");
   }
   return new(I) LoadLocalNode(TokenPos(), receiver);
 }
 
 
 AstNode* Parser::LoadTypeArgumentsParameter(intptr_t token_pos) {
   // A nested function may access ':type_arguments' to use as instantiator,
   // referring to the implicit first parameter of the outermost enclosing
   // factory function.
   const bool kTestOnly = false;
@@ skipping 28 matching lines @@
     const intptr_t assign_pos = TokenPos();
     ConsumeToken();
     AstNode* expr = ParseExpr(is_const, kConsumeCascades);
     initialization = new(I) StoreLocalNode(
         assign_pos, variable, expr);
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
       variable->SetConstValue(expr->AsLiteralNode()->literal());
     }
   } else if (is_final || is_const) {
-    ErrorMsg(ident_pos,
-    "missing initialization of 'final' or 'const' variable");
+    ReportError(ident_pos,
+                "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
     AstNode* null_expr = new(I) LiteralNode(
         ident_pos, Instance::ZoneHandle(I));
     initialization = new(I) StoreLocalNode(
         ident_pos, variable, null_expr);
   }
 
   ASSERT(current_block_ != NULL);
   const intptr_t previous_pos =
   current_block_->scope->PreviousReferencePos(ident);
   if (previous_pos >= 0) {
     ASSERT(!script_.IsNull());
     if (previous_pos > ident_pos) {
-      ErrorMsg(ident_pos,
-               "initializer of '%s' may not refer to itself",
-               ident.ToCString());
+      ReportError(ident_pos,
+                  "initializer of '%s' may not refer to itself",
+                  ident.ToCString());
 
     } else {
       intptr_t line_number;
       script_.GetTokenLocation(previous_pos, &line_number, NULL);
-      ErrorMsg(ident_pos,
-               "identifier '%s' previously used in line %" Pd "",
-               ident.ToCString(),
-               line_number);
+      ReportError(ident_pos,
+                  "identifier '%s' previously used in line %" Pd "",
+                  ident.ToCString(),
+                  line_number);
     }
   }
 
   // Add variable to scope after parsing the initalizer expression.
   // The expression must not be able to refer to the variable.
   if (!current_block_->scope->AddVariable(variable)) {
     LocalVariable* existing_var =
         current_block_->scope->LookupVariable(variable->name(), true);
     ASSERT(existing_var != NULL);
     if (existing_var->owner() == current_block_->scope) {
-      ErrorMsg(ident_pos, "identifier '%s' already defined",
-               variable->name().ToCString());
+      ReportError(ident_pos, "identifier '%s' already defined",
+                  variable->name().ToCString());
     } else {
-      ErrorMsg(ident_pos,
-               "'%s' from outer scope has already been used, cannot redefine",
-               variable->name().ToCString());
+      ReportError(ident_pos, "'%s' from outer scope has already been used, "
+                  "cannot redefine",
+                  variable->name().ToCString());
     }
   }
   if (is_final || is_const) {
     variable->set_is_final();
   }
   return initialization;
 }
 
 
 // Parses ('var' | 'final' [type] | 'const' [type] | type).
 // The presence of 'final' or 'const' must be detected and remembered
 // before the call. If a type is parsed, it may be resolved and finalized
 // according to the given type finalization mode.
 RawAbstractType* Parser::ParseConstFinalVarOrType(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseConstFinalVarOrType");
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     return Type::DynamicType();
   }
   bool type_is_optional = false;
   if ((CurrentToken() == Token::kFINAL) || (CurrentToken() == Token::kCONST)) {
     ConsumeToken();
     type_is_optional = true;
   }
   if (CurrentToken() != Token::kIDENT) {
     if (type_is_optional) {
       return Type::DynamicType();
     } else {
-      ErrorMsg("type name expected");
+      ReportError("type name expected");
     }
   }
   if (type_is_optional) {
     Token::Kind follower = LookaheadToken(1);
     // We have an identifier followed by a 'follower' token.
     // We either parse a type or return now.
     if ((follower != Token::kLT) &&  // Parameterized type.
         (follower != Token::kPERIOD) &&  // Qualified class name of type.
         !Token::IsIdentifier(follower) &&  // Variable name following a type.
         (follower != Token::kTHIS)) {  // Field parameter following a type.
       return Type::DynamicType();
     }
   }
   return ParseType(finalization);
 }
 
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   SkipMetadata();
   bool is_final = (CurrentToken() == Token::kFINAL);
   bool is_const = (CurrentToken() == Token::kCONST);
   const AbstractType& type = AbstractType::ZoneHandle(I,
       ParseConstFinalVarOrType(FLAG_enable_type_checks ?
           ClassFinalizer::kCanonicalize : ClassFinalizer::kIgnore));
   if (!IsIdentifier()) {
-    ErrorMsg("identifier expected");
+    ReportError("identifier expected");
   }
 
   AstNode* initializers = ParseVariableDeclaration(type, is_final, is_const);
   ASSERT(initializers != NULL);
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
     if (!IsIdentifier()) {
-      ErrorMsg("identifier expected after comma");
+      ReportError("identifier expected after comma");
     }
     // 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_pos(),
                                                 initializers,
                                                 NULL);
     sequence->Add(ParseVariableDeclaration(type, is_final, is_const));
     initializers = sequence;
   }
   return initializers;
@@ skipping 26 matching lines @@
 
     // Check that the function name has not been referenced
     // before this declaration.
     ASSERT(current_block_ != NULL);
     const intptr_t previous_pos =
         current_block_->scope->PreviousReferencePos(*function_name);
     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);
+      ReportError(name_pos,
+                  "identifier '%s' previously used in line %" Pd "",
+                  function_name->ToCString(),
+                  line_number);
     }
   }
   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(I);
@@ skipping 39 matching lines @@
                                           function_type);
     function_variable->set_is_final();
     ASSERT(current_block_ != NULL);
     ASSERT(current_block_->scope != NULL);
     if (!current_block_->scope->AddVariable(function_variable)) {
       LocalVariable* existing_var =
           current_block_->scope->LookupVariable(function_variable->name(),
                                                 true);
       ASSERT(existing_var != NULL);
       if (existing_var->owner() == current_block_->scope) {
-        ErrorMsg(function_pos, "identifier '%s' already defined",
-                 function_variable->name().ToCString());
+        ReportError(function_pos, "identifier '%s' already defined",
+                    function_variable->name().ToCString());
       } else {
-        ErrorMsg(function_pos,
-                 "'%s' from outer scope has already been used, cannot redefine",
-                 function_variable->name().ToCString());
+        ReportError(function_pos,
+                    "'%s' from outer scope has already been used, "
+                    "cannot redefine",
+                    function_variable->name().ToCString());
       }
     }
   }
 
   // Parse the local function.
   Array& default_parameter_values = Array::Handle(I);
   SequenceNode* statements = Parser::ParseFunc(function,
                                                &default_parameter_values);
 
   // Now that the local function has formal parameters, lookup the signature
@@ skipping 420 matching lines @@
   while (CurrentToken() != Token::kRBRACE) {
     const intptr_t statement_pos = TokenPos();
     AstNode* statement = ParseStatement();
     // Do not add statements with no effect (e.g., LoadLocalNode).
     if ((statement != NULL) && statement->IsLoadLocalNode()) {
       // Skip load local.
       continue;
     }
     if (statement != NULL) {
       if (!dead_code_allowed && abrupt_completing_seen) {
-        ErrorMsg(statement_pos, "dead code after abrupt completing statement");
+        ReportError(statement_pos,
+                    "dead code after abrupt completing statement");
       }
       current_block_->statements->Add(statement);
       abrupt_completing_seen |= IsAbruptCompleting(statement);
     }
   }
 }
 
 
 // Parse nested statement of if, while, for, etc. We automatically generate
 // a sequence of one statement if there are no curly braces.
@@ skipping 78 matching lines @@
   const intptr_t num_expressions = values.length();
   if (num_expressions == 0) {
     return Object::dynamic_class();
   }
   const Instance& first_value = values[0]->literal();
   for (intptr_t i = 0; i < num_expressions; i++) {
     const Instance& val = values[i]->literal();
     const intptr_t val_pos = values[i]->token_pos();
     if (first_value.IsInteger()) {
       if (!val.IsInteger()) {
-        ErrorMsg(val_pos, "expected case expression of type int");
+        ReportError(val_pos, "expected case expression of type int");
       }
       continue;
     }
     if (first_value.IsString()) {
       if (!val.IsString()) {
-        ErrorMsg(val_pos, "expected case expression of type String");
+        ReportError(val_pos, "expected case expression of type String");
       }
       continue;
     }
     if (val.IsDouble()) {
-      ErrorMsg(val_pos, "case expression may not be of type double");
+      ReportError(val_pos, "case expression may not be of type double");
     }
     if (val.clazz() != first_value.clazz()) {
-      ErrorMsg(val_pos, "all case expressions must be of same type");
+      ReportError(val_pos, "all case expressions must be of same type");
     }
     if (i == 0) {
       // The value is of some type other than int, String or double.
       // Check that the type class does not override the == operator.
       // Check this only in the first loop iteration since all values
       // are of the same type, which we check above.
       if (ImplementsEqualOperator(val)) {
-        ErrorMsg(val_pos,
-            "type class of case expression must not implement operator ==");
+        ReportError(val_pos,
+                    "type class of case expression must not "
+                    "implement operator ==");
       }
     }
   }
   if (first_value.IsInteger()) {
     return Type::Handle(I, Type::IntType()).type_class();
   } else if (first_value.IsString()) {
     return Type::Handle(I, Type::StringType()).type_class();
   }
   return first_value.clazz();
 }
 
 
 CaseNode* Parser::ParseCaseClause(LocalVariable* switch_expr_value,
                                   GrowableArray<LiteralNode*>* case_expr_values,
                                   SourceLabel* case_label) {
   TRACE_PARSER("ParseCaseClause");
   bool default_seen = false;
   const intptr_t case_pos = TokenPos();
   // The case expressions node sequence does not own the enclosing scope.
   SequenceNode* case_expressions = new(I) 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");
+        ReportError("default clause must be last case");
       }
       ConsumeToken();  // Keyword case.
       const intptr_t expr_pos = TokenPos();
       AstNode* expr = ParseExpr(kRequireConst, kConsumeCascades);
       ASSERT(expr->IsLiteralNode());
       case_expr_values->Add(expr->AsLiteralNode());
 
       AstNode* switch_expr_load = new(I) LoadLocalNode(
           case_pos, switch_expr_value);
       AstNode* case_comparison = new(I) ComparisonNode(
           expr_pos, Token::kEQ, expr, switch_expr_load);
       case_expressions->Add(case_comparison);
     } else {
       if (default_seen) {
-        ErrorMsg("only one default clause is allowed");
+        ReportError("only one default clause is allowed");
       }
       ConsumeToken();  // Keyword default.
       default_seen = true;
       // The default case always succeeds.
     }
     ExpectToken(Token::kCOLON);
   }
 
   OpenBlock();
   bool abrupt_completing_seen = false;
@@ skipping 86 matching lines @@
       if (case_label == NULL) {
         // Label does not exist yet. Add it to scope of switch statement.
         case_label = new(I) SourceLabel(
             label_pos, *label_name, SourceLabel::kCase);
         current_block_->scope->AddLabel(case_label);
       } else if (case_label->kind() == SourceLabel::kForward) {
         // We have seen a 'continue' with this label name. Resolve
         // the forward reference.
         case_label->ResolveForwardReference();
       } else {
-        ErrorMsg(label_pos, "label '%s' already exists in scope",
-                 label_name->ToCString());
+        ReportError(label_pos, "label '%s' already exists in scope",
+                    label_name->ToCString());
       }
       ASSERT(case_label->kind() == SourceLabel::kCase);
     }
     if (CurrentToken() == Token::kCASE ||
         CurrentToken() == Token::kDEFAULT) {
       if (default_seen) {
-        ErrorMsg("no case clauses allowed after default clause");
+        ReportError("no case clauses allowed after default clause");
       }
       CaseNode* case_clause =
           ParseCaseClause(temp_variable, &case_expr_values, case_label);
       default_seen = case_clause->contains_default();
       current_block_->statements->Add(case_clause);
     } else if (CurrentToken() != Token::kRBRACE) {
-      ErrorMsg("'case' or '}' expected");
+      ReportError("'case' or '}' expected");
     } else if (case_label != NULL) {
-      ErrorMsg("expecting at least one case clause after label");
+      ReportError("expecting at least one case clause after label");
     } else {
       break;
     }
   }
 
   // Check that all expressions in case clauses are of the same class,
   // or implement int, double or String. Patch the type of the temporary
   // variable holding the switch expression to match the type of the
   // case clause constants.
   temp_var_type.set_type_class(
       Class::Handle(I, CheckCaseExpressions(case_expr_values)));
 
   // Check for unresolved label references.
   SourceLabel* unresolved_label =
       current_block_->scope->CheckUnresolvedLabels();
   if (unresolved_label != NULL) {
-    ErrorMsg("unresolved reference to label '%s'",
-             unresolved_label->name().ToCString());
+    ReportError("unresolved reference to label '%s'",
+                unresolved_label->name().ToCString());
   }
 
   SequenceNode* switch_body = CloseBlock();
   ExpectToken(Token::kRBRACE);
   return new(I) SwitchNode(switch_pos, label, switch_body);
 }
 
 
 AstNode* Parser::ParseWhileStatement(String* label_name) {
   TRACE_PARSER("ParseWhileStatement");
@@ skipping 25 matching lines @@
   ExpectSemicolon();
   return new(I) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
 AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
                                      SourceLabel* label) {
   TRACE_PARSER("ParseForInStatement");
   bool is_final = (CurrentToken() == Token::kFINAL);
   if (CurrentToken() == Token::kCONST) {
-    ErrorMsg("Loop variable cannot be 'const'");
+    ReportError("Loop variable cannot be 'const'");
   }
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     const AbstractType& type =
@@ skipping 251 matching lines @@
     exception_param->var = var;
   }
   if (stack_trace_param->name != NULL) {
     LocalVariable* var = new(I) LocalVariable(
         stack_trace_param->token_pos,
         *stack_trace_param->name,
         *stack_trace_param->type);
     var->set_is_final();
     bool added_to_scope = scope->AddVariable(var);
     if (!added_to_scope) {
-      ErrorMsg(stack_trace_param->token_pos,
-               "name '%s' already exists in scope",
-               stack_trace_param->name->ToCString());
-    }
+      ReportError(stack_trace_param->token_pos,
+                  "name '%s' already exists in scope",
+                  stack_trace_param->name->ToCString());
+       }
     stack_trace_param->var = var;
   }
 }
 
 
 SequenceNode* Parser::ParseFinallyBlock() {
   TRACE_PARSER("ParseFinallyBlock");
   OpenBlock();
   ExpectToken(Token::kLBRACE);
   ParseStatementSequence();
@@ skipping 297 matching lines @@
   // Now parse the 'try' block.
   OpenBlock();
   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");
+    ReportError("catch or finally clause expected");
   }
 
   // Now parse the 'catch' blocks if any.
   try_blocks_list_->enter_catch();
   const intptr_t handler_pos = TokenPos();
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(I, GrowableObjectArray::New());
   bool needs_stack_trace = false;
   SequenceNode* catch_handler_list =
       ParseCatchClauses(handler_pos, exception_var, stack_trace_var,
@@ skipping 63 matching lines @@
   const intptr_t jump_pos = TokenPos();
   SourceLabel* target = NULL;
   ConsumeToken();
   if (IsIdentifier()) {
     // Explicit label after break/continue.
     const String& target_name = *CurrentLiteral();
     ConsumeToken();
     // Handle pathological cases first.
     if (label_name != NULL && target_name.Equals(*label_name)) {
       if (jump_kind == Token::kCONTINUE) {
-        ErrorMsg(jump_pos, "'continue' jump to label '%s' is illegal",
-                 target_name.ToCString());
+        ReportError(jump_pos, "'continue' jump to label '%s' is illegal",
+                    target_name.ToCString());
       }
       // L: break L; is a no-op.
       return NULL;
     }
     target = current_block_->scope->LookupLabel(target_name);
     if (target == NULL && jump_kind == Token::kCONTINUE) {
       // Either a reference to a non-existent label, or a forward reference
       // to a case label that we haven't seen yet. If we are inside a switch
       // statement, create a "forward reference" label in the scope of
       // the switch statement.
       LocalScope* switch_scope = current_block_->scope->LookupSwitchScope();
       if (switch_scope != NULL) {
         // We found a switch scope. Enter a forward reference to the label.
         target = new(I) SourceLabel(
             TokenPos(), target_name, SourceLabel::kForward);
         switch_scope->AddLabel(target);
       }
     }
     if (target == NULL) {
-      ErrorMsg(jump_pos, "label '%s' not found", target_name.ToCString());
+      ReportError(jump_pos, "label '%s' not found", target_name.ToCString());
     }
   } else {
     target = current_block_->scope->LookupInnermostLabel(jump_kind);
     if (target == NULL) {
-      ErrorMsg(jump_pos, "'%s' is illegal here", Token::Str(jump_kind));
+      ReportError(jump_pos, "'%s' is illegal here", Token::Str(jump_kind));
     }
   }
   ASSERT(target != NULL);
   if (jump_kind == Token::kCONTINUE) {
     if (target->kind() == SourceLabel::kSwitch) {
-      ErrorMsg(jump_pos, "'continue' jump to switch statement is illegal");
+      ReportError(jump_pos, "'continue' jump to switch statement is illegal");
     } else if (target->kind() == SourceLabel::kStatement) {
-      ErrorMsg(jump_pos, "'continue' jump to label '%s' is illegal",
-               target->name().ToCString());
+      ReportError(jump_pos, "'continue' jump to label '%s' is illegal",
+                  target->name().ToCString());
     }
   }
   if (jump_kind == Token::kBREAK && target->kind() == SourceLabel::kCase) {
-    ErrorMsg(jump_pos, "'break' to case clause label is illegal");
+    ReportError(jump_pos, "'break' to case clause label is illegal");
   }
   if (target->FunctionLevel() != current_block_->scope->function_level()) {
-    ErrorMsg(jump_pos, "'%s' target must be in same function context",
-             Token::Str(jump_kind));
+    ReportError(jump_pos, "'%s' target must be in same function context",
+                Token::Str(jump_kind));
   }
   return new(I) JumpNode(jump_pos, jump_kind, target);
 }
 
 
 AstNode* Parser::ParseStatement() {
   TRACE_PARSER("ParseStatement");
   AstNode* statement = NULL;
   intptr_t label_pos = 0;
   String* label_name = NULL;
@@ skipping 19 matching lines @@
   } else if (token == Token::kSWITCH) {
     statement = ParseSwitchStatement(label_name);
   } else if (token == Token::kTRY) {
     statement = ParseTryStatement(label_name);
   } else if (token == Token::kRETURN) {
     const intptr_t return_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() != Token::kSEMICOLON) {
       if (current_function().IsConstructor() &&
           (current_block_->scope->function_level() == 0)) {
-        ErrorMsg(return_pos, "return of a value not allowed in constructors");
+        ReportError(return_pos,
+                    "return of a value not allowed in constructors");
       }
       AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
       statement = new(I) ReturnNode(statement_pos, expr);
     } else {
       statement = new(I) ReturnNode(statement_pos);
     }
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (token == Token::kIF) {
     statement = ParseIfStatement(label_name);
@@ skipping 29 matching lines @@
     ExpectSemicolon();
   } else if (token == Token::kSEMICOLON) {
     // Empty statement, nothing to do.
     ConsumeToken();
   } else if (token == Token::kRETHROW) {
     // Rethrow of current exception.
     ConsumeToken();
     ExpectSemicolon();
     // Check if it is ok to do a rethrow.
     if ((try_blocks_list_ == NULL) || !try_blocks_list_->inside_catch()) {
-      ErrorMsg(statement_pos, "rethrow of an exception is not valid here");
+      ReportError(statement_pos, "rethrow of an exception is not valid here");
     }
     // The exception and stack trace variables are bound in the block
     // containing the try.
     LocalScope* scope = try_blocks_list_->try_block()->scope->parent();
     ASSERT(scope != NULL);
     LocalVariable* excp_var =
         scope->LocalLookupVariable(Symbols::ExceptionVar());
     ASSERT(excp_var != NULL);
     LocalVariable* trace_var =
         scope->LocalLookupVariable(Symbols::StackTraceVar());
     ASSERT(trace_var != NULL);
     statement = new(I) ThrowNode(
         statement_pos,
         new(I) LoadLocalNode(statement_pos, excp_var),
         new(I) LoadLocalNode(statement_pos, trace_var));
   } else {
     statement = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
-void Parser::ErrorMsg(intptr_t token_pos, const char* format, ...) const {
-  va_list args;
-  va_start(args, format);
-  const Error& error = Error::Handle(I, LanguageError::NewFormattedV(
-      Error::Handle(I), script_, token_pos,
-      LanguageError::kError, Heap::kNew, format, args));
-  va_end(args);
-  I->long_jump_base()->Jump(1, error);
+void Parser::ReportError(const Error& error) {
+  Report::LongJump(error);
   UNREACHABLE();
 }
 
 
-void Parser::ErrorMsg(const char* format, ...) {
+void Parser::ReportErrors(const Error& prev_error,
+                          const Script& script, intptr_t token_pos,
+                          const char* format, ...) {
   va_list args;
   va_start(args, format);
-  const Error& error = Error::Handle(I, LanguageError::NewFormattedV(
-      Error::Handle(I), script_, TokenPos(),
-      LanguageError::kError, Heap::kNew, format, args));
+  Report::LongJumpV(prev_error, script, token_pos, format, args);
   va_end(args);
-  I->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
-void Parser::ErrorMsg(const Error& error) {
-  Isolate::Current()->long_jump_base()->Jump(1, error);
+void Parser::ReportError(intptr_t token_pos, const char* format, ...) const {
+  va_list args;
+  va_start(args, format);
+  Report::MessageV(Report::kError, script_, token_pos, format, args);
+  va_end(args);
   UNREACHABLE();
 }
 
 
-void Parser::AppendErrorMsg(
-      const Error& prev_error, intptr_t token_pos, const char* format, ...) {
+void Parser::ReportError(const char* format, ...) const {
   va_list args;
   va_start(args, format);
-  const Error& error = Error::Handle(I, LanguageError::NewFormattedV(
-      prev_error, script_, token_pos,
-      LanguageError::kError, Heap::kNew,
-      format, args));
+  Report::MessageV(Report::kError, script_, TokenPos(), format, args);
   va_end(args);
-  I->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
-void Parser::Warning(intptr_t token_pos, const char* format, ...) {
-  if (FLAG_silent_warnings) return;
+void Parser::ReportWarning(intptr_t token_pos, const char* format, ...) const {
   va_list args;
   va_start(args, format);
-  const Error& error = Error::Handle(I, LanguageError::NewFormattedV(
-      Error::Handle(I), script_, token_pos,
-      LanguageError::kWarning, Heap::kNew,
-      format, args));
+  Report::MessageV(Report::kWarning, script_, token_pos, format, args);
   va_end(args);
-  if (FLAG_warning_as_error) {
-    I->long_jump_base()->Jump(1, error);
-    UNREACHABLE();
-  } else {
-    OS::Print("%s", error.ToErrorCString());
-    va_start(args, format);
-    Exceptions::TraceJSWarningV(script_, token_pos, format, args);
-    va_end(args);
-  }
 }
 
 
-void Parser::Warning(const char* format, ...) {
-  if (FLAG_silent_warnings) return;
+void Parser::ReportWarning(const char* format, ...) const {
   va_list args;
   va_start(args, format);
-  const Error& error = Error::Handle(I, LanguageError::NewFormattedV(
-      Error::Handle(I), script_, TokenPos(),
-      LanguageError::kWarning, Heap::kNew,
-      format, args));
+  Report::MessageV(Report::kWarning, script_, TokenPos(), format, args);
   va_end(args);
-  if (FLAG_warning_as_error) {
-    I->long_jump_base()->Jump(1, error);
-    UNREACHABLE();
-  } else {
-    OS::Print("%s", error.ToErrorCString());
-    va_start(args, format);
-    Exceptions::TraceJSWarningV(script_, TokenPos(), format, args);
-    va_end(args);
-  }
-}
-
-
-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);
+      ReportError("%s", msg);
     } else {
-      ErrorMsg("'%s' expected", Token::Str(token_expected));
+      ReportError("'%s' expected", Token::Str(token_expected));
     }
   }
 }
 
 
 void Parser::ExpectToken(Token::Kind token_expected) {
   if (CurrentToken() != token_expected) {
-    ErrorMsg("'%s' expected", Token::Str(token_expected));
+    ReportError("'%s' expected", Token::Str(token_expected));
   }
   ConsumeToken();
 }
 
 
 void Parser::ExpectSemicolon() {
   if (CurrentToken() != Token::kSEMICOLON) {
-    ErrorMsg("semicolon expected");
+    ReportError("semicolon expected");
   }
   ConsumeToken();
 }
 
 
 void Parser::UnexpectedToken() {
-  ErrorMsg("unexpected token '%s'",
-           CurrentToken() == Token::kIDENT ?
-               CurrentLiteral()->ToCString() : Token::Str(CurrentToken()));
+  ReportError("unexpected token '%s'",
+              CurrentToken() == Token::kIDENT ?
+                  CurrentLiteral()->ToCString() : Token::Str(CurrentToken()));
 }
 
 
 String* Parser::ExpectUserDefinedTypeIdentifier(const char* msg) {
   if (CurrentToken() != Token::kIDENT) {
-    ErrorMsg("%s", msg);
+    ReportError("%s", msg);
   }
   String* ident = CurrentLiteral();
   if (ident->Equals("dynamic")) {
-    ErrorMsg("%s", msg);
+    ReportError("%s", msg);
   }
   ConsumeToken();
   return ident;
 }
 
 
 // Check whether current token is an identifier or a built-in identifier.
 String* Parser::ExpectIdentifier(const char* msg) {
   if (!IsIdentifier()) {
-    ErrorMsg("%s", msg);
+    ReportError("%s", msg);
   }
   String* ident = CurrentLiteral();
   ConsumeToken();
   return ident;
 }
 
 
 bool Parser::IsLiteral(const char* literal) {
   return IsIdentifier() && CurrentLiteral()->Equals(literal);
 }
@@ skipping 132 matching lines @@
                         arguments);
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= Token::Precedence(Token::kOR));
   AstNode* left_operand = ParseUnaryExpr();
   if (left_operand->IsPrimaryNode() &&
       (left_operand->AsPrimaryNode()->IsSuper())) {
-    ErrorMsg(left_operand->token_pos(), "illegal use of 'super'");
+    ReportError(left_operand->token_pos(), "illegal use of 'super'");
   }
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
     while (Token::Precedence(CurrentToken()) == current_preced) {
       Token::Kind op_kind = CurrentToken();
       const intptr_t op_pos = TokenPos();
       ConsumeToken();
       AstNode* right_operand = NULL;
       if ((op_kind != Token::kIS) && (op_kind != Token::kAS)) {
         right_operand = ParseBinaryExpr(current_preced + 1);
@@ skipping 176 matching lines @@
       return new(I) BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
     case Token::kASSIGN_SHL:
       return new(I) BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
     case Token::kASSIGN_OR:
       return new(I) BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
     case Token::kASSIGN_AND:
       return new(I) BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
     case Token::kASSIGN_XOR:
       return new(I) BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
     default:
-      ErrorMsg(op_pos, "internal error: ExpandAssignableOp '%s' unimplemented",
-          Token::Name(assignment_op));
+      ReportError(op_pos,
+                  "internal error: ExpandAssignableOp '%s' unimplemented",
+                  Token::Name(assignment_op));
       UNIMPLEMENTED();
       return NULL;
   }
 }
 
 
 // Evaluates the value of the compile time constant expression
 // and returns a literal node for the value.
 AstNode* Parser::FoldConstExpr(intptr_t expr_pos, AstNode* expr) {
   if (expr->IsLiteralNode()) {
     return expr;
   }
   if (expr->EvalConstExpr() == NULL) {
-    ErrorMsg(expr_pos, "expression is not a valid compile-time constant");
+    ReportError(expr_pos, "expression is not a valid compile-time constant");
   }
   return new(I) LiteralNode(
       expr_pos, EvaluateConstExpr(expr_pos, expr));
 }
 
 
 LetNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
   AstNode* node = *expr;
   intptr_t token_pos = node->token_pos();
   LetNode* result = new(I) LetNode(token_pos);
@@ skipping 66 matching lines @@
     } else if (original->IsLoadStaticFieldNode()) {
       name = original->AsLoadStaticFieldNode()->field().name();
       target_cls = &Class::Handle(I,
           original->AsLoadStaticFieldNode()->field().owner());
     } else if ((left_ident != NULL) &&
                (original->IsLiteralNode() ||
                 original->IsLoadLocalNode())) {
       name = left_ident->raw();
     }
     if (name.IsNull()) {
-      ErrorMsg(left_pos, "expression is not assignable");
+      ReportError(left_pos, "expression is not assignable");
     }
     result = ThrowNoSuchMethodError(
         original->token_pos(),
         *target_cls,
         String::Handle(I, Field::SetterName(name)),
         NULL,  // No arguments.
         InvocationMirror::kStatic,
         original->IsLoadLocalNode() ?
             InvocationMirror::kLocalVar : InvocationMirror::kSetter,
         NULL);  // No existing function.
@@ skipping 16 matching lines @@
   while (CurrentToken() == Token::kCASCADE) {
     cascade_pos = TokenPos();
     LoadLocalNode* load_cascade_receiver =
         new(I) LoadLocalNode(cascade_pos, cascade_receiver_var);
     if (Token::IsIdentifier(LookaheadToken(1))) {
       // Replace .. with . for ParseSelectors().
       token_kind_ = Token::kPERIOD;
     } else if (LookaheadToken(1) == Token::kLBRACK) {
       ConsumeToken();
     } else {
-      ErrorMsg("identifier or [ expected after ..");
+      ReportError("identifier or [ expected after ..");
     }
     String* expr_ident =
         Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
     const intptr_t expr_pos = TokenPos();
     expr = ParseSelectors(load_cascade_receiver, true);
 
     // Assignments after a cascade are part of the cascade. The
     // assigned expression must not contain cascades.
     if (Token::IsAssignmentOperator(CurrentToken())) {
       Token::Kind assignment_op = CurrentToken();
@@ skipping 47 matching lines @@
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const intptr_t expr_pos = TokenPos();
 
   if (CurrentToken() == Token::kTHROW) {
     ConsumeToken();
     if (CurrentToken() == Token::kSEMICOLON) {
-      ErrorMsg("expression expected after throw");
+      ReportError("expression expected after throw");
     }
     AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
     return new(I) ThrowNode(expr_pos, expr, NULL);
   }
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if ((CurrentToken() == Token::kCASCADE) && consume_cascades) {
       return ParseCascades(expr);
     }
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
     } else {
       expr = LiteralIfStaticConst(I, expr);
     }
     return expr;
   }
   // Assignment expressions.
   if (!IsLegalAssignableSyntax(expr, TokenPos())) {
-    ErrorMsg(expr_pos, "expression is not assignable");
+    ReportError(expr_pos, "expression is not assignable");
   }
   const Token::Kind assignment_op = CurrentToken();
   const intptr_t assignment_pos = TokenPos();
   ConsumeToken();
   const intptr_t right_expr_pos = TokenPos();
   if (require_compiletime_const && (assignment_op != Token::kASSIGN)) {
-    ErrorMsg(right_expr_pos, "expression is not a valid compile-time constant");
+    ReportError(right_expr_pos,
+                "expression is not a valid compile-time constant");
   }
   AstNode* right_expr = ParseExpr(require_compiletime_const, consume_cascades);
   if (assignment_op != Token::kASSIGN) {
     // Compound assignment: store inputs with side effects into temp. locals.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     AstNode* assigned_value =
         ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
     AstNode* assign_expr =
         CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos);
     ASSERT(assign_expr != NULL);
     let_expr->AddNode(assign_expr);
     return let_expr;
   } else {
     AstNode* assigned_value = LiteralIfStaticConst(I, right_expr);
     AstNode* assign_expr =
         CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos);
     ASSERT(assign_expr != NULL);
     return assign_expr;
   }
 }
 
 
 LiteralNode* Parser::ParseConstExpr() {
   TRACE_PARSER("ParseConstExpr");
   intptr_t expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kRequireConst, kNoCascades);
   if (!expr->IsLiteralNode()) {
-    ErrorMsg(expr_pos, "expression must be a compile-time constant");
+    ReportError(expr_pos, "expression must be a compile-time constant");
   }
   return expr->AsLiteralNode();
 }
 
 
 AstNode* Parser::ParseConditionalExpr() {
   TRACE_PARSER("ParseConditionalExpr");
   const intptr_t expr_pos = TokenPos();
   AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kOR));
   if (CurrentToken() == Token::kCONDITIONAL) {
@@ skipping 25 matching lines @@
       expr = UnaryOpNode::UnaryOpOrLiteral(op_pos, unary_op, expr);
     }
   } else if (IsIncrementOperator(CurrentToken())) {
     Token::Kind incr_op = CurrentToken();
     ConsumeToken();
     String* expr_ident =
         Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
     const intptr_t expr_pos = TokenPos();
     expr = ParseUnaryExpr();
     if (!IsLegalAssignableSyntax(expr, TokenPos())) {
-      ErrorMsg(expr_pos, "expression is not assignable");
+      ReportError(expr_pos, "expression is not assignable");
     }
     // Is prefix.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new(I) BinaryOpNode(
         op_pos,
         binary_op,
         expr,
         new(I) LiteralNode(op_pos, Smi::ZoneHandle(I, Smi::New(1))));
@@ skipping 31 matching lines @@
       ConsumeToken();
       if (IsIdentifier() && (LookaheadToken(1) == Token::kCOLON)) {
         named_argument_seen = true;
         // The canonicalization of the arguments descriptor array built in
         // the code generator requires that the names are symbols, i.e.
         // canonicalized strings.
         ASSERT(CurrentLiteral()->IsSymbol());
         for (int i = 0; i < names.Length(); i++) {
           arg_name ^= names.At(i);
           if (CurrentLiteral()->Equals(arg_name)) {
-            ErrorMsg("duplicate named argument");
+            ReportError("duplicate named argument");
           }
         }
         names.Add(*CurrentLiteral());
         ConsumeToken();  // ident.
         ConsumeToken();  // colon.
       } else if (named_argument_seen) {
-        ErrorMsg("named argument expected");
+        ReportError("named argument expected");
       }
       arguments->Add(ParseExpr(require_const, kConsumeCascades));
     } while (CurrentToken() == Token::kCOMMA);
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
   SetAllowFunctionLiterals(saved_mode);
   if (named_argument_seen) {
     arguments->set_names(Array::Handle(I, Array::MakeArray(names)));
@@ skipping 209 matching lines @@
   if (func.is_static()) {
     // Static function access.
     ClosureNode* closure =
         CreateImplicitClosureNode(func, primary->token_pos(), NULL);
     closure->set_is_deferred(primary->is_deferred_reference());
     return closure;
   } else {
     // Instance function access.
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
-      ErrorMsg(primary->token_pos(),
-               "cannot access instance method '%s' from static method",
-               funcname.ToCString());
+      ReportError(primary->token_pos(),
+                  "cannot access instance method '%s' from static method",
+                  funcname.ToCString());
     }
     AstNode* receiver = LoadReceiver(primary->token_pos());
     return CallGetter(primary->token_pos(), receiver, funcname);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const intptr_t primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
             const String& name = String::ZoneHandle(I,
                 TypeParameter::Cast(primary_node->primary()).name());
-            ErrorMsg(primary_pos,
-                     "cannot access type parameter '%s' from static function",
-                     name.ToCString());
+            ReportError(primary_pos,
+                        "cannot access type parameter '%s' "
+                        "from static function",
+                        name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle(I);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
@@ skipping 62 matching lines @@
                         primary_pos, Heap::kOld));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           array = new(I) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
             const String& name = String::ZoneHandle(I,
                 TypeParameter::Cast(primary_node->primary()).name());
-            ErrorMsg(primary_pos,
-                     "cannot access type parameter '%s' from static function",
-                     name.ToCString());
+            ReportError(primary_pos,
+                        "cannot access type parameter '%s' "
+                        "from static function",
+                        name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle(I);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
@@ skipping 12 matching lines @@
         if (primary_node->primary().IsFunction()) {
           const Function& func = Function::Cast(primary_node->primary());
           const String& func_name = String::ZoneHandle(I, func.name());
           if (func.is_static()) {
             // Parse static function call.
             Class& cls = Class::Handle(I, func.Owner());
             selector = ParseStaticCall(cls, func_name, primary_pos);
           } else {
             // Dynamic function call on implicit "this" parameter.
             if (current_function().is_static()) {
-              ErrorMsg(primary_pos,
-                       "cannot access instance method '%s' "
-                       "from static function",
-                       func_name.ToCString());
+              ReportError(primary_pos,
+                          "cannot access instance method '%s' "
+                          "from static function",
+                          func_name.ToCString());
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name);
           }
         } else if (primary_node->primary().IsString()) {
           // Primary is an unresolved name.
           if (primary_node->IsSuper()) {
-            ErrorMsg(primary_pos, "illegal use of super");
+            ReportError(primary_pos, "illegal use of super");
           }
           String& name = String::CheckedZoneHandle(
               primary_node->primary().raw());
           if (current_function().is_static()) {
             selector = ThrowNoSuchMethodError(primary_pos,
                                               current_class(),
                                               name,
                                               NULL,  // No arguments.
                                               InvocationMirror::kStatic,
                                               InvocationMirror::kMethod,
                                               NULL);  // No existing function.
           } else {
             // Treat as call to unresolved (instance) method.
             selector = ParseInstanceCall(LoadReceiver(primary_pos), name);
           }
         } else if (primary_node->primary().IsTypeParameter()) {
           const String& name = String::ZoneHandle(I,
               TypeParameter::Cast(primary_node->primary()).name());
           if (current_function().is_static()) {
             // Treat as this.T(), because T is in scope.
-            ErrorMsg(primary_pos,
-                     "cannot access type parameter '%s' from static function",
-                     name.ToCString());
+            ReportError(primary_pos,
+                        "cannot access type parameter '%s' "
+                        "from static function",
+                        name.ToCString());
           } else {
             // Treat as call to unresolved (instance) method.
             selector = ParseInstanceCall(LoadReceiver(primary_pos), name);
           }
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(I, Type::New(
               type_class, TypeArguments::Handle(I), primary_pos));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
@@ skipping 23 matching lines @@
               type_class, TypeArguments::Handle(I), primary_pos));
           type = ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           left = new(I) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
             const String& name = String::ZoneHandle(I,
                 TypeParameter::Cast(primary_node->primary()).name());
-            ErrorMsg(primary_pos,
-                     "cannot access type parameter '%s' from static function",
-                     name.ToCString());
+            ReportError(primary_pos,
+                        "cannot access type parameter '%s' "
+                        "from static function",
+                        name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle(I);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
@@ skipping 19 matching lines @@
 AstNode* Parser::ParsePostfixExpr() {
   TRACE_PARSER("ParsePostfixExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const intptr_t expr_pos = TokenPos();
   AstNode* expr = ParsePrimary();
   expr = ParseSelectors(expr, false);
   if (IsIncrementOperator(CurrentToken())) {
     TRACE_PARSER("IncrementOperator");
     if (!IsLegalAssignableSyntax(expr, TokenPos())) {
-      ErrorMsg(expr_pos, "expression is not assignable");
+      ReportError(expr_pos, "expression is not assignable");
     }
     Token::Kind incr_op = CurrentToken();
     ConsumeToken();
     // Not prefix.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     LocalVariable* temp = let_expr->AddInitializer(expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new(I) BinaryOpNode(
         expr_pos,
@@ skipping 120 matching lines @@
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(ident, kTestOnly);
 }
 
 
 void Parser::CheckInstanceFieldAccess(intptr_t field_pos,
                                       const String& field_name) {
   // Fields are not accessible from a static function, except from a
   // constructor, which is considered as non-static by the compiler.
   if (current_function().is_static()) {
-    ErrorMsg(field_pos,
-             "cannot access instance field '%s' from a static function",
-             field_name.ToCString());
+    ReportError(field_pos,
+                "cannot access instance field '%s' from a static function",
+                field_name.ToCString());
   }
 }
 
 
 bool Parser::ParsingStaticMember() const {
   if (is_top_level_) {
     return (current_member_ != NULL) &&
            current_member_->has_static && !current_member_->has_factory;
   }
   ASSERT(!current_function().IsNull());
@@ skipping 31 matching lines @@
 
 RawInstance* Parser::TryCanonicalize(const Instance& instance,
                                      intptr_t token_pos) {
   if (instance.IsNull()) {
     return instance.raw();
   }
   const char* error_str = NULL;
   Instance& result =
       Instance::Handle(I, instance.CheckAndCanonicalize(&error_str));
   if (result.IsNull()) {
-    ErrorMsg(token_pos, "Invalid const object %s", error_str);
+    ReportError(token_pos, "Invalid const object %s", error_str);
   }
   return result.raw();
 }
 
 
 // If the field is already initialized, return no ast (NULL).
 // Otherwise, if the field is constant, initialize the field and return no ast.
 // If the field is not initialized and not const, return the ast for the getter.
 AstNode* Parser::RunStaticFieldInitializer(const Field& field,
                                            intptr_t field_ref_pos) {
   ASSERT(field.is_static());
   const Class& field_owner = Class::ZoneHandle(I, field.owner());
   const String& field_name = String::ZoneHandle(I, field.name());
   const String& getter_name = String::Handle(I, Field::GetterName(field_name));
   const Function& getter = Function::Handle(I,
       field_owner.LookupStaticFunction(getter_name));
   const Instance& value = Instance::Handle(I, field.value());
   if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
-      ErrorMsg("circular dependency while initializing static field '%s'",
-               field_name.ToCString());
+      ReportError("circular dependency while initializing static field '%s'",
+                  field_name.ToCString());
     } else {
       // The implicit static getter will throw the exception if necessary.
       return new(I) StaticGetterNode(
           field_ref_pos, NULL, false, field_owner, field_name);
     }
   } else if (value.raw() == Object::sentinel().raw()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
@@ skipping 14 matching lines @@
       if (const_value.IsError()) {
         const Error& error = Error::Cast(const_value);
         if (error.IsUnhandledException()) {
           // An exception may not occur in every parse attempt, i.e., the
           // generated AST is not deterministic. Therefore mark the function as
           // not optimizable.
           current_function().SetIsOptimizable(false);
           field.set_value(Object::null_instance());
           // It is a compile-time error if evaluation of a compile-time constant
           // would raise an exception.
-          AppendErrorMsg(error, field_ref_pos,
-                         "error initializing const field '%s'",
-                         String::Handle(I, field.name()).ToCString());
+          const String& field_name = String::Handle(I, field.name());
+          ReportErrors(error,
+                       script_, field_ref_pos,
+                       "error initializing const field '%s'",
+                       field_name.ToCString());
         } else {
-          I->long_jump_base()->Jump(1, error);
-          UNREACHABLE();
+          ReportError(error);
         }
+        UNREACHABLE();
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
       Instance& instance = Instance::Handle(I);
       instance ^= const_value.raw();
       instance = TryCanonicalize(instance, field_ref_pos);
       field.set_value(instance);
       return NULL;   // Constant
     } else {
       return new(I) StaticGetterNode(
           field_ref_pos, NULL, false, field_owner, field_name);
@@ skipping 17 matching lines @@
   // Factories have one extra argument: the type arguments.
   // Constructors have 2 extra arguments: rcvr and construction phase.
   const int kNumExtraArgs = constructor.IsFactory() ? 1 : 2;
   const int num_arguments = arguments->length() + kNumExtraArgs;
   const Array& arg_values = Array::Handle(I, Array::New(num_arguments));
   Instance& instance = Instance::Handle(I);
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class, Heap::kOld);
     if (!type_arguments.IsNull()) {
       if (!type_arguments.IsInstantiated()) {
-        ErrorMsg("type must be constant in const constructor");
+        ReportError("type must be constant in const constructor");
       }
       instance.SetTypeArguments(
           TypeArguments::Handle(I, type_arguments.Canonicalize()));
     }
     arg_values.SetAt(0, instance);
     arg_values.SetAt(1, Smi::Handle(I, Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Prepend type_arguments to list of arguments to factory.
     ASSERT(type_arguments.IsZoneHandle());
     arg_values.SetAt(0, type_arguments);
@@ skipping 338 matching lines @@
                                           InvocationMirror::kField,
                                           NULL);  // No existing function.
       } else {
         // Treat as call to unresolved instance field.
         resolved = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
     } else if (primary->primary().IsFunction()) {
       if (allow_closure_names) {
         resolved = LoadClosure(primary);
       } else {
-        ErrorMsg(ident_pos, "illegal reference to method '%s'",
-                 ident.ToCString());
+        ReportError(ident_pos, "illegal reference to method '%s'",
+                    ident.ToCString());
       }
     } else if (primary->primary().IsClass()) {
       const Class& type_class = Class::Cast(primary->primary());
       AbstractType& type = Type::ZoneHandle(I,
           Type::New(type_class, TypeArguments::Handle(I), primary_pos));
       type ^= ClassFinalizer::FinalizeType(
           current_class(), type, ClassFinalizer::kCanonicalize);
       // Type may be malbounded, but not malformed.
       ASSERT(!type.IsMalformed());
       resolved = new(I) TypeNode(primary_pos, type);
@@ skipping 78 matching lines @@
     intptr_t pos, const Function& constructor,
     const TypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
     const Class& constructor_class = Class::Handle(I, constructor.Owner());
     ASSERT(!constructor_class.IsNull());
     ASSERT(constructor_class.is_finalized());
     ASSERT(type_arguments.IsCanonical());
     // Do not report the expected vs. actual number of type arguments, because
     // the type argument vector is flattened and raw types are allowed.
     if (type_arguments.Length() != constructor_class.NumTypeArguments()) {
-      ErrorMsg(pos, "wrong number of type arguments passed to constructor");
+      ReportError(pos, "wrong number of type arguments passed to constructor");
     }
   }
 }
 
 
 // Parse "[" [ expr { "," expr } ["," ] "]".
 // Note: if the list literal is empty and the brackets have no whitespace
 // between them, the scanner recognizes the opening and closing bracket
 // as one token of type Token::kINDEX.
 AstNode* Parser::ParseListLiteral(intptr_t type_pos,
@@ skipping 14 matching lines @@
   if (!list_type_arguments.IsNull()) {
     ASSERT(list_type_arguments.Length() > 0);
     // List literals take a single type argument.
     if (list_type_arguments.Length() == 1) {
       element_type = list_type_arguments.TypeAt(0);
       ASSERT(!element_type.IsMalformed());  // Would be mapped to dynamic.
       ASSERT(!element_type.IsMalbounded());  // No declared bound in List.
       if (element_type.IsDynamicType()) {
         list_type_arguments = TypeArguments::null();
       } else if (is_const && !element_type.IsInstantiated()) {
-        ErrorMsg(type_pos,
-                 "the type argument of a constant list literal cannot include "
-                 "a type variable");
+        ReportError(type_pos,
+                    "the type argument of a constant list literal cannot "
+                    "include a type variable");
       }
     } else {
       if (FLAG_error_on_bad_type) {
-        ErrorMsg(type_pos,
-                 "a list literal takes one type argument specifying "
-                 "the element type");
+        ReportError(type_pos,
+                    "a list literal takes one type argument specifying "
+                    "the element type");
       }
       // Ignore type arguments.
       list_type_arguments = TypeArguments::null();
     }
   }
   ASSERT(list_type_arguments.IsNull() || (list_type_arguments.Length() == 1));
   const Class& array_class = Class::Handle(I, I->object_store()->array_class());
   Type& type = Type::ZoneHandle(I,
       Type::New(array_class, list_type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
@@ skipping 11 matching lines @@
           !element_type.IsDynamicType()) {
         element = new(I) AssignableNode(element_pos,
                                         element,
                                         element_type,
                                         Symbols::ListLiteralElement());
       }
       element_list.Add(element);
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
       } else if (CurrentToken() != Token::kRBRACK) {
-        ErrorMsg("comma or ']' expected");
+        ReportError("comma or ']' expected");
       }
     }
     ExpectToken(Token::kRBRACK);
     SetAllowFunctionLiterals(saved_mode);
   }
 
   if (is_const) {
     // Allocate and initialize the const list at compile time.
     Array& const_list =
         Array::ZoneHandle(I, Array::New(element_list.length(), Heap::kOld));
     const_list.SetTypeArguments(
         TypeArguments::Handle(I, list_type_arguments.Canonicalize()));
     Error& malformed_error = Error::Handle(I);
     for (int i = 0; i < element_list.length(); i++) {
       AstNode* elem = element_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(elem->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (FLAG_enable_type_checks &&
           !element_type.IsDynamicType() &&
           (!elem->AsLiteralNode()->literal().IsNull() &&
            !elem->AsLiteralNode()->literal().IsInstanceOf(
                element_type,
                TypeArguments::Handle(I),
                &malformed_error))) {
         // If the failure is due to a malformed type error, display it instead.
         if (!malformed_error.IsNull()) {
-          ErrorMsg(malformed_error);
+          ReportError(malformed_error);
         } else {
-          ErrorMsg(elem->AsLiteralNode()->token_pos(),
-                   "list literal element at index %d must be "
-                   "a constant of type '%s'",
-                   i,
-                   String::Handle(I,
-                       element_type.UserVisibleName()).ToCString());
+          ReportError(elem->AsLiteralNode()->token_pos(),
+                      "list literal element at index %d must be "
+                      "a constant of type '%s'",
+                      i,
+                      String::Handle(I,
+                          element_type.UserVisibleName()).ToCString());
         }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= TryCanonicalize(const_list, literal_pos);
     const_list.MakeImmutable();
     return new(I) LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
     const Class& factory_class =
@@ skipping 103 matching lines @@
     if (map_type_arguments.Length() == 2) {
       key_type = map_type_arguments.TypeAt(0);
       value_type = map_type_arguments.TypeAt(1);
       // Malformed type arguments are mapped to dynamic.
       ASSERT(!key_type.IsMalformed() && !value_type.IsMalformed());
       // No declared bounds in Map.
       ASSERT(!key_type.IsMalbounded() && !value_type.IsMalbounded());
       if (key_type.IsDynamicType() && value_type.IsDynamicType()) {
         map_type_arguments = TypeArguments::null();
       } else if (is_const && !type_arguments.IsInstantiated()) {
-        ErrorMsg(type_pos,
-                 "the type arguments of a constant map literal cannot include "
-                 "a type variable");
+        ReportError(type_pos,
+                    "the type arguments of a constant map literal cannot "
+                    "include a type variable");
       }
     } else {
       if (FLAG_error_on_bad_type) {
-        ErrorMsg(type_pos,
-                 "a map literal takes two type arguments specifying "
-                 "the key type and the value type");
+        ReportError(type_pos,
+                    "a map literal takes two type arguments specifying "
+                    "the key type and the value type");
       }
       // Ignore type arguments.
       map_type_arguments = TypeArguments::null();
     }
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
   GrowableArray<AstNode*> kv_pairs_list;
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   while (CurrentToken() != Token::kRBRACE) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const intptr_t key_pos = TokenPos();
     AstNode* key = ParseExpr(is_const, kConsumeCascades);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !key_type.IsDynamicType()) {
       key = new(I) AssignableNode(
           key_pos, key, key_type, Symbols::ListLiteralElement());
     }
     if (is_const) {
       ASSERT(key->IsLiteralNode());
       const Instance& key_value = key->AsLiteralNode()->literal();
       if (key_value.IsDouble()) {
-        ErrorMsg(key_pos, "key value must not be of type double");
+        ReportError(key_pos, "key value must not be of type double");
       }
       if (!key_value.IsInteger() &&
           !key_value.IsString() &&
           ImplementsEqualOperator(key_value)) {
-        ErrorMsg(key_pos, "key value must not implement operator ==");
+        ReportError(key_pos, "key value must not implement operator ==");
       }
     }
     ExpectToken(Token::kCOLON);
     const intptr_t value_pos = TokenPos();
     AstNode* value = ParseExpr(is_const, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !value_type.IsDynamicType()) {
       value = new(I) AssignableNode(
           value_pos, value, value_type, Symbols::ListLiteralElement());
     }
     AddKeyValuePair(&kv_pairs_list, is_const, key, value);
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() != Token::kRBRACE) {
-      ErrorMsg("comma or '}' expected");
+      ReportError("comma or '}' expected");
     }
   }
   ASSERT(kv_pairs_list.length() % 2 == 0);
   ExpectToken(Token::kRBRACE);
 
   if (is_const) {
     // Create the key-value pair array, canonicalize it and then create
     // the immutable map object with it. This all happens at compile time.
     // The resulting immutable map object is returned as a literal.
 
@@ skipping 16 matching lines @@
           arg_type = value_type.raw();
         }
         if (!arg_type.IsDynamicType() &&
             (!arg->AsLiteralNode()->literal().IsNull() &&
              !arg->AsLiteralNode()->literal().IsInstanceOf(
                  arg_type,
                  Object::null_type_arguments(),
                  &malformed_error))) {
           // If the failure is due to a malformed type error, display it.
           if (!malformed_error.IsNull()) {
-            ErrorMsg(malformed_error);
+            ReportError(malformed_error);
           } else {
-            ErrorMsg(arg->AsLiteralNode()->token_pos(),
-                     "map literal %s at index %d must be "
-                     "a constant of type '%s'",
-                     ((i % 2) == 0) ? "key" : "value",
-                     i >> 1,
-                     String::Handle(I,
-                                    arg_type.UserVisibleName()).ToCString());
+            ReportError(arg->AsLiteralNode()->token_pos(),
+                        "map literal %s at index %d must be "
+                        "a constant of type '%s'",
+                        ((i % 2) == 0) ? "key" : "value",
+                        i >> 1,
+                        String::Handle(I,
+                                       arg_type.UserVisibleName()).ToCString());
           }
         }
       }
       key_value_array.SetAt(i, arg->AsLiteralNode()->literal());
     }
     key_value_array ^= TryCanonicalize(key_value_array, TokenPos());
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     const Class& immutable_map_class = Class::Handle(I,
         Library::LookupCoreClass(Symbols::ImmutableMap()));
     ASSERT(!immutable_map_class.IsNull());
     // If the immutable map class extends other parameterized classes, we need
     // to adjust the type argument vector. This is currently not the case.
     ASSERT(immutable_map_class.NumTypeArguments() == 2);
     ArgumentListNode* constr_args = new(I) ArgumentListNode(TokenPos());
     constr_args->Add(new(I) LiteralNode(literal_pos, key_value_array));
     const Function& map_constr =
         Function::ZoneHandle(I, immutable_map_class.LookupConstructor(
             Library::PrivateCoreLibName(Symbols::ImmutableMapConstructor())));
     ASSERT(!map_constr.IsNull());
     const Object& constructor_result = Object::Handle(I,
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
     if (constructor_result.IsUnhandledException()) {
-      AppendErrorMsg(Error::Cast(constructor_result),
-                     literal_pos,
-                     "error executing const Map constructor");
+      ReportErrors(Error::Cast(constructor_result),
+                   script_, literal_pos,
+                   "error executing const Map constructor");
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       return new(I) LiteralNode(
           literal_pos, Instance::ZoneHandle(I, const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
     const Class& factory_class =
         Class::Handle(I, Library::LookupCoreClass(Symbols::Map()));
     ASSERT(!factory_class.IsNull());
@@ skipping 53 matching lines @@
   // them here.
   // Map and List interfaces do not declare bounds on their type parameters, so
   // we will not see malbounded type arguments here.
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
     primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
-    ErrorMsg("unexpected token %s", Token::Str(CurrentToken()));
+    ReportError("unexpected token %s", Token::Str(CurrentToken()));
   }
   return primary;
 }
 
 
 AstNode* Parser::ParseSymbolLiteral() {
   ASSERT(CurrentToken() == Token::kHASH);
   ConsumeToken();
   intptr_t symbol_pos = TokenPos();
   String& symbol = String::Handle(I);
   if (IsIdentifier()) {
     symbol = CurrentLiteral()->raw();
     ConsumeToken();
     while (CurrentToken() == Token::kPERIOD) {
       symbol = String::Concat(symbol, Symbols::Dot());
       ConsumeToken();
       symbol = String::Concat(symbol,
                               *ExpectIdentifier("identifier expected"));
     }
   } else if (Token::CanBeOverloaded(CurrentToken())) {
     symbol = String::New(Token::Str(CurrentToken()));
     ConsumeToken();
   } else {
-    ErrorMsg("illegal symbol literal");
+    ReportError("illegal symbol literal");
   }
   // Lookup class Symbol from internal library and call the
   // constructor to create a symbol instance.
   const Library& lib = Library::Handle(I, Library::InternalLibrary());
   const Class& symbol_class = Class::Handle(I,
                                             lib.LookupClass(Symbols::Symbol()));
   ASSERT(!symbol_class.IsNull());
   ArgumentListNode* constr_args = new(I) ArgumentListNode(symbol_pos);
   constr_args->Add(new(I) LiteralNode(
       symbol_pos, String::ZoneHandle(I, Symbols::New(symbol))));
   const Function& constr = Function::ZoneHandle(I,
       symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!constr.IsNull());
   const Object& result = Object::Handle(I,
       EvaluateConstConstructorCall(symbol_class,
                                    TypeArguments::Handle(I),
                                    constr,
                                    constr_args));
   if (result.IsUnhandledException()) {
-    AppendErrorMsg(Error::Cast(result),
-                   symbol_pos,
-                   "error executing const Symbol constructor");
+    ReportErrors(Error::Cast(result),
+                 script_, symbol_pos,
+                 "error executing const Symbol constructor");
   }
   const Instance& instance = Instance::Cast(result);
   return new(I) LiteralNode(symbol_pos,
                             Instance::ZoneHandle(I, instance.raw()));
 }
 
 
 static String& BuildConstructorName(const String& type_class_name,
                                     const String* named_constructor) {
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
   // unnamed constructor for class 'A' is labeled 'A.'.
   // This convention prevents users from explicitly calling constructors.
   String& constructor_name =
       String::Handle(String::Concat(type_class_name, Symbols::Dot()));
   if (named_constructor != NULL) {
     constructor_name = String::Concat(constructor_name, *named_constructor);
   }
   return constructor_name;
 }
 
 
 AstNode* Parser::ParseNewOperator(Token::Kind op_kind) {
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = TokenPos();
   ASSERT((op_kind == Token::kNEW) || (op_kind == Token::kCONST));
   bool is_const = (op_kind == Token::kCONST);
   if (!IsIdentifier()) {
-    ErrorMsg("type name expected");
+    ReportError("type name expected");
   }
   intptr_t type_pos = TokenPos();
   // Can't allocate const objects of a deferred type.
   const bool allow_deferred_type = !is_const;
   AbstractType& type = AbstractType::Handle(I,
       ParseType(ClassFinalizer::kCanonicalizeWellFormed, allow_deferred_type));
   // In case the type is malformed, throw a dynamic type error after finishing
   // parsing the instance creation expression.
   if (!type.IsMalformed() && (type.IsTypeParameter() || type.IsDynamicType())) {
     // Replace the type with a malformed type.
@@ skipping 21 matching lines @@
   // Parse constructor parameters.
   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 or
   // malbounded type or report a compile-time error if the constructor is const.
   if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
       const Error& error = Error::Handle(I, type.error());
-      ErrorMsg(error);
+      ReportError(error);
     }
     return ThrowTypeError(type_pos, type);
   }
 
   // Resolve the type and optional identifier to a constructor or factory.
   Class& type_class = Class::Handle(I, type.type_class());
   String& type_class_name = String::Handle(I, type_class.Name());
   TypeArguments& type_arguments =
       TypeArguments::ZoneHandle(I, type.arguments());
 
@@ skipping 19 matching lines @@
       // Replace the type with a malformed type and compile a throw or report a
       // compile-time error if the constructor is const.
       if (is_const) {
         type = ClassFinalizer::NewFinalizedMalformedType(
             Error::Handle(I),  // No previous error.
             script_,
             call_pos,
             "class '%s' has no constructor or factory named '%s'",
             String::Handle(I, type_class.Name()).ToCString(),
             external_constructor_name.ToCString());
-        ErrorMsg(Error::Handle(I, type.error()));
+        ReportError(Error::Handle(I, type.error()));
       }
       return ThrowNoSuchMethodError(call_pos,
                                     type_class,
                                     external_constructor_name,
                                     arguments,
                                     InvocationMirror::kConstructor,
                                     InvocationMirror::kMethod,
                                     NULL);  // No existing function.
     } else if (constructor.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(type_class, constructor);
       Type& redirect_type = Type::Handle(I, constructor.RedirectionType());
       if (!redirect_type.IsMalformedOrMalbounded() &&
           !redirect_type.IsInstantiated()) {
         // The type arguments of the redirection type are instantiated from the
         // type arguments of the parsed type of the 'new' or 'const' expression.
         Error& error = Error::Handle(I);
         redirect_type ^= redirect_type.InstantiateFrom(type_arguments, &error);
         if (!error.IsNull()) {
           redirect_type = ClassFinalizer::NewFinalizedMalformedType(
               error,
               script_,
               call_pos,
               "redirecting factory type '%s' cannot be instantiated",
               String::Handle(I, redirect_type.UserVisibleName()).ToCString());
         }
       }
       if (redirect_type.IsMalformedOrMalbounded()) {
         if (is_const) {
-          ErrorMsg(Error::Handle(I, redirect_type.error()));
+          ReportError(Error::Handle(I, redirect_type.error()));
         }
         return ThrowTypeError(redirect_type.token_pos(), redirect_type);
       }
       if (FLAG_enable_type_checks && !redirect_type.IsSubtypeOf(type, NULL)) {
         // Additional type checking of the result is necessary.
         type_bound = type.raw();
       }
       type = redirect_type.raw();
       type_class = type.type_class();
       type_class_name = type_class.Name();
@@ skipping 28 matching lines @@
                        error_arguments));
     return result;
   }
   String& error_message = String::Handle(I);
   if (!constructor.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     if (is_const) {
-      ErrorMsg(call_pos,
-               "invalid arguments passed to constructor '%s' "
-               "for class '%s': %s",
-               external_constructor_name.ToCString(),
-               String::Handle(I, type_class.Name()).ToCString(),
-               error_message.ToCString());
+      ReportError(call_pos,
+                  "invalid arguments passed to constructor '%s' "
+                  "for class '%s': %s",
+                  external_constructor_name.ToCString(),
+                  String::Handle(I, type_class.Name()).ToCString(),
+                  error_message.ToCString());
     }
     return ThrowNoSuchMethodError(call_pos,
                                   type_class,
                                   external_constructor_name,
                                   arguments,
                                   InvocationMirror::kConstructor,
                                   InvocationMirror::kMethod,
                                   &constructor);
   }
 
   // Return a throw in case of a malformed or malbounded type or report a
   // compile-time error if the constructor is const.
   if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
-      ErrorMsg(Error::Handle(I, type.error()));
+      ReportError(Error::Handle(I, type.error()));
     }
     return ThrowTypeError(type_pos, type);
   }
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
       const String& external_constructor_name =
           (named_constructor ? constructor_name : type_class_name);
-      ErrorMsg("non-const constructor '%s' cannot be used in "
-               "const object creation",
-               external_constructor_name.ToCString());
+      ReportError("non-const constructor '%s' cannot be used in "
+                  "const object creation",
+                  external_constructor_name.ToCString());
     }
     const Object& constructor_result = Object::Handle(I,
         EvaluateConstConstructorCall(type_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
     if (constructor_result.IsUnhandledException()) {
       // It's a compile-time error if invocation of a const constructor
       // call fails.
-      AppendErrorMsg(Error::Cast(constructor_result),
-                     new_pos,
-                     "error while evaluating const constructor");
+      ReportErrors(Error::Cast(constructor_result),
+                   script_, new_pos,
+                   "error while evaluating const constructor");
     } else {
       // Const constructors can return null in the case where a const native
       // factory returns a null value. Thus we cannot use a Instance::Cast here.
       Instance& const_instance = Instance::Handle(I);
       const_instance ^= constructor_result.raw();
       new_object = new(I) LiteralNode(
           new_pos, Instance::ZoneHandle(I, const_instance.raw()));
       if (!type_bound.IsNull()) {
         ASSERT(!type_bound.IsMalformed());
         Error& malformed_error = Error::Handle(I);
@@ skipping 52 matching lines @@
   const Array& interpolate_arg = Array::Handle(I, Array::New(1));
   interpolate_arg.SetAt(0, value_arr);
 
   // Call interpolation function.
   Object& result = Object::Handle(I);
   {
     PAUSETIMERSCOPE(I, time_compilation);
     result = DartEntry::InvokeFunction(func, interpolate_arg);
   }
   if (result.IsUnhandledException()) {
-    ErrorMsg("%s", Error::Cast(result).ToErrorCString());
+    ReportError("%s", Error::Cast(result).ToErrorCString());
   }
   String& concatenated = String::ZoneHandle(I);
   concatenated ^= result.raw();
   concatenated = Symbols::New(concatenated);
   return concatenated;
 }
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
@@ skipping 22 matching lines @@
   while (CurrentToken() == Token::kSTRING) {
     if (CurrentLiteral()->Length() > 0) {
       // Only add non-empty string sections to the values list
       // that will be concatenated.
       values_list.Add(new(I) LiteralNode(TokenPos(), *CurrentLiteral()));
     }
     ConsumeToken();
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
       if (!allow_interpolation) {
-        ErrorMsg("string interpolation not allowed in this context");
+        ReportError("string interpolation not allowed in this context");
       }
       has_interpolation = true;
       AstNode* expr = NULL;
       const intptr_t expr_pos = TokenPos();
       if (CurrentToken() == Token::kINTERPOL_VAR) {
         expr = ResolveIdent(TokenPos(), *CurrentLiteral(), true);
         ConsumeToken();
       } else {
         ASSERT(CurrentToken() == Token::kINTERPOL_START);
         ConsumeToken();
@@ skipping 128 matching lines @@
                                            InvocationMirror::kTopLevel,
                                            call_type,
                                            NULL);  // No existing function.
         }
       }
     }
     ASSERT(primary != NULL);
   } else if (token == Token::kTHIS) {
     LocalVariable* local = LookupLocalScope(Symbols::This());
     if (local == NULL) {
-      ErrorMsg("receiver 'this' is not in scope");
+      ReportError("receiver 'this' is not in scope");
     }
     primary = new(I) LoadLocalNode(TokenPos(), local);
     ConsumeToken();
   } else if (token == Token::kINTEGER) {
     const Integer& literal = Integer::ZoneHandle(I, CurrentIntegerLiteral());
     primary = new(I) LiteralNode(TokenPos(), literal);
     ConsumeToken();
   } else if (token == Token::kTRUE) {
     primary = new(I) LiteralNode(TokenPos(), Bool::True());
     ConsumeToken();
   } else if (token == Token::kFALSE) {
     primary = new(I) LiteralNode(TokenPos(), Bool::False());
     ConsumeToken();
   } else if (token == Token::kNULL) {
     primary = new(I) LiteralNode(TokenPos(), Instance::ZoneHandle(I));
     ConsumeToken();
   } else if (token == Token::kLPAREN) {
     ConsumeToken();
     const bool saved_mode = SetAllowFunctionLiterals(true);
     primary = ParseExpr(kAllowConst, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     ExpectToken(Token::kRPAREN);
   } else if (token == Token::kDOUBLE) {
     Double& double_value = Double::ZoneHandle(I, CurrentDoubleLiteral());
     if (double_value.IsNull()) {
-      ErrorMsg("invalid double literal");
+      ReportError("invalid double literal");
     }
     primary = new(I) LiteralNode(TokenPos(), double_value);
     ConsumeToken();
   } else if (token == Token::kSTRING) {
     primary = ParseStringLiteral(true);
   } else if (token == Token::kNEW) {
     ConsumeToken();
     primary = ParseNewOperator(Token::kNEW);
   } else if (token == Token::kCONST) {
     if ((LookaheadToken(1) == Token::kLT) ||
         (LookaheadToken(1) == Token::kLBRACK) ||
         (LookaheadToken(1) == Token::kINDEX) ||
         (LookaheadToken(1) == Token::kLBRACE)) {
       primary = ParseCompoundLiteral();
     } else {
       ConsumeToken();
       primary = ParseNewOperator(Token::kCONST);
     }
   } else if (token == Token::kLT ||
              token == Token::kLBRACK ||
              token == Token::kINDEX ||
              token == Token::kLBRACE) {
     primary = ParseCompoundLiteral();
   } else if (token == Token::kHASH) {
     primary = ParseSymbolLiteral();
   } else if (token == Token::kSUPER) {
     if (current_function().is_static()) {
-      ErrorMsg("cannot access superclass from static method");
+      ReportError("cannot access superclass from static method");
     }
     if (current_class().SuperClass() == Class::null()) {
-      ErrorMsg("class '%s' does not have a superclass",
-               String::Handle(I, current_class().Name()).ToCString());
+      ReportError("class '%s' does not have a superclass",
+                  String::Handle(I, current_class().Name()).ToCString());
     }
     if (current_class().IsMixinApplication()) {
       const Type& mixin_type = Type::Handle(I, current_class().mixin());
       if (mixin_type.type_class() == current_function().origin()) {
-        ErrorMsg("method of mixin class '%s' may not refer to 'super'",
-                 String::Handle(I, Class::Handle(I,
-                     current_function().origin()).Name()).ToCString());
+        ReportError("method of mixin class '%s' may not refer to 'super'",
+                    String::Handle(I, Class::Handle(I,
+                        current_function().origin()).Name()).ToCString());
       }
     }
     const intptr_t super_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       const intptr_t ident_pos = TokenPos();
       const String& ident = *ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
@@ skipping 35 matching lines @@
     ReturnNode* ret = new(I) ReturnNode(expr->token_pos(), expr);
     // Compile time constant expressions cannot reference anything from a
     // local scope.
     LocalScope* empty_scope = new(I) LocalScope(NULL, 0, 0);
     SequenceNode* seq = new(I) SequenceNode(expr->token_pos(),
                                                     empty_scope);
     seq->Add(ret);
 
     Object& result = Object::Handle(I, Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
-      AppendErrorMsg(Error::Cast(result),
-                     expr_pos,
-                     "error evaluating constant expression");
+      ReportErrors(Error::Cast(result),
+                   script_, expr_pos,
+                   "error evaluating constant expression");
     }
     ASSERT(result.IsInstance());
     Instance& value = Instance::ZoneHandle(I);
     value ^= result.raw();
     value = TryCanonicalize(value, TokenPos());
     return value;
   }
 }
 
 
@@ skipping 323 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart