Use List instead of Link in the type system.

sdk/lib/_internal/compiler/implementation/resolution/class_members.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.
 
 library resolution.compute_members;
 
 import '../elements/elements.dart'
     show Element,
          Name,
          PublicName,
@@ skipping 176 matching lines @@
         }
 
         Name name = new Name(element.name, library);
         if (element.isField) {
           DartType type = element.computeType(compiler);
           addDeclaredMember(name, type, new FunctionType.synthesized(type));
           if (!element.isConst && !element.isFinal) {
             addDeclaredMember(name.setter, type,
                 new FunctionType.synthesized(
                                  const VoidType(),
-                                 const Link<DartType>().prepend(type)));
+                                 <DartType>[type]));
           }
         } else if (element.isGetter) {
           FunctionType functionType = element.computeType(compiler);
           DartType type = functionType.returnType;
           addDeclaredMember(name, type, functionType);
         } else if (element.isSetter) {
           FunctionType functionType = element.computeType(compiler);
           DartType type;
           if (!functionType.parameterTypes.isEmpty) {
-            type = functionType.parameterTypes.head;
+            type = functionType.parameterTypes.first;
           } else {
             type = const DynamicType();
           }
           name = name.setter;
           addDeclaredMember(name, type, functionType);
         } else {
           assert(invariant(element, element.isFunction));
           FunctionType type = element.computeType(compiler);
           addDeclaredMember(name, type, type);
         }
@@ skipping 501 matching lines @@
     for (MemberSignature member in inheritedMembers) {
       int requiredParameters = 0;
       int optionalParameters = 0;
       if (member.isSetter) {
         requiredParameters = 1;
       }
       if (member.type.isFunctionType) {
         FunctionType type = member.type;
         type.namedParameters.forEach(
             (String name) => names.add(name));
-        requiredParameters = type.parameterTypes.slowLength();
-        optionalParameters = type.optionalParameterTypes.slowLength();
+        requiredParameters = type.parameterTypes.length;
+        optionalParameters = type.optionalParameterTypes.length;
       }
       int positionalParameters = requiredParameters + optionalParameters;
       if (minRequiredParameters == null ||
           minRequiredParameters > requiredParameters) {
         minRequiredParameters = requiredParameters;
       }
       if (maxPositionalParameters == null ||
           maxPositionalParameters < positionalParameters) {
         maxPositionalParameters = positionalParameters;
       }
     }
     int optionalParameters =
         maxPositionalParameters - minRequiredParameters;
     // TODO(johnniwinther): Support function types with both optional
     // and named parameters?
     if (optionalParameters == 0 || names.isEmpty) {
-      Link<DartType> requiredParameterTypes = const Link<DartType>();
-      while (--minRequiredParameters >= 0) {
-        requiredParameterTypes =
-            requiredParameterTypes.prepend(const DynamicType());
-      }
-      Link<DartType> optionalParameterTypes = const Link<DartType>();
-      while (--optionalParameters >= 0) {
-        optionalParameterTypes =
-            optionalParameterTypes.prepend(const DynamicType());
-      }
-      Link<String> namedParameters = const Link<String>();
-      Link<DartType> namedParameterTypes = const Link<DartType>();
-      List<String> namesReversed =
-          names.toList()..sort((a, b) => -a.compareTo(b));
-      for (String name in namesReversed) {
-        namedParameters = namedParameters.prepend(name);
-        namedParameterTypes =
-            namedParameterTypes.prepend(const DynamicType());
-      }
+      DartType dynamic = const DynamicType();
+      List<DartType> requiredParameterTypes =
+          new List.filled(minRequiredParameters, dynamic);
+      List<DartType> optionalParameterTypes =
+          new List.filled(optionalParameters, dynamic);
+      List<String> namedParameters =
+          names.toList()..sort((a, b) => a.compareTo(b));
+      List<DartType> namedParameterTypes =
+          new List.filled(namedParameters.length, dynamic);
       FunctionType memberType = new FunctionType.synthesized(
           const DynamicType(),
           requiredParameterTypes,
           optionalParameterTypes,
           namedParameters, namedParameterTypes);
       DartType type = memberType;
       if (inheritedMembers.first.isGetter ||
           inheritedMembers.first.isSetter) {
         type = const DynamicType();
       }
@@ skipping 123 matching lines @@
         message: "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }