Cleanup of error and warning reporting.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
+#include "vm/report.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, error_on_bad_override, false,
             "Report error for bad overrides.");
 DEFINE_FLAG(bool, error_on_bad_type, false,
             "Report error for malformed types.");
 DEFINE_FLAG(bool, print_classes, false, "Prints details about loaded classes.");
 DEFINE_FLAG(bool, trace_class_finalization, false, "Trace class finalization.");
@@ skipping 248 matching lines @@
 void ClassFinalizer::ResolveRedirectingFactoryTarget(
     const Class& cls,
     const Function& factory,
     const GrowableObjectArray& visited_factories) {
   ASSERT(factory.IsRedirectingFactory());
 
   // Check for redirection cycle.
   for (intptr_t i = 0; i < visited_factories.Length(); i++) {
     if (visited_factories.At(i) == factory.raw()) {
       // A redirection cycle is reported as a compile-time error.
-      const Script& script = Script::Handle(cls.script());
-      ReportError(Error::Handle(),  // No previous error.
-                  script, factory.token_pos(),
+      ReportError(cls, factory.token_pos(),
                   "factory '%s' illegally redirects to itself",
                   String::Handle(factory.name()).ToCString());
     }
   }
   visited_factories.Add(factory);
 
   // Check if target is already resolved.
   Type& type = Type::Handle(factory.RedirectionType());
   Function& target = Function::Handle(factory.RedirectionTarget());
   if (type.IsMalformedOrMalbounded()) {
@@ skipping 71 matching lines @@
           String::Handle(target.name()).ToCString(),
           String::Handle(factory.name()).ToCString());
       factory.SetRedirectionType(type);
       ASSERT(factory.RedirectionTarget() == Function::null());
       return;
     }
   }
 
   // Verify that the target is const if the redirecting factory is const.
   if (factory.is_const() && !target.is_const()) {
-    const Script& script = Script::Handle(target_class.script());
-    ReportError(Error::Handle(),  // No previous error.
-                script, target.token_pos(),
-                "constructor '%s' must be const as required by redirecting "
-                "const factory '%s'",
+    ReportError(target_class, target.token_pos(),
+                "constructor '%s' must be const as required by "
+                "redirecting const factory '%s'",
                 String::Handle(target.name()).ToCString(),
                 String::Handle(factory.name()).ToCString());
   }
 
   // Update redirection data with resolved target.
   factory.SetRedirectionTarget(target);
   // Not needed anymore.
   factory.SetRedirectionIdentifier(Object::null_string());
   if (!target.IsRedirectingFactory()) {
     return;
@@ skipping 174 matching lines @@
     }
     if ((pending_type.raw() != type.raw()) &&
         (pending_type.type_class() == type_cls.raw())) {
       pending_arguments = pending_type.arguments();
       if (!pending_arguments.IsSubvectorEquivalent(arguments,
                                                    first_type_param,
                                                    num_type_params) &&
           !pending_arguments.IsSubvectorInstantiated(first_type_param,
                                                      num_type_params)) {
         // Reject the non-contractive recursive type.
-        const Script& script = Script::Handle(isolate, cls.script());
         const String& type_name = String::Handle(isolate, type.Name());
-        ReportError(Error::Handle(isolate),  // No previous error.
-                    script, type.token_pos(),
-                    "illegal recursive type '%s'",
-                    type_name.ToCString());
+        ReportError(cls, type.token_pos(),
+                    "illegal recursive type '%s'", type_name.ToCString());
       }
     }
   }
 }
 
 
 // Finalize the type argument vector 'arguments' of the type defined by the
 // class 'cls' parameterized with the type arguments 'cls_args'.
 // The vector 'cls_args' is already initialized as a subvector at the correct
 // position in the passed in 'arguments' vector.
@@ skipping 371 matching lines @@
 
   // Initialize the type argument vector.
   // Check the number of parsed type arguments, if any.
   // Specifying no type arguments indicates a raw type, which is not an error.
   // However, type parameter bounds are checked below, even for a raw type.
   TypeArguments& arguments =
       TypeArguments::Handle(isolate, parameterized_type.arguments());
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
     // Wrong number of type arguments. The type is mapped to the raw type.
     if (FLAG_error_on_bad_type) {
-      const Script& script = Script::Handle(isolate, cls.script());
       const String& type_class_name =
           String::Handle(isolate, type_class.Name());
-      ReportError(Error::Handle(isolate),  // No previous error.
-                  script, parameterized_type.token_pos(),
+      ReportError(cls, parameterized_type.token_pos(),
                   "wrong number of type arguments for class '%s'",
                   type_class_name.ToCString());
     }
     // Make the type raw and continue without reporting any error.
     // A static warning should have been reported.
     arguments = TypeArguments::null();
     parameterized_type.set_arguments(arguments);
   }
 
   // Mark the type as being finalized in order to detect self reference and
@@ skipping 283 matching lines @@
     type = field.type();
     type = FinalizeType(cls, type, kCanonicalize);
     field.set_type(type);
     name = field.name();
     if (field.is_static()) {
       getter_name = Field::GetterSymbol(name);
       super_class = FindSuperOwnerOfInstanceMember(cls, name, getter_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        const Script& script = Script::Handle(cls.script());
-        ReportError(Error::Handle(),  // No previous error.
-                    script, field.token_pos(),
+        ReportError(cls, field.token_pos(),
                     "static field '%s' of class '%s' conflicts with "
                     "instance member '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
       // An implicit setter is not generated for a static field, therefore, we
       // cannot rely on the code below handling the static setter case to report
       // a conflict with an instance setter. So we check explicitly here.
       setter_name = Field::SetterSymbol(name);
       super_class = FindSuperOwnerOfFunction(cls, setter_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        const Script& script = Script::Handle(cls.script());
-        ReportError(Error::Handle(),  // No previous error.
-                    script, field.token_pos(),
+        ReportError(cls, field.token_pos(),
                     "static field '%s' of class '%s' conflicts with "
                     "instance setter '%s=' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
 
     } else {
       // Instance field. Check whether the field overrides a method
       // (but not getter).
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        const Script& script = Script::Handle(cls.script());
-        ReportError(Error::Handle(),  // No previous error.
-                    script, field.token_pos(),
+        ReportError(cls, field.token_pos(),
                     "field '%s' of class '%s' conflicts with method '%s' "
                     "of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     }
     if (field.is_static() &&
         (field.value() != Object::null()) &&
@@ skipping 11 matching lines @@
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type,
                                      Object::null_type_arguments(),
                                      &error))) {
         if (FLAG_error_on_bad_type) {
           const AbstractType& const_value_type = AbstractType::Handle(
               const_value.GetType());
           const String& const_value_type_name = String::Handle(
               const_value_type.UserVisibleName());
           const String& type_name = String::Handle(type.UserVisibleName());
-          const Script& script = Script::Handle(cls.script());
-          ReportError(error, script, field.token_pos(),
-                      "error initializing static %s field '%s': "
-                      "type '%s' is not a subtype of type '%s'",
-                      field.is_const() ? "const" : "final",
-                      name.ToCString(),
-                      const_value_type_name.ToCString(),
-                      type_name.ToCString());
+          ReportErrors(error, cls, field.token_pos(),
+                       "error initializing static %s field '%s': "
+                       "type '%s' is not a subtype of type '%s'",
+                       field.is_const() ? "const" : "final",
+                       name.ToCString(),
+                       const_value_type_name.ToCString(),
+                       type_name.ToCString());
         } else {
           // Do not report an error yet, even in checked mode, since the field
           // may not actually be used.
           // Also, we may be generating a snapshot in production mode that will
           // later be executed in checked mode, in which case an error needs to
           // be reported, should the field be accessed.
           // Therefore, we undo the optimization performed by the parser, i.e.
           // we create an implicit static final getter and reset the field value
           // to the sentinel value.
           const Function& getter = Function::Handle(
@@ skipping 49 matching lines @@
         super_class ^= interfaces.At(i);
         // Finalize superclass since overrides check relies on all members
         // of the superclass to be finalized.
         FinalizeClass(super_class);
         overridden_function = super_class.LookupDynamicFunction(name);
         if (!overridden_function.IsNull() &&
             !function.HasCompatibleParametersWith(overridden_function,
                                                   &error)) {
           const String& class_name = String::Handle(cls.Name());
           const String& super_class_name = String::Handle(super_class.Name());
-          const Script& script = Script::Handle(cls.script());
-          ReportError(error, script, function.token_pos(),
-                      "class '%s' overrides method '%s' of super class '%s' "
-                      "with incompatible parameters",
-                      class_name.ToCString(),
-                      name.ToCString(),
-                      super_class_name.ToCString());
+          ReportErrors(error, cls, function.token_pos(),
+                       "class '%s' overrides method '%s' of super "
+                       "class '%s' with incompatible parameters",
+                       class_name.ToCString(),
+                       name.ToCString(),
+                       super_class_name.ToCString());
         }
       }
     }
     if (function.IsSetterFunction() || function.IsImplicitSetterFunction()) {
       if (function.is_static()) {
         super_class = FindSuperOwnerOfFunction(cls, name);
         if (!super_class.IsNull()) {
           const String& class_name = String::Handle(cls.Name());
           const String& super_class_name = String::Handle(super_class.Name());
-          const Script& script = Script::Handle(cls.script());
-          ReportError(Error::Handle(),  // No previous error.
-                      script, function.token_pos(),
+          ReportError(cls, function.token_pos(),
                       "static setter '%s=' of class '%s' conflicts with "
                       "instance setter '%s=' of super class '%s'",
                       name.ToCString(),
                       class_name.ToCString(),
                       name.ToCString(),
                       super_class_name.ToCString());
         }
       }
       continue;
     }
     if (function.IsGetterFunction() || function.IsImplicitGetterFunction()) {
       getter_name = name.raw();
       name = Field::NameFromGetter(getter_name);
     } else {
       getter_name = Field::GetterSymbol(name);
     }
     if (function.is_static()) {
       super_class = FindSuperOwnerOfInstanceMember(cls, name, getter_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        const Script& script = Script::Handle(cls.script());
-        ReportError(Error::Handle(),  // No previous error.
-                    script, function.token_pos(),
+        ReportError(cls, function.token_pos(),
                     "static %s '%s' of class '%s' conflicts with "
                     "instance member '%s' of super class '%s'",
                     (function.IsGetterFunction() ||
                      function.IsImplicitGetterFunction()) ? "getter" : "method",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
       // The function may be a still unresolved redirecting factory. Do not yet
       // try to resolve it in order to avoid cycles in class finalization.
     } else if (function.IsGetterFunction() ||
                function.IsImplicitGetterFunction()) {
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        const Script& script = Script::Handle(cls.script());
-        ReportError(Error::Handle(),  // No previous error.
-                    script, function.token_pos(),
+        ReportError(cls, function.token_pos(),
                     "getter '%s' of class '%s' conflicts with "
                     "method '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     } else if (!function.IsSetterFunction() &&
                !function.IsImplicitSetterFunction()) {
       // A function cannot conflict with a setter, since they cannot
       // have the same name. Thus, we do not need to check setters.
       super_class = FindSuperOwnerOfFunction(cls, getter_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        const Script& script = Script::Handle(cls.script());
-        ReportError(Error::Handle(),  // No previous error.
-                    script, function.token_pos(),
+        ReportError(cls, function.token_pos(),
                     "method '%s' of class '%s' conflicts with "
                     "getter '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     }
   }
 }
@@ skipping 443 matching lines @@
     OS::Print("Applying mixin type '%s' to %s at pos %" Pd "\n",
               String::Handle(mixin_type.Name()).ToCString(),
               mixin_app_class.ToCString(),
               mixin_app_class.token_pos());
   }
 
   // Check for illegal self references. This has to be done before checking
   // that the super class of the mixin class is class Object.
   GrowableArray<intptr_t> visited_mixins;
   if (!IsMixinCycleFree(mixin_class, &visited_mixins)) {
-    const Script& script = Script::Handle(mixin_class.script());
     const String& class_name = String::Handle(mixin_class.Name());
-    ReportError(Error::Handle(),  // No previous error.
-                script, mixin_class.token_pos(),
+    ReportError(mixin_class, mixin_class.token_pos(),
                 "mixin class '%s' illegally refers to itself",
                 class_name.ToCString());
   }
 
   // Check that the super class of the mixin class is class Object.
   Class& mixin_super_class = Class::Handle(mixin_class.SuperClass());
   // Skip over mixin application alias classes, which are implemented as
   // subclasses of the mixin application classes they name.
   if (!mixin_super_class.IsNull() && mixin_class.is_mixin_app_alias()) {
     while (mixin_super_class.is_mixin_app_alias()) {
       mixin_super_class = mixin_super_class.SuperClass();
     }
     mixin_super_class = mixin_super_class.SuperClass();
   }
   if (mixin_super_class.IsNull() || !mixin_super_class.IsObjectClass()) {
-    const Script& script = Script::Handle(mixin_app_class.script());
     const String& class_name = String::Handle(mixin_class.Name());
-    ReportError(Error::Handle(),  // No previous error.
-                script, mixin_app_class.token_pos(),
+    ReportError(mixin_app_class, mixin_app_class.token_pos(),
                 "mixin class '%s' must extend class 'Object'",
                 class_name.ToCString());
   }
 
   // Copy type parameters to mixin application class.
   CloneMixinAppTypeParameters(mixin_app_class);
 
   // Verify that no restricted class is used as a mixin by checking the
   // interfaces of the mixin application class, which implements its mixin.
   GrowableArray<intptr_t> visited_interfaces;
@@ skipping 117 matching lines @@
   // The parser creates the mixin application class with no functions.
   ASSERT((functions = cls.functions(), functions.Length() == 0));
   // Now clone the functions from the mixin class.
   functions = mixin_cls.functions();
   const intptr_t num_functions = functions.Length();
   for (intptr_t i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
     if (func.IsConstructor()) {
       // A mixin class must not have explicit constructors.
       if (!func.IsImplicitConstructor()) {
-        const Script& script = Script::Handle(isolate, cls.script());
-        ReportError(Error::Handle(),  // No previous error.
-                    script, cls.token_pos(),
+        ReportError(cls, cls.token_pos(),
                     "mixin class '%s' must not have constructors\n",
                     String::Handle(isolate, mixin_cls.Name()).ToCString());
       }
       continue;  // Skip the implicit constructor.
     }
     if (!func.is_static()) {
       func = func.Clone(cls);
       cloned_funcs.Add(func);
     }
   }
@@ skipping 28 matching lines @@
 void ClassFinalizer::FinalizeTypesInClass(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   if (cls.is_type_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize types in %s\n", cls.ToCString());
   }
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
-    const Script& script = Script::Handle(cls.script());
-    ReportError(Error::Handle(),  // No previous error.
-                script, cls.token_pos(),
+    ReportError(cls, cls.token_pos(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   // Finalize super class.
   Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull()) {
     FinalizeTypesInClass(super_class);
   }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);  // May change super type.
@@ skipping 11 matching lines @@
     // vector of any type of the base class will contain a BoundedType for the
     // out of bound type argument.
     super_type = FinalizeType(cls, super_type, kCanonicalizeWellFormed);
     cls.set_super_type(super_type);
   }
   if (cls.IsSignatureClass()) {
     // Check for illegal self references.
     GrowableArray<intptr_t> visited_aliases;
     if (!IsAliasCycleFree(cls, &visited_aliases)) {
       const String& name = String::Handle(cls.Name());
-      const Script& script = Script::Handle(cls.script());
-      ReportError(Error::Handle(),  // No previous error.
-                  script, cls.token_pos(),
+      ReportError(cls, cls.token_pos(),
                   "typedef '%s' illegally refers to itself",
                   name.ToCString());
     }
     cls.set_is_type_finalized();
 
     // The type parameters of signature classes may have bounds.
     FinalizeUpperBounds(cls);
 
     // Resolve and finalize the result and parameter types of the signature
     // function of this signature class.
@@ skipping 13 matching lines @@
     interface_type ^= interface_types.At(i);
     interface_type = FinalizeType(cls, interface_type, kCanonicalizeWellFormed);
     interface_types.SetAt(i, interface_type);
 
     // Check whether the interface is duplicated. We need to wait with
     // this check until the super type and interface types are finalized,
     // so that we can use Type::Equals() for the test.
     ASSERT(interface_type.IsFinalized());
     ASSERT(super_type.IsNull() || super_type.IsFinalized());
     if (!super_type.IsNull() && interface_type.Equals(super_type)) {
-      const Script& script = Script::Handle(cls.script());
-      ReportError(Error::Handle(),  // No previous error.
-                  script, cls.token_pos(),
+      ReportError(cls, cls.token_pos(),
                   "super type '%s' may not be listed in "
                   "implements clause of class '%s'",
                   String::Handle(super_type.Name()).ToCString(),
                   String::Handle(cls.Name()).ToCString());
     }
     for (intptr_t j = 0; j < i; j++) {
       seen_interf ^= interface_types.At(j);
       if (interface_type.Equals(seen_interf)) {
-        const Script& script = Script::Handle(cls.script());
-        ReportError(Error::Handle(),  // No previous error.
-                    script, cls.token_pos(),
+        ReportError(cls, cls.token_pos(),
                     "interface '%s' appears twice in "
                     "implements clause of class '%s'",
                     String::Handle(interface_type.Name()).ToCString(),
                     String::Handle(cls.Name()).ToCString());
       }
     }
   }
   // Mark as type finalized before resolving type parameter upper bounds
   // in order to break cycles.
   cls.set_is_type_finalized();
@@ skipping 218 matching lines @@
     if (num_type_arguments == num_type_parameters) {
       for (intptr_t i = 0; i < num_type_arguments; i++) {
         arg = type_args.TypeAt(i);
         arg = arg.CloneUnfinalized();
         ASSERT(!arg.IsBeingFinalized());
         collected_args.Add(arg);
       }
       return;
     }
     if (FLAG_error_on_bad_type) {
-      const Script& script = Script::Handle(cls.script());
       const String& type_class_name = String::Handle(type_class.Name());
-      ReportError(Error::Handle(),  // No previous error.
-                  script, type.token_pos(),
+      ReportError(cls, type.token_pos(),
                   "wrong number of type arguments for class '%s'",
                   type_class_name.ToCString());
     }
     // Discard provided type arguments and treat type as raw.
   }
   // Fill arguments with type dynamic.
   for (intptr_t i = 0; i < num_type_parameters; i++) {
     arg = Type::DynamicType();
     collected_args.Add(arg);
   }
@@ skipping 148 matching lines @@
   ASSERT(visited != NULL);
   if (FLAG_trace_class_finalization) {
     OS::Print("Resolving super and interfaces: %s\n", cls.ToCString());
   }
   Isolate* isolate = Isolate::Current();
   const intptr_t cls_index = cls.id();
   for (intptr_t i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited class 'cls'. We found a cycle.
       const String& class_name = String::Handle(isolate, cls.Name());
-      const Script& script = Script::Handle(isolate, cls.script());
-      ReportError(Error::Handle(isolate),  // No previous error.
-                  script, cls.token_pos(),
+      ReportError(cls, cls.token_pos(),
                   "cyclic reference found for class '%s'",
                   class_name.ToCString());
     }
   }
 
   // If the class/interface has no explicit super class/interfaces
   // and is not a mixin application, we are done.
   AbstractType& super_type = AbstractType::Handle(isolate, cls.super_type());
   Array& super_interfaces = Array::Handle(isolate, cls.interfaces());
   if ((super_type.IsNull() || super_type.IsObjectType()) &&
@@ skipping 20 matching lines @@
   visited->Add(cls_index);
   AbstractType& interface = AbstractType::Handle(isolate);
   Class& interface_class = Class::Handle(isolate);
 
   // Resolve super type. Failures lead to a longjmp.
   ResolveType(cls, super_type);
   if (super_type.IsMalformedOrMalbounded()) {
     ReportError(Error::Handle(isolate, super_type.error()));
   }
   if (super_type.IsDynamicType()) {
-    const Script& script = Script::Handle(isolate, cls.script());
-    ReportError(Error::Handle(isolate),  // No previous error.
-                script, cls.token_pos(),
+    ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend 'dynamic'",
                 String::Handle(isolate, cls.Name()).ToCString());
   }
   interface_class = super_type.type_class();
   if (interface_class.IsSignatureClass()) {
-    const Script& script = Script::Handle(isolate, cls.script());
-    ReportError(Error::Handle(isolate),  // No previous error.
-                script, cls.token_pos(),
+    ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend function type alias '%s'",
                 String::Handle(isolate, cls.Name()).ToCString(),
                 String::Handle(isolate,
-                               super_type.UserVisibleName()).ToCString());
+                                  super_type.UserVisibleName()).ToCString());
   }
 
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   if (!cls_belongs_to_core_lib) {
     // Prevent extending core implementation classes.
     bool is_error = false;
     switch (interface_class.id()) {
       case kNumberCid:
       case kIntegerCid:  // Class Integer, not int.
@@ skipping 24 matching lines @@
         // Special case: classes for which we don't have a known class id.
         if (super_type.IsDoubleType() ||
             super_type.IsIntType() ||
             super_type.IsStringType()) {
           is_error = true;
         }
         break;
       }
     }
     if (is_error) {
-      const Script& script = Script::Handle(isolate, cls.script());
-      ReportError(Error::Handle(isolate),  // No previous error.
-                  script, cls.token_pos(),
+      const String& interface_name = String::Handle(isolate,
+                                                    interface_class.Name());
+      ReportError(cls, cls.token_pos(),
                   "'%s' is not allowed to extend '%s'",
                   String::Handle(isolate, cls.Name()).ToCString(),
-                  String::Handle(isolate, interface_class.Name()).ToCString());
+                  interface_name.ToCString());
     }
   }
   // Now resolve the super interfaces of the super type.
   ResolveSuperTypeAndInterfaces(interface_class, visited);
 
   // Resolve interfaces. Failures lead to a longjmp.
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     ResolveType(cls, interface);
     ASSERT(!interface.IsTypeParameter());  // Should be detected by parser.
     // A malbounded interface is only reported when involved in a type test.
     if (interface.IsMalformed()) {
       ReportError(Error::Handle(isolate, interface.error()));
     }
     if (interface.IsDynamicType()) {
-      const Script& script = Script::Handle(isolate, cls.script());
-      ReportError(Error::Handle(isolate),  // No previous error.
-                  script, cls.token_pos(),
+      ReportError(cls, cls.token_pos(),
                   "'dynamic' may not be used as interface");
     }
     interface_class = interface.type_class();
     if (interface_class.IsSignatureClass()) {
-      const Script& script = Script::Handle(isolate, cls.script());
-      ReportError(Error::Handle(isolate),  // No previous error.
-                  script, cls.token_pos(),
+      const String& interface_name = String::Handle(isolate,
+                                                    interface_class.Name());
+      ReportError(cls, cls.token_pos(),
                   "function type alias '%s' may not be used as interface",
-                  String::Handle(isolate, interface_class.Name()).ToCString());
+                  interface_name.ToCString());
     }
     // Verify that unless cls belongs to core lib, it cannot extend, implement,
     // or mixin any of Null, bool, num, int, double, String, dynamic.
     if (!cls_belongs_to_core_lib) {
       if (interface.IsBoolType() ||
           interface.IsNullType() ||
           interface.IsNumberType() ||
           interface.IsIntType() ||
           interface.IsDoubleType() ||
           interface.IsStringType() ||
           interface.IsDynamicType()) {
-        const Script& script = Script::Handle(isolate, cls.script());
         const String& interface_name = String::Handle(isolate,
                                                       interface_class.Name());
         if (cls.IsMixinApplication()) {
-          ReportError(Error::Handle(isolate),  // No previous error.
-                      script, cls.token_pos(),
+          ReportError(cls, cls.token_pos(),
                       "illegal mixin of '%s'",
                       interface_name.ToCString());
         } else {
-          ReportError(Error::Handle(isolate),  // No previous error.
-                      script, cls.token_pos(),
+          ReportError(cls, cls.token_pos(),
                       "'%s' is not allowed to extend or implement '%s'",
                       String::Handle(isolate, cls.Name()).ToCString(),
                       interface_name.ToCString());
         }
       }
     }
     interface_class.set_is_implemented();
     // Now resolve the super interfaces.
     ResolveSuperTypeAndInterfaces(interface_class, visited);
   }
   visited->RemoveLast();
   cls.set_is_cycle_free();
 }
 
 
 // A class is marked as constant if it has one constant constructor.
 // A constant class can only have final instance fields.
 // Note: we must check for cycles before checking for const properties.
 void ClassFinalizer::CheckForLegalConstClass(const Class& cls) {
   ASSERT(cls.is_const());
   const Array& fields_array = Array::Handle(cls.fields());
   intptr_t len = fields_array.Length();
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     if (!field.is_static() && !field.is_final()) {
       const String& class_name = String::Handle(cls.Name());
       const String& field_name = String::Handle(field.name());
-      const Script& script = Script::Handle(cls.script());
-      ReportError(Error::Handle(),  // No previous error.
-                  script, field.token_pos(),
+      ReportError(cls, field.token_pos(),
                   "const class '%s' has non-final field '%s'",
                   class_name.ToCString(), field_name.ToCString());
     }
   }
 }
 
 
 void ClassFinalizer::PrintClassInformation(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   const String& class_name = String::Handle(cls.Name());
@@ skipping 34 matching lines @@
   const Array& fields_array = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   len = fields_array.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     OS::Print("  %s\n", field.ToCString());
   }
 }
 
 // Either report an error or mark the type as malformed.
-void ClassFinalizer::ReportMalformedType(const Error& prev_error,
-                                         const Script& script,
-                                         const Type& type,
-                                         const char* format,
-                                         va_list args) {
+void ClassFinalizer::MarkTypeMalformed(const Error& prev_error,
+                                       const Script& script,
+                                       const Type& type,
+                                       const char* format,
+                                       va_list args) {
   LanguageError& error = LanguageError::Handle(
       LanguageError::NewFormattedV(
           prev_error, script, type.token_pos(),
-          LanguageError::kMalformedType, Heap::kOld,
+          Report::kMalformedType, Heap::kOld,
           format, args));
   if (FLAG_error_on_bad_type) {
     ReportError(error);
   }
   type.set_error(error);
   // Make the type raw, since it may not be possible to
   // properly finalize its type arguments.
   type.set_type_class(Class::Handle(Object::dynamic_class()));
   type.set_arguments(Object::null_type_arguments());
   if (!type.IsFinalized()) {
@@ skipping 12 matching lines @@
                                                    intptr_t type_pos,
                                                    const char* format, ...) {
   va_list args;
   va_start(args, format);
   const UnresolvedClass& unresolved_class = UnresolvedClass::Handle(
       UnresolvedClass::New(LibraryPrefix::Handle(),
                            Symbols::Empty(),
                            type_pos));
   const Type& type = Type::Handle(
       Type::New(unresolved_class, TypeArguments::Handle(), type_pos));
-  ReportMalformedType(prev_error, script, type, format, args);
+  MarkTypeMalformed(prev_error, script, type, format, args);
   va_end(args);
   ASSERT(type.IsMalformed());
   ASSERT(type.IsFinalized());
   return type.raw();
 }
 
 
 void ClassFinalizer::FinalizeMalformedType(const Error& prev_error,
                                            const Script& script,
                                            const Type& type,
                                            const char* format, ...) {
   va_list args;
   va_start(args, format);
-  ReportMalformedType(prev_error, script, type, format, args);
+  MarkTypeMalformed(prev_error, script, type, format, args);
   va_end(args);
 }
 
 
 void ClassFinalizer::FinalizeMalboundedType(const Error& prev_error,
                                             const Script& script,
                                             const Type& type,
                                             const char* format, ...) {
   va_list args;
   va_start(args, format);
   LanguageError& error = LanguageError::Handle(
       LanguageError::NewFormattedV(
           prev_error, script, type.token_pos(),
-          LanguageError::kMalboundedType, Heap::kOld,
+          Report::kMalboundedType, Heap::kOld,
           format, args));
   va_end(args);
   if (FLAG_error_on_bad_type) {
     ReportError(error);
   }
   type.set_error(error);
   if (!type.IsFinalized()) {
     type.SetIsFinalized();
     // Do not canonicalize malbounded types.
   }
 }
 
 
 void ClassFinalizer::ReportError(const Error& error) {
-  Isolate::Current()->long_jump_base()->Jump(1, error);
+  Report::LongJump(error);
   UNREACHABLE();
 }
 
 
-void ClassFinalizer::ReportError(const Error& prev_error,
-                                 const Script& script,
+void ClassFinalizer::ReportErrors(const Error& prev_error,
+                                  const Class& cls,
+                                  intptr_t token_pos,
+                                  const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  const Script& script = Script::Handle(cls.script());
+  Report::LongJumpV(prev_error, script, token_pos, format, args);
+  va_end(args);
+  UNREACHABLE();
+}
+
+
+void ClassFinalizer::ReportError(const Class& cls,
                                  intptr_t token_pos,
                                  const char* format, ...) {
   va_list args;
   va_start(args, format);
-  Error& error = Error::Handle(
-      LanguageError::NewFormattedV(
-          prev_error, script, token_pos,
-          LanguageError::kError, Heap::kNew,
-          format, args));
+  const Script& script = Script::Handle(cls.script());
+  Report::MessageV(Report::kError, script, token_pos, format, args);
   va_end(args);
-  ReportError(error);
+  UNREACHABLE();
 }
 
 
 void ClassFinalizer::VerifyImplicitFieldOffsets() {
 #ifdef DEBUG
   Isolate* isolate = Isolate::Current();
   const ClassTable& class_table = *(isolate->class_table());
   Class& cls = Class::Handle(isolate);
   Array& fields_array = Array::Handle(isolate);
   Field& field = Field::Handle(isolate);
@@ skipping 43 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart