Implement updated method overriding rules in the vm.

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/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.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_malformed_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.");
 DEFINE_FLAG(bool, trace_type_finalization, false, "Trace type finalization.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, use_cha);
 
 bool ClassFinalizer::AllClassesFinalized() {
   ObjectStore* object_store = Isolate::Current()->object_store();
@@ skipping 16 matching lines @@
   // Switch all functions' code to unoptimized.
   const ClassTable& class_table = *Isolate::Current()->class_table();
   Class& cls = Class::Handle();
   Array& array = Array::Handle();
   Function& function = Function::Handle();
   for (intptr_t i = 0; i < added_subclasses_to_cids.length(); i++) {
     intptr_t cid = added_subclasses_to_cids[i];
     cls = class_table.At(cid);
     ASSERT(!cls.IsNull());
     array = cls.functions();
-    intptr_t num_functions = array.IsNull() ? 0 : array.Length();
+    const intptr_t num_functions = array.IsNull() ? 0 : array.Length();
     for (intptr_t f = 0; f < num_functions; f++) {
       function ^= array.At(f);
       ASSERT(!function.IsNull());
       if (function.HasOptimizedCode()) {
         function.SwitchToUnoptimizedCode();
       }
     }
   }
 }
 
@@ skipping 69 matching lines @@
     GrowableObjectArray& class_array = GrowableObjectArray::Handle();
     class_array = object_store->pending_classes();
     ASSERT(!class_array.IsNull());
     // Collect superclasses that were already finalized before this run of
     // finalization.
     CollectFinalizedSuperClasses(class_array, &added_subclasses_to_cids);
     Class& cls = Class::Handle();
     // First resolve all superclasses.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
-      if (FLAG_trace_class_finalization) {
-        OS::Print("Resolving super and interfaces: %s\n", cls.ToCString());
-      }
       GrowableArray<intptr_t> visited_interfaces;
       ResolveSuperTypeAndInterfaces(cls, &visited_interfaces);
     }
     // Finalize all classes.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       FinalizeTypesInClass(cls);
     }
     if (FLAG_print_classes) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
@@ skipping 145 matching lines @@
     const Class& cls,
     const Function& factory,
     const GrowableObjectArray& visited_factories) {
   ASSERT(factory.IsRedirectingFactory());
 
   // Check for redirection cycle.
   for (int 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(script, factory.token_pos(),
+      ReportError(Error::Handle(),  // No previous error.
+                  script, 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.IsMalformed()) {
@@ skipping 53 matching lines @@
         cls,
         factory.token_pos(),
         "class '%s' has no constructor or factory named '%s'",
         target_class_name.ToCString(),
         user_visible_target_name.ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
-  // Verify that the target is compatible with the redirecting factory.
-  if (!target.HasCompatibleParametersWith(factory)) {
-    type = NewFinalizedMalformedType(
-        Error::Handle(),  // No previous error.
-        cls,
-        factory.token_pos(),
-        "constructor '%s' has incompatible parameters with "
-        "redirecting factory '%s'",
-        String::Handle(target.name()).ToCString(),
-        String::Handle(factory.name()).ToCString());
-    factory.SetRedirectionType(type);
-    ASSERT(factory.RedirectionTarget() == Function::null());
-    return;
+  if (FLAG_error_on_bad_override) {
+    // Verify that the target is compatible with the redirecting factory.
+    Error& error = Error::Handle();
+    if (!target.HasCompatibleParametersWith(factory, &error)) {
+      type = NewFinalizedMalformedType(
+          error, target_class, target.token_pos(),
+          "constructor '%s' has incompatible parameters with "
+          "redirecting factory '%s'",
+          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(cls.script());
-    ReportError(script, factory.token_pos(),
+    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'",
                 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());
@@ skipping 78 matching lines @@
       }
       return;
     }
     parameterized_type.set_type_class(type_class);
   }
 
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type.arguments());
   if (!arguments.IsNull()) {
-    intptr_t num_arguments = arguments.Length();
+    const intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       ResolveType(cls, type_argument, finalization);
     }
   }
 }
 
 
 void ClassFinalizer::FinalizeTypeParameters(const Class& cls) {
@@ skipping 248 matching lines @@
   if (!type_class.is_type_finalized()) {
     FinalizeTypeParameters(type_class);
     ResolveUpperBounds(type_class);
   }
 
   // Finalize the current type arguments of the type, which are still the
   // parsed type arguments.
   AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(parameterized_type.arguments());
   if (!arguments.IsNull()) {
-    intptr_t num_arguments = arguments.Length();
+    const intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       type_argument = FinalizeType(cls, type_argument, finalization);
       if (type_argument.IsMalformed()) {
         // Malformed type arguments are mapped to dynamic.
         type_argument = Type::DynamicType();
       }
       arguments.SetTypeAt(i, type_argument);
     }
   }
 
   // The finalized type argument vector needs num_type_arguments types.
   const intptr_t num_type_arguments = type_class.NumTypeArguments();
   // The type class has num_type_parameters type parameters.
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
 
   // 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.
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
     // Wrong number of type arguments. The type is malformed.
     if (FLAG_error_on_malformed_type) {
       const Script& script = Script::Handle(cls.script());
       const String& type_class_name = String::Handle(type_class.Name());
-      ReportError(script, parameterized_type.token_pos(),
+      ReportError(Error::Handle(),  // No previous error.
+                  script, 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 = AbstractTypeArguments::null();
     parameterized_type.set_arguments(arguments);
   }
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which may be initialized from the parsed
@@ skipping 212 matching lines @@
   //   class or in a subclass.
   // - a static field, instance field, or static method (but not an instance
   //   method) having the same name as an instance member in a super class.
 
   // Resolve type of fields and check for conflicts in super classes.
   Array& array = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   AbstractType& type = AbstractType::Handle();
   String& name = String::Handle();
   Class& super_class = Class::Handle();
-  intptr_t num_fields = array.Length();
+  const intptr_t num_fields = array.Length();
   for (intptr_t i = 0; i < num_fields; i++) {
     field ^= array.At(i);
     type = field.type();
     ResolveType(cls, type, kCanonicalize);
     type = FinalizeType(cls, type, kCanonicalize);
     field.set_type(type);
     name = field.name();
     if (field.is_static()) {
       super_class = FindSuperOwnerOfInstanceMember(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(script, field.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, 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());
       }
     } 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(script, field.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, 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 ((FLAG_enable_type_checks || FLAG_error_on_malformed_type) &&
         field.is_static() && field.is_const() &&
         (field.value() != Object::null()) &&
         (field.value() != Object::sentinel().raw())) {
       // The parser does not preset the value if the type is a type parameter or
       // is parameterized unless the value is null.
       Error& malformed_error = Error::Handle();
       if (type.IsMalformed()) {
         malformed_error = type.malformed_error();
       } else {
         ASSERT(type.IsInstantiated());
       }
       const Instance& const_value = Instance::Handle(field.value());
       if (!malformed_error.IsNull() ||
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type,
                                      AbstractTypeArguments::Handle(),
                                      &malformed_error))) {
-        // If the failure is due to a malformed type error, display it instead.
-        if (!malformed_error.IsNull()) {
-          ReportError(malformed_error);
-        } else {
-          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(script, field.token_pos(),
-                      "error initializing const field '%s': type '%s' is not a "
-                      "subtype of type '%s'",
-                      name.ToCString(),
-                      const_value_type_name.ToCString(),
-                      type_name.ToCString());
-        }
+        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(malformed_error, script, field.token_pos(),
+                    "error initializing const field '%s': type '%s' is not a "
+                    "subtype of type '%s'",
+                    name.ToCString(),
+                    const_value_type_name.ToCString(),
+                    type_name.ToCString());
       }
     }
   }
   // Collect interfaces, super interfaces, and super classes of this class.
   const GrowableObjectArray& interfaces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   CollectInterfaces(cls, interfaces);
   // Include superclasses in list of interfaces and super interfaces.
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
     interfaces.Add(super_class);
     CollectInterfaces(super_class, interfaces);
     super_class = super_class.SuperClass();
   }
   // Resolve function signatures and check for conflicts in super classes and
   // interfaces.
   array = cls.functions();
   Function& function = Function::Handle();
   Function& overridden_function = Function::Handle();
-  intptr_t num_functions = array.Length();
+  const intptr_t num_functions = array.Length();
   String& function_name = String::Handle();
+  Error& error = Error::Handle();
   for (intptr_t i = 0; i < num_functions; i++) {
     function ^= array.At(i);
     ResolveAndFinalizeSignature(cls, function);
     function_name = function.name();
     if (function.is_static()) {
       super_class = FindSuperOwnerOfInstanceMember(cls, function_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(script, function.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, function.token_pos(),
                     "static function '%s' of class '%s' conflicts with "
                     "instance member '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_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 {
+    } else if (FLAG_error_on_bad_override && !function.IsConstructor()) {
+      // A constructor cannot override anything.
       for (int i = 0; i < interfaces.Length(); i++) {
         super_class ^= interfaces.At(i);
         overridden_function = super_class.LookupDynamicFunction(function_name);
         if (!overridden_function.IsNull() &&
-            !function.HasCompatibleParametersWith(overridden_function)) {
+            !function.HasCompatibleParametersWith(overridden_function,
+                                                  &error)) {
           // Function types are purposely not checked for subtyping.
           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(script, function.token_pos(),
+          ReportError(error, script, function.token_pos(),
                       "class '%s' overrides function '%s' of super class '%s' "
                       "with incompatible parameters",
                       class_name.ToCString(),
                       function_name.ToCString(),
                       super_class_name.ToCString());
         }
       }
     }
     if (function.IsGetterFunction()) {
       name = Field::NameFromGetter(function_name);
       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(script, function.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, function.token_pos(),
                     "getter '%s' of class '%s' conflicts with "
                     "function '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     } else if (!function.IsSetterFunction()) {
       // A function cannot conflict with a setter, since they cannot
       // have the same name. Thus, we do not need to check setters.
       name = Field::GetterName(function_name);
       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(script, function.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, function.token_pos(),
                     "function '%s' of class '%s' conflicts with "
                     "getter '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
     }
   }
 }
@@ skipping 33 matching lines @@
         TypeArguments::Handle(super_class.type_parameters());
     const TypeArguments& super_type_args =
         TypeArguments::Handle(TypeArguments::New(num_super_parameters));
     for (int i = 0; i < num_super_parameters; i++) {
       param ^= super_params.TypeAt(i);
       param_name = param.name();
       param_bound = param.bound();
       // TODO(hausner): handle type bounds.
       if (!param_bound.IsObjectType()) {
         const Script& script = Script::Handle(mixapp_class.script());
-        ReportError(script, param.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, param.token_pos(),
                     "type parameter '%s': type bounds not yet"
                     " implemented for mixins\n",
                     param_name.ToCString());
       }
       param_name = String::Concat(param_name, Symbols::Backtick());
       param_name = Symbols::New(param_name);
       cloned_param = TypeParameter::New(mixapp_class,
                                         cloned_index,
                                         param_name,
                                         param_bound,
@@ skipping 21 matching lines @@
     const TypeArguments& interface_type_args = TypeArguments::Handle(
         TypeArguments::New(num_mixin_parameters));
     for (int i = 0; i < num_mixin_parameters; i++) {
       param ^= mixin_params.TypeAt(i);
       param_name = param.name();
       param_bound = param.bound();
 
       // TODO(hausner): handle type bounds.
       if (!param_bound.IsObjectType()) {
         const Script& script = Script::Handle(mixapp_class.script());
-        ReportError(script, param.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, param.token_pos(),
                     "type parameter '%s': type bounds not yet"
                     " implemented for mixins\n",
                     param_name.ToCString());
       }
       cloned_param = TypeParameter::New(mixapp_class,
                                         cloned_index,
                                         param_name,
                                         param_bound,
                                         param.token_pos());
       cloned_type_params.SetTypeAt(cloned_index, cloned_param);
@@ skipping 30 matching lines @@
               cls.token_pos());
   }
 
   // Check that the super class of the mixin class is extending
   // class Object.
   const AbstractType& mixin_super_type =
       AbstractType::Handle(mixin_cls.super_type());
   if (!mixin_super_type.IsObjectType()) {
     const Script& script = Script::Handle(cls.script());
     const String& class_name = String::Handle(mixin_cls.Name());
-    ReportError(script, cls.token_pos(),
+    ReportError(Error::Handle(),  // No previous error.
+                script, cls.token_pos(),
                 "mixin class %s must extend class Object",
                 class_name.ToCString());
   }
 
   // Copy type parameters to mixin application class.
   CloneTypeParameters(cls);
 
   if (FLAG_trace_class_finalization) {
     OS::Print("Done applying mixin type '%s' to class %s %s extending '%s'\n",
               String::Handle(mixin_type.Name()).ToCString(),
               String::Handle(cls.Name()).ToCString(),
               TypeArguments::Handle(cls.type_parameters()).ToCString(),
               AbstractType::Handle(cls.super_type()).ToCString());
   }
 }
 
 
 void ClassFinalizer::CreateForwardingConstructors(
     const Class& mixin_app,
     const GrowableObjectArray& cloned_funcs) {
   const String& mixin_name = String::Handle(mixin_app.Name());
   const Class& super_class = Class::Handle(mixin_app.SuperClass());
   const String& super_name = String::Handle(super_class.Name());
   const Type& dynamic_type = Type::Handle(Type::DynamicType());
   const Array& functions = Array::Handle(super_class.functions());
-  intptr_t num_functions = functions.Length();
+  const intptr_t num_functions = functions.Length();
   Function& func = Function::Handle();
   for (intptr_t i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
     if (func.IsConstructor()) {
       // Build constructor name from mixin application class name
       // and name of cloned super class constructor.
       String& ctor_name = String::Handle(func.name());
       ctor_name = String::SubString(ctor_name, super_name.Length());
       String& clone_name =
           String::Handle(String::Concat(mixin_name, ctor_name));
@@ skipping 57 matching lines @@
   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 (int 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(script, cls.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, 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 31 matching lines @@
   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(script, cls.token_pos(),
+    ReportError(Error::Handle(),  // No previous error.
+                script, cls.token_pos(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   // Finalize super class.
   const Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull()) {
     FinalizeTypesInClass(super_class);
   }
   if (cls.mixin() != Type::null()) {
     // Copy the type parameters to the mixin application.
@@ skipping 13 matching lines @@
     // 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(script, cls.token_pos(),
+      ReportError(Error::Handle(),  // No previous error.
+                  script, cls.token_pos(),
                   "typedef '%s' illegally refers to itself",
                   name.ToCString());
     }
     cls.set_is_type_finalized();
     // Signature classes extend Object. No need to add this class to the direct
     // subclasses of Object.
     ASSERT(super_type.IsNull() || super_type.IsObjectType());
 
     // The type parameters of signature classes may have bounds.
     FinalizeUpperBounds(cls);
@@ skipping 17 matching lines @@
     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(script, cls.token_pos(),
+      ReportError(Error::Handle(),  // No previous error.
+                  script, 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(script, cls.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, 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();
   // Finalize bounds even if running in production mode, so that a snapshot
   // contains them.
   FinalizeUpperBounds(cls);
   // Add this class to the direct subclasses of the superclass, unless the
   // superclass is Object.
   if (!super_type.IsNull() && !super_type.IsObjectType()) {
     ASSERT(!super_class.IsNull());
     super_class.AddDirectSubclass(cls);
   }
-  // Top level classes are parsed eagerly so just finalize it.
+  // A top level class is parsed eagerly so just finalize it.
   if (cls.IsTopLevel()) {
     FinalizeClass(cls);
+  } else {
+    // This class should not contain any fields or functions yet, because it has
+    // not been compiled yet. Since 'ResolveAndFinalizeMemberTypes(cls)' has not
+    // been called yet, unfinalized member types could choke the snapshotter.
+    ASSERT(Array::Handle(cls.fields()).Length() == 0);
+    ASSERT(Array::Handle(cls.functions()).Length() == 0);
   }
 }
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
   if (cls.mixin() != Type::null()) {
     // Copy instance methods and fields from the mixin class.
     // This has to happen before the check whether the methods of
     // the class conflict with inherited methods.
     ApplyMixin(cls);
   }
   // Ensure super class is finalized.
   const Class& super = Class::Handle(cls.SuperClass());
   if (!super.IsNull()) {
     FinalizeClass(super);
   }
   // Mark as parsed and finalized.
   cls.Finalize();
+  // Mixin typedef classes may still lack their implicit constructor.
+  // TODO(regis): Implement mixin typedefs with an alias class.
+  if (cls.is_synthesized_class() &&
+      (cls.functions() == Object::empty_array().raw())) {
+    Parser::AddImplicitConstructor(cls);
+  }
+  // Every class should have at least a constructor, unless it is a top level
+  // class or a signature class.
+  ASSERT(cls.IsTopLevel() ||
+         cls.IsSignatureClass() ||
+         (Array::Handle(cls.functions()).Length() > 0));
   // Resolve and finalize all member types.
   ResolveAndFinalizeMemberTypes(cls);
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
   }
 }
 
 
 bool ClassFinalizer::IsSuperCycleFree(const Class& cls) {
@@ skipping 76 matching lines @@
     type = function.ParameterTypeAt(i);
     if (!IsParameterTypeCycleFree(cls, type, visited)) {
       return false;
     }
   }
   visited->RemoveLast();
   return true;
 }
 
 
-void ClassFinalizer::CollectTypeArguments(const Class& cls,
-                              const Type& type,
-                              const GrowableObjectArray& collected_args) {
+void ClassFinalizer::CollectTypeArguments(
+    const Class& cls,
+    const Type& type,
+    const GrowableObjectArray& collected_args) {
   ASSERT(type.HasResolvedTypeClass());
   Class& type_class = Class::Handle(type.type_class());
   AbstractTypeArguments& type_args =
       AbstractTypeArguments::Handle(type.arguments());
-  intptr_t num_type_parameters = type_class.NumTypeParameters();
-  intptr_t num_type_arguments = type_args.IsNull() ? 0 : type_args.Length();
+  const intptr_t num_type_parameters = type_class.NumTypeParameters();
+  const intptr_t num_type_arguments =
+      type_args.IsNull() ? 0 : type_args.Length();
   AbstractType& arg = AbstractType::Handle();
   if (num_type_arguments > 0) {
     if (num_type_arguments != num_type_parameters) {
       const Script& script = Script::Handle(cls.script());
       const String& type_class_name = String::Handle(type_class.Name());
-      ReportError(script, type.token_pos(),
-          "wrong number of type arguments for class '%s'",
-          type_class_name.ToCString());
+      ReportError(Error::Handle(),  // No previous error.
+                  script, type.token_pos(),
+                  "wrong number of type arguments for class '%s'",
+                  type_class_name.ToCString());
     }
     for (int i = 0; i < num_type_arguments; i++) {
       arg = type_args.TypeAt(i);
       collected_args.Add(arg);
     }
   } else {
     // Fill arguments with type dynamic.
     for (int i = 0; i < num_type_parameters; i++) {
       arg = Type::DynamicType();
       collected_args.Add(arg);
@@ skipping 52 matching lines @@
 // Recursively walks the graph of explicitly declared super type and
 // interfaces, resolving unresolved super types and interfaces.
 // Reports an error if there is an interface reference that cannot be
 // resolved, or if there is a cycle in the graph. We detect cycles by
 // remembering interfaces we've visited in each path through the
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
 void ClassFinalizer::ResolveSuperTypeAndInterfaces(
     const Class& cls, GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
+  if (FLAG_trace_class_finalization) {
+    OS::Print("Resolving super and interfaces: %s\n", cls.ToCString());
+  }
   const intptr_t cls_index = cls.id();
   for (int 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(cls.Name());
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, cls.token_pos(),
+      ReportError(Error::Handle(),  // No previous error.
+                  script, 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(cls.super_type());
   Array& super_interfaces = Array::Handle(cls.interfaces());
   if ((super_type.IsNull() || super_type.IsObjectType()) &&
@@ skipping 16 matching lines @@
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
 
   // Resolve super type. Failures lead to a longjmp.
   ResolveType(cls, super_type, kCanonicalizeWellFormed);
   if (super_type.IsMalformed()) {
     ReportError(Error::Handle(super_type.malformed_error()));
   }
   if (super_type.IsDynamicType()) {
     const Script& script = Script::Handle(cls.script());
-    ReportError(script, cls.token_pos(),
+    ReportError(Error::Handle(),  // No previous error.
+                script, cls.token_pos(),
                 "class '%s' may not extend 'dynamic'",
                 String::Handle(cls.Name()).ToCString());
   }
+  interface_class = super_type.type_class();
+  if (interface_class.IsSignatureClass()) {
+    const Script& script = Script::Handle(cls.script());
+    ReportError(Error::Handle(),  // No previous error.
+                script, cls.token_pos(),
+                "class '%s' may not extend function type alias '%s'",
+                String::Handle(cls.Name()).ToCString(),
+                String::Handle(super_type.UserVisibleName()).ToCString());
+  }
 
-  interface_class = super_type.type_class();
   // 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.
       case kSmiCid:
       case kMintCid:
@@ skipping 23 matching lines @@
         if (super_type.IsDoubleType() ||
             super_type.IsIntType() ||
             super_type.IsStringType()) {
           is_error = true;
         }
         break;
       }
     }
     if (is_error) {
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, cls.token_pos(),
+      ReportError(Error::Handle(),  // No previous error.
+                  script, cls.token_pos(),
                   "'%s' is not allowed to extend '%s'",
                   String::Handle(cls.Name()).ToCString(),
                   String::Handle(interface_class.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, kCanonicalizeWellFormed);
     ASSERT(!interface.IsTypeParameter());  // Should be detected by parser.
     if (interface.IsMalformed()) {
       ReportError(Error::Handle(interface.malformed_error()));
     }
     if (interface.IsDynamicType()) {
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, cls.token_pos(),
+      ReportError(Error::Handle(),  // No previous error.
+                  script, cls.token_pos(),
                   "'dynamic' may not be used as interface");
     }
     interface_class = interface.type_class();
     if (interface_class.IsSignatureClass()) {
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, cls.token_pos(),
-                  "'%s' is used where an interface or class name is expected",
+      ReportError(Error::Handle(),  // No previous error.
+                  script, cls.token_pos(),
+                  "function type alias '%s' may not be used as interface",
                   String::Handle(interface_class.Name()).ToCString());
     }
     // Verify that unless cls belongs to core lib, it cannot extend or implement
     // any of bool, num, int, double, String, Function, dynamic.
     // The exception is signature classes, which are compiler generated and
     // represent a function type, therefore implementing the Function interface.
     if (!cls_belongs_to_core_lib) {
       if (interface.IsBoolType() ||
           interface.IsNumberType() ||
           interface.IsIntType() ||
           interface.IsDoubleType() ||
           interface.IsStringType() ||
           (interface.IsFunctionType() && !cls.IsSignatureClass()) ||
           interface.IsDynamicType()) {
         const Script& script = Script::Handle(cls.script());
-        ReportError(script, cls.token_pos(),
+        ReportError(Error::Handle(),  // No previous error.
+                    script, cls.token_pos(),
                     "'%s' is not allowed to extend or implement '%s'",
                     String::Handle(cls.Name()).ToCString(),
                     String::Handle(interface_class.Name()).ToCString());
       }
     }
     interface_class.set_is_implemented();
     // Now resolve the super interfaces.
     ResolveSuperTypeAndInterfaces(interface_class, visited);
   }
   visited->RemoveLast();
 }
 
 
 // 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(script, field.token_pos(),
+      ReportError(Error::Handle(),  // No previous error.
+                  script, 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 104 matching lines @@
   va_end(args);
 }
 
 
 void ClassFinalizer::ReportError(const Error& error) {
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
-void ClassFinalizer::ReportError(const Script& script,
+void ClassFinalizer::ReportError(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(
-      Parser::FormatError(script, token_pos, "Error", format, args));
+  Error& error = Error::Handle();
+  if (prev_error.IsNull()) {
+    error ^= Parser::FormatError(script, token_pos, "Error", format, args);
+  } else {
+    error ^= Parser::FormatErrorWithAppend(
+        prev_error, script, token_pos, "Error", format, args);
+  }
   va_end(args);
   ReportError(error);
 }
 
 
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
@@ skipping 55 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