Check upper bounds of type arguments when allocating objects of a generic type

runtime/vm/object.cc

Index: runtime/vm/object.cc
===================================================================
--- runtime/vm/object.cc	(revision 7209)
+++ runtime/vm/object.cc	(working copy)
@@ -2203,8 +2203,8 @@
   }
   // AbstractType parameters cannot be handled by Class::IsSubtypeOf().
   if (IsTypeParameter() || other.IsTypeParameter()) {
-    // An uninstantiated type parameter is equivalent to Dynamic.
-    return true;
+    return IsTypeParameter() && other.IsTypeParameter() &&
+        (Index() == other.Index());

[srdjan, 2012/05/01 23:30:51]

I do not understand this change.

[regis, 2012/05/02 01:34:16]

The previous test was too lenient. You can imagine comparing two signatures, one
returning K, the other one returning V, both type parameters. They should
differ.

Previously, we only encountered type parameters when testing signatures,
because, beside uninstantiated function result types and uninstantiated function
parameter types, we only tested instantiated types. With this change, we can
also test uninstantiated types. This is how we decide whether a run time bounds
check is necessary or not. We perform a subtype check of the uninstantiated
bounds and only return true if the test is guaranteed to succeed.
For example, with class A<K, V extends K>, new A<T, T> called from with a class
<T> will never require a run time bounds check, even it T is uninstantiated at
compile time.

I have added a comment.

   }
   const Class& cls = Class::Handle(type_class());
   return cls.IsSubtypeOf(AbstractTypeArguments::Handle(arguments()),
@@ -2629,8 +2629,10 @@
   }
   TypeParameter& other_type_param = TypeParameter::Handle();
   other_type_param ^= other.raw();
-  // Both type parameters may have different type_class and their index may be
-  // different after finalization, which is OK. Do not check.
+  // IsIdentical may be called on type parameters belonging to different
+  // classes, e.g. to an interface and to its default factory class.
+  // Therefore, both type parameters may have different parameterized classes
+  // and different indices. Compare the type parameter names only.
   String& name = String::Handle(Name());
   String& other_name = String::Handle(other_type_param.Name());
   return name.Equals(other_name);
@@ -2959,7 +2961,9 @@
     const AbstractTypeArguments& bounds_instantiator,
     Error* malformed_error) const {
   ASSERT(FLAG_enable_type_checks);
-  ASSERT(IsInstantiated());
+  // This function may be called at compile time on (partially) uninstantiated
+  // type arguments and may return true, in which case a run time bounds check
+  // can be avoided.
   ASSERT(Length() >= cls.NumTypeArguments());
   const intptr_t num_type_params = cls.NumTypeParameters();
   const intptr_t offset = cls.NumTypeArguments() - num_type_params;