NoSuchMethod on different super accesses/invocations handled.

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 1659 matching lines @@
       // Register this invocation to collect the types used at all call sites.
       backend.registerStaticInvocation(node, types);
     }
     use(node.target);
     push(new js.Call(pop(), visitArguments(node.inputs)), node);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     Element superMethod = node.element;
     Element superClass = superMethod.getEnclosingClass();
-    if (superMethod.kind == ElementKind.FIELD) {
+    if (superMethod.isField()) {
       ClassElement currentClass = work.element.getEnclosingClass();
       if (currentClass.isClosure()) {
         ClosureClassElement closure = currentClass;
         currentClass = closure.methodElement.getEnclosingClass();
       }
       String fieldName;
       if (currentClass.isShadowedByField(superMethod)) {
         fieldName = backend.namer.shadowedFieldName(superMethod);
       } else {
         LibraryElement library = superMethod.getLibrary();
         SourceString name = superMethod.name;
         fieldName = backend.namer.instanceFieldName(library, name);
       }
       use(node.inputs[1]);
       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 {
+      bool isPropertyAccess = false;
       String methodName;
-      if (superMethod.kind == ElementKind.FUNCTION ||
-          superMethod.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
-        methodName = backend.namer.instanceMethodName(superMethod);
-      } else if (superMethod.kind == ElementKind.GETTER) {
+      if (superMethod.isGetter()) {
         methodName =
             backend.namer.getterName(currentLibrary, superMethod.name);
-      } else {
-        assert(superMethod.kind == ElementKind.SETTER);
+      } else if (node.isSetter || superMethod.isSetter()) {
         methodName =
             backend.namer.setterName(currentLibrary, superMethod.name);
+      } else if (superMethod.isFunction() ||
+                 superMethod.isGenerativeConstructor()) {
+        if (node.isGetter) {
+          methodName =
+              backend.namer.getterName(currentLibrary, superMethod.name);
+          isPropertyAccess = true;
+        } else {
+          methodName = backend.namer.instanceMethodName(superMethod);
+        }
       }
       String className = backend.namer.isolateAccess(superClass);
       js.VariableUse classReference = new js.VariableUse(className);
       js.PropertyAccess prototype =
           new js.PropertyAccess.field(classReference, "prototype");
-      js.PropertyAccess method =
-          new js.PropertyAccess.field(prototype, methodName);
-      push(jsPropertyCall(method, "call", visitArguments(node.inputs)), node);
+      if (isPropertyAccess) {
+        // Property access of a function. Obtain the bound closure instead of
+        // invoking the function.
+        push(jsPropertyCall(prototype, methodName,
+                            visitArguments(node.inputs)), node);
+      } else {
+        js.PropertyAccess method =
+            new js.PropertyAccess.field(prototype, methodName);
+        push(jsPropertyCall(method, "call", visitArguments(node.inputs)), node);
+      }
     }
     world.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
     if (node.element == backend.jsArrayLength
         || node.element == backend.jsStringLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
@@ skipping 1345 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }