Consider upper bounds of type parameters in type checks.

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 416 matching lines @@
       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) {
     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());
+    const bool check_type_parameter_bounds = true;
     if (!AbstractTypeArguments::AreIdentical(expected_type_parameters,
-                                             actual_type_parameters) ||
-        !AbstractTypeArguments::AreIdentical(expected_type_parameter_bounds,
-                                             actual_type_parameter_bounds)) {
+                                             actual_type_parameters,
+                                             check_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_pos(),
                   "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.
+  // have identical names, but not necessarily identical bounds.
   const TypeArguments& interface_type_parameters =
       TypeArguments::Handle(interface.type_parameters());
   const TypeArguments& factory_type_parameters =
       TypeArguments::Handle(factory_class.type_parameters());
+  const bool check_type_parameter_bounds = false;
   if (!AbstractTypeArguments::AreIdentical(interface_type_parameters,
-                                           factory_type_parameters)) {
+                                           factory_type_parameters,
+                                           check_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_pos(),
                 "mismatch in number or names of type parameters between "
                 "interface '%s' and default factory class '%s'",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
 }
@@ skipping 157 matching lines @@
     const Class& parameterized_class =
         Class::Handle(type_parameter.parameterized_class());
     ASSERT(!parameterized_class.IsNull());
     // The index must reflect the position of this type parameter in the type
     // arguments vector of its parameterized class. The offset to add is the
     // number of type arguments in the super type, which is equal to the
     // difference in number of type arguments and type parameters of the
     // parameterized class.
     const intptr_t offset = parameterized_class.NumTypeArguments() -
                             parameterized_class.NumTypeParameters();
-    type_parameter.set_index(type_parameter.Index() + offset);
+    type_parameter.set_index(type_parameter.index() + offset);
     type_parameter.set_is_finalized();
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
   // At this point, we can only have a parameterized_type.
   Type& parameterized_type = Type::Handle();
   parameterized_type ^= type.raw();
 
   if (parameterized_type.IsBeingFinalized()) {
@@ skipping 245 matching lines @@
     }
     super_class = super_class.SuperClass();
   }
   return Class::null();
 }
 
 
 // Resolve and finalize the upper bounds of the type parameters of class cls.
 void ClassFinalizer::ResolveAndFinalizeUpperBounds(const Class& cls) {
   const intptr_t num_type_params = cls.NumTypeParameters();
+  TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
-  const AbstractTypeArguments& bounds =
-      AbstractTypeArguments::Handle(cls.type_parameter_bounds());
-  ASSERT((bounds.IsNull() && (num_type_params == 0)) ||
-         (bounds.Length() == num_type_params));
+  const AbstractTypeArguments& type_params =
+      AbstractTypeArguments::Handle(cls.type_parameters());
+  ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
+         (type_params.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
-    bound = bounds.TypeAt(i);
+    type_param ^= type_params.TypeAt(i);
+    bound = type_param.bound();
     if (bound.IsFinalized()) {
       continue;
     }
     ResolveType(cls, bound, kFinalize);
     bound = FinalizeType(cls, bound, kFinalize);
-    bounds.SetTypeAt(i, bound);
+    type_param.set_bound(bound);
   }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
   // Note that getters and setters are explicitly listed as such in the list of
   // functions of a class, so we do not need to consider fields as implicitly
   // generating getters and setters.
   // The only compile errors we report are therefore:
   // - a getter having the same name as a method (but not a getter) in a super
@@ skipping 571 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