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

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 862 matching lines @@
                                                    script_);
         // Record the function signature class in the current library.
         library_.AddClass(signature_class);
       } else {
         signature_function.set_signature_class(signature_class);
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
       Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
         String& errmsg = String::Handle();
-        signature_type =
-            ClassFinalizer::FinalizeAndCanonicalizeType(signature_type,
+        signature_type ^=
+            ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
+                                                        signature_type,
                                                         &errmsg);
         if (!errmsg.IsNull()) {
           ErrorMsg(errmsg.ToCString());
         }
       }
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
   }
 
@@ skipping 2852 matching lines @@
     // We need to create a new type for proper finalization, since the existing
     // type is already marked as finalized.
     Type& signature_type = Type::Handle(signature_class.SignatureType());
     const AbstractTypeArguments& signature_type_arguments =
         AbstractTypeArguments::Handle(signature_type.arguments());
 
     // Since the signature type is cached by the signature class, it may have
     // been finalized already.
     if (!signature_type.IsFinalized()) {
       String& errmsg = String::Handle();
-      signature_type =
-          ClassFinalizer::FinalizeAndCanonicalizeType(signature_type, &errmsg);
+      signature_type ^=
+          ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
+                                                      signature_type,
+                                                      &errmsg);
       if (!errmsg.IsNull()) {
         ErrorMsg(errmsg.ToCString());
       }
       // The call to ClassFinalizer::FinalizeAndCanonicalizeType may have
       // extended the vector of type arguments.
       ASSERT(signature_type_arguments.IsNull() ||
              (signature_type_arguments.Length() ==
               signature_class.NumTypeArguments()));
       // The signature_class should not have changed.
       ASSERT(signature_type.type_class() == signature_class.raw());
@@ skipping 2779 matching lines @@
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   const intptr_t type_pos = token_index_;
   ParseQualIdent(&type_name);
   if (type_name.is_local_scope_ident) {
     ErrorMsg(type_pos, "using '%s' in this context is invalid",
              type_name.ident->ToCString());
   }
+  Class& scope_class = Class::Handle();
   Object& type_class = Object::Handle();
   if (type_resolution == kDoNotResolve) {
     String& qualifier = String::Handle();
     if (type_name.qualifier != NULL) {
       qualifier ^= type_name.qualifier->raw();
     }
     type_class = UnresolvedClass::New(type_pos, qualifier, *(type_name.ident));
   } else {
-    const Class& scope_class = Class::Handle(TypeParametersScopeClass());
+    scope_class = TypeParametersScopeClass();
     if (!scope_class.IsNull()) {
       TypeParameter& type_parameter = TypeParameter::Handle();
       // Check if qualifier is a type parameter in scope.
       if (type_name.qualifier != NULL) {
         type_parameter = scope_class.LookupTypeParameter(*type_name.qualifier);
         if (!type_parameter.IsNull()) {
           ErrorMsg(type_pos, "type Parameter '%s' cannot be used as qualifier",
                    type_name.qualifier->ToCString());
         }
       } else {
         // Check if ident is a type parameter in scope.
         type_parameter = scope_class.LookupTypeParameter(*type_name.ident);
         if (!type_parameter.IsNull()) {
           if (CurrentToken() == Token::kLT) {
             // A type parameter cannot be parameterized.
             ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
                      String::Handle(type_parameter.Name()).ToCString());
           }
+          if (type_resolution == kMustResolve) {
+            String& errmsg = String::Handle();
+            type_parameter ^=
+                ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
+                                                            type_parameter,
+                                                            &errmsg);
+            if (!errmsg.IsNull()) {
+              ErrorMsg(errmsg.ToCString());
+            }
+          }
           return type_parameter.raw();
         }
       }
     }
     // Try to resolve the type class.
     type_class = LookupTypeClass(type_name, type_resolution);
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(ParseTypeArguments(type_resolution));
   Type& type = Type::Handle(
       Type::NewParameterizedType(type_class, type_arguments));
   if (type_resolution == kMustResolve) {
     ASSERT(type_class.IsClass());  // Must be resolved.
     String& errmsg = String::Handle();
-    type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
+    type ^= ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
+                                                        type,
+                                                        &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
@@ skipping 530 matching lines @@
     if (constructor.IsFactory()) {
       signature_class = constructor.signature_class();
     } else {
       signature_class = constructor.owner();
       ASSERT(signature_class.raw() == type_class.raw());
     }
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
         Type::NewParameterizedType(signature_class, type_arguments));
     String& errmsg = String::Handle();
-    type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
+    type ^= ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
+                                                        type,
+                                                        &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
     }
     // The type argument vector may have been expanded with the type arguments
     // of the super type when finalizing the type.
     type_arguments = type.arguments();
   }
 
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
@@ skipping 459 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart