Reapply r3590 with frog fixes

frog/gen.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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 19 matching lines @@
   /** Global const and static field initializations. */
   Map<String, GlobalValue> globals;
   CoreJs corejs;
 
   /** */
   Set<Type> typesWithDynamicDispatch;
 
   WorldGenerator(this.main, this.writer)
     : globals = {}, corejs = new CoreJs();
 
+
+
+
   analyze() {
     // Walk all code and find all NewExpressions - to determine possible types
     int nlibs=0, ntypes=0, nmems=0, nnews=0;
-    //Set<Type> newedTypes = new Set<Type>();
     for (var lib in world.libraries.getValues()) {
       nlibs += 1;
       for (var type in lib.types.getValues()) {
+        // TODO(jmesserly): we can't accurately track if DOM types are
+        // created or not, so we need to prepare to handle them.
+        // This should be fixed by tightening up the return types in DOM.
+        // Until then, this 'analysis' just marks all the DOM types as used.
+        // TODO(jimhug): Do we still need this?  Or do/can we handle this by
+        // using return values?
+        if (type.library.isDom || type.isHiddenNativeType) {
+          if (type.isClass) type.markUsed();
+        }
+
         ntypes += 1;
         var allMembers = [];
         allMembers.addAll(type.constructors.getValues());
         allMembers.addAll(type.members.getValues());
         type.factories.forEach((f) => allMembers.add(f));
         for (var m in allMembers) {
           if (m.isAbstract || !m.isMethod) continue;
 
           m.methodData.analyze();
         }
@@ skipping 161 matching lines @@
     }
     for (var file in lib.natives) {
       var filename = basename(file.filename);
       writer.comment('//  ********** Natives $filename **************');
       writer.writeln(file.text);
     }
     lib.topType.markUsed(); // TODO(jimhug): EGREGIOUS HACK
 
     var orderedTypes = _orderValues(lib.types);
 
-    // TODO(jmesserly): we can't accurately track if DOM types are
-    // created or not, so we need to prepare to handle them.
-    // This should be fixed by tightening up the return types in DOM.
-    // Until then, this 'analysis' just marks all the DOM types as used.
-    for (var type in orderedTypes) {
-      if ((type.library.isDom || type.isHiddenNativeType) &&
-          type.isClass) {
-        type.markUsed();
-      }
-    }
-
     for (var type in orderedTypes) {
       if (type.isUsed && type.isClass) {
         writeType(type);
         // TODO(jimhug): Performance is terrible if we use current
         // reified generics approach for reified generic Arrays.
         if (type.isGeneric && type !== world.listFactoryType) {
           for (var ct in _orderValues(type._concreteTypes)) {
             if (ct.isUsed) writeType(ct);
           }
         }
@@ skipping 2189 matching lines @@
     return true;
   }
 
 }
 
 class ReturnKind {
   static final int IGNORE = 1;
   static final int POST = 2;
   static final int PRE = 3;
 }