Remove parent_level field of function type parameters.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/code_generator.h"
 #include "vm/flags.h"
 #include "vm/hash_table.h"
 #include "vm/heap.h"
@@ skipping 907 matching lines @@
                 "Instantiating TypeRef '%s': '%s'\n"
                 "  instantiator: '%s'\n",
                 String::Handle(super_type_arg.Name()).ToCString(),
                 ref_type.ToCString(), arguments.ToCString());
           }
           // In the typical case of an F-bounded type, the instantiation of the
           // super_type_arg from arguments is a fixpoint. Take the shortcut.
           // Example: class B<T>; class D<T> extends B<D<T>>;
           // While finalizing D<T>, the super type arg D<T> (a typeref) gets
           // instantiated from vector [T], yielding itself.
-          //
           if (super_type_arg.IsTypeRef() && super_type_arg.IsBeingFinalized() &&
               (super_type_arg.arguments() == arguments.raw())) {
             arguments.SetTypeAt(i, super_type_arg);
             continue;
           }
           Error& error = Error::Handle();
           super_type_arg = super_type_arg.InstantiateFrom(
               arguments, Object::null_type_arguments(), &error,
               instantiation_trail, NULL, Heap::kOld);
           if (!error.IsNull()) {
@@ skipping 228 matching lines @@
   if (FLAG_trace_type_finalization) {
     THR_Print("Finalizing type '%s' for class '%s'\n",
               String::Handle(zone, type.Name()).ToCString(),
               String::Handle(zone, cls.Name()).ToCString());
   }
 
   if (type.IsTypeParameter()) {
     const TypeParameter& type_parameter = TypeParameter::Cast(type);
     const Class& parameterized_class =
         Class::Handle(zone, type_parameter.parameterized_class());
+    intptr_t offset;
     if (!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();
-      // Calling NumTypeParameters() may finalize this type parameter if it
-      // belongs to a mixin application class.
-      if (!type_parameter.IsFinalized()) {
-        type_parameter.set_index(type_parameter.index() + offset);
-        type_parameter.SetIsFinalized();
-      } else {
-        ASSERT(cls.IsMixinApplication());
-      }
+      offset = parameterized_class.NumTypeArguments() -
+               parameterized_class.NumTypeParameters();
     } else {
-      // A function type parameter is always finalized.
-      ASSERT(type_parameter.IsFinalized());
+      const Function& function =
+          Function::Handle(zone, type_parameter.parameterized_function());
+      ASSERT(!function.IsNull());
+      offset = function.NumParentTypeParameters();
+    }
+    // Calling NumTypeParameters() may finalize this type parameter if it
+    // belongs to a mixin application class.
+    if (!type_parameter.IsFinalized()) {
+      type_parameter.set_index(type_parameter.index() + offset);
+      type_parameter.SetIsFinalized();
+    } else {
+      ASSERT(cls.IsMixinApplication());
     }
 
     if (FLAG_trace_type_finalization) {
       THR_Print("Done finalizing type parameter '%s' with index %" Pd "\n",
                 String::Handle(zone, type_parameter.name()).ToCString(),
                 type_parameter.index());
     }
 
     // We do not canonicalize type parameters.
     return type_parameter.raw();
@@ skipping 132 matching lines @@
     ResolveType(cls, type);
   }
 }
 
 
 void ClassFinalizer::FinalizeSignature(const Class& cls,
                                        const Function& function,
                                        FinalizationKind finalization) {
   AbstractType& type = AbstractType::Handle();
   AbstractType& finalized_type = AbstractType::Handle();
-  // Finalize upper bounds of function type parameters.
+  // Finalize function type parameters and their upper bounds.
+  const intptr_t num_parent_type_params = function.NumParentTypeParameters();
   const intptr_t num_type_params = function.NumTypeParameters();
   if (num_type_params > 0) {
     TypeParameter& type_param = TypeParameter::Handle();
     const TypeArguments& type_params =
         TypeArguments::Handle(function.type_parameters());
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_param ^= type_params.TypeAt(i);
+      if (!type_param.IsFinalized()) {
+        type_param.set_index(num_parent_type_params + i);
+        type_param.SetIsFinalized();
+      }
       type = type_param.bound();
       finalized_type = FinalizeType(cls, type, finalization);
       if (finalized_type.raw() != type.raw()) {
         type_param.set_bound(finalized_type);
       }
     }
   }
   // Finalize result type.
   type = function.result_type();
   finalized_type = FinalizeType(cls, type, finalization);
@@ skipping 449 matching lines @@
       // the super class of its mixin. Note also that the other mixin
       // application will only mixin the last mixin type listed in the first
       // mixin application it is mixing in.
       param_bound = thread->isolate()->object_store()->object_type();
       for (intptr_t i = 0; i < num_super_type_params; i++) {
         param ^= super_type_params.TypeAt(i);
         param_name = param.name();
         param_name =
             Symbols::FromConcat(thread, param_name, Symbols::Backtick());
         cloned_param =
-            TypeParameter::New(mixin_app_class, null_function, cloned_index, 0,
+            TypeParameter::New(mixin_app_class, null_function, cloned_index,
                                param_name, param_bound, param.token_pos());
         cloned_type_params.SetTypeAt(cloned_index, cloned_param);
         // Change the type arguments of the super type to refer to the
         // cloned type parameters of the mixin application class.
         super_type_args.SetTypeAt(cloned_index, cloned_param);
         cloned_index++;
       }
       // The super type may have a BoundedType as type argument, but cannot be
       // a BoundedType itself.
       Type::Cast(super_type).set_arguments(super_type_args);
@@ skipping 17 matching lines @@
       for (intptr_t i = 0; i < num_mixin_type_params; i++) {
         param ^= mixin_params.TypeAt(i);
         param_name = param.name();
         param_bound = param.bound();  // The bound will be adjusted below.
         if (!param_bound.IsInstantiated()) {
           has_uninstantiated_bounds = true;
         }
         cloned_param =
             TypeParameter::New(mixin_app_class, null_function,
                                cloned_index,  // Unfinalized index.
-                               0, param_name, param_bound, param.token_pos());
+                               param_name, param_bound, param.token_pos());
         cloned_type_params.SetTypeAt(cloned_index, cloned_param);
         mixin_type_args.SetTypeAt(i, cloned_param);  // Unfinalized length.
         instantiator.SetTypeAt(offset + i, cloned_param);  // Finalized length.
         cloned_index++;
       }
 
       // Third, replace the type parameters appearing in the bounds of the mixin
       // type parameters, if any, by the cloned type parameters. This can be
       // done by instantiating each bound using the instantiator built above.
       // If the mixin class extends a generic super class, its first finalized
@@ skipping 553 matching lines @@
     ReportError(cls, cls.token_pos(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   // Finalize super class.
   Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull()) {
     FinalizeTypesInClass(super_class);
   }
   // Finalize type parameters before finalizing the super type.
-  FinalizeTypeParameters(cls);  // May change super type.
-  super_class = cls.SuperClass();
+  FinalizeTypeParameters(cls);  // May change super type while applying mixin.
+  super_class = cls.SuperClass();  // Get again possibly changed super class.
   ASSERT(super_class.IsNull() || super_class.is_type_finalized());
   // Only resolving rather than finalizing the upper bounds here would result in
   // instantiated type parameters of the super type to temporarily have
   // unfinalized bounds. It is more efficient to finalize them early.
   // Finalize bounds even if running in production mode, so that a snapshot
   // contains them.
   FinalizeUpperBounds(cls);
   // Finalize super type.
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
@@ skipping 1314 matching lines @@
   ProgramVisitor::VisitFunctions(&function_visitor);
 
   class ClearCodeClassVisitor : public ClassVisitor {
     void Visit(const Class& cls) { cls.DisableAllocationStub(); }
   };
   ClearCodeClassVisitor class_visitor;
   ProgramVisitor::VisitClasses(&class_visitor);
 }
 
 }  // namespace dart