Fix a bunch of issues with 'hidden' DOM types.

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 10 matching lines @@
 
   /**
    * Whether the app has any static fields used. Note this could still be true
    * and [globals] be empty if no static field has a default initialization.
    */
   bool hasStatics = false;
 
   /** Global const and static field initializations. */
   Map<String, GlobalValue> globals;
   CoreJs corejs;
-  bool _inheritsGenerated = false;
 
-  WorldGenerator(this.main, this.writer): globals = {}, corejs = new CoreJs();
+  WorldGenerator(this.main, this.writer)
+    : globals = {}, corejs = new CoreJs();
 
   run() {
     var metaGen = new MethodGenerator(main, null);
     var mainTarget = new Value.type(main.declaringType, main.span);
     var mainCall = main.invoke(metaGen, null, mainTarget, Arguments.EMPTY);
     main.declaringType.markUsed();
 
     if (options.compileAll) {
       markLibraryUsed(world.corelib);
       markLibraryUsed(main.declaringType.library);
@@ skipping 25 matching lines @@
     }
 
     writeTypes(world.coreimpl);
     writeTypes(world.corelib);
 
     // Write the main library. This will cause all libraries to be written in
     // the topographic sort order.
     writeTypes(main.declaringType.library);
 
     // Write out any inherited concrete members.
+    // TODO(jmesserly): this won't need to come last once we are sorting types
+    // correctly.
     if (_mixins != null) writer.write(_mixins.text);
 
     writeGlobals();
     writer.writeln('${mainCall.code};');
   }
 
   void markLibraryUsed(Library l) {
     if (l.isMarked) return;
     l.isMarked = true;
 
@@ skipping 64 matching lines @@
       corejs.generate(writer);
     }
     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
 
     for (var type in _orderValues(lib.types)) {
-      if (type.isUsed && type.isClass) {
+      // TODO(jmesserly): we can't accurately track if DOM types are
+      // created or not, so we need to prepare to handle them.
+      if ((type.isUsed || type.isHiddenNativeType) && type.isClass) {
         writeType(type);
 
         if (type.isGeneric) {
           for (var ct in _orderValues(type._concreteTypes)) {
             writeType(ct);
           }
         }
-      }
-      if (type.isFunction && type.varStubs != null) {
-        // Emit stubs on "Function" if needed
+      } else if (type.isFunction && type.varStubs.length > 0) {
+        // Emit stubs on "Function" or hidden types if needed
         writer.comment('// ********** Code for ${type.jsname} **************');
         _writeDynamicStubs(type);
       }
       // Type check functions for builtin JS types
       if (type.typeCheckCode != null) {
         writer.writeln(type.typeCheckCode);
       }
     }
   }
 
   genMethod(Member meth, [MethodGenerator enclosingMethod=null]) {
     if (!meth.isGenerated && !meth.isAbstract && meth.definition != null) {
       new MethodGenerator(meth, enclosingMethod).run();
     }
   }
 
+  String _prototypeOf(Type type, String name) {
+    if (type.isHiddenNativeType) {
+      corejs.ensureDynamicProto();
+      return '\$dynamic("$name").${type.jsname}';
+    } else {
+      return '${type.jsname}.prototype.$name';
+    }
+  }
+
   _maybeIsTest(Type onType, Type checkType) {
-    if (!checkType.isTested) return;
-
-    var value = 'false';
-    if (onType.isSubtypeOf(checkType)) {
-      value = 'function(){return this;}';
+    bool isSubtype = onType.isSubtypeOf(checkType);
+    if (checkType.isTested) {
+      // TODO(jmesserly): cache these functions? they just return true or false.
+      writer.writeln(_prototypeOf(onType, 'is\$${checkType.jsname}')
+          + ' = function(){return $isSubtype};');
     }
 
-    writer.writeln('${onType.jsname}.prototype.is\$${checkType.jsname} = '
-        + '$value;');
+    if (checkType.isChecked) {
+      String body = 'return this';
+      String checkName = 'assert\$${checkType.jsname}';
+      if (!isSubtype) {
+        // Get the code to throw a TypeError.
+        // TODO(jmesserly): it'd be nice not to duplicate this code, and instead
+        // be able to refer to the JS function.
+        body = world.objectType.varStubs[checkName].body;
+      }
+      writer.writeln(_prototypeOf(onType, checkName) + ' = function(){$body};');
+    }
   }
 
   writeType(Type type) {
     // 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;
     }
@@ skipping 30 matching lines @@
       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;
-        _ensureInheritsHelper();
+        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) {
-          _ensureInheritsHelper();
+          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);
     }
@@ skipping 38 matching lines @@
 
       if (member.isMethod) {
         _writeMethod(member);
       }
     }
 
     _writeDynamicStubs(type);
   }
 
   /**
-   * Generates the $inherits function when it's first used. Unlike some of the
-   * other helpers in [CoreJS], we don't notice that we need this one until
-   * we're generating types.
-   */
-  _ensureInheritsHelper() {
-    if (_inheritsGenerated) return;
-
-    _inheritsGenerated = true;
-    writer.writeln(@"""
-/** Implements extends for Dart classes on JavaScript prototypes. */
-function $inherits(child, parent) {
-  if (child.prototype.__proto__) {
-    child.prototype.__proto__ = parent.prototype;
-  } else {
-    function tmp() {};
-    tmp.prototype = parent.prototype;
-    child.prototype = new tmp();
-    child.prototype.constructor = child;
-  }
-}""");
-  }
-
-  /**
    * Generates the $inheritsMembers function when it's first used.
    * This is used to mix in specialized generic members from the base class.
    */
   _ensureInheritMembersHelper() {
     if (_mixins != null) return;
     _mixins = new CodeWriter();
     _mixins.comment('// ********** Generic Type Inheritance **************');
     _mixins.writeln(@"""
 /** Implements extends for generic types. */
 function $inheritsMembers(child, parent) {
   child = child.prototype;
   parent = parent.prototype;
   Object.getOwnPropertyNames(parent).forEach(function(name) {
     if (typeof(child[name]) == 'undefined') child[name] = parent[name];
   });
 }""");
   }
 
   _writeDynamicStubs(Type type) {
-    if (type.varStubs != null) {
-      for (var stub in orderValuesByKeys(type.varStubs)) {
-        stub.generate(writer);
-      }
+    for (var stub in orderValuesByKeys(type.varStubs)) {
+      stub.generate(writer);
     }
   }
 
   _writeStaticField(FieldMember field) {
     // Final static fields must be constants which will be folded and inlined.
     if (field.isFinal) return;
 
     var fullname = "${field.declaringType.jsname}.${field.jsname}";
     if (globals.containsKey(fullname)) {
       var value = globals[fullname];
       if (field.declaringType.isTop && !field.isNative) {
         writer.writeln('\$globals.${field.jsname} = ${value.exp.code};');
       } else {
         writer.writeln('\$globals.${field.declaringType.jsname}_${field.jsname}'
             + ' = ${value.exp.code};');
       }
     }
     // No need to write code for a static class field with no initial value.
   }
 
   _writeField(FieldMember field) {
     // Generate declarations for static top-level fields with no value.
     if (field.declaringType.isTop && !field.isNative && field.value == null) {
       writer.writeln('var ${field.jsname};');
     }
 
     // generate code for instance fields
     if (field._providePropertySyntax) {
-      writer.writeln(
-        '${field.declaringType.jsname}.prototype.get\$${field.jsname} = ' +
-        'function() { return this.${field.jsname}; };');
+      writer.writeln(_prototypeOf(field.declaringType, 'get\$${field.jsname}')
+        + ' = function() { return this.${field.jsname}; };');
       if (!field.isFinal) {
-        writer.writeln(
-          '${field.declaringType.jsname}.prototype.set\$${field.jsname} = ' +
-          'function(value) { return this.${field.jsname} = value; };');
+        writer.writeln(_prototypeOf(field.declaringType, 'set\$${field.jsname}')
+          + ' = function(value) { return this.${field.jsname} = value; };');
       }
     }
 
     // TODO(jimhug): Currently choose not to initialize fields on objects, but
     //    instead to rely on uninitialized === null in our generated code.
     //    Investigate the perf pros and cons of this.
   }
 
   _writeProperty(PropertyMember property) {
     if (property.getter != null) _writeMethod(property.getter);
     if (property.setter != null) _writeMethod(property.setter);
 
+    // TODO(jmesserly): make sure we don't do this on hidden native types!
     if (property._provideFieldSyntax) {
       writer.enterBlock('Object.defineProperty(' +
         '${property.declaringType.jsname}.prototype, "${property.jsname}", {');
       if (property.getter != null) {
         writer.write(
           'get: ${property.declaringType.jsname}.prototype.${property.getter.jsname}');
         // The shenanigan below is to make IE happy -- IE 9 doesn't like a
         // trailing comma on the last element in a list.
         writer.writeln(property.setter == null ? '' : ',');
       }
@@ skipping 562 matching lines @@
             initializedFields.add(f.name);
             writer.writeln('this.${f.jsname} = ${visitValue(init.y).code};');
           } else {
             world.error('invalid initializer', init.span);
           }
         }
       }
       writer.comment('// Initializers done');
     }
 
-    if (method.isConstructor && initializerCall == null) {
+    if (method.isConstructor && initializerCall == null && !method.isNative) {
       var parentType = method.declaringType.parent;
       if (parentType != null && !parentType.isObject) {
         // TODO(jmesserly): we could omit this if all supertypes are using
         // default constructors.
         initializerCall = new CallExpression(
             new SuperExpression(method.span), [], method.span);
       }
     }
 
     if (initializerCall != null) {
@@ skipping 281 matching lines @@
       }
     }
     return true;
   }
 
   bool visitAssertStatement(AssertStatement node) {
     // be sure to walk test for static checking even is asserts disabled
     var test = visitValue(node.test); // TODO(jimhug): check bool or callable.
     if (options.enableAsserts) {
       var err = world.corelib.types['AssertError'];
-      world.gen.genMethod(err.getConstructor(''));
+      world.gen.genMethod(err.getConstructor('_internal'));
       world.gen.genMethod(err.members['toString']);
       var span = node.test.span;
 
       // TODO(jmesserly): do we need to include path/line/column here?
       // It should be captured in the stack trace.
       var line = span.file.getLine(span.start);
       var column = span.file.getColumn(line, span.start);
       writer.writeln('\$assert(${test.code}, "${_escapeString(span.text)}",' +
         ' "${basename(span.file.filename)}", ${line + 1}, ${column + 1});');
       world.gen.corejs.useAssert = true;
@@ skipping 1117 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);
   }
 }