dart2js kernel: Sort constants

pkg/compiler/lib/src/kernel/kernel_backend_strategy.dart

 // Copyright (c) 2017, 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 dart2js.kernel.backend_strategy;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../backend_strategy.dart';
 import '../common.dart';
@@ skipping 204 matching lines @@
         entity1, sourceSpan1.begin, null, entity2, sourceSpan2.begin, null);
   }
 
   @override
   Iterable<LibraryEntity> sortLibraries(Iterable<LibraryEntity> libraries) {
     return libraries.toList()..sort(_compareLibraries);
   }
 
   @override
   Iterable<MemberEntity> sortMembers(Iterable<MemberEntity> members) {
-    return members.toList()
-      ..sort((MemberEntity member1, MemberEntity member2) {
-        int r = _compareLibraries(member1.library, member2.library);
-        if (r != 0) return r;
-        MemberDefinition definition1 = elementMap.getMemberDefinition(member1);
-        MemberDefinition definition2 = elementMap.getMemberDefinition(member2);
-        return _compareSourceSpans(
-            member1, definition1.location, member2, definition2.location);
-      });
+    return members.toList()..sort(compareMembersByLocation);
   }
 
   @override
   Iterable<ClassEntity> sortClasses(Iterable<ClassEntity> classes) {
-    int compareClasses(ClassEntity cls1, ClassEntity cls2) {
-      int r = _compareLibraries(cls1.library, cls2.library);
-      if (r != 0) return r;
-      ClassDefinition definition1 = elementMap.getClassDefinition(cls1);
-      ClassDefinition definition2 = elementMap.getClassDefinition(cls2);
-      return _compareSourceSpans(
-          cls1, definition1.location, cls2, definition2.location);
-    }
-
     List<ClassEntity> regularClasses = <ClassEntity>[];
     List<ClassEntity> unnamedMixins = <ClassEntity>[];
     for (ClassEntity cls in classes) {
       if (elementMap.elementEnvironment.isUnnamedMixinApplication(cls)) {
         unnamedMixins.add(cls);
       } else {
         regularClasses.add(cls);
       }
     }
     List<ClassEntity> sorted = <ClassEntity>[];
-    regularClasses.sort(compareClasses);
+    regularClasses.sort(compareClassesByLocation);
     sorted.addAll(regularClasses);
     unnamedMixins.sort((a, b) {
       int result = _compareLibraries(a.library, b.library);
       if (result != 0) return result;
       result = a.name.compareTo(b.name);
       assert(result != 0,
           failedAt(a, "Multiple mixins named ${a.name}: $a vs $b."));
       return result;
     });
     sorted.addAll(unnamedMixins);
     return sorted;
   }
 
   @override
   Iterable<TypedefEntity> sortTypedefs(Iterable<TypedefEntity> typedefs) {
     // TODO(redemption): Support this.
     assert(typedefs.isEmpty);
     return typedefs;
   }
+
+  @override
+  int compareLibrariesByLocation(LibraryEntity a, LibraryEntity b) {
+    return _compareLibraries(a, b);
+  }
+
+  @override
+  int compareClassesByLocation(ClassEntity a, ClassEntity b) {
+    int r = _compareLibraries(a.library, b.library);
+    if (r != 0) return r;
+    ClassDefinition definition1 = elementMap.getClassDefinition(a);
+    ClassDefinition definition2 = elementMap.getClassDefinition(b);
+    return _compareSourceSpans(
+        a, definition1.location, b, definition2.location);
+  }
+
+  @override
+  int compareTypedefsByLocation(TypedefEntity a, TypedefEntity b) {
+    // TODO(redemption): Support this.
+    failedAt(a, 'KernelSorter.compareTypedefsByLocation unimplemented');
+    return 0;
+  }
+
+  @override
+  int compareMembersByLocation(MemberEntity a, MemberEntity b) {
+    int r = _compareLibraries(a.library, b.library);
+    if (r != 0) return r;
+    MemberDefinition definition1 = elementMap.getMemberDefinition(a);
+    MemberDefinition definition2 = elementMap.getMemberDefinition(b);
+    return _compareSourceSpans(
+        a, definition1.location, b, definition2.location);
+  }
 }