Store named parameters in sorted lists instead of using maps.

lib/analyzer/ast_from_analyzer.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.
 library kernel.analyzer.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
@@ skipping 438 matching lines @@
 
         case ParameterKind.POSITIONAL:
           positional.add(parameterNode);
           break;
 
         case ParameterKind.NAMED:
           named.add(parameterNode);
           break;
       }
     }
+    if (named.isNotEmpty) {
+      named.sort();
+    }
     var returnType = element is ConstructorElement
         ? const ast.VoidType()
         : buildType(element.returnType);
     return new ast.FunctionNode(null,
         typeParameters: typeParameters,
         positionalParameters: positional,
         namedParameters: named,
         requiredParameterCount: requiredParameterCount,
         returnType: returnType);
   }
@@ skipping 81 matching lines @@
 
         case ParameterKind.POSITIONAL:
           positional.add(declaration);
           break;
 
         case ParameterKind.NAMED:
           named.add(declaration);
           break;
       }
     }
+    if (named.isNotEmpty) {
+      named.sort();
+    }
     return new ast.FunctionNode(buildOptionalFunctionBody(body),
         typeParameters: typeParameters,
         positionalParameters: positional,
         namedParameters: named,
         requiredParameterCount: requiredParameterCount,
         returnType: buildOptionalTypeAnnotation(returnType) ??
             inferredReturnType ??
             const ast.DynamicType(),
         asyncMarker: getAsyncMarker(
             isAsync: body.isAsynchronous, isStar: body.isGenerator));
@@ skipping 1573 matching lines @@
         .map((tp) => convertTypeParameter(tp, boundVariables))
         .toList();
   }
 
   List<ast.DartType> convertTypeList(
       Iterable<DartType> types, List<TypeParameterElement> boundVariables) {
     if (types.isEmpty) return const <ast.DartType>[];
     return types.map((t) => convertType(t, boundVariables)).toList();
   }
 
-  Map<String, ast.DartType> convertTypeMap(
+  List<ast.NamedType> convertTypeMap(
       Map<String, DartType> types, List<TypeParameterElement> boundVariables) {
-    if (types.isEmpty) return const <String, ast.DartType>{};
-    var result = <String, ast.DartType>{};
+    if (types.isEmpty) return const <ast.NamedType>[];
+    List<ast.NamedType> result = <ast.NamedType>[];
     types.forEach((name, type) {
-      result[name] = convertType(type, boundVariables);
+      result.add(new ast.NamedType(name, convertType(type, boundVariables)));
     });
+    result.sort();
     return result;
   }
 
   ast.DartType visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     switch (ElementKind.of(element)) {
       case ElementKind.CLASS:
         return new ast.InterfaceType(scope.getClassReference(element));
 
       case ElementKind.DYNAMIC:
@@ skipping 606 matching lines @@
   if (element is FieldElement) return element.getter;
   return element;
 }
 
 Element desynthesizeSetter(Element element) {
   if (element == null || !element.isSynthetic) return element;
   if (element is PropertyAccessorElement) return element.variable;
   if (element is FieldElement) return element.setter;
   return element;
 }