Fix noSuchMethod handling of methods that are also extension methods. Fix noSuchMethod handling of …

pkg/dev_compiler/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;
 
 class InvocationImpl extends Invocation {
   final Symbol memberName;
   final List positionalArguments;
   final Map<Symbol, dynamic> namedArguments;
   final bool isMethod;
   final bool isGetter;
   final bool isSetter;
 
-  InvocationImpl(String memberName, this.positionalArguments,
+  InvocationImpl(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));
   }
 }
 
+// Warning: dload, dput, and dsend assume they are never called on methods
+// implemented by the Object base class as those methods can always be
+// statically resolved.
 dload(obj, field) {
   var f = _canonicalMember(obj, field);
+
   _trackCall(obj);
   if (f != null) {
-    if (hasMethod(obj, f)) return bind(obj, f, JS('', 'void 0'));
-    return JS('', '#[#]', obj, f);
+    // XXX verify it is a Dart type first
+    var type = getType(obj);
+
+    if (hasField(type, f) || hasGetter(type, f)) return JS('', '#[#]', obj, f);
+    if (hasMethod(type, f)) return bind(obj, f, JS('', 'void 0'));
   }
   return noSuchMethod(
       obj, new InvocationImpl(field, JS('', '[]'), isGetter: true));
 }
 
 dput(obj, field, value) {
   var f = _canonicalMember(obj, field);
   _trackCall(obj);
   if (f != null) {
-    return JS('', '#[#] = #', obj, f, value);
+    // XXX verify it is a Dart type first
+    var type = getType(obj);
+    var setter = getSetterType(type, f);
+    if (JS('bool', '# != void 0', setter)) {
+      // TODO(jacobr): throw a type error instead of a NoSuchMethodError if
+      // the type of the setter doesn't match.
+      if (instanceOfOrNull(value, JS('', '#.args[0]', setter))) {
+        return JS('', '#[#] = #', obj, f, value);
+      }
+    } else {
+      var field = getFieldType(type, f);
+      // TODO(jacobr): propogate metadata tracking which fields are private.
+      if (JS('bool', '# != void 0', field)) {
+        // TODO(jacobr): throw a type error instead of a NoSuchMethodError if
+        // the type of the field doesn't match.
+        if (instanceOfOrNull(value, field)) {
+          return JS('', '#[#] = #', obj, f, value);
+        }
+      }
+    }
   }
   return noSuchMethod(
       obj, new InvocationImpl(field, JS('', '[#]', value), isSetter: true));
 }
 
 /// Check that a function of a given type can be applied to
 /// actuals.
 _checkApply(type, actuals) => JS(
     '',
     '''(() => {
@@ skipping 24 matching lines @@
   if (names.length == 0) return false;
   for (var name of names) {
     if (!($hasOwnProperty.call($type.named, name))) {
       return false;
     }
     $check(opts[name], $type.named[name]);
   }
   return true;
 })()''');
 
-Symbol _dartSymbol(name) =>
-    JS('', '#(#.new(#.toString()))', const_, Symbol, name);
+_toSymbolName(symbol) => JS(
+    '',
+    '''(() => {
+        let str = $symbol.toString();
+        // Strip leading 'Symbol(' and trailing ')'
+        return str.substring(7, str.length-1);
+    })()''');
+
+_toDisplayName(name) => JS(
+    '',
+    '''(() => {
+      // Names starting with _ are escaped names used to disambiguate Dart and
+      // JS names.
+      if ($name[0] === '_') {
+        // Inverse of 
+        switch($name) {
+          case '_get':
+            return '[]';
+          case '_set':
+            return '[]=';
+          case '_negate':
+            return 'unary-';
+          case '_constructor':
+          case '_prototype':
+            return $name.substring(1);
+        }
+      }
+      return $name;
+  })()''');
+
+Symbol _dartSymbol(name) {
+  return (JS('bool', 'typeof # === "symbol"', name))
+      ? JS('', '#(new #.es6(#, #))', const_, _internal.Symbol,
+          _toSymbolName(name), name)
+      : JS('', '#(#.new(#))', const_, Symbol, _toDisplayName(name));
+}
 
 /// Extracts the named argument array from a list of arguments, and returns it.
 // TODO(jmesserly): we need to handle named arguments better.
 extractNamedArgs(args) {
   if (JS('bool', '#.length > 0', args)) {
     var last = JS('', '#[#.length - 1]', args, args);
     if (JS(
         'bool', '# != null && #.__proto__ === Object.prototype', last, last)) {
       return JS('', '#.pop()', args);
     }
@@ skipping 10 matching lines @@
 
   function callNSM() {
     return $noSuchMethod(originalTarget, new $InvocationImpl(
         $name, $args,
         {namedArguments: $extractNamedArgs($args), 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');
+      $ftype = $getMethodType($getType($f), 'call');
       $f = $f.call;
     }
     if (!($f instanceof Function)) {
       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) {
@@ skipping 161 matching lines @@
 }
 
 /// Shared code for dsend, dindex, and dsetindex.
 _callMethod(obj, name, typeArgs, args, displayName) {
   var symbol = _canonicalMember(obj, name);
   if (symbol == null) {
     return noSuchMethod(
         obj, new InvocationImpl(displayName, args, isMethod: true));
   }
   var f = obj != null ? JS('', '#[#]', obj, symbol) : null;
-  var ftype = getMethodType(obj, symbol);
+  var type = getType(obj);
+  var ftype = getMethodType(type, symbol);
+  // No such method if dart object and ftype is missing.
   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);
 
 dindex(obj, index) =>
     _callMethod(obj, '_get', null, JS('', '[#]', index), '[]');
@@ skipping 513 matching lines @@
 
 _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') {
+  /*(if (name == 'constructor' || name == 'prototype') {
     name = '+' + name;
-  }
+  }*/
+  if (JS('bool', '# instanceof #', obj, Object)) {
+    // This is a Dart type not a JS interop type.
+
+  } else {}
   return name;
 }
 
 /// Emulates the implicit "loadLibrary" function provided by a deferred library.
 ///
 /// Libraries are not actually deferred in DDC, so this just returns a future
 /// that completes immediately.
 Future loadLibrary() => new Future.value();