Change Link to List in FunctionSignature.

pkg/compiler/lib/src/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 '../constants/expressions.dart';
 import '../constants/constructors.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
@@ skipping 1731 matching lines @@
   bool get isAbstract {
     return getter != null && getter.isAbstract
         || setter != null && setter.isAbstract;
   }
 }
 
 // TODO(johnniwinther): [FunctionSignature] should be merged with
 // [FunctionType].
 // TODO(karlklose): all these lists should have element type [FormalElement].
 class FunctionSignatureX implements FunctionSignature {
-  final Link<Element> requiredParameters;
-  final Link<Element> optionalParameters;
+  final List<Element> requiredParameters;
+  final List<Element> optionalParameters;
   final int requiredParameterCount;
   final int optionalParameterCount;
   final bool optionalParametersAreNamed;
   final List<Element> orderedOptionalParameters;
   final FunctionType type;
   final bool hasOptionalParameters;
 
-  FunctionSignatureX({this.requiredParameters: const Link<Element>(),
+  FunctionSignatureX({this.requiredParameters: const <Element>[],
                       this.requiredParameterCount: 0,
-                      Link<Element> optionalParameters: const Link<Element>(),
+                      List<Element> optionalParameters: const <Element>[],
                       this.optionalParameterCount: 0,
                       this.optionalParametersAreNamed: false,
                       this.orderedOptionalParameters: const <Element>[],
                       this.type})
       : optionalParameters = optionalParameters,
         hasOptionalParameters = !optionalParameters.isEmpty;
 
   void forEachRequiredParameter(void function(Element parameter)) {
-    for (Link<Element> link = requiredParameters;
-         !link.isEmpty;
-         link = link.tail) {
-      function(link.head);
-    }
+    requiredParameters.forEach(function);
   }
 
   void forEachOptionalParameter(void function(Element parameter)) {
-    for (Link<Element> link = optionalParameters;
-         !link.isEmpty;
-         link = link.tail) {
-      function(link.head);
-    }
+    optionalParameters.forEach(function);
   }
 
-  Element get firstOptionalParameter => optionalParameters.head;
+  Element get firstOptionalParameter => optionalParameters.first;
 
   void forEachParameter(void function(Element parameter)) {
     forEachRequiredParameter(function);
     forEachOptionalParameter(function);
   }
 
   void orderedForEachParameter(void function(Element parameter)) {
     forEachRequiredParameter(function);
     orderedOptionalParameters.forEach(function);
   }
 
   int get parameterCount => requiredParameterCount + optionalParameterCount;
 
   /**
    * Check whether a function with this signature can be used instead of a
    * function with signature [signature] without causing a `noSuchMethod`
    * exception/call.
    */
   bool isCompatibleWith(FunctionSignature signature) {
     if (optionalParametersAreNamed) {
       if (!signature.optionalParametersAreNamed) {
         return requiredParameterCount == signature.parameterCount;
       }
       // If both signatures have named parameters, then they must have
       // the same number of required parameters, and the names in
       // [signature] must all be in [:this:].
       if (requiredParameterCount != signature.requiredParameterCount) {
         return false;
       }
-      Set<String> names = optionalParameters.mapToSet(
-          (Element element) => element.name);
+      Set<String> names = optionalParameters.map(
+          (Element element) => element.name).toSet();
       for (Element namedParameter in signature.optionalParameters) {
         if (!names.contains(namedParameter.name)) {
           return false;
         }
       }
     } else {
       if (signature.optionalParametersAreNamed) return false;
       // There must be at least as many arguments as in the other signature, but
       // this signature must not have more required parameters.  Having more
       // optional parameters is not a problem, they simply are never provided
@@ skipping 1396 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }