Sort the output (for now just the classes and instance members).

lib/compiler/implementation/universe.dart

 // Copyright (c) 2012, 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.
 
 class Universe {
+  int nextFreeClassId = 0;
   Map<Element, String> generatedCode;
   Map<Element, String> generatedBailoutCode;
   final Set<ClassElement> instantiatedClasses;
   final Set<SourceString> instantiatedClassInstanceFields;
   final Set<FunctionElement> staticFunctionsNeedingGetter;
   final Map<SourceString, Set<Selector>> invokedNames;
   final Map<SourceString, Set<Selector>> invokedGetters;
   final Map<SourceString, Set<Selector>> invokedSetters;
   final Map<String, LibraryElement> libraries;
   // TODO(ngeoffray): This should be a Set<Type>.
   final Set<Element> isChecks;
   final RuntimeTypeInformation rti;
 
   Universe() : generatedCode = new Map<Element, String>(),
                generatedBailoutCode = new Map<Element, String>(),
                libraries = new Map<String, LibraryElement>(),
                instantiatedClasses = new Set<ClassElement>(),
                instantiatedClassInstanceFields = new Set<SourceString>(),
                staticFunctionsNeedingGetter = new Set<FunctionElement>(),
                invokedNames = new Map<SourceString, Set<Selector>>(),
                invokedGetters = new Map<SourceString, Set<Selector>>(),
                invokedSetters = new Map<SourceString, Set<Selector>>(),
                isChecks = new Set<Element>(),
                rti = new RuntimeTypeInformation();
 
+  int getNextFreeClassId() => nextFreeClassId++;
+
   void addGeneratedCode(WorkItem work, String code) {
     generatedCode[work.element] = code;
   }
 
   void addBailoutCode(WorkItem work, String code) {
     generatedBailoutCode[work.element] = code;
   }
 
   bool hasMatchingSelector(Set<Selector> selectors,
                            Element member,
@@ skipping 11 matching lines @@
   }
 
   bool hasGetter(Element member, Compiler compiler) {
     return hasMatchingSelector(
         compiler.universe.invokedGetters[member.name], member, compiler);
   }
 
   bool hasSetter(Element member, Compiler compiler) {
     return hasMatchingSelector(
         compiler.universe.invokedSetters[member.name], member, compiler);
-  }  
+  }
 }
 
 class SelectorKind {
   final String name;
   const SelectorKind(this.name);
 
   static final SelectorKind GETTER = const SelectorKind('getter');
   static final SelectorKind SETTER = const SelectorKind('setter');
   static final SelectorKind INVOCATION = const SelectorKind('invocation');
   static final SelectorKind OPERATOR = const SelectorKind('operator');
@@ skipping 15 matching lines @@
   Selector(
       this.kind,
       this.argumentCount,
       [List<SourceString> namedArguments = const <SourceString>[]])
     : this.namedArguments = namedArguments,
       this.orderedNamedArguments = namedArguments.isEmpty()
           ? namedArguments
           : <SourceString>[];
 
   Selector.invocation(
-      int argumentCount, 
+      int argumentCount,
       [List<SourceString> namedArguments = const <SourceString>[]])
     : this(SelectorKind.INVOCATION, argumentCount, namedArguments);
 
   int hashCode() => argumentCount + 1000 * namedArguments.length;
   int get namedArgumentCount() => namedArguments.length;
   int get positionalArgumentCount() => argumentCount - namedArgumentCount;
 
   static final Selector GETTER =
       const Selector.constant(SelectorKind.GETTER, 0);
   static final Selector SETTER =
@@ skipping 127 matching lines @@
       for (int i = 0; i < namedArguments.length; i++) {
         SourceString name = namedArguments[i];
         if (name == parameter.name) {
           foundIndex = i;
           break;
         }
       }
       if (foundIndex != -1) {
         list.add(compiledNamedArguments[foundIndex]);
       } else {
-        list.add(compileConstant(parameter)); 
+        list.add(compileConstant(parameter));
       }
     }
     return true;
   }
 
   static bool sameNames(List<SourceString> first, List<SourceString> second) {
     for (int i = 0; i < first.length; i++) {
       if (first[i] != second[i]) return false;
     }
     return true;
@@ skipping 81 matching lines @@
 
     return false;
   }
 
   bool operator ==(other) {
     if (other is !TypedSelector) return false;
     if (other.receiverType !== receiverType) return false;
     return super == other;
   }
 }