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

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/classes.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 the operations that define and manipulate Dart
 /// classes.  Included in this are:
 ///   - Generics
 ///   - Class metadata
 ///   - Extension methods
 ///
@@ skipping 35 matching lines @@
 
   // Set the signature of the Mixin class to be the composition
   // of the signatures of the mixins.
   $setSignature(Mixin, {
     methods: () => {
       let s = {};
       for (let m of $mixins) {
         $copyProperties(s, m[$_methodSig]);
       }
       return s;
+    },
+    fields: () => {

[Jacob, 2017/01/21 01:11:30]

hole in propagating  metadata

+      let s = {};
+      for (let m of $mixins) {
+        $copyProperties(s, m[$_fieldSig]);
+      }
+      return s;
+    },
+    getters: () => {
+      let s = {};
+      for (let m of $mixins) {
+        $copyProperties(s, m[$_getterSig]);
+      }
+      return s;
+    },
+    setters: () => {
+      let s = {};
+      for (let m of $mixins) {
+        $copyProperties(s, m[$_setterSig]);
+      }
+      return s;
     }
   });
 
   // Save mixins for reflection
   Mixin[$_mixins] = $mixins;
   return Mixin;
 })()''');
 
 /// The Symbol for storing type arguments on a specialized generic type.
 final _mixins = JS('', 'Symbol("mixins")');
 
-getMixins(clazz) => JS('', 'Object.hasOwnProperty.call(#, #) ? #[#] : null', clazz, _mixins, clazz, _mixins);
+getMixins(clazz) => JS('', 'Object.hasOwnProperty.call(#, #) ? #[#] : null',
+    clazz, _mixins, clazz, _mixins);
 
 @JSExportName('implements')
 final _implements = JS('', 'Symbol("implements")');
 
-getImplements(clazz) => JS('', 'Object.hasOwnProperty.call(#, #) ? #[#] : null', clazz, _implements, clazz, _implements);
+getImplements(clazz) => JS('', 'Object.hasOwnProperty.call(#, #) ? #[#] : null',
+    clazz, _implements, clazz, _implements);
 
 /// The Symbol for storing type arguments on a specialized generic type.
 final _typeArguments = JS('', 'Symbol("typeArguments")');
 
 final _originalDeclaration = JS('', 'Symbol("originalDeclaration")');
 
 /// Wrap a generic class builder function with future flattening.
 flattenFutures(builder) => JS(
     '',
     '''(() => {
@@ skipping 61 matching lines @@
 
 getGenericClass(type) =>
     JS('', '$safeGetOwnProperty($type, $_originalDeclaration)');
 
 getGenericArgs(type) => JS('', '$safeGetOwnProperty($type, $_typeArguments)');
 
 // TODO(vsm): Collapse into one expando.
 final _constructorSig = JS('', 'Symbol("sigCtor")');
 final _methodSig = JS('', 'Symbol("sigMethod")');
 final _fieldSig = JS('', 'Symbol("sigField")');
-final _getterSig= JS('', 'Symbol("sigGetter")');
-final _setterSig= JS('', 'Symbol("sigSetter")');
+final _getterSig = JS('', 'Symbol("sigGetter")');
+final _setterSig = JS('', 'Symbol("sigSetter")');
 final _staticSig = JS('', 'Symbol("sigStaticMethod")');
 final _staticFieldSig = JS('', 'Symbol("sigStaticField")');
-final _staticGetterSig= JS('', 'Symbol("sigStaticGetter")');
-final _staticSetterSig= JS('', 'Symbol("sigStaticSetter")');
+final _staticGetterSig = JS('', 'Symbol("sigStaticGetter")');

[Jacob, 2017/01/21 01:11:30]

Ran the formatter. Sorry about the formatter related delta.

+final _staticSetterSig = JS('', 'Symbol("sigStaticSetter")');
 final _genericTypeCtor = JS('', 'Symbol("genericType")');
 
 // TODO(vsm): Collapse this as well - just provide a dart map to mirrors code.
 // These are queried by mirrors code.
 getConstructorSig(value) => JS('', '#[#]', value, _constructorSig);
 getMethodSig(value) => JS('', '#[#]', value, _methodSig);
 getFieldSig(value) => JS('', '#[#]', value, _fieldSig);
 getGetterSig(value) => JS('', '#[#]', value, _getterSig);
 getSetterSig(value) => JS('', '#[#]', value, _setterSig);
 getStaticSig(value) => JS('', '#[#]', value, _staticSig);
 getStaticFieldSig(value) => JS('', '#[#]', value, _staticFieldSig);
 getStaticGetterSig(value) => JS('', '#[#]', value, _staticGetterSig);
 getStaticSetterSig(value) => JS('', '#[#]', value, _staticSetterSig);
 
 getGenericTypeCtor(value) => JS('', '#[#]', value, _genericTypeCtor);
 
 /// Get the type of a method from an object using the stored signature
-getMethodType(obj, name) => JS(
+getType(obj) => JS(
     '',
     '''(() => {
-  let type = $obj == null ? $Object : $obj.__proto__.constructor;
-  return $getMethodTypeFromType(type, $name);
+  return $obj == null ? $Object : $obj.__proto__.constructor;
 })()''');
 
 /// Get the type of a method from a type using the stored signature
-getMethodTypeFromType(type, name) => JS(

[Jacob, 2017/01/21 01:11:30]

removed the getMethodType call that used an object so all versions now just take
a type.
We generally have a type lying around when we call these methods so it is
simpler and more efficient
to always pass the type instead of the object.

+getMethodType(type, name) => JS(
     '',
     '''(() => {
   let sigObj = $type[$_methodSig];
   if (sigObj === void 0) return void 0;
   return sigObj[$name];
 })()''');
 
+getFieldType(type, name) => JS(
+    '',
+    '''(() => {
+  let sigObj = $type[$_fieldSig];
+  if (sigObj === void 0) return void 0;
+  return sigObj[$name];
+})()''');
+
+getSetterType(type, name) => JS(
+    '',
+    '''(() => {
+  let sigObj = $type[$_setterSig];
+  if (sigObj === void 0) return void 0;
+  return sigObj[$name];
+})()''');
+
 /// Get the type of a constructor from a class using the stored signature
 /// If name is undefined, returns the type of the default constructor
 /// Returns undefined if the constructor is not found.
 classGetConstructorType(cls, name) => JS(
     '',
     '''(() => {
   if(!$name) $name = 'new';
   if ($cls === void 0) return void 0;
   if ($cls == null) return void 0;
   let sigCtor = $cls[$_constructorSig];
   if (sigCtor === void 0) return void 0;
   return sigCtor[$name];
 })()''');
 
 /// Given an object and a method name, tear off the method.
 /// Sets the runtime type of the torn off method appropriately,
 /// and also binds the object.
 ///
 /// If the optional `f` argument is passed in, it will be used as the method.
 /// This supports cases like `super.foo` where we need to tear off the method
 /// from the superclass, not from the `obj` directly.
 /// TODO(leafp): Consider caching the tearoff on the object?
 bind(obj, name, f) => JS(
     '',
     '''(() => {
   if ($f === void 0) $f = $obj[$name];
   $f = $f.bind($obj);
   // TODO(jmesserly): track the function's signature on the function, instead
   // of having to go back to the class?
-  let sig = $getMethodType($obj, $name);
+  let sig = $getMethodType($getType($obj), $name);
   $assert_(sig);
   $tag($f, sig);
   return $f;
 })()''');
 
 /// Instantiate a generic method.
 ///
 /// We need to apply the type arguments both to the function, as well as its
 /// associated function type.
 gbind(f, @rest typeArgs) {
   var result = JS('', '#.apply(null, #)', f, typeArgs);
   var sig = JS('', '#.apply(null, #)', _getRuntimeType(f), typeArgs);
   tag(result, sig);
   return result;
 }
 
 // Set up the method signature field on the constructor
 _setInstanceSignature(f, sigF, kind) => JS(
     '',
     '''(() => {
   $defineMemoizedGetter($f, $kind, () => {
     let sigObj = $sigF();
-    sigObj.__proto__ = $f.__proto__[$kind];
+    let proto = $f.__proto__;
+    // We need to set the root proto to null not undefined.

[Jacob, 2017/01/21 01:11:30]

This bug resulted in our type metadata looking like it contained the fields on
the JS Object class.

+    sigObj.__proto__ = ($kind in proto) ? proto[$kind] : null;
     return sigObj;
   });
 })()''');
 
 _setMethodSignature(f, sigF) => _setInstanceSignature(f, sigF, _methodSig);
 _setFieldSignature(f, sigF) => _setInstanceSignature(f, sigF, _fieldSig);
 _setGetterSignature(f, sigF) => _setInstanceSignature(f, sigF, _getterSig);
 _setSetterSignature(f, sigF) => _setInstanceSignature(f, sigF, _setterSig);
 
 // Set up the constructor signature field on the constructor
@@ skipping 67 matching lines @@
   $_setFieldSignature($f, fields);
   $_setGetterSignature($f, getters);
   $_setSetterSignature($f, setters);
   $_setStaticSignature($f, statics);
   $_setStaticFieldSignature($f, staticFields);
   $_setStaticGetterSignature($f, staticGetters);
   $_setStaticSetterSignature($f, staticSetters);
   $_setStaticTypes($f, names);
 })()''');
 
-hasMethod(obj, name) => JS('', '$getMethodType($obj, $name) !== void 0');
+_hasSigEntry(type, sigF, name) => JS(
+    '',
+    '''(() => {
+  let sigObj = $type[$sigF];
+  if (sigObj === void 0) return false;
+  return $name in sigObj;
+})()''');
+
+hasMethod(type, name) => _hasSigEntry(type, _methodSig, name);
+hasGetter(type, name) => _hasSigEntry(type, _getterSig, name);
+hasSetter(type, name) => _hasSigEntry(type, _setterSig, name);
+hasField(type, name) => _hasSigEntry(type, _fieldSig, name);
 
 /// Given a class and an initializer method name, creates a constructor
 /// function with the same name.
 ///
 /// After we define the named constructor, the class can be constructed with
 /// `new SomeClass.name(args)`.
 defineNamedConstructor(clazz, name) => JS(
     '',
     '''(() => {
   let proto = $clazz.prototype;
@@ skipping 80 matching lines @@
   let extProto = $dartExtType.prototype;
   let jsProto = $jsType.prototype;
 
   // TODO(vsm): This sometimes doesn't exist on FF.  These types will be
   // broken.
   if (!jsProto) return;
 
   // Mark the JS type's instances so we can easily check for extensions.
   jsProto[$_extensionType] = $dartExtType;
   $_installProperties(jsProto, extProto);
-  let originalSigFn = $getOwnPropertyDescriptor($dartExtType, $_methodSig).get;

[Jacob, 2017/01/21 01:11:30]

We were forgetting to call updateSig on anything but methods. Same issue bellow.

-  $assert_(originalSigFn);
-  $defineMemoizedGetter($jsType, $_methodSig, originalSigFn);
+  function updateSig(sigF) {
+    let originalSigFn = $getOwnPropertyDescriptor($dartExtType, sigF).get;
+    $assert_(originalSigFn);
+    $defineMemoizedGetter($jsType, sigF, originalSigFn);
+  }
+  updateSig($_methodSig);
+  updateSig($_fieldSig);
+  updateSig($_getterSig);
+  updateSig($_setterSig);
 })()''');
 
 ///
 /// Mark a concrete type as implementing extension methods.
 /// For example: `class MyIter implements Iterable`.
 ///
 /// This takes a list of names, which are the extension methods implemented.
 /// It will add a forwarder, so the extension method name redirects to the
 /// normal Dart method name. For example:
 ///
@@ skipping 15 matching lines @@
   for (let name of $methodNames) {
     let method = $getOwnPropertyDescriptor(proto, name);
     $defineProperty(proto, $getExtensionSymbol(name), method);
   }
   // Ensure the signature is available too.
   // TODO(jmesserly): not sure if we can do this in a cleaner way. Essentially
   // we need to copy the signature (and in the future, other data like
   // annotations) any time we copy a method as part of our metaprogramming.
   // It might be more friendly to JS metaprogramming if we include this info
   // on the function.
-  let originalSigFn = $getOwnPropertyDescriptor($type, $_methodSig).get;
-  $defineMemoizedGetter(type, $_methodSig, function() {
-    let sig = originalSigFn();
-    for (let name of $methodNames) {
-      sig[$getExtensionSymbol(name)] = sig[name];
-    }
-    return sig;
-  });
+
+  function upgradeSig(sigF) {
+    let originalSigFn = $getOwnPropertyDescriptor($type, sigF).get;
+    $defineMemoizedGetter(type, sigF, function() {
+      let sig = originalSigFn();
+      let propertyNames = Object.getOwnPropertyNames(sig);
+      for (let name of methodNames) {
+        if (name in sig) {
+          sig[$getExtensionSymbol(name)] = sig[name];
+        }
+      }
+      return sig;
+    });
+  };
+  upgradeSig($_methodSig);
+  upgradeSig($_fieldSig);
+  upgradeSig($_getterSig);
+  upgradeSig($_setterSig);
 })()''');
 
 /// Sets the type of `obj` to be `type`
 setType(obj, type) {
   JS('', '#.__proto__ = #.prototype', obj, type);
   return obj;
 }
 
 /// Sets the element type of a list literal.
 list(obj, elementType) =>
     JS('', '$setType($obj, ${getGenericClass(JSArray)}($elementType))');
 
 /// Link the extension to the type it's extending as a base class.
 setBaseClass(derived, base) {
   JS('', '#.prototype.__proto__ = #.prototype', derived, base);
   // We use __proto__ to track the superclass hierarchy (see isSubtype).
   JS('', '#.__proto__ = #', derived, base);
 }
 
 /// Like [setBaseClass] but for generic extension types, e.g. `JSArray<E>`
 setExtensionBaseClass(derived, base) {
   // Mark the generic type as an extension type and link the prototype objects
-  return JS('', '''(() => {
+  return JS(
+      '',
+      '''(() => {
     if ($base) {
       $derived.prototype[$_extensionType] = $derived;
       $derived.prototype.__proto__ = $base.prototype
     }
 })()''');
 }
 
 /// Given a special constructor function that creates a function instances,
 /// and a class with a `call` method, merge them so the constructor function
 /// will have the correct methods and prototype.
@@ skipping 35 matching lines @@
     '''(() => {
   let values = [];
   for (var i = 0; i < $names.length; i++) {
     let value = $const_(new $enumClass(i));
     values.push(value);
     Object.defineProperty($enumClass, $names[i],
         { value: value, configurable: true });
   }
   $enumClass.values = $constList(values, $enumClass);
 })()''');