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 129 matching lines @@
           declaredMembers[name] = new DeclaredMember(
               name, element, thisType, type,
               new FunctionType(compiler.functionClass, type));
           if (!element.modifiers.isConst() &&
               !element.modifiers.isFinal()) {
             name = name.setter;
             declaredMembers[name] = new DeclaredMember(
                 name, element, thisType, type,
                 new FunctionType(compiler.functionClass,
                                  compiler.types.voidType,
-                                 const Link<DartType>().prepend(type)));
+                                 [type]));
           }
         } else if (element.isGetter()) {
           FunctionType functionType = element.computeType(compiler);
           DartType type = functionType.returnType;
           declaredMembers[name] =
               new DeclaredMember(name, element, thisType, 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 = compiler.types.dynamicType;
           }
           name = name.setter;
           declaredMembers[name] = new DeclaredMember(
               name, element, thisType, type, functionType);
         } else {
           assert(invariant(element, element.isFunction()));
           FunctionType type = element.computeType(compiler);
           declaredMembers[name] = new DeclaredMember(
@@ skipping 116 matching lines @@
     int maxPositionalParameters;
     Set<String> names = new Set<String>();
     for (MemberSignature member in inheritedMembers) {
       int requiredParameters = 0;
       int optionalParameters = 0;
       if (member.isSetter) {
         requiredParameters = 1;
       }
       if (member.type.kind == TypeKind.FUNCTION) {
         FunctionType type = member.type;
-        type.namedParameters.forEach(
-            (String name) => names.add(name));
-        requiredParameters = type.parameterTypes.slowLength();
-        optionalParameters = type.optionalParameterTypes.slowLength();
+        type.namedParameters.forEach((String name) => names.add(name));
+        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(compiler.types.dynamicType);
-      }
-      Link<DartType> optionalParameterTypes = const Link<DartType>();
-      while (--optionalParameters >= 0) {
-        optionalParameterTypes =
-            optionalParameterTypes.prepend(compiler.types.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(compiler.types.dynamicType);
+      List<DartType> requiredParameterTypes = new List<DartType>.generate(
+          minRequiredParameters, (_) => compiler.types.dynamicType);
+      List<DartType> optionalParameterTypes = new List<DartType>.generate(
+          optionalParameters, (_) => compiler.types.dynamicType);
+      List<String> namedParameters = <String>[];
+      List<DartType> namedParameterTypes = <DartType>[];
+      for (String name in namedParameters) {
+        namedParameters.add(name);
+        namedParameterTypes.add(compiler.types.dynamicType);
       }
       FunctionType memberType = new FunctionType(
           compiler.functionClass,
           compiler.types.dynamicType,
           requiredParameterTypes,
           optionalParameterTypes,
           namedParameters, namedParameterTypes);
       DartType type = memberType;
       if (inheritedMembers.first.isGetter ||
           inheritedMembers.first.isSetter) {
@@ skipping 214 matching lines @@
   }
 
   static void computeClassMembers(Compiler compiler, BaseClassElementX cls) {
     if (cls.classMembers != null) return;
     MembersCreator creator = new MembersCreator(compiler, cls);
     creator.computeMembers();
     cls.classMembers = creator.classMembers;
     cls.interfaceMembers = creator.interfaceMembers;
   }
 }