Use List instead of Link in the type system.

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // 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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 1650 matching lines @@
       if (backend.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
         ClassElement currentClass = caller.enclosingClass;
         // For a super constructor call, the type is the supertype of
         // [currentClass]. For a redirecting constructor, the type is
         // the current type. [InterfaceType.asInstanceOf] takes care
         // of both.
         InterfaceType type = currentClass.thisType.asInstanceOf(enclosingClass);
         type = localsHandler.substInContext(type);
-        Link<DartType> typeVariables = enclosingClass.typeVariables;
-        type.typeArguments.forEach((DartType argument) {
-          localsHandler.updateLocal(
-              typeVariables.head.element,
-              analyzeTypeArgument(argument));
-          typeVariables = typeVariables.tail;
-        });
-        // If the supertype is a raw type, we need to set to null the
-        // type variables.
-        assert(typeVariables.isEmpty
-               || enclosingClass.typeVariables == typeVariables);
-        while (!typeVariables.isEmpty) {
-          localsHandler.updateLocal(typeVariables.head.element,
-              graph.addConstantNull(compiler));
-          typeVariables = typeVariables.tail;
+        List<DartType> arguments = type.typeArguments;
+        List<DartType> typeVariables = enclosingClass.typeVariables;
+        if (!type.isRaw) {
+          assert(arguments.length == typeVariables.length);
+          Iterator<DartType> variables = typeVariables.iterator;
+          type.typeArguments.forEach((DartType argument) {
+            variables.moveNext();
+            localsHandler.updateLocal(
+                variables.current.element,
+                analyzeTypeArgument(argument));
+          });
+        } else {
+          // If the supertype is a raw type, we need to set to null the
+          // type variables.
+          for (DartType variable in typeVariables) {
+            localsHandler.updateLocal(variable.element,
+                graph.addConstantNull(compiler));
+          }
         }
       }
 
       // For redirecting constructors, the fields have already been
       // initialized by the caller.
       if (callee.enclosingClass != caller.enclosingClass) {
         inlinedFrom(callee, () {
           buildFieldInitializers(callee.enclosingElement.implementation,
                                fieldValues);
         });
@@ skipping 281 matching lines @@
       // would be of the form:
       //  [getTypeArgumentByIndex(this, 0), .., getTypeArgumentByIndex(this, k)]
       // and k is the number of type arguments of this.  If this is the case,
       // we can simply copy the list from this.
 
       // These locals are modified by [isIndexedTypeArgumentGet].
       HInstruction source;  // The source of the type arguments.
       bool allIndexed = true;
       int expectedIndex = 0;
       ClassElement contextClass;  // The class of `this`.
-      Link typeVariables;  // The list of 'remaining type variables' of `this`.
+      int remainingTypeVariables;  // The number of 'remaining type variables'
+                                   // of `this`.
 
       /// Helper to identify instructions that read a type variable without
       /// substitution (that is, directly use the index). These instructions
       /// are of the form:
       ///   HInvokeStatic(getTypeArgumentByIndex, this, index)
       ///
       /// Return `true` if [instruction] is of that form and the index is the
       /// next index in the sequence (held in [expectedIndex]).
       bool isIndexedTypeArgumentGet(HInstruction instruction) {
         if (instruction is! HInvokeStatic) return false;
         HInvokeStatic invoke = instruction;
         if (invoke.element != backend.getGetTypeArgumentByIndex()) {
           return false;
         }
         HConstant index = invoke.inputs[1];
         HInstruction newSource = invoke.inputs[0];
         if (newSource is! HThis) {
           return false;
         }
         if (source == null) {
           // This is the first match. Extract the context class for the type
           // variables and get the list of type variables to keep track of how
           // many arguments we need to process.
           source = newSource;
           contextClass = source.sourceElement.enclosingClass;
-          typeVariables = contextClass.typeVariables;
+          remainingTypeVariables = contextClass.typeVariables.length;
         } else {
           assert(source == newSource);
         }
         // If there are no more type variables, then there are more type
         // arguments for the new object than the source has, and it can't be
         // a copy.  Otherwise remove one argument.
-        if (typeVariables.isEmpty) return false;
-        typeVariables = typeVariables.tail;
+        if (remainingTypeVariables == 0) return false;
+        remainingTypeVariables--;
         // Check that the index is the one we expect.
         IntConstant constant = index.constant;
         return constant.value == expectedIndex++;
       }
 
       List<HInstruction> typeArguments = <HInstruction>[];
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
         HInstruction argument = localsHandler.readLocal(typeVariable.element);
         if (allIndexed && !isIndexedTypeArgumentGet(argument)) {
           allIndexed = false;
         }
         typeArguments.add(argument);
       });
 
-      if (source != null && allIndexed && typeVariables.isEmpty) {
+      if (source != null && allIndexed && remainingTypeVariables == 0) {
         copyRuntimeTypeInfo(source, newObject);
       } else {
         newObject =
             callSetRuntimeTypeInfo(classElement, typeArguments, newObject);
       }
     }
 
     // Generate calls to the constructor bodies.
     HInstruction interceptor = null;
     for (int index = constructors.length - 1; index >= 0; index--) {
@@ skipping 2095 matching lines @@
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
       ClassElement cls = constructor.enclosingClass;
       if (cls.isAbstract && constructor.isGenerativeConstructor) {
         generateAbstractClassInstantiationError(send, cls.name);
         return;
       }
-      if (backend.classNeedsRti(cls)) {
-        Link<DartType> typeVariable = cls.typeVariables;
-        expectedType.typeArguments.forEach((DartType argument) {
-          inputs.add(analyzeTypeArgument(argument));
-          typeVariable = typeVariable.tail;
-        });
-        assert(typeVariable.isEmpty);
-      }
+      potentiallyAddTypeArguments(inputs, cls, expectedType);
 
       addInlinedInstantiation(expectedType);
       pushInvokeStatic(node, constructor, inputs, elementType);
       removeInlinedInstantiation(expectedType);
     }
     HInstruction newInstance = stack.last;
     if (isFixedList) {
       // Overwrite the element type, in case the allocation site has
       // been inlined.
       newInstance.instructionType = elementType;
@@ skipping 15 matching lines @@
     // Finally, if we called a redirecting factory constructor, check the type.
     if (isRedirected) {
       HInstruction checked = potentiallyCheckType(newInstance, type);
       if (checked != newInstance) {
         pop();
         stack.add(checked);
       }
     }
   }
 
+  void potentiallyAddTypeArguments(List<HInstruction> inputs, ClassElement cls,
+                                   InterfaceType expectedType) {
+    if (!backend.classNeedsRti(cls)) return;
+    assert(expectedType.typeArguments.isEmpty ||
+        cls.typeVariables.length == expectedType.typeArguments.length);
+    expectedType.typeArguments.forEach((DartType argument) {
+      inputs.add(analyzeTypeArgument(argument));
+    });
+  }
+
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(ast.NewExpression node, InterfaceType type) {
     if (!compiler.enableTypeAssertions) return false;
 
     Map<DartType, Set<DartType>> seenChecksMap =
         new Map<DartType, Set<DartType>>();
     bool definitelyFails = false;
 
     addTypeVariableBoundCheck(GenericType instance,
@@ skipping 676 matching lines @@
           targetSignature.orderedOptionalParameters;
       List<Element> redirectingOptionals =
           redirectingSignature.orderedOptionalParameters;
       int i = 0;
       for (; i < redirectingOptionals.length; i++) {
         inputs.add(localsHandler.readLocal(redirectingOptionals[i]));
       }
       for (; i < targetOptionals.length; i++) {
         inputs.add(handleConstantForOptionalParameter(targetOptionals[i]));
       }
-
       ClassElement targetClass = targetConstructor.enclosingClass;
       if (backend.classNeedsRti(targetClass)) {
         ClassElement cls = redirectingConstructor.enclosingClass;
         InterfaceType targetType =
             redirectingConstructor.computeEffectiveTargetType(cls.thisType);
         targetType = localsHandler.substInContext(targetType);
         targetType.typeArguments.forEach((DartType argument) {
           inputs.add(analyzeTypeArgument(argument));
         });
       }
@@ skipping 293 matching lines @@
         functionElement.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     if (constructor.isFactoryConstructor) {
       registry.registerFactoryWithTypeArguments();
     }
 
     ClassElement cls = constructor.enclosingClass;
 
     if (backend.classNeedsRti(cls)) {
-      Link<DartType> typeVariable = cls.typeVariables;
+      List<DartType> typeVariable = cls.typeVariables;
       expectedType.typeArguments.forEach((DartType argument) {
             inputs.add(analyzeTypeArgument(argument));
-            typeVariable = typeVariable.tail;
           });
       assert(typeVariable.isEmpty);
     }
 
     // The instruction type will always be a subtype of the mapLiteralClass, but
     // type inference might discover a more specific type, or find nothing (in
     // dart2js unit tests).
     TypeMask mapType = new TypeMask.nonNullSubtype(backend.mapLiteralClass);
     TypeMask returnTypeMask = TypeMaskFactory.inferredReturnTypeForElement(
         constructor, compiler);
@@ skipping 1114 matching lines @@
     for (DartType parameter in type.parameterTypes) {
       parameter.accept(this, builder);
       inputs.add(builder.pop());
     }
 
     for (DartType parameter in type.optionalParameterTypes) {
       parameter.accept(this, builder);
       inputs.add(builder.pop());
     }
 
-    Link<DartType> namedParameterTypes = type.namedParameterTypes;
-    for (String name in type.namedParameters) {
-      ast.DartString dartString = new ast.DartString.literal(name);
+    List<DartType> namedParameterTypes = type.namedParameterTypes;
+    List<String> names = type.namedParameters;
+    for (int index = 0; index < names.length; index++) {
+      ast.DartString dartString = new ast.DartString.literal(names[index]);
       inputs.add(
           builder.graph.addConstantString(dartString, builder.compiler));
-      namedParameterTypes.head.accept(this, builder);
+      namedParameterTypes[index].accept(this, builder);
       inputs.add(builder.pop());
-      namedParameterTypes = namedParameterTypes.tail;
     }
 
     ClassElement cls = builder.backend.findHelper('RuntimeFunctionType');
     builder.push(new HFunctionType(inputs, type, new TypeMask.exact(cls)));
   }
 
   void visitMalformedType(MalformedType type, SsaBuilder builder) {
     visitDynamicType(const DynamicType(), builder);
   }
 
@@ skipping 25 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }