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

runtime/vm/object.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/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 2185 matching lines @@
   }
   if (other.IsMalformed()) {
     ASSERT(FLAG_enable_type_checks);
     if (malformed_error->IsNull()) {
       *malformed_error = other.malformed_error();
     }
     return false;
   }
   // 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()),
                          Class::Handle(other.type_class()),
                          AbstractTypeArguments::Handle(other.arguments()),
                          malformed_error);
 }
 
 RawAbstractType* AbstractType::NewTypeParameter(const Class& clazz,
                                                 intptr_t index,
@@ skipping 404 matching lines @@
 
 bool TypeParameter::IsIdentical(const AbstractType& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
   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);
 }
 
 
 void TypeParameter::set_parameterized_class(const Class& value) const {
   // Set value may be null.
   StorePointer(&raw_ptr()->parameterized_class_, value.raw());
 }
@@ skipping 308 matching lines @@
                                          "Error", format, args);
   }
 }
 
 
 bool AbstractTypeArguments::IsWithinBoundsOf(
     const Class& cls,
     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;
   AbstractType& type = AbstractType::Handle();
   AbstractType& bound = AbstractType::Handle();
   const TypeArguments& bounds =
       TypeArguments::Handle(cls.type_parameter_bounds());
   ASSERT((bounds.IsNull() && (num_type_params == 0)) ||
          (bounds.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
@@ skipping 6316 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart