Angular workarounds

lib/runtime/dart_runtime.js

 // Copyright (c) 2015, 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.
 
 var dart, _js_helper, _js_primitives;
 (function (dart) {
   'use strict';
 
+  // TODO(vsm): This is referenced (as init.globalState) from
+  // isolate_helper.dart.  Where should it go?
+  // See: https://github.com/dart-lang/dev_compiler/issues/164
+  dart.globalState = null;
+
   let defineProperty = Object.defineProperty;
   let getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
   let getOwnPropertyNames = Object.getOwnPropertyNames;
   let getOwnPropertySymbols = Object.getOwnPropertySymbols;
 
   function getOwnNamesAndSymbols(obj) {
     return getOwnPropertyNames(obj).concat(getOwnPropertySymbols(obj));
   }
 
   // Adapted from Angular.js
@@ skipping 11 matching lines @@
     let r = argDecl[1].split(FN_ARG_SPLIT);
     for (let arg of r) {
       arg.replace(FN_ARG, function(all, underscore, name){
         args.push(name);
       });
     }
     return args;
   }
 
   function dload(obj, field) {
-    if (!(field in obj)) {
-      throw new core.NoSuchMethodError(obj, field);
-    }
+    // TODO(vsm): Implement NSM robustly.  An 'in' check breaks on certain
+    // types.  hasOwnProperty doesn't chase the proto chain.
+    // Also, do we want an NSM on regular JS objects?
+    // See: https://github.com/dart-lang/dev_compiler/issues/169
     var result = obj[field];
-    if (typeof result == "function") {
-      // We can't tell if the result needs binding. Fortunately binding the
-      // same function twice has no effect, so we can simply attempt to bind.
+
+    // TODO(vsm): Check this more robustly.
+    if (typeof result == "function" &&
+        !Object.prototype.hasOwnProperty.call(obj, field)) {
+      // This appears to be a method tearoff.  Bind this.
       return result.bind(obj);
     }
     return result;
   }
   dart.dload = dload;
 
+  function dput(obj, field, value) {
+    // TODO(vsm): Implement NSM and type checks.
+    // See: https://github.com/dart-lang/dev_compiler/issues/170
+    obj[field] = value;
+  }
+  dart.dput = dput;
+
   // TODO(jmesserly): this should call noSuchMethod, not throw.
   function throwNoSuchMethod(obj, name, args, opt_func) {
     if (obj === void 0) obj = opt_func;
     throw new core.NoSuchMethodError(obj, name, args);
   }
 
   function checkAndCall(f, obj, args, name) {
     if (!(f instanceof Function)) {
       // Grab the `call` method if it's not a function.
       if (f !== null) f = f.call;
@@ skipping 17 matching lines @@
     */
     return f.apply(obj, args);
   }
 
   function dcall(f/*, ...args*/) {
     let args = Array.prototype.slice.call(arguments, 1);
     return checkAndCall(f, void 0, args, 'call');
   }
   dart.dcall = dcall;
 
+  // TODO(vsm): Automatically build this.
+  // All dynamic methods should check for these.
+  // See: https://github.com/dart-lang/dev_compiler/issues/142
+  var _extensionMethods = {
+    // Lazy - as these symbols may not be loaded yet.
+    // TODO(vsm): This should record / check the receiver type
+    // as well.  E.g., only look for core.$map if the receiver
+    // is an Iterable.
+    'map': () => core.$map,
+  };
+
   function dsend(obj, method/*, ...args*/) {
     let args = Array.prototype.slice.call(arguments, 2);
-    return checkAndCall(obj[method], obj, args, method);
+    var f = obj[method];
+    if (f === void 0) {
+      var symbol = _extensionMethods[method]();
+      f = obj[symbol];
+    }
+    return checkAndCall(f, obj, args, method);
   }
   dart.dsend = dsend;
 
   function dindex(obj, index) {
     // TODO(jmesserly): remove this special case once Array extensions are
     // hooked up.
     if (obj instanceof Array && realRuntimeType(index) == core.int) {
       return obj[index];
     }
     return checkAndCall(obj.get, obj, [index], '[]');
   }
   dart.dindex = dindex;
 
   function dsetindex(obj, index, value) {
     return checkAndCall(obj.set, obj, [index, value], '[]=');
   }
   dart.dsetindex = dsetindex;
 
   /**
    * Returns bound `method`.
    * This helper function avoids needing a temp for `obj`.
    */
   function bind(obj, method) {
     // This is a static bind (dynamic would use `dload`) so no need to check
     // if `method` is really there on `obj`.`
     return obj[method].bind(obj);
   }
   dart.bind = bind;
 
+  function typeToString(type) {
+    if (typeof(type) == "function") {
+      var name = type.name;
+      var args = type[dart.typeArguments];
+      if (args) {
+        name += '<';
+        for (var i = 0; i < args.length; ++i) {
+          if (i > 0) name += ', ';
+          name += typeToString(args[i]);
+        }
+        name += '>';
+      }
+      return name;
+    } else {
+      return type.toString();
+    }
+  }
+  dart.typeName = typeToString;
+
   function cast(obj, type) {
     // TODO(vsm): handle non-nullable types
     if (obj == null) return obj;
     let actual = realRuntimeType(obj);
     if (isSubtype(actual, type)) return obj;
+    // TODO(vsm): Remove this hack ... due to
+    // lack of generic methods.
+    if (isSubtype(type, core.Iterable) && isSubtype(actual, core.Iterable) ||
+        isSubtype(type, async.Future) && isSubtype(actual, async.Future) ||
+        isSubtype(type, core.Map) && isSubtype(actual, core.Map)) {
+      console.log('Warning: ignoring cast fail from ' + typeToString(actual) + ' to ' + typeToString(type));
+      return obj;
+    }
+    // console.log('Error: cast fail from ' + typeToString(actual) + ' to ' + typeToString(type));
     throw new _js_helper.CastErrorImplementation(actual, type);
   }
   dart.as = cast;
 
 
   // TODO(vsm): How should we encode the runtime type?
   let _runtimeType = Symbol('_runtimeType');
 
   function checkPrimitiveType(obj) {
     switch (typeof obj) {
@@ skipping 637 matching lines @@
     let initMethod = proto[name];
     let ctor = function() { return initMethod.apply(this, arguments); }
     ctor.prototype = proto;
     // Use defineProperty so we don't hit a property defined on Function,
     // like `caller` and `arguments`.
     defineProperty(clazz, name, { value: ctor, configurable: true });
   }
   dart.defineNamedConstructor = defineNamedConstructor;
 
   function stackTrace(exception) {
-    throw new core.UnimplementedError();
+    return _js_helper.getTraceFromException(exception);
   }
   dart.stackTrace = stackTrace;
 
   /** The Symbol for storing type arguments on a specialized generic type. */
   dart.typeArguments = Symbol('typeArguments');
   dart.originalDeclaration = Symbol('originalDeclaration');
 
   /** Memoize a generic type constructor function. */
   function generic(typeConstructor) {
     let length = typeConstructor.length;
@@ skipping 81 matching lines @@
     // initializing them, but easier to not depend on that.
     for (let name of getOwnNamesAndSymbols(obj)) {
       // TODO(jmesserly): we can make this faster if needed.
       objectKey.push(name);
       objectKey.push(obj[name]);
     }
     return multiKeyPutIfAbsent(constants, objectKey, () => obj);
   }
   dart.const = constant;
 
+  // TODO(vsm): Rationalize these type methods.  We're currently using the
+  // setType / proto scheme for nominal types (e.g., classes) and the
+  // setRuntimeType / field scheme for structural types (e.g., functions
+  // - and only in tests for now).
+  // See: https://github.com/dart-lang/dev_compiler/issues/172
+
   /** Sets the type of `obj` to be `type` */
   function setType(obj, type) {
     obj.__proto__ = type.prototype;
+    // Note, we generate code of the form:
+    // - return dart.setType([], List$(E))
     return obj;
   }
   dart.setType = setType;
 
   /** Sets the internal runtime type of `obj` to be `type` */
   function setRuntimeType(obj, type) {
     obj[_runtimeType] = type;
   }
   dart.setRuntimeType = setRuntimeType;
 
@@ skipping 63 matching lines @@
   // TODO(jmesserly): right now this is a sentinel. It should be a type object
   // of some sort, assuming we keep around `dynamic` at runtime.
   dart.dynamic = { toString() { return 'dynamic'; } };
   dart.void = { toString() { return 'void'; } };
   dart.bottom = { toString() { return 'bottom'; } };
 
   dart.global = window || global;
   dart.JsSymbol = Symbol;
 
   function import_(value) {
-    // TODO(jmesserly): throw once we're loading all of core libs.
-    if (!value && console) console.warn('missing required module');
+    // TODO(vsm): Change this to a hard throw.
+    // For now, we're missing some libraries.  E.g., dart:js:
+    // https://github.com/dart-lang/dev_compiler/issues/168
+    if (!value) {
+      console.log('missing required module');
+    }
     return value;
   }
   dart.import = import_;
   
   function lazyImport(value) {
     return defineLibrary(value, {});
   }
   dart.lazyImport = lazyImport;
 
   function defineLibrary(value, defaultValue) {
     return value ? value : defaultValue;
   }
   dart.defineLibrary = defineLibrary;
 
   // TODO(jmesserly): hack to bootstrap the SDK
   _js_helper = _js_helper || {};
   _js_helper.checkNum = notNull;
 
   _js_primitives = _js_primitives || {};
   _js_primitives.printString = (s) => console.log(s);
 
+  // TODO(vsm): Plumb this correctly.
+  // See: https://github.com/dart-lang/dev_compiler/issues/40
+  String.prototype.contains = function(sub) { return this.indexOf(sub) >= 0; }
+  let _split = String.prototype.split;
+  String.prototype.split = function() {
+    let result = _split.apply(this, arguments);
+    dart.setType(result, core.List$(core.String));
+    return result;
+  }
+  String.prototype.get = function(i) {
+    return this[i];
+  }
+  String.prototype.codeUnitAt = function(i) {
+    return this.charCodeAt(i);
+  }
+  String.prototype.replaceAllMapped =  function(from, cb) {
+    return this.replace(from.multiple, function() {
+      // Remove offset & string from the result array
+      var matches = arguments;
+      matches.splice(-2, 2);
+      // The callback receives match, p1, ..., pn
+      return cb(matches);
+    });
+  }
+  String.prototype['+'] = function (arg) { return this.valueOf() + arg; };
+
+  Boolean.prototype['!'] = function () { return !this.valueOf(); };
+  Boolean.prototype['&&'] = function (arg) { return this.valueOf() && arg; };
+  Boolean.prototype['||'] = function (arg) { return this.valueOf() || arg; };
+  Number.prototype['<'] = function (arg) { return this.valueOf() < arg; };
+  Number.prototype['<='] = function (arg) { return this.valueOf() <= arg; };
+  Number.prototype['>'] = function (arg) { return this.valueOf() > arg; };
+  Number.prototype['+'] = function (arg) { return this.valueOf() + arg; };
+
+  // TODO(vsm): DOM facades?
+  // See: https://github.com/dart-lang/dev_compiler/issues/173
+  NodeList.prototype.get = function (i) { return this[i]; };
+  NamedNodeMap.prototype.get = function (i) { return this[i]; };
+  DOMTokenList.prototype.get = function (i) { return this[i]; };
+
 })(dart || (dart = {}));