Fix for issue 23432 - Get the correct receiver in noSuchMethod stubs.

sdk/lib/_internal/compiler/js_lib/interceptors.dart

 // Copyright (c) 2012, 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.
 
 library _interceptors;
 
 import 'dart:_js_embedded_names' show
     DISPATCH_PROPERTY_NAME,
     TYPE_TO_INTERCEPTOR_MAP;
 
@@ skipping 232 matching lines @@
  * The code `r.foo(a)` is compiled to `getInterceptor(r).foo$1(r, a)`.  The
  * value returned by [getInterceptor] holds the methods separately from the
  * state of the instance.  The compiler converts the methods on an interceptor
  * to take the Dart `this` argument as an explicit `receiver` argument.  The
  * JavaScript `this` parameter is bound to the interceptor.
  *
  * In order to have uniform call sites, if a method is defined on an
  * interceptor, methods of that name on plain unintercepted classes also use the
  * interceptor calling convention.  The plain classes are _self-interceptors_,
  * and for them, `getInterceptor(r)` returns `r`.  Methods on plain
- * unintercepted classes have a redundant `receiver` argument and should ignore
- * it in favour of `this`.
+ * unintercepted classes have a redundant `receiver` argument and, to enable
+ * some optimizations, must ignore `receiver` in favour of `this`.
  *
  * In the case of mixins, a method may be placed on both an intercepted class
  * and an unintercepted class.  In this case, the method must use the `receiver`
  * parameter.
  *
  *
  * There are various optimizations of the general call pattern.
  *
  * When the interceptor can be statically determined, it can be used directly:
  *
@@ skipping 22 matching lines @@
  */
 abstract class Interceptor {
   const Interceptor();
 
   bool operator ==(other) => identical(this, other);
 
   int get hashCode => Primitives.objectHashCode(this);
 
   String toString() => Primitives.objectToHumanReadableString(this);
 
+  // [Interceptor.noSuchMethod] is identical to [Object.noSuchMethod].  However,
+  // each copy is compiled differently.  The presence of the method on an
+  // Interceptor class forces [noSuchMethod] to use interceptor calling
+  // convention.  In the [Interceptor] version, `this` is the explicit receiver
+  // argument. In the [Object] version, as Object is not an intercepted class,
+  // `this` is the JavaScript receiver, and the explicit receiver is ignored.
+  // The noSuchMethod stubs for selectors that use the interceptor calling
+  // convention do not know the calling convention and forward `this` and
+  // `receiver` to one of these noSuchMethod implementations which selects the
+  // correct Dart receiver.
+  //
+  // We don't allow [noSuchMethod] on intercepted classes (that would force all
+  // calls to use interceptor calling convention).  If we did allow it, the
+  // interceptor context would select the correct `this`.
   dynamic noSuchMethod(Invocation invocation) {
     throw new NoSuchMethodError(
         this,
         invocation.memberName,
         invocation.positionalArguments,
         invocation.namedArguments);
   }
 
   Type get runtimeType => getRuntimeType(this);
 }
@@ skipping 95 matching lines @@
  * Interceptor for unclassified JavaScript objects, typically objects with a
  * non-trivial prototype chain.
  *
  * This class also serves as a fallback for unknown JavaScript exceptions.
  */
 class UnknownJavaScriptObject extends JavaScriptObject {
   const UnknownJavaScriptObject();
 
   String toString() => JS('String', 'String(#)', this);
 }