Modification to the order that classes are printed out so that the prototype

frog/gen.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 210 matching lines @@
         body = world.objectType.varStubs[checkName].body;
       } else if (onType.name == 'StringImplementation' ||
           onType.name == 'NumImplementation') {
         body = 'return ${onType.nativeType.name}(this)';
       }
       writer.writeln(_prototypeOf(onType, checkName) + ' = function(){$body};');
     }
   }
 
   writeType(Type type) {
+    if (type.isWritten) return;
+
+    type.isWritten = true;
+    // Ensure parent has been written before the child. Important ordering for
+    // IE when we're using $inherits, since we don't have __proto__ available.
+    if (type.parent !=  null && !type.isNative) {
+      writeType(type.parent);
+    }
+
     // TODO(jimhug): Workaround for problems with reified generic Array.
     if (type.name != null && type is ConcreteType &&
         type.library == world.coreimpl &&
         type.name.startsWith('ListFactory')) {
       writer.writeln('${type.jsname} = ${type.genericType.jsname};');
       return;
     }
 
     var typeName = type.jsname != null ? type.jsname : 'top level';
     writer.comment('// ********** Code for ${typeName} **************');
     if (type.isNative && !type.isTop) {
       var nativeName = type.definition.nativeType.name;
       if (nativeName == '') {
         writer.writeln('function ${type.jsname}() {}');
       } else if (type.jsname != nativeName) {
         writer.writeln('${type.jsname} = ${nativeName};');
       }
     }
 
+    // We need the $inherits function to be declared before factory constructors
+    // so that inheritance ($inherits) will work correctly in IE.
+    if (!type.isTop) {
+      if (type is ConcreteType) {
+        ConcreteType c = type;
+        corejs.ensureInheritsHelper();
+        writer.writeln('\$inherits(${c.jsname}, ${c.genericType.jsname});');
+
+        // Mixin members from concrete specializations of base types too.
+        // TODO(jmesserly): emit this sooner instead of at the end.
+        // But it needs to come after we've emitted both types.
+        // TODO(jmesserly): HACK: using _parent instead of parent so we don't
+        // try to inherit things that we didn't actually use.
+        for (var p = c._parent; p is ConcreteType; p = p._parent) {
+          _ensureInheritMembersHelper();
+          _mixins.writeln('\$inheritsMembers(${c.jsname}, ${p.jsname});');
+        }
+      } else if (!type.isNative) {
+        if (type.parent != null && !type.parent.isObject) {
+          corejs.ensureInheritsHelper();
+          writer.writeln('\$inherits(${type.jsname}, ${type.parent.jsname});');
+        }
+      }
+    }
+    
     if (type.isTop) {
       // no preludes for top type
     } else if (type.constructors.length == 0) {
       if (!type.isNative) {
         // TODO(jimhug): More guards to guarantee staticness
         writer.writeln('function ${type.jsname}() {}');
       }
     } else {
       Member standardConstructor = type.constructors[''];
       if (standardConstructor == null ||
           standardConstructor.generator == null) {
         if (!type.isNative) {
           writer.writeln('function ${type.jsname}() {}');
         }
       } else {
         standardConstructor.generator.writeDefinition(writer, null);
       }
 
       for (var c in type.constructors.getValues()) {
         if (c.generator != null && c != standardConstructor) {
           c.generator.writeDefinition(writer, null);
         }
       }
     }
 
-    if (!type.isTop) {
-      if (type is ConcreteType) {
-        ConcreteType c = type;
-        corejs.ensureInheritsHelper();
-        writer.writeln('\$inherits(${c.jsname}, ${c.genericType.jsname});');
-
-        // Mixin members from concrete specializations of base types too.
-        // TODO(jmesserly): emit this sooner instead of at the end.
-        // But it needs to come after we've emitted both types.
-        // TODO(jmesserly): HACK: using _parent instead of parent so we don't
-        // try to inherit things that we didn't actually use.
-        for (var p = c._parent; p is ConcreteType; p = p._parent) {
-          _ensureInheritMembersHelper();
-          _mixins.writeln('\$inheritsMembers(${c.jsname}, ${p.jsname});');
-        }
-      } else if (!type.isNative) {
-        if (type.parent != null && !type.parent.isObject) {
-          corejs.ensureInheritsHelper();
-          writer.writeln('\$inherits(${type.jsname}, ${type.parent.jsname});');
-        }
-      }
-    }
-
     // Concrete types (like List<String>) will have this already defined on
     // their prototype from the generic type (like List)
     if (type is! ConcreteType) {
       _maybeIsTest(type, type);
     }
     if (type.genericType._concreteTypes != null) {
       for (var ct in _orderValues(type.genericType._concreteTypes)) {
         _maybeIsTest(type, ct);
       }
     }
@@ skipping 2179 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }