Do not require upper bounds to be resolved and finalized before comparing them

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 39 matching lines @@
     ASSERT(!class_array.IsNull());
     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 default: %s\n", cls.ToCString());
       }
       ResolveSuperType(cls);
       if (cls.is_interface()) {
-        ResolveDefaultClass(cls);
+        ResolveFactoryClass(cls);
       }
     }
     // Finalize all classes.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       FinalizeClass(cls, generating_snapshot);
     }
     if (FLAG_print_classes) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
         cls ^= class_array.At(i);
@@ skipping 261 matching lines @@
       ReportError(script, cls.token_index(),
                   "'%s' is not allowed to extend '%s'",
                   String::Handle(cls.Name()).ToCString(),
                   String::Handle(super_class.Name()).ToCString());
     }
   }
   return;
 }
 
 
-void ClassFinalizer::ResolveDefaultClass(const Class& interface) {
+void ClassFinalizer::ResolveFactoryClass(const Class& interface) {
   ASSERT(interface.is_interface());
   if (interface.is_finalized() ||
       !interface.HasFactoryClass() ||
       interface.HasResolvedFactoryClass()) {
     return;
   }
   const UnresolvedClass& unresolved_factory_class =
       UnresolvedClass::Handle(interface.UnresolvedFactoryClass());
 
   // Lookup the factory class.
   const Class& factory_class =
       Class::Handle(ResolveClass(interface, unresolved_factory_class));
   if (factory_class.IsNull()) {
     const Script& script = Script::Handle(interface.script());
     ReportError(script, unresolved_factory_class.token_index(),
                 "cannot resolve factory class name '%s' from '%s'",
                 String::Handle(unresolved_factory_class.Name()).ToCString(),
                 String::Handle(interface.Name()).ToCString());
   }
   if (factory_class.is_interface()) {
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     const Script& script = Script::Handle(interface.script());
     ReportError(script, unresolved_factory_class.token_index(),
                 "default clause of interface '%s' names non-class '%s'",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
   interface.set_factory_class(factory_class);
-  ResolveAndFinalizeUpperBounds(factory_class);
+  // It is not necessary to finalize the bounds before comparing them between
+  // the expected and actual factory class.
   const Class& factory_signature_class = Class::Handle(
       unresolved_factory_class.factory_signature_class());
   ASSERT(!factory_signature_class.IsNull());
   // If a type parameter list is included in the default factory clause (it
   // can be omitted), verify that it matches the list of type parameters of
   // the factory class in number, names, and bounds.
   if (factory_signature_class.NumTypeParameters() > 0) {
-    ResolveAndFinalizeUpperBounds(factory_signature_class);
     const TypeArguments& expected_type_parameters =
         TypeArguments::Handle(factory_signature_class.type_parameters());
     const TypeArguments& actual_type_parameters =
         TypeArguments::Handle(factory_class.type_parameters());
     const TypeArguments& expected_type_parameter_bounds =
         TypeArguments::Handle(factory_signature_class.type_parameter_bounds());
     const TypeArguments& actual_type_parameter_bounds =
         TypeArguments::Handle(factory_class.type_parameter_bounds());
-    if (!TypeArguments::AreIdenticalTypeParameters(expected_type_parameters,
-                                                   actual_type_parameters) ||
-        !AbstractTypeArguments::AreEqual(expected_type_parameter_bounds,
-                                         actual_type_parameter_bounds)) {
+    if (!AbstractTypeArguments::AreIdentical(expected_type_parameters,
+                                             actual_type_parameters) ||
+        !AbstractTypeArguments::AreIdentical(expected_type_parameter_bounds,
+                                             actual_type_parameter_bounds)) {
       const String& interface_name = String::Handle(interface.Name());
       const String& factory_name = String::Handle(factory_class.Name());
       const Script& script = Script::Handle(interface.script());
       ReportError(script, unresolved_factory_class.token_index(),
                   "mismatch in number, names, or bounds of type parameters "
                   "between default clause of interface '%s' and actual factory "
                   "class '%s'",
                   interface_name.ToCString(),
                   factory_name.ToCString());
     }
   }
   // Verify that the type parameters of the factory class and of the interface
   // have identical names.
   const TypeArguments& interface_type_parameters =
       TypeArguments::Handle(interface.type_parameters());
   const TypeArguments& factory_type_parameters =
       TypeArguments::Handle(factory_class.type_parameters());
-  if (!TypeArguments::AreIdenticalTypeParameters(interface_type_parameters,
-                                                 factory_type_parameters)) {
+  if (!AbstractTypeArguments::AreIdentical(interface_type_parameters,
+                                           factory_type_parameters)) {
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     const Script& script = Script::Handle(interface.script());
     ReportError(script, unresolved_factory_class.token_index(),
                 "mismatch in number or names of type parameters between "
                 "interface '%s' and default factory class '%s'",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
 }
@@ skipping 882 matching lines @@
 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));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart