Change Link to List in FunctionSignature.

pkg/compiler/lib/src/resolution/signatures.dart

 // Copyright (c) 2014, 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.
 
 part of resolution;
 
 /**
  * [SignatureResolver] resolves function signatures.
  */
 class SignatureResolver extends MappingVisitor<FormalElementX> {
   final ResolverVisitor resolver;
   final FunctionTypedElement enclosingElement;
   final Scope scope;
   final MessageKind defaultValuesError;
   final bool createRealParameters;
-  Link<Element> optionalParameters = const Link<Element>();
+  List<Element> optionalParameters = const <Element>[];
   int optionalParameterCount = 0;
   bool isOptionalParameter = false;
   bool optionalParametersAreNamed = false;
   VariableDefinitions currentDefinitions;
 
   SignatureResolver(Compiler compiler,
                     FunctionTypedElement enclosingElement,
                     ResolutionRegistry registry,
                     {this.defaultValuesError,
                      this.createRealParameters})
       : this.enclosingElement = enclosingElement,
         this.scope = enclosingElement.buildScope(),
         this.resolver =
             new ResolverVisitor(compiler, enclosingElement, registry),
         super(compiler, registry);
 
   bool get defaultValuesAllowed => defaultValuesError == null;
 
   visitNodeList(NodeList node) {
     // This must be a list of optional arguments.
     String value = node.beginToken.stringValue;
     if ((!identical(value, '[')) && (!identical(value, '{'))) {
       internalError(node, "expected optional parameters");
     }
     optionalParametersAreNamed = (identical(value, '{'));
     isOptionalParameter = true;
     LinkBuilder<Element> elements = analyzeNodes(node.nodes);
     optionalParameterCount = elements.length;
-    optionalParameters = elements.toLink();
+    optionalParameters = elements.toList();
   }
 
   FormalElementX visitVariableDefinitions(VariableDefinitions node) {
     Link<Node> definitions = node.definitions.nodes;
     if (definitions.isEmpty) {
       internalError(node, 'no parameter definition');
       return null;
     }
     if (!definitions.tail.isEmpty) {
       internalError(definitions.tail.head, 'extra definition');
@@ skipping 211 matching lines @@
       Node returnNode,
       FunctionTypedElement element,
       ResolutionRegistry registry,
       {MessageKind defaultValuesError,
        bool createRealParameters: false,
        bool isFunctionExpression: false}) {
 
     SignatureResolver visitor = new SignatureResolver(compiler, element,
         registry, defaultValuesError: defaultValuesError,
         createRealParameters: createRealParameters);
-    Link<Element> parameters = const Link<Element>();
+    List<Element> parameters = const <Element>[];
     int requiredParameterCount = 0;
     if (formalParameters == null) {
       if (!element.isGetter) {
         if (element.isErroneous) {
           // If the element is erroneous, an error should already have been
           // reported. In the case of parse errors, it is possible that there
           // are formal parameters, but something else in the method failed to
           // parse. So we suppress the message about missing formals.
           assert(invariant(element, compiler.compilationFailed));
         } else {
           compiler.reportError(element, MessageKind.MISSING_FORMALS);
         }
       }
     } else {
       if (element.isGetter) {
         if (!identical(formalParameters.endToken.next.stringValue,
                        // TODO(ahe): Remove the check for native keyword.
                        'native')) {
           compiler.reportError(formalParameters,
                                MessageKind.EXTRA_FORMALS);
         }
       }
       LinkBuilder<Element> parametersBuilder =
         visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount  = parametersBuilder.length;
-      parameters = parametersBuilder.toLink();
+      parameters = parametersBuilder.toList();
     }
     DartType returnType;
     if (element.isFactoryConstructor) {
       returnType = element.enclosingClass.thisType;
       // Because there is no type annotation for the return type of
       // this element, we explicitly add one.
       if (compiler.enableTypeAssertions) {
         registry.registerIsCheck(returnType);
       }
     } else {
@@ skipping 89 matching lines @@
 
   DartType resolveReturnType(TypeAnnotation annotation) {
     if (annotation == null) return const DynamicType();
     DartType result = resolver.resolveTypeAnnotation(annotation);
     if (result == null) {
       return const DynamicType();
     }
     return result;
   }
 }