Store named parameters in sorted lists instead of using maps.

lib/type_algebra.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.type_algebra;
 
 import 'ast.dart';
 
 /// Returns a type where all occurrences of the given type parameters have been
 /// replaced with the corresponding types.
 ///
@@ skipping 307 matching lines @@
   }
 
   Supertype visitSupertype(Supertype node) {
     if (node.typeArguments.isEmpty) return node;
     int before = useCounter;
     var typeArguments = node.typeArguments.map(visit).toList();
     if (useCounter == before) return node;
     return new Supertype(node.classNode, typeArguments);
   }
 
+  NamedType visitNamedType(NamedType node) {
+    int before = useCounter;
+    var type = visit(node.type);
+    if (useCounter == before) return node;
+    return new NamedType(node.name, type);
+  }
+
   DartType visit(DartType node) => node.accept(this);
 
   DartType visitInvalidType(InvalidType node) => node;
   DartType visitDynamicType(DynamicType node) => node;
   DartType visitVoidType(VoidType node) => node;
   DartType visitBottomType(BottomType node) => node;
 
   DartType visitInterfaceType(InterfaceType node) {
     if (node.typeArguments.isEmpty) return node;
     int before = useCounter;
@@ skipping 23 matching lines @@
     // environment has been used inside the function.
     var inner = node.typeParameters.isEmpty ? this : newInnerEnvironment();
     int before = this.useCounter;
     // Invert the variance when translating parameters.
     inner.invertVariance();
     var typeParameters = inner.freshTypeParameters(node.typeParameters);
     var positionalParameters = node.positionalParameters.isEmpty
         ? const <DartType>[]
         : node.positionalParameters.map(inner.visit).toList();
     var namedParameters = node.namedParameters.isEmpty
-        ? const <String, DartType>{}
-        : _mapValues(node.namedParameters, inner.visit);
+        ? const <NamedType>[]
+        : node.namedParameters.map(inner.visitNamedType).toList();
     inner.invertVariance();
     var returnType = inner.visit(node.returnType);
     if (this.useCounter == before) return node;
     return new FunctionType(positionalParameters, returnType,
         namedParameters: namedParameters,
         typeParameters: typeParameters,
         requiredParameterCount: node.requiredParameterCount);
   }
 
   void bumpCountersUntil(_TypeSubstitutor target) {
@@ skipping 162 matching lines @@
       for (int i = 0; i < type1.typeParameters.length; ++i) {
         var left = substitute(type1.typeParameters[i].bound, leftInstance);
         var right = substitute(type2.typeParameters[i].bound, rightInstance);
         if (!_unify(left, right)) return false;
       }
       for (int i = 0; i < type1.positionalParameters.length; ++i) {
         var left = substitute(type1.positionalParameters[i], leftInstance);
         var right = substitute(type2.positionalParameters[i], rightInstance);
         if (!_unify(left, right)) return false;
       }
-      for (var name in type1.namedParameters.keys) {
-        var right = type2.namedParameters[name];
-        if (right == null) return _fail();
-        right = substitute(right, rightInstance);
-        var left = substitute(type1.namedParameters[name], leftInstance);
+      for (int i = 0; i < type1.namedParameters.length; ++i) {
+        if (type1.namedParameters[i].name != type2.namedParameters[i].name) {
+          return false;
+        }
+        var left = substitute(type1.namedParameters[i].type, leftInstance);
+        var right = substitute(type2.namedParameters[i].type, rightInstance);
         if (!_unify(left, right)) return false;
       }
       var leftReturn = substitute(type1.returnType, leftInstance);
       var rightReturn = substitute(type2.returnType, rightInstance);
       if (!_unify(leftReturn, rightReturn)) return false;
       return true;
     }
     if (type1 is TypeParameterType &&
         type2 is TypeParameterType &&
         type1.parameter == type2.parameter) {
@@ skipping 28 matching lines @@
   }
 }
 
 class _OccurrenceVisitor extends DartTypeVisitor<bool> {
   final Set<TypeParameter> variables;
 
   _OccurrenceVisitor(this.variables);
 
   bool visit(DartType node) => node.accept(this);
 
+  bool visitNamedType(NamedType node) {
+    return visit(node.type);
+  }
+
   bool visitInvalidType(InvalidType node) => false;
   bool visitDynamicType(DynamicType node) => false;
   bool visitVoidType(VoidType node) => false;
 
   bool visitInterfaceType(InterfaceType node) {
     return node.typeArguments.any(visit);
   }
 
   bool visitFunctionType(FunctionType node) {
     return node.typeParameters.any(handleTypeParameter) ||
         node.positionalParameters.any(visit) ||
-        node.namedParameters.values.any(visit) ||
+        node.namedParameters.any(visitNamedType) ||
         visit(node.returnType);
   }
 
   bool visitTypeParameterType(TypeParameterType node) {
     return variables == null || variables.contains(node.parameter);
   }
 
   bool handleTypeParameter(TypeParameter node) {
     assert(!variables.contains(node));
     return node.bound.accept(this);
   }
 }
 
 Map<dynamic/*=K*/, dynamic/*=W*/ > _mapValues/*<K,V,W>*/(
     Map<dynamic/*=K*/, dynamic/*=V*/ > map, dynamic/*=W*/ fn(dynamic/*=V*/)) {
   Map<dynamic/*=K*/, dynamic/*=W*/ > result = {};
   map.forEach((key, value) {
     result[key] = fn(value);
   });
   return result;
 }