Adjust index of type parameters at finalization time (fix issue 718).

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 1348 matching lines @@
         // parameters of this type before performing the type test.
         if (type_arguments.IsNull()) {
           // This type is raw, so the uninstantiated type arguments of the
           // interface cannot be instantiated and we must check against a raw
           // interface.
           interface_args = TypeArguments::null();
         } else {
           // The type arguments of this type that are referred to by the type
           // parameters of the interface are at the end of the type vector,
           // after the type arguments of the super type of this type.
-          const intptr_t offset = NumTypeArguments() - NumTypeParameters();
-          interface_args = interface_args.InstantiateFrom(type_arguments,
-                                                          offset);
+          // The index of the type parameters is adjusted upon finalization.
+          ASSERT(interface.IsFinalized());
+          interface_args = interface_args.InstantiateFrom(type_arguments);
           // TODO(regis): Check the subtyping constraints if any, i.e. if
           // interface.type_parameter_extends() is not an array of DynamicType.
           // Should we pass the constraints to InstantiateFrom and it would
           // return null on failure?
         }
       }
       if (interface_class.IsMoreSpecificThan(interface_args,
                                              other,
                                              other_type_arguments)) {
         return true;
@@ skipping 357 matching lines @@
 
 
 bool AbstractType::Equals(const AbstractType& other) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 RawAbstractType* AbstractType::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
-    intptr_t offset) const {
+    const AbstractTypeArguments& instantiator_type_arguments) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawAbstractType* AbstractType::Canonicalize() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
@@ skipping 26 matching lines @@
       first_type_param_index = num_args - num_type_params;
     }
     if (cls.IsSignatureClass()) {
       // We may be reporting an error about an illformed function type. In that
       // case, avoid instantiating the signature, since it may lead to cycles.
       if (!IsFinalized() || IsBeingFinalized()) {
         return class_name.raw();
       }
       const Function& signature_function = Function::Handle(
           cls.signature_function());
-      return signature_function.InstantiatedSignatureFrom(
-          args, first_type_param_index);
+      // Signature classes have no super type.
+      ASSERT(first_type_param_index == 0);
+      return signature_function.InstantiatedSignatureFrom(args);
     }
   } else {
     const UnresolvedClass& cls = UnresolvedClass::Handle(unresolved_class());
     class_name = cls.Name();
     num_type_params = num_args;
     first_type_param_index = 0;
   }
   String& type_name = String::Handle();
   if (num_type_params == 0) {
     type_name = class_name.raw();
@@ skipping 279 matching lines @@
 
 
 bool Type::IsInstantiated() const {
   const AbstractTypeArguments& args =
       AbstractTypeArguments::Handle(arguments());
   return args.IsNull() || args.IsInstantiated();
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
-    intptr_t offset) const {
+    const AbstractTypeArguments& instantiator_type_arguments) const {
   ASSERT(IsFinalized());
   ASSERT(!IsInstantiated());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(arguments());
-  type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
-                                                  offset);
+  type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments);
   const Class& cls = Class::Handle(type_class());
   ASSERT(cls.is_finalized());
   Type& instantiated_type = Type::Handle(Type::New(cls, type_arguments));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
   instantiated_type.set_is_finalized();
   return instantiated_type.raw();
 }
 
 
@@ skipping 124 matching lines @@
           Isolate::Current()->current_zone()->Allocate(len));
       OS::SNPrint(chars, len, format, class_name, args_cstr);
       return chars;
     }
   } else {
     return "Unresolved Type";
   }
 }
 
 
+void TypeParameter::set_is_finalized() const {
+  ASSERT(!IsFinalized());
+  set_type_state(RawTypeParameter::kFinalized);
+}
+
+
 bool TypeParameter::Equals(const AbstractType& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
   TypeParameter& other_type_parameter = TypeParameter::Handle();
   other_type_parameter ^= other.raw();
   return Index() == other_type_parameter.Index();
 }
 
 
 void TypeParameter::set_index(intptr_t value) const {
   ASSERT(value >= 0);
   raw_ptr()->index_ = value;
 }
 
 
 void TypeParameter::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 RawAbstractType* TypeParameter::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
-    intptr_t offset) const {
+    const AbstractTypeArguments& instantiator_type_arguments) const {
+  ASSERT(IsFinalized());
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
-  return instantiator_type_arguments.TypeAt(Index() + offset);
+  return instantiator_type_arguments.TypeAt(Index());
 }
 
 
 RawTypeParameter* TypeParameter::New() {
   const Class& type_parameter_class =
       Class::Handle(Object::type_parameter_class());
   RawObject* raw = Object::Allocate(type_parameter_class,
                                     TypeParameter::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawTypeParameter*>(raw);
 }
 
 
 RawTypeParameter* TypeParameter::New(intptr_t index, const String& name) {
   const TypeParameter& result = TypeParameter::Handle(TypeParameter::New());
   result.set_index(index);
   result.set_name(name);
+  result.raw_ptr()->type_state_ = RawTypeParameter::kAllocated;
   return result.raw();
 }
 
 
+void TypeParameter::set_type_state(int8_t state) const {
+  ASSERT(state == RawTypeParameter::kAllocated ||
+         state == RawTypeParameter::kBeingFinalized ||
+         state == RawTypeParameter::kFinalized);
+  raw_ptr()->type_state_ = state;
+}
+
+
 const char* TypeParameter::ToCString() const {
   const char* format = "TypeParameter: name %s; index: %d";
   const char* name_cstr = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, name_cstr, Index()) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, format, name_cstr, Index());
   return chars;
 }
 
@@ skipping 122 matching lines @@
     return other_arguments.IsDynamicTypes(other_arguments.Length());
   }
   if (other_arguments.IsNull()) {
     return arguments.IsDynamicTypes(arguments.Length());
   }
   return arguments.Equals(other_arguments);
 }
 
 
 RawAbstractTypeArguments* AbstractTypeArguments::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
-    intptr_t offset) const {
+    const AbstractTypeArguments& instantiator_type_arguments) const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 bool AbstractTypeArguments::IsDynamicTypes(intptr_t len) const {
   ASSERT(Length() >= len);
   AbstractType& type = AbstractType::Handle();
   Class& type_class = Class::Handle();
@@ skipping 94 matching lines @@
     type = TypeAt(i);
     if (!type.IsTypeParameter() || (type.Index() != i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawAbstractTypeArguments* TypeArguments::InstantiateFrom(
-    const AbstractTypeArguments& instantiator_type_arguments,
-    intptr_t offset) const {
+    const AbstractTypeArguments& instantiator_type_arguments) const {
   ASSERT(!IsInstantiated());
-  if ((offset == 0) &&
-      !instantiator_type_arguments.IsNull() &&
+  if (!instantiator_type_arguments.IsNull() &&
       IsUninstantiatedIdentity() &&
       (instantiator_type_arguments.Length() == Length())) {
     return instantiator_type_arguments.raw();
   }
   const intptr_t num_types = Length();
   TypeArguments& instantiated_array =
       TypeArguments::Handle(TypeArguments::New(num_types));
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsInstantiated()) {
-      type = type.InstantiateFrom(instantiator_type_arguments, offset);
+      type = type.InstantiateFrom(instantiator_type_arguments);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
 
 
 RawTypeArguments* TypeArguments::New(intptr_t len) {
   if ((len < 0) || (len > kMaxTypes)) {
     // TODO(iposva): Should we throw an illegal parameter exception?
@@ skipping 458 matching lines @@
 
 
 bool Function::TestParameterType(
     intptr_t parameter_position,
     const AbstractTypeArguments& type_arguments,
     const Function& other,
     const AbstractTypeArguments& other_type_arguments) const {
   AbstractType& param_type =
       AbstractType::Handle(ParameterTypeAt(parameter_position));
   if (!param_type.IsInstantiated()) {
-    param_type = param_type.InstantiateFrom(type_arguments, 0);
+    param_type = param_type.InstantiateFrom(type_arguments);
   }
   if (param_type.IsDynamicType()) {
     return true;
   }
   AbstractType& other_param_type =
       AbstractType::Handle(other.ParameterTypeAt(parameter_position));
   if (!other_param_type.IsInstantiated()) {
-    other_param_type =
-        other_param_type.InstantiateFrom(other_type_arguments, 0);
+    other_param_type = other_param_type.InstantiateFrom(other_type_arguments);
   }
   if (other_param_type.IsDynamicType()) {
     return true;
   }
   if (!param_type.IsSubtypeOf(other_param_type) &&
       !other_param_type.IsSubtypeOf(param_type)) {
     return false;
   }
   return true;
 }
 
 
 bool Function::TestType(
     TypeTestKind test,
     const AbstractTypeArguments& type_arguments,
     const Function& other,
     const AbstractTypeArguments& other_type_arguments) const {
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_params = num_optional_parameters();
   const intptr_t other_num_fixed_params = other.num_fixed_parameters();
   const intptr_t other_num_opt_params = other.num_optional_parameters();
   if ((num_fixed_params != other_num_fixed_params) ||
       ((test == AbstractType::kIsSubtypeOf) &&
        (num_opt_params < other_num_opt_params))) {
     return false;
   }
   // Check the result type.
   AbstractType& other_res_type = AbstractType::Handle(other.result_type());
   if (!other_res_type.IsInstantiated()) {
-    other_res_type = other_res_type.InstantiateFrom(other_type_arguments, 0);
+    other_res_type = other_res_type.InstantiateFrom(other_type_arguments);
   }
   if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
     AbstractType& res_type = AbstractType::Handle(result_type());
     if (!res_type.IsInstantiated()) {
-      res_type = res_type.InstantiateFrom(type_arguments, 0);
+      res_type = res_type.InstantiateFrom(type_arguments);
     }
     if (!res_type.IsDynamicType() &&
         (res_type.IsVoidType() ||
          !(res_type.IsSubtypeOf(other_res_type) ||
            other_res_type.IsSubtypeOf(res_type)))) {
       return false;
     }
   }
   // Check the types of fixed parameters.
   for (intptr_t i = 0; i < num_fixed_params; i++) {
@@ skipping 159 matching lines @@
     signature_class = Class::NewSignatureClass(signature,
                                                closure_function,
                                                script);
     library.AddClass(signature_class);
   } else {
     closure_function.set_signature_class(signature_class);
   }
   const Type& signature_type = Type::Handle(signature_class.SignatureType());
   if (!signature_type.IsFinalized()) {
     String& errmsg = String::Handle();
-    ClassFinalizer::FinalizeAndCanonicalizeType(signature_type, &errmsg);
+    ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
+                                                signature_type,
+                                                &errmsg);
     ASSERT(errmsg.IsNull());
   }
   ASSERT(closure_function.signature_class() == signature_class.raw());
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
 
 
 template<typename T>
 static RawArray* NewArray(const GrowableArray<T*>& objs) {
   Array& a = Array::Handle(Array::New(objs.length(), Heap::kOld));
   for (int i = 0; i < objs.length(); i++) {
     a.SetAt(i, *objs[i]);
   }
   return a.raw();
 }
 
 
-RawString* Function::BuildSignature(bool instantiate,
-                                    const AbstractTypeArguments& instantiator,
-                                    intptr_t offset) const {
+RawString* Function::BuildSignature(
+    bool instantiate,
+    const AbstractTypeArguments& instantiator) const {
   GrowableArray<const String*> pieces;
   const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
   const String& kColonSpace = String::Handle(String::NewSymbol(": "));
   const String& kLParen = String::Handle(String::NewSymbol("("));
   const String& kRParen = String::Handle(String::NewSymbol(") => "));
   const String& kLBracket = String::Handle(String::NewSymbol("["));
   const String& kRBracket = String::Handle(String::NewSymbol("]"));
   if (!instantiate && !is_static()) {
     const String& kSpaceExtendsSpace =
         String::Handle(String::NewSymbol(" extends "));
@@ skipping 28 matching lines @@
   AbstractType& param_type = AbstractType::Handle();
   const intptr_t num_params = NumberOfParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_params = num_optional_parameters();
   ASSERT((num_fixed_params + num_opt_params) == num_params);
   pieces.Add(&kLParen);
   for (intptr_t i = 0; i < num_fixed_params; i++) {
     param_type = ParameterTypeAt(i);
     ASSERT(!param_type.IsNull());
     if (instantiate && !param_type.IsInstantiated()) {
-      param_type = param_type.InstantiateFrom(instantiator, offset);
+      param_type = param_type.InstantiateFrom(instantiator);
     }
     pieces.Add(&String::ZoneHandle(param_type.Name()));
     if (i != (num_params - 1)) {
       pieces.Add(&kCommaSpace);
     }
   }
   if (num_opt_params > 0) {
     pieces.Add(&kLBracket);
     for (intptr_t i = num_fixed_params; i < num_params; i++) {
       pieces.Add(&String::ZoneHandle(ParameterNameAt(i)));
       pieces.Add(&kColonSpace);
       param_type = ParameterTypeAt(i);
       if (instantiate && !param_type.IsInstantiated()) {
-        param_type = param_type.InstantiateFrom(instantiator, offset);
+        param_type = param_type.InstantiateFrom(instantiator);
       }
       ASSERT(!param_type.IsNull());
       pieces.Add(&String::ZoneHandle(param_type.Name()));
       if (i != (num_params - 1)) {
         pieces.Add(&kCommaSpace);
       }
     }
     pieces.Add(&kRBracket);
   }
   pieces.Add(&kRParen);
   AbstractType& res_type = AbstractType::Handle(result_type());
   if (instantiate && !res_type.IsInstantiated()) {
-    res_type = res_type.InstantiateFrom(instantiator, offset);
+    res_type = res_type.InstantiateFrom(instantiator);
   }
   pieces.Add(&String::Handle(res_type.Name()));
   const Array& strings = Array::Handle(NewArray<const String>(pieces));
   return String::NewSymbol(String::Handle(String::ConcatAll(strings)));
 }
 
 
 bool Function::HasInstantiatedSignature() const {
   AbstractType& type = AbstractType::Handle(result_type());
   if (!type.IsInstantiated()) {
@@ skipping 1728 matching lines @@
     // 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() == num_type_arguments) ||
            (cls.IsSignatureClass() &&
             (type_arguments.Length() > num_type_arguments)));
   }
   Class& other_class = Class::Handle();
   AbstractTypeArguments& other_type_arguments = AbstractTypeArguments::Handle();
   // In case 'other' is not instantiated, we could simply call
-  // other.InstantiateFrom(other_instantiator, 0), however, we can save the
+  // other.InstantiateFrom(other_instantiator), however, we can save the
   // allocation of a new AbstractType by inlining the code.
   if (other.IsTypeParameter()) {
     AbstractType& instantiated_other = AbstractType::Handle();
     if (!other_instantiator.IsNull()) {
       instantiated_other = other_instantiator.TypeAt(other.Index());
       ASSERT(instantiated_other.IsInstantiated());
     } else {
       instantiated_other = Type::DynamicType();
     }
     other_class = instantiated_other.type_class();
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
     if (!other_type_arguments.IsNull() &&
         !other_type_arguments.IsInstantiated()) {
       other_type_arguments =
-          other_type_arguments.InstantiateFrom(other_instantiator, 0);
+          other_type_arguments.InstantiateFrom(other_instantiator);
     }
   }
   return cls.TestType(test, type_arguments, other_class, other_type_arguments);
 }
 
 
 bool Instance::IsValidNativeIndex(int index) const {
   const Class& cls = Class::Handle(clazz());
   return (index >= 0 && index < cls.num_native_fields());
 }
@@ skipping 2165 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