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 '../helpers/helpers.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 1079 matching lines @@
     ensureResolved(compiler);
     return thisTypeCache;
   }
 
   void ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolve(this);
     }
   }
 
-  TypedefType createType(Link<DartType> typeArguments) {
+  TypedefType createType(List<DartType> typeArguments) {
     return new TypedefType(this, typeArguments);
   }
 
   Scope buildScope() {
     return new TypeDeclarationScope(enclosingElement.buildScope(), this);
   }
 
   void checkCyclicReference(Compiler compiler) {
     if (hasBeenCheckedForCycles) return;
     var visitor = new TypedefCyclicVisitor(compiler, this);
@@ skipping 726 matching lines @@
                      message: 'This type has not been computed for $this'));
     return thisTypeCache;
   }
 
   T get rawType {
     assert(invariant(this, rawTypeCache != null,
                      message: 'Raw type has not been computed for $this'));
     return rawTypeCache;
   }
 
-  T createType(Link<DartType> typeArguments);
+  T createType(List<DartType> typeArguments);
 
-  void setThisAndRawTypes(Compiler compiler, Link<DartType> typeParameters) {
+  void setThisAndRawTypes(Compiler compiler, List<DartType> typeParameters) {
     assert(invariant(this, thisTypeCache == null,
         message: "This type has already been set on $this."));
     assert(invariant(this, rawTypeCache == null,
         message: "Raw type has already been set on $this."));
     thisTypeCache = createType(typeParameters);
     if (typeParameters.isEmpty) {
       rawTypeCache = thisTypeCache;
     } else {
-      Link<DartType> dynamicParameters = const Link<DartType>();
-      typeParameters.forEach((_) {
-        dynamicParameters =
-            dynamicParameters.prepend(const DynamicType());
-      });
+      List<DartType> dynamicParameters =
+          new List.filled(typeParameters.length, const DynamicType());
       rawTypeCache = createType(dynamicParameters);
     }
   }
 
-  Link<DartType> get typeVariables => thisType.typeArguments;
+  List<DartType> get typeVariables => thisType.typeArguments;
 
   /**
    * 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.
    */
-  Link<DartType> createTypeVariables(NodeList parameters) {
-    if (parameters == null) return const Link<DartType>();
+  List<DartType> createTypeVariables(NodeList parameters) {
+    if (parameters == null) return const <DartType>[];
 
     // Create types and elements for type variable.
-    LinkBuilder<DartType> arguments = new LinkBuilder<DartType>();
-    for (Link<Node> link = parameters.nodes; !link.isEmpty; link = link.tail) {
-      TypeVariable node = link.head;
+    Link<Node> nodes = parameters.nodes;
+    List<DartType> arguments =
+        new List.generate(nodes.slowLength(), (_) {
+      TypeVariable node = nodes.head;
       String variableName = node.name.source;
+      nodes = nodes.tail;
       TypeVariableElementX variableElement =
           new TypeVariableElementX(variableName, this, node);
       TypeVariableType variableType = new TypeVariableType(variableElement);
       variableElement.typeCache = variableType;
-      arguments.addLast(variableType);
-    }
-    return arguments.toLink();
+      return variableType;
+    }, growable: false);
+    return arguments;
   }
 
   bool get isResolved => resolutionState == STATE_DONE;
 }
 
 abstract class BaseClassElementX extends ElementX
     with AstElementMixin,
          AnalyzableElementX,
          TypeDeclarationElementX<InterfaceType>,
          PatchMixin<ClassElement>,
@@ skipping 33 matching lines @@
 
   bool get isUnnamedMixinApplication => false;
 
   InterfaceType computeType(Compiler compiler) {
     if (thisTypeCache == null) {
       computeThisAndRawType(compiler, computeTypeParameters(compiler));
     }
     return thisTypeCache;
   }
 
-  void computeThisAndRawType(Compiler compiler, Link<DartType> typeVariables) {
+  void computeThisAndRawType(Compiler compiler, List<DartType> typeVariables) {
     if (thisTypeCache == null) {
       if (origin == null) {
         setThisAndRawTypes(compiler, typeVariables);
       } else {
         thisTypeCache = origin.computeType(compiler);
         rawTypeCache = origin.rawType;
       }
     }
   }
 
-  InterfaceType createType(Link<DartType> typeArguments) {
+  InterfaceType createType(List<DartType> typeArguments) {
     return new InterfaceType(this, typeArguments);
   }
 
-  Link<DartType> computeTypeParameters(Compiler compiler);
+  List<DartType> computeTypeParameters(Compiler compiler);
 
   InterfaceType asInstanceOf(ClassElement cls) {
     if (cls == this) return thisType;
     return allSupertypesAndSelf.asInstanceOf(cls);
   }
 
   /**
    * Return [:true:] if this element is the [:Object:] class for the [compiler].
    */
   bool isObject(Compiler compiler) =>
@@ skipping 375 matching lines @@
       if (element.isConstructor) return true;
     }
     return false;
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
     // The default constructor, although synthetic, is part of a class' API.
     addMember(constructor, compiler);
   }
 
-  Link<DartType> computeTypeParameters(Compiler compiler) {
+  List<DartType> computeTypeParameters(Compiler compiler) {
     ClassNode node = parseNode(compiler);
     return createTypeVariables(node.typeParameters);
   }
 
   Scope buildScope() => new ClassScope(enclosingElement.buildScope(), this);
 
   String toString() {
     if (origin != null) {
       return 'patch ${super.toString()}';
     } else if (patch != null) {
@@ skipping 68 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 createTypeVariables(named.typeParameters);
   }
 
   accept(ElementVisitor visitor) => visitor.visitMixinApplicationElement(this);
@@ skipping 214 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }