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

frog/corejs.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.
 
 /**
  * Generates JS helpers for dart:core. This used to be in a file "core.js".
  * Having them in Dart code means we can easily control which are generated.
  */
 // TODO(jmesserly): one idea to make this cleaner: put these as private "native"
 // methods somewhere in a library that we import. This would be rather elegant
 // because they'd get the right name collision behavior, conversions,
 // include-if-used, etc for free. Not sure if it's worth doing that.
 class CoreJs {
   // These values track if the helper is actually used. If it is we generate it.
-  bool useTypeNameOf = false;
   bool useStackTraceOf = false;
   bool useThrow = false;
-  bool useVarMethod = false;
   bool useGenStub = false;
   bool useMap = false;
   bool useAssert = false;
   bool useNotNullBool = false;
   bool useIndex = false;
   bool useSetIndex = false;
 
   bool useWrap0 = false;
   bool useWrap1 = false;
   bool useIsolates = false;
 
   /** An experimental toString implementation. Currently unused. */
   bool useToString = false;
 
+  // These helpers had to switch to a new pattern, because they can be generated
+  // after everything else.
+  bool _generatedTypeNameOf = false;
+  bool _generatedDynamicProto = false;
+  bool _generatedInherits = false;
+
   Map<String, String> _usedOperators;
 
-  CoreJs(): _usedOperators = {};
+  CodeWriter writer;
+
+  CoreJs(): _usedOperators = {}, writer = new CodeWriter();
 
   /**
    * Generates the special operator method, e.g. $add.
    * We want to do $add(x, y) instead of x.$add(y) so it doesn't box.
    * Same idea for the other methods.
    */
   void useOperator(String name) {
     if (_usedOperators[name] != null) return;
 
     var code;
@@ skipping 88 matching lines @@
 function ${name}(x, y) {
   return (typeof(x) == 'number' && typeof(y) == 'number')
     ? x ${op} y : x.${name}(y);
 }""";
         break;
     }
 
     _usedOperators[name] = code;
   }
 
+  // NOTE: some helpers can't be generated when we generate corelib,
+  // because we don't discover that we need them until later.
+  // Generate on-demand instead
+  void ensureDynamicProto() {
+    if (_generatedDynamicProto) return;
+    _generatedDynamicProto = true;
+
+    ensureTypeNameOf();
+
+    // Usage:
+    // $dynamic(name).SomeTypeName = ... method ...;
+    // $dynamic(name).Object = ... noSuchMethod ...;
+    writer.writeln(@"""
+function $dynamic(name) {
+  var f = Object.prototype[name];
+  if (f && f.methods) return f.methods;
+
+  var methods = {};
+  if (f) methods.Object = f;
+  function $dynamicBind() {
+    // Find the target method
+    var method;
+    var proto = Object.getPrototypeOf(this);
+    var obj = proto;
+    do {
+      method = methods[obj.$typeNameOf()];
+      if (method) break;
+      obj = Object.getPrototypeOf(obj);
+    } while (obj);
+
+    // Patch the prototype, but don't overwrite an existing stub, like
+    // the one on Object.prototype.
+    if (!proto.hasOwnProperty(name)) proto[name] = method || methods.Object;
+
+    return method.apply(this, Array.prototype.slice.call(arguments));
+  };
+  $dynamicBind.methods = methods;
+  Object.prototype[name] = $dynamicBind;
+  return methods;
+}""");
+  }
+
+  void ensureTypeNameOf() {
+    if (_generatedTypeNameOf) return;
+    _generatedTypeNameOf = true;
+
+    // TODO(sigmund): find a way to make this work on all browsers, including
+    // checking the typeName on prototype objects (so we can fix dynamic
+    // dispatching on $varMethod).
+    writer.writeln(@"""
+Object.prototype.$typeNameOf = function() {
+  if ((typeof(window) != 'undefined' && window.constructor.name == 'DOMWindow')
+      || typeof(process) != 'undefined') { // fast-path for Chrome and Node
+    return this.constructor.name;
+  }
+  var str = Object.prototype.toString.call(this);
+  str = str.substring(8, str.length - 1);
+  if (str == 'Window') str = 'DOMWindow';
+  return str;
+}""");
+  }
+
+
+  /** Generates the $inherits function when it's first used. */
+  ensureInheritsHelper() {
+    if (_generatedInherits) return;
+    _generatedInherits = 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;
+  }
+}""");
+  }
+
   void generate(CodeWriter w) {
-    if (useVarMethod) {
-      useTypeNameOf = true;
-      w.writeln(@"""
-function $varMethod(name, methods) {
-  Object.prototype[name] = function() {
-    $patchMethod(this, name, methods);
-    return this[name].apply(this, Array.prototype.slice.call(arguments));
-  };
-}
-function $patchMethod(obj, name, methods) {
-  // Get the prototype to patch.
-  // Don't overwrite an existing stub, like the one on Object.prototype
-  var proto = Object.getPrototypeOf(obj);
-  if (!proto || proto.hasOwnProperty(name)) proto = obj;
-  var method;
-  while (obj && !(method = methods[obj.$typeNameOf()])) {
-    obj = Object.getPrototypeOf(obj);
-  }
-  obj[name] = method || methods['Object'];
-}""");
-    }
+    // Write any stuff we had queued up, then replace our writer with the one
+    // in WorldGenerator so anything we discover that we need later on will be
+    // generated on-demand.
+    w.write(writer.text);
+    writer = w;
 
     if (useGenStub) {
       useThrow = true;
       w.writeln(@"""
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
- *   function($0, $1, capture) { this($0, $1, true, capture); }
+ *   function($0, $1, capture) { return this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
  * arguments.
  */
 Function.prototype.$genStub = function(argsLength, names) {
-  // TODO(jmesserly): only emit $genStub if actually needed
-
   // Fast path: if no named arguments and arg count matches
   if (this.length == argsLength && !names) {
     return this;
   }
 
   function $throwArgMismatch() {
     // TODO(jmesserly): better error message
     $throw(new ClosureArgumentMismatchException());
   }
 
@@ skipping 54 matching lines @@
   return  (e && e.stack) ? e.stack : null;
 }""");
     }
 
     if (useNotNullBool) {
       useThrow = true;
       // This pattern chosen because IE9 does really badly with typeof, and
       // it's still decent on other browsers.
       w.writeln(@"""
 function $notnull_bool(test) {
-  return (test === true || test === false) ? test : test.is$bool(); // TypeError
+  if (test === true || test === false) return test;
+  $throw(new TypeError(test, 'bool'));
 }""");
     }
 
     if (useAssert) {
       useThrow = true;
       w.writeln(@"""
 function $assert(test, text, url, line, column) {
   if (typeof test == 'function') test = test();
   if (!test) $throw(new AssertError(text, url, line, column));
 }""");
@@ skipping 31 matching lines @@
   if (o == null) return 'null';
   var t = typeof(o);
   if (t == 'object') { return o.toString(); }
   else if (t == 'string') { return o; }
   else if (t == 'bool') { return ''+o; }
   else if (t == 'number') { return ''+o; }
   else return o.toString();
 }""");
     }
 
-    if (useTypeNameOf) {
-      // TODO(sigmund): find a way to make this work on all browsers, including
-      // checking the typeName on prototype objects (so we can fix dynamic
-      // dispatching on $varMethod).
-      w.writeln(@"""
-Object.prototype.$typeNameOf = function() {
-  if ((typeof(window) != 'undefined' && window.constructor.name == 'DOMWindow')
-      || typeof(process) != 'undefined') { // fast-path for Chrome and Node
-    return this.constructor.name;
-  }
-  var str = Object.prototype.toString.call(this);
-  str = str.substring(8, str.length - 1);
-  if (str == 'Window') 
-    str = 'DOMWindow';
-  return str;
-}""");
-    }
-
     if (useIndex) {
       // If not overridden, $index and $setindex fall back to JS [] and []=
       // accessors
       // TODO(jimhug): This fallback could be very confusing in a few cases -
       // because of the bizare default [] rules in JS.  We need to revisit this
       // to get the right errors - at least in checked mode (once we have that).
       // TODO(jmesserly): do perf analysis, figure out if this is worth it and
       // what the cost of $index $setindex is on all browsers
       w.writeln(@"""
 Object.prototype.$index = function(i) { return this[i]; }
@@ skipping 57 matching lines @@
         w.writeln(@"function $wrap_call$1(fn) { return fn; }");
       }
     }
 
     // Write operator helpers
     for (var opImpl in orderValuesByKeys(_usedOperators)) {
       w.writeln(opImpl);
     }
   }
 }