Set type argument vector at run time in instantiated closure objects.

runtime/vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 958 matching lines @@
   result.set_is_interface();
   return result.raw();
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script,
                                    intptr_t token_index) {
   ASSERT(!signature_function.IsNull());
+  Type& super_type = Type::Handle(Type::ObjectType());
   Array& type_parameters = Array::Handle();
   TypeArray& type_parameter_extends = TypeArray::Handle();
   if (!signature_function.is_static()) {
-    const Class& function_class =
-        Class::Handle(signature_function.owner());
-    ASSERT(!function_class.IsNull());
-    type_parameters = function_class.type_parameters();
-    type_parameter_extends = function_class.type_parameter_extends();
+    const Class& owner_class = Class::Handle(signature_function.owner());
+    ASSERT(!owner_class.IsNull());
+    ASSERT(!owner_class.is_interface());
+    if (owner_class.IsParameterized()) {
+      // Share the function owner super class as the super class of the
+      // signature class, so that the type argument vector of the closure at
+      // run time  matches the type argument vector of the closure instantiator.
+      type_parameters = owner_class.type_parameters();
+      type_parameter_extends = owner_class.type_parameter_extends();
+      super_type = owner_class.super_type();
+    }
   }
   Class& result = Class::Handle(New<Closure>(name, script));
+  result.set_super_type(super_type);
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
   result.set_type_parameter_extends(type_parameter_extends);
   result.SetFields(Array::Handle(Array::Empty()));
   result.SetFunctions(Array::Handle(Array::Empty()));
-  // Set super class to Object.
-  result.set_super_type(Type::Handle(Type::ObjectType()));
   // Implements interface Function.
   const Type& function_interface = Type::Handle(Type::FunctionInterface());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
   interfaces.SetAt(0, function_interface);
   result.set_interfaces(interfaces);
   return result.raw();
 }
 
 
 RawClass* Class::GetClass(ObjectKind kind) {
@@ skipping 3363 matching lines @@
       return false;
     } else {
       ASSERT(test == Type::kIsAssignableTo);
       return true;
     }
   }
   const Class& cls = Class::Handle(clazz());
   TypeArguments& type_arguments = TypeArguments::Handle();
   if (cls.IsParameterized()) {
     type_arguments = GetTypeArguments();
+    // Verify that the number of type arguments in the instance matches the
+    // number of type arguments expected by the instance class.
+    // A discrepancy is allowed for closures, which borrow the type argument
+    // vector of their instantiator, which may be of a super class of the class
+    // defining the closure. Truncating the vector to the correct length on
+    // instantiation is unnecessary. The vector may therefore be longer.
     ASSERT(type_arguments.IsNull() ||
-           (type_arguments.Length() == cls.NumTypeArguments()));
+           (type_arguments.Length() == cls.NumTypeArguments()) ||
+           (cls.IsSignatureClass() &&
+            (type_arguments.Length() > cls.NumTypeArguments())));
   }
   Class& other_class = Class::Handle();
   TypeArguments& other_type_arguments = TypeArguments::Handle();
   // In case 'other' is not instantiated, we could simply call
   // other.InstantiateFrom(other_instantiator, 0), however, we can save the
   // allocation of a new Type by inlining the code.
   if (other.IsTypeParameter()) {
     Type& instantiated_other = Type::Handle();
     if (!other_instantiator.IsNull()) {
       instantiated_other = other_instantiator.TypeAt(other.Index());
@@ skipping 1894 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