implement user-defined nSM, Object members on functions

tool/input_sdk/private/ddc_runtime/operations.dart

 // 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.
 
 /// This library defines runtime operations on objects used by the code
 /// generator.
 part of dart._runtime;
 
-_canonicalFieldName(obj, name, args, displayName) => JS('', '''(() => {
-  $name = $canonicalMember($obj, $name);
-  if ($name) return $name;
-  // TODO(jmesserly): in the future we might have types that "overlay" Dart
-  // methods while also exposing the full native API, e.g. dart:html vs
-  // dart:dom. To support that we'd need to fall back to the normal name
-  // if an extension method wasn't found.
-  $throwNoSuchMethodFunc($obj, $displayName, $args);
-})()''');
+class _Invocation extends Invocation {
+  final Symbol memberName;
+  final List positionalArguments;
+  final Map<Symbol, dynamic> namedArguments;
+  final bool isMethod;
+  final bool isGetter;
+  final bool isSetter;
 
-dload(obj, field) => JS('', '''(() => {
-  $field = $_canonicalFieldName($obj, $field, [], $field);
-  $_trackCall($obj, $field);
-  if ($hasMethod($obj, $field)) {
-    return $bind($obj, $field);
+  _Invocation(String memberName, this.positionalArguments,
+      {namedArguments,
+      this.isMethod: false,
+      this.isGetter: false,
+      this.isSetter: false})
+    : memberName = _dartSymbol(memberName),
+      namedArguments = _namedArgsToSymbols(namedArguments);
+
+  static Map<Symbol, dynamic> _namedArgsToSymbols(namedArgs) {
+    if (namedArgs == null) return {};
+    return new Map.fromIterable(
+        getOwnPropertyNames(namedArgs),
+        key: _dartSymbol,
+        value: (k) => JS('', '#[#]', namedArgs, k));
   }
-  // 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
-  let result = $obj[$field];
-  return result;
-})()''');
+}
 
-dput(obj, field, value) => JS('', '''(() => {
-  $field = $_canonicalFieldName($obj, $field, [$value], $field);
-  $_trackCall($obj, $field);
+dload(obj, field) {
+  var f = _canonicalMember(obj, field);
+  _trackCall(obj, f);
+  if (f != null) {
+    if (hasMethod(obj, f)) return bind(obj, f, JS('', 'void 0'));
+    return JS('', '#[#]', obj, f);
+  }
+  return noSuchMethod(obj,
+      new _Invocation(field, JS('', '[]'), isGetter: true));
+}
 
-  // TODO(vsm): Implement NSM and type checks.
-  // See: https://github.com/dart-lang/dev_compiler/issues/170
-  $obj[$field] = $value;
-  return $value;
-})()''');
+dput(obj, field, value) {
+  var f = _canonicalMember(obj, field);
+  _trackCall(obj, f);
+  if (f != null) {
+    return JS('', '#[#] = #', obj, f, value);
+  }
+  return noSuchMethod(obj,
+      new _Invocation(field, JS('', '[#]', value), isSetter: true));
+}
 
 /// Check that a function of a given type can be applied to
 /// actuals.
 _checkApply(type, actuals) => JS('', '''(() => {
   if ($actuals.length < $type.args.length) return false;
   let index = 0;
   for(let i = 0; i < $type.args.length; ++i) {
     if (!$instanceOfOrNull($actuals[i], $type.args[i])) return false;
     ++index;
   }
@@ skipping 18 matching lines @@
   if (names.length == 0) return false;
   for (var name of names) {
     if (!($hasOwnProperty.call($type.named, name))) {
       return false;
     }
     if (!$instanceOfOrNull(opts[name], $type.named[name])) return false;
   }
   return true;
 })()''');
 
-_dartSymbol(name) => JS('', '''
-  $const_($Symbol.new($name.toString()))
-''');
+Symbol _dartSymbol(name) =>
+    JS('', '#(#.new(#.toString()))', const_, Symbol, name);
 
-throwNoSuchMethod(obj, name, pArgs, nArgs, extras) => JS('', '''(() => {
-  $throw_(new $NoSuchMethodError($obj, $_dartSymbol($name), $pArgs, $nArgs, $extras));
-})()''');
-
-throwNoSuchMethodFunc(obj, name, pArgs, opt_func) => JS('', '''(() => {
-  if ($obj === void 0) $obj = $opt_func;
-  $throwNoSuchMethod($obj, $name, $pArgs);
-})()''');
-
+// TODO(jmesserly): we need to handle named arguments better.
 _checkAndCall(f, ftype, obj, typeArgs, args, name) => JS('', '''(() => {
   $_trackCall($obj, $name);
 
-  let originalFunction = $f;
+  let originalTarget = obj === void 0 ? f : obj;
+
+  function callNSM() {
+    let namedArgs = null;
+    if (args.length > 0 &&
+        args[args.length - 1].__proto__ == Object.prototype) {
+      namedArgs = args.pop();
+    }
+    return $noSuchMethod(originalTarget, new $_Invocation(
+        $name, $args, {namedArguments: namedArgs, isMethod: true}));
+  }
   if (!($f instanceof Function)) {
     // We're not a function (and hence not a method either)
     // Grab the `call` method if it's not a function.
     if ($f != null) {
       $ftype = $getMethodType($f, 'call');
       $f = $f.call;
     }
     if (!($f instanceof Function)) {
-      $throwNoSuchMethodFunc($obj, $name, $args, originalFunction);
+      return callNSM();
     }
   }
   // If f is a function, but not a method (no method type)
   // then it should have been a function valued field, so
   // get the type from the function.
   if ($ftype === void 0) {
     $ftype = $_getRuntimeType($f);
   }
 
   if (!$ftype) {
@@ skipping 29 matching lines @@
   if ($_checkApply($ftype, $args)) {
     if ($typeArgs != null) {
       return $f.apply($obj, $typeArgs).apply($obj, $args);
     }
     return $f.apply($obj, $args);
   }
 
   // TODO(leafp): throw a type error (rather than NSM)
   // if the arity matches but the types are wrong.
   // TODO(jmesserly): nSM should include type args?
-  $throwNoSuchMethodFunc($obj, $name, $args, originalFunction);
+  return callNSM();
 })()''');
 
 dcall(f, @rest args) => _checkAndCall(
     f, _getRuntimeType(f), JS('', 'void 0'), null, args, 'call');
 
-
 dgcall(f, typeArgs, @rest args) => _checkAndCall(
     f, _getRuntimeType(f), JS('', 'void 0'), typeArgs, args, 'call');
 
 Map<String, int> _callMethodStats = new Map();
 
 List<List<Object>> getDynamicStats() {
   List<List<Object>> ret = [];
 
   var keys = _callMethodStats.keys.toList();
 
@@ skipping 30 matching lines @@
   name = "${typeName(actual)}.$name <$src>";
   if (_callMethodStats.containsKey(name)) {
     _callMethodStats[name] = _callMethodStats[name] + 1;
   } else {
     _callMethodStats[name] = 1;
   }
 }
 
 /// Shared code for dsend, dindex, and dsetindex.
 _callMethod(obj, name, typeArgs, args, displayName) {
-  var symbol = _canonicalFieldName(obj, name, args, displayName);
+  var symbol = _canonicalMember(obj, name);
+  if (symbol == null) {
+    return noSuchMethod(obj,
+        new _Invocation(displayName, args, isMethod: true));
+  }
   var f = obj != null ? JS('', '#[#]', obj, symbol) : null;
   var ftype = getMethodType(obj, symbol);
   return _checkAndCall(f, ftype, obj, typeArgs, args, displayName);
 }
 
 dsend(obj, method, @rest args) => _callMethod(obj, method, null, args, method);
 
 dgsend(obj, typeArgs, method, @rest args) =>
     _callMethod(obj, method, typeArgs, args, method);
 
@@ skipping 381 matching lines @@
 // the compiler.
 hashCode(obj) {
   if (obj == null) return 0;
 
   switch (JS('String', 'typeof #', obj)) {
     case "number":
       return JS('','# & 0x1FFFFFFF', obj);
     case "boolean":
       // From JSBool.hashCode, see comment there.
       return JS('', '# ? (2 * 3 * 23 * 3761) : (269 * 811)', obj);
+    case "function":
+      // TODO(jmesserly): this doesn't work for method tear-offs.
+      return Primitives.objectHashCode(obj);
   }
 
   var extension = getExtensionType(obj);
   if (extension != null) {
     return JS('', '#[dartx.hashCode]', obj);
   }
   return JS('', '#.hashCode', obj);
 }
 
 @JSExportName('toString')
 String _toString(obj) {
   if (obj == null) return "null";
 
   var extension = getExtensionType(obj);
   if (extension != null) {
     return JS('String', '#[dartx.toString]()', obj);
   }
+  if (JS('bool', 'typeof # == "function"', obj)) {
+    return JS('String', r'"Closure: " + # + " from: " + #',
+        getReifiedType(obj), obj);
+  }
   // TODO(jmesserly): restore this faster path once ES Symbol is treated as
   // an extension type (and thus hits the above code path).
   // See https://github.com/dart-lang/dev_compiler/issues/578.
   // return JS('', '"" + #', obj);
   return JS('String', '#.toString()', obj);
 }
 
 // TODO(jmesserly): is the argument type verified statically?
 noSuchMethod(obj, Invocation invocation) {
-  if (obj == null) {
+  if (obj == null || JS('bool', 'typeof # == "function"', obj)) {
     throw new NoSuchMethodError(
-        null,
+        obj,
         invocation.memberName,
         invocation.positionalArguments,
         invocation.namedArguments);
   }
   // Delegate to the (possibly user-defined) method on the object.
   var extension = getExtensionType(obj);
   if (extension != null) {
     return JS('', '#[dartx.noSuchMethod](#)', obj, invocation);
   }
   return JS('', '#.noSuchMethod(#)', obj, invocation);
 }
 
 constFn(x) => JS('', '() => x');
 
 runtimeType(obj) {
   // Handle primitives where the method isn't on the object.
   var result = _checkPrimitiveType(obj);
   if (result != null) return wrapType(result);
 
   // Delegate to the (possibly user-defined) method on the object.
   var extension = getExtensionType(obj);
   if (extension != null) {
     return JS('', '#[dartx.runtimeType]', obj);
   }
+  if (JS('bool', 'typeof # == "function"', obj)) {
+    return wrapType(getReifiedType(obj));
+  }
   return JS('', '#.runtimeType', obj);
 }
 
 /// Implements Dart's interpolated strings as ES2015 tagged template literals.
 ///
 /// For example: dart.str`hello ${name}`
 String str(strings, @rest values) => JS('', '''(() => {
   let s = $strings[0];
   for (let i = 0, len = $values.length; i < len; ) {
     s += $notNull($_toString($values[i])) + $strings[++i];
   }
   return s;
 })()''');
 
 
 final JsIterator = JS('', '''
   class JsIterator {
     constructor(dartIterator) {
       this.dartIterator = dartIterator;
     }
     next() {
       let i = this.dartIterator;
       let done = !i.moveNext();
       return { done: done, value: done ? void 0 : i.current };
     }
   }
 ''');
+
+_canonicalMember(obj, name) {
+  // Private names are symbols and are already canonical.
+  if (JS('bool', 'typeof # === "symbol"', name)) return name;
+
+  if (obj != null && getExtensionType(obj) != null) {
+    return JS('', 'dartx.#', name);
+  }
+
+  // Check for certain names that we can't use in JS
+  if (name == 'constructor' || name == 'prototype') {
+    name = '+' + name;
+  }
+  return name;
+}