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 1628 matching lines @@
       ClassElement enclosingClass = callee.getEnclosingClass();
       if (backend.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
         ClassElement currentClass = caller.getEnclosingClass();
         // 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);
-        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.getEnclosingClass() != caller.getEnclosingClass()) {
         inlinedFrom(callee, () {
           buildFieldInitializers(callee.enclosingElement.implementation,
                                fieldValues);
         });
@@ skipping 286 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.getEnclosingClass();
-          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 1930 matching lines @@
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
       ClassElement cls = constructor.getEnclosingClass();
       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 662 matching lines @@
           calleeSignature.orderedOptionalParameters;
       List<Element> callerOptionals =
           callerSignature.orderedOptionalParameters;
       int i = 0;
       for (; i < callerOptionals.length; i++) {
         inputs.add(localsHandler.readLocal(callerOptionals[i]));
       }
       for (; i < calleeOptionals.length; i++) {
         inputs.add(handleConstantForOptionalParameter(calleeOptionals[i]));
       }
-
-      if (backend.classNeedsRti(element.getEnclosingClass())) {
-        ClassElement cls = function.getEnclosingClass();
-        Link<DartType> typeVariable = cls.typeVariables;
-        InterfaceType type = elements.getType(node.expression);
-        type.typeArguments.forEach((DartType argument) {
-          inputs.add(analyzeTypeArgument(argument));
-          typeVariable = typeVariable.tail;
-        });
-        assert(typeVariable.isEmpty);
-      }
+      potentiallyAddTypeArguments(inputs, element.getEnclosingClass(),
+                                  elements.getType(node.expression));
       pushInvokeStatic(node, element, inputs);
       value = pop();
     } else if (node.expression == null) {
       value = graph.addConstantNull(compiler);
     } else {
       visit(node.expression);
       value = pop();
       value = potentiallyCheckType(value, returnType);
     }
 
@@ skipping 1346 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.compiler.findHelper('RuntimeFunctionType');
     builder.push(new HFunctionType(inputs, type, new TypeMask.exact(cls)));
   }
 
   void visitMalformedType(MalformedType type, SsaBuilder builder) {
     visitDynamicType(builder.compiler.types.dynamicType, builder);
   }
 
@@ skipping 24 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }