Change how we generate bound closures to handler boud closures due to super getters: we need to pas…

sdk/lib/_internal/compiler/implementation/ssa/codegen.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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1628 matching lines @@
       });
     }
 
     push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
     push(new js.Call(pop(), visitArguments(node.inputs, start: 0)), node);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     Element superMethod = node.element;
     world.registerStaticUse(superMethod);
-    Element superClass = superMethod.getEnclosingClass();
+    ClassElement superClass = superMethod.getEnclosingClass();
     if (superMethod.kind == ElementKind.FIELD) {
       String fieldName = node.caller.isShadowedByField(superMethod)
           ? backend.namer.shadowedFieldName(superMethod)
           : backend.namer.instanceFieldName(superMethod);
       use(node.inputs[0]);
       js.PropertyAccess access =
           new js.PropertyAccess.field(pop(), fieldName);
       if (node.isSetter) {
         use(node.value);
         push(new js.Assignment(access, pop()), node);
       } else {
         push(access, node);
       }
     } else {
-      String methodName = backend.namer.getNameOfInstanceMember(superMethod);
-      String className = backend.namer.isolateAccess(superClass);
-      js.VariableUse classReference = new js.VariableUse(className);
-      js.PropertyAccess prototype =
-          new js.PropertyAccess.field(classReference, "prototype");
+      Selector selector = node.selector;
+      String methodName;
+      if (selector.isGetter()) {
+        // If the selector we need to register a typed getter to the
+        // [world]. The emitter needs to know if it needs to emit a
+        // bound closure for a method.
+        TypeMask receiverType = new TypeMask.nonNullExact(superClass.rawType);
+        selector = new TypedSelector(receiverType, selector);
+        world.registerDynamicGetter(selector);
+        methodName = backend.namer.invocationName(selector);
+      } else {
+        methodName = backend.namer.getNameOfInstanceMember(superMethod);
+      }
       js.PropertyAccess method =
-          new js.PropertyAccess.field(prototype, methodName);
+          backend.namer.elementAccess(superClass)['prototype'][methodName];
       push(jsPropertyCall(
           method, "call", visitArguments(node.inputs, start: 0)), node);
     }
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
     Element element = node.element;
     if (element == backend.jsIndexableLength) {
       // We're accessing a native JavaScript property called 'length'
@@ skipping 1332 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive(compiler) && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }