Use List instead of Link in the type system.

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // 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.
 
 library elements.modelx;
 
 import 'elements.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
@@ skipping 1066 matching lines @@
    * system.
    *
    * The [functionSignature] is not available until the typedef element has been
    * resolved.
    */
   FunctionSignature functionSignature;
 
   TypedefType computeType(Compiler compiler) {
     if (thisType != null) return thisType;
     Typedef node = parseNode(compiler);
-    Link<DartType> parameters =
+    List<DartType> parameters =
         TypeDeclarationElementX.createTypeVariables(this, node.typeParameters);
     thisType = new TypedefType(this, parameters);
     if (parameters.isEmpty) {
       rawType = thisType;
     } else {
-      var dynamicParameters = const Link<DartType>();
-      parameters.forEach((_) {
-        dynamicParameters =
-            dynamicParameters.prepend(compiler.types.dynamicType);
-      });
+      List<DartType> dynamicParameters =new List<DartType>.generate(

[Johnni Winther, 2014/02/26 14:01:54]

Space after =

[karlklose, 2014/02/27 09:31:41]

Done.

+          parameters.length,
+          (_) => compiler.types.dynamicType);
       rawType = new TypedefType(this, dynamicParameters);
     }
     compiler.resolveTypedef(this);
     return thisType;
   }
 
-  Link<DartType> get typeVariables => thisType.typeArguments;
+  List<DartType> get typeVariables => thisType.typeArguments;
 
   Scope buildScope() {
     return new TypeDeclarationScope(enclosingElement.buildScope(), this);
   }
 
   void checkCyclicReference(Compiler compiler) {
     if (hasBeenCheckedForCycles) return;
     var visitor = new TypedefCyclicVisitor(compiler, this);
     computeType(compiler).accept(visitor, null);
     hasBeenCheckedForCycles = true;
@@ skipping 640 matching lines @@
 
   accept(ElementVisitor visitor) => visitor.visitVoidElement(this);
 }
 
 class TypeDeclarationElementX {
   /**
    * Creates the type variables, their type and corresponding element, for the
    * type variables declared in [parameter] on [element]. The bounds of the type
    * variables are not set until [element] has been resolved.
    */
-  static Link<DartType> createTypeVariables(TypeDeclarationElement element,
+  static List<DartType> createTypeVariables(TypeDeclarationElement element,
                                             NodeList parameters) {
-    if (parameters == null) return const Link<DartType>();
+    if (parameters == null) return const <DartType>[];
 
     // Create types and elements for type variable.
-    var arguments = new LinkBuilder<DartType>();
+    List<DartType> arguments = <DartType>[];
     for (Link link = parameters.nodes; !link.isEmpty; link = link.tail) {
       TypeVariable node = link.head;
       String variableName = node.name.source;
       TypeVariableElement variableElement =
           new TypeVariableElementX(variableName, element, node);
       TypeVariableType variableType = new TypeVariableType(variableElement);
       variableElement.type = variableType;
-      arguments.addLast(variableType);
+      arguments.add(variableType);
     }
-    return arguments.toLink();
+    return arguments;
   }
 }
 
 abstract class BaseClassElementX extends ElementX implements ClassElement {
   final int id;
 
   /**
    * The type of [:this:] for this class declaration.
    *
    * The type of [:this:] is the interface type based on this element in which
@@ skipping 56 matching lines @@
   int get hashCode => id;
   ClassElement get patch => super.patch;
   ClassElement get origin => super.origin;
   ClassElement get declaration => super.declaration;
   ClassElement get implementation => super.implementation;
 
   bool get hasBackendMembers => !backendMembers.isEmpty;
 
   bool get isUnnamedMixinApplication => false;
 
-  void computeThisAndRawType(Compiler compiler, Link<DartType> typeVariables) {
+  void computeThisAndRawType(Compiler compiler, List<DartType> typeVariables) {
     if (thisType == null) {
       if (origin == null) {
-        Link<DartType> parameters = typeVariables;
+        List<DartType> parameters = typeVariables;
         thisType = new InterfaceType(this, parameters);
         if (parameters.isEmpty) {
           rawTypeCache = thisType;
         } else {
-          var dynamicParameters = const Link<DartType>();
-          parameters.forEach((_) {
-            dynamicParameters =
-                dynamicParameters.prepend(compiler.types.dynamicType);
-          });
+          // TODO(karlklose): there is similar code in another place; share.
+          List<DartType> dynamicParameters = new List<DartType>.generate(
+              parameters.length,
+              (_) => compiler.types.dynamicType);
           rawTypeCache = new InterfaceType(this, dynamicParameters);
         }
       } else {
         thisType = origin.computeType(compiler);
         rawTypeCache = origin.rawType;
       }
     }
   }
 
   // TODO(johnniwinther): Add [thisType] getter similar to [rawType].
   InterfaceType computeType(Compiler compiler) {
     if (thisType == null) {
       computeThisAndRawType(compiler, computeTypeParameters(compiler));
     }
     return thisType;
   }
 
   InterfaceType get rawType {
     assert(invariant(this, rawTypeCache != null,
                      message: 'Raw type has not been computed for $this'));
     return rawTypeCache;
   }
 
-  Link<DartType> computeTypeParameters(Compiler compiler);
+  List<DartType> computeTypeParameters(Compiler compiler);
 
   /**
    * Return [:true:] if this element is the [:Object:] class for the [compiler].
    */
   bool isObject(Compiler compiler) =>
       identical(declaration, compiler.objectClass);
 
-  Link<DartType> get typeVariables => thisType.typeArguments;
+  List<DartType> get typeVariables => thisType.typeArguments;
 
   ClassElement ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveClass(this);
     }
     return this;
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler);
 
@@ skipping 367 matching lines @@
     }
     return false;
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
     addToScope(constructor, compiler);
     // The default constructor, although synthetic, is part of a class' API.
     localMembers = localMembers.prepend(constructor);
   }
 
-  Link<DartType> computeTypeParameters(Compiler compiler) {
+  List<DartType> computeTypeParameters(Compiler compiler) {
     ClassNode node = parseNode(compiler);
     return TypeDeclarationElementX.createTypeVariables(
         this, node.typeParameters);
   }
 
   Scope buildScope() => new ClassScope(enclosingElement.buildScope(), this);
 
   String toString() {
     if (origin != null) {
       return 'patch ${super.toString()}';
@@ skipping 74 matching lines @@
 
   void addConstructor(FunctionElement constructor) {
     constructors = constructors.prepend(constructor);
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
     assert(!hasConstructor);
     addConstructor(constructor);
   }
 
-  Link<DartType> computeTypeParameters(Compiler compiler) {
+  List<DartType> computeTypeParameters(Compiler compiler) {
     NamedMixinApplication named = node.asNamedMixinApplication();
     if (named == null) {
       throw new SpannableAssertionFailure(node,
           "Type variables on unnamed mixin applications must be set on "
           "creation.");
     }
     return TypeDeclarationElementX.createTypeVariables(
         this, named.typeParameters);
   }
 
@@ skipping 145 matching lines @@
   final Metadata metadata;
 
   ParameterMetadataAnnotation(Metadata this.metadata);
 
   Node parseNode(DiagnosticListener listener) => metadata.expression;
 
   Token get beginToken => metadata.getBeginToken();
 
   Token get endToken => metadata.getEndToken();
 }