DOM fixes for types that are not marked hidden

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 147 matching lines @@
       var filename = basename(file.filename);
       writer.comment('//  ********** Natives $filename **************');
       writer.writeln(file.text);
     }
     lib.topType.markUsed(); // TODO(jimhug): EGREGIOUS HACK
 
     for (var type in _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.
-      if ((type.isUsed || type.isHiddenNativeType) && type.isClass) {
+      if ((type.isUsed || type.library == world.dom

[sra1, 2011/12/08 22:04:32]

I assume isUsed get set when a subclass is used?

Then there is a work-around for Event:  
  if (false) { <create a subclass of event> }

But that is harder to do in the source than first appears.

Could you do a pre-walk over the types, marking *Foo types and their parents as
used?

[Jennifer Messerly, 2011/12/08 22:17:48]

Maybe. The "hidden" bit isn't really related, though--that was just a quick hack
to make the DOM work and to make your "makeA" tests work.

What we need is to be more explicit--for every native method, including corelib,
coreimpl, DOM and any special Frog tests, we need the list of types it might
create--similar to what we do some places in corelib. (the block of code
following the "native" declaration).

+          || type.isHiddenNativeType) && type.isClass) {
         writeType(type);
 
         if (type.isGeneric) {
           for (var ct in _orderValues(type._concreteTypes)) {
             writeType(ct);
           }
         }
       } else if (type.isFunction && type.varStubs.length > 0) {
         // Emit stubs on "Function" or hidden types if needed
         writer.comment('// ********** Code for ${type.jsname} **************');
@@ skipping 94 matching lines @@
           _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 ||
@@ skipping 2204 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);
   }
 }