Store named parameters in sorted lists instead of using maps.

test/type_parser.dart

 // Copyright (c) 2016, 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.
 // A very simple parser for a subset of DartTypes for use in testing type
 // algebra.
 library kernel.test.type_parser;
 
 import 'package:kernel/kernel.dart';
 import 'package:kernel/text/ast_to_text.dart';
 
@@ skipping 133 matching lines @@
         } else if (target is TypeParameter) {
           if (peekToken() == Token.LeftAngle) {
             return fail('Attempt to apply type arguments to a type variable');
           }
           return new TypeParameterType(target);
         }
         return fail("Unexpected lookup result for $name: $target");
 
       case Token.LeftParen:
         List<DartType> parameters = <DartType>[];
-        Map<String, DartType> namedParameters = <String, DartType>{};
+        List<NamedType> namedParameters = <NamedType>[];
         parseParameterList(parameters, namedParameters);
         consumeString('=>');
         var returnType = parseType();
         return new FunctionType(parameters, returnType,
             namedParameters: namedParameters);
 
       case Token.LeftAngle:
         var typeParameters = parseAndPushTypeParameterList();
         List<DartType> parameters = <DartType>[];
-        Map<String, DartType> namedParameters = <String, DartType>{};
+        List<NamedType> namedParameters = <NamedType>[];
         parseParameterList(parameters, namedParameters);
         consumeString('=>');
         var returnType = parseType();
         popTypeParameters(typeParameters);
         return new FunctionType(parameters, returnType,
             typeParameters: typeParameters, namedParameters: namedParameters);
 
       default:
         return fail('Unexpected token: $tokenText');
     }
   }
 
   void parseParameterList(
-      List<DartType> positional, Map<String, DartType> named) {
+      List<DartType> positional, List<NamedType> named) {
     int token = scanToken();
     assert(token == Token.LeftParen);
     token = peekToken();
     while (token != Token.RightParen) {
       var type = parseType(); // Could be a named parameter name.
       token = scanToken();
       if (token == Token.Colon) {
         String name = convertTypeToParameterName(type);
-        named[name] = parseType();
+        named.add(new NamedType(name, parseType()));
         token = scanToken();
       } else {
         positional.add(type);
       }
       if (token != Token.Comma && token != Token.RightParen) {
         return fail('Unterminated parameter list');
       }
     }
+    named.sort();
   }
 
   String convertTypeToParameterName(DartType type) {
     if (type is InterfaceType && type.typeArguments.isEmpty) {
       return type.classNode.name;
     } else if (type is TypeParameterType) {
       return type.parameter.name;
     } else {
       return fail('Unexpected colon after $type');
     }
@@ skipping 108 matching lines @@
 void main(List<String> args) {
   if (args.length != 1) {
     print('Usage: type_parser TYPE');
   }
   var environment = new LazyTypeEnvironment();
   var type = parseDartType(args[0], environment.lookup);
   var buffer = new StringBuffer();
   new Printer(buffer).writeType(type);
   print(buffer);
 }