Fix the order in which elements are emitted.

lib/compiler/implementation/dart_backend/backend.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 DartBackend extends Backend {
   final List<CompilerTask> tasks;
   final UnparseValidator unparseValidator;
 
   Map<Element, TreeElements> get resolvedElements() =>
       compiler.enqueuer.resolution.resolvedElements;
@@ skipping 30 matching lines @@
     ];
     bool shouldOutput(Element element) =>
       element.kind !== ElementKind.VOID &&
       LIBS_TO_IGNORE.indexOf(element.getLibrary()) == -1 &&
       !isDartCoreLib(compiler, element.getLibrary()) &&
       element is !AbstractFieldElement;
 
     final emptyTreeElements = new TreeElementMapping();
 
     Set<Element> topLevelElements = new Set<Element>();
-    Map<ClassElement, Set<Element>> classes =
+    Map<ClassElement, Set<Element>> classMembers =
         new Map<ClassElement, Set<Element>>();
 
     PlaceholderCollector collector = new PlaceholderCollector(compiler);
     var newTypedefElementCallback, newClassElementCallback;
 
     processElement(element, treeElements) {
       collector.collect(element, treeElements);
       new ReferencedElementCollector(
           compiler,
           element, treeElements,
           newTypedefElementCallback, newClassElementCallback).collect();
     }
 
     addTopLevel(element, treeElements) {
       if (topLevelElements.contains(element)) return;
       topLevelElements.add(element);
       processElement(element, treeElements);
     }
     addClass(classElement) {
-      if (classes.containsKey(classElement)) return;
-      classes[classElement] = new Set<Element>();
-      processElement(classElement, emptyTreeElements);
+      addTopLevel(classElement, emptyTreeElements);
+      classMembers.putIfAbsent(classElement, () => new Set());
     }
 
     newTypedefElementCallback = (TypedefElement element) {
       if (!shouldOutput(element)) return;
       addTopLevel(element, emptyTreeElements);
     };
     newClassElementCallback = (ClassElement classElement) {
       if (!shouldOutput(classElement)) return;
       addClass(classElement);
     };
 
     resolvedElements.forEach((element, treeElements) {
       if (!shouldOutput(element)) return;
 
       if (element.isMember()) {
         ClassElement enclosingClass = element.getEnclosingClass();
         assert(enclosingClass.isClass());
         assert(enclosingClass.isTopLevel());
         assert(shouldOutput(enclosingClass));
         addClass(enclosingClass);
-        classes[enclosingClass].add(element);
+        classMembers[enclosingClass].add(element);
         processElement(element, treeElements);
       } else {
         if (!element.isTopLevel()) {
           compiler.cancel(reason: 'Cannot process $element', element: element);
         }
         addTopLevel(element, treeElements);
       }
     });
 
     Map<Node, String> renames = new Map<Node, String>();
     Map<LibraryElement, String> imports = new Map<LibraryElement, String>();
     renamePlaceholders(compiler, collector, renames, imports);
 
-    Emitter emitter = new Emitter(compiler, renames);
+    // Sort elements.
+    compareElements(e0, e1) {

[Roman, 2012/08/16 15:23:14]

I miss SortedSet now

+      compareBy(x, y, f) => f(x).compareTo(f(y));
+      int result = compareBy(e0, e1, (e) => e.getLibrary().uri.toString());
+      if (result != 0) return result;
+      return compareBy(e0, e1, (e) => e.position().charOffset);
+    }
+
+    final sortedTopLevels = new List<Element>.from(topLevelElements);
+    sortedTopLevels.sort(compareElements);
+
+    final sortedClassMembers = new Map<ClassElement, List<Element>>();
+    classMembers.forEach((classElement, members) {
+      final sortedMembers = new List<Element>.from(members);
+      sortedMembers.sort(compareElements);
+      sortedClassMembers[classElement] = sortedMembers;
+    });
+
+    Emitter emitter = new Emitter(compiler, renames, sortedClassMembers);
     emitter.outputImports(imports);
-    topLevelElements.forEach(emitter.outputElement);
-    classes.forEach(emitter.outputClass);
+    sortedTopLevels.forEach(emitter.outputElement);
 
     compiler.assembledCode = emitter.toString();
   }
 
   log(String message) => compiler.log('[DartBackend] $message');
 }
 
 /**
  * Checks if [:libraryElement:] is a core lib, that is a library
  * provided by the implementation like dart:core, dart:coreimpl, etc.
@@ skipping 47 matching lines @@
     if (typeElement.isClass()) newClassElementCallback(typeElement);
     typeAnnotation.visitChildren(this);
   }
 
   void collect() {
     compiler.withCurrentElement(rootElement, () {
       rootElement.parseNode(compiler).accept(this);
     });
   }
 }