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) {
+      sortAndRemoveDuplicates(named);
+    }
     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) {
+      sortAndRemoveDuplicates(named);
+    }
     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 1373 matching lines @@
       return new SuperPropertyAccessor(
           scope.buildName(node.propertyName),
           scope.resolveConcreteGet(element, auxiliary),
           scope.resolveConcreteSet(element, auxiliary));
     } else if (target is Identifier && target.staticElement is ClassElement) {
       // Note that this case also covers null-aware static access on a class,
       // which is equivalent to a regular static access.
       return scope.staticAccess(node.propertyName.name, element, auxiliary);
     } else if (node.operator.value() == '?.') {
       return new NullAwarePropertyAccessor(
-          build(target), scope.buildName(node.propertyName), getter, setter,
+          build(target),
+          scope.buildName(node.propertyName),
+          getter,
+          setter,
           scope.buildType(node.staticType));
     } else {
       return PropertyAccessor.make(
           build(target), scope.buildName(node.propertyName), getter, setter);
     }
   }
 
   ast.Expression visitRethrowExpression(RethrowExpression node) {
     return new ast.Rethrow();
   }
@@ skipping 179 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)));
     });
+    sortAndRemoveDuplicates(result);
     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;
 }
+
+void sortAndRemoveDuplicates/*<T extends Comparable<T>>*/(List/*<T>*/ list) {
+  list.sort();
+  int deleted = 0;
+  for (int i = 1; i < list.length; ++i) {
+    var item = list[i];
+    if (list[i - 1].compareTo(item) == 0) {
+      ++deleted;
+    } else if (deleted > 0) {
+      list[i - deleted] = item;
+    }
+  }
+  if (deleted > 0) {
+    list.length -= deleted;
+  }
+}