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

lib/compiler/implementation/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 408 matching lines @@
         buffer.add('"${fields[i]}"');
       }
       buffer.add(']');
     }
     buffer.add(', {\n');
 
     void defineInstanceMember(String name, String value) {
       buffer.add(' $name: $value,\n');
     }
 
+    List<Element> instanceMembers = <Element>[];
     classElement.forEachMember(includeBackendMembers: true,
                                f: (ClassElement enclosing, Element member) {
       if (member.isInstanceMember()) {
-        addInstanceMember(member, defineInstanceMember);
+        instanceMembers.add(member);
       }
     });
+    instanceMembers.sort((Element member1, Element member2) {
+      return member1.compareTo(member2);

[ngeoffray, 2012/05/08 07:58:02]

Should the list already be sorted? After all, these elements are stored in the
ClassElement, and we should build that list sorted when creating the
ClassElement.

[floitsch, 2012/05/09 10:55:07]

Removed sorting of instance members.

+    });
+    for (Element member in instanceMembers) {
+      addInstanceMember(member, defineInstanceMember);
+    }
 
     generateTypeTests(classElement, (Element other) {
       if (nativeEmitter.requiresNativeIsCheck(other)) {
         defineInstanceMember(namer.operatorIs(other),
                              'function() { return true; }');
       } else {
         defineInstanceMember(namer.operatorIs(other), 'true');
       }
     });
 
@@ skipping 35 matching lines @@
     Set<ClassElement> neededClasses =
         new Set<ClassElement>.from(instantiatedClasses);
     for (ClassElement element in instantiatedClasses) {
       for (ClassElement superclass = element.superclass;
            superclass !== null;
            superclass = superclass.superclass) {
         if (neededClasses.contains(superclass)) break;
         neededClasses.add(superclass);
       }
     }
-    for (ClassElement element in neededClasses) {
+    List<ClassElement> sortedClasses =
+        new List<ClassElement>.from(neededClasses);
+    sortedClasses.sort((ClassElement class1, ClassElement class2) {

[ngeoffray, 2012/05/08 07:58:02]

I guess this one is hard to sort eagerly. How about assigning an index to the
ClassElement when it's created, so the order is only dependent on the way we
scan files?

[floitsch, 2012/05/09 10:55:07]

Done.

+      return class1.compareTo(class2);
+    });
+    for (ClassElement element in sortedClasses) {
       generateClass(element, buffer);
     }
 
     // The closure class could have become necessary because of the generation
     // of stubs.
     ClassElement closureClass = compiler.closureClass;
     if (needsClosureClass && !instantiatedClasses.contains(closureClass)) {
       generateClass(closureClass, buffer);
     }
   }
@@ skipping 62 matching lines @@
     //   BoundClosure499(this.self);
     //   $call3(x, y, z) { return self.foo(x, y, z); }
     // }
 
     // TODO(floitsch): share the closure classes with other classes
     // if they share methods with the same signature.
 
     // The closure class.
     SourceString name = const SourceString("BoundClosure");
     ClassElement closureClassElement =
-        new ClosureClassElement(compiler, member.getCompilationUnit());
+        new ClosureClassElement(compiler,
+                                member.getCompilationUnit(),
+                                member.position());

[ngeoffray, 2012/05/08 07:58:02]

Maybe a FunctionElement should contain a list of closure elements?

[floitsch, 2012/05/09 10:55:07]

change reverted.

     String mangledName = namer.getName(closureClassElement);
     String superName = namer.getName(closureClassElement.superclass);
     needsClosureClass = true;
 
     // Define the constructor with a name so that Object.toString can
     // find the class name of the closure class.
     boundClosureBuffer.add("$defineClassName('$mangledName', '$superName', ");
     boundClosureBuffer.add("function $name(self) { this.self = self; }, {\n");
 
     // Now add the methods on the closure class. The instance method does not
@@ skipping 314 matching lines @@
       mainBuffer.add('function init() {\n');
       mainBuffer.add('  $isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }