fix #30108, mock support for callable classes

pkg/dev_compiler/lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1819 matching lines @@
     // See if we have a "call" with a statically known function type:
     //
     // - if it's a method, then it does because all methods do,
     // - if it's a getter, check the return type.
     //
     // Other cases like a getter returning dynamic/Object/Function will be
     // handled at runtime by the dynamic call mechanism. So we only
     // concern ourselves with statically known function types.
     //
     // For the same reason, we can ignore "noSuchMethod".
     // call-implemented-by-nSM will be dispatched by dcall at runtime.

[vsm, 2017/07/14 14:19:56]

Remove or update the two lines above?

[Jennifer Messerly, 2017/07/14 18:40:20]

they're still accurate but i'll try and clarify:

    // We can ignore `noSuchMethod` because:
    // * `dynamic d; d();` without a declared `call` method is handled by dcall.
    // * for `class C implements Callable { noSuchMethod(i) { ... } }` we find
    //   the `call` method on the `Callable` interface.

-    bool isCallable = classElem.lookUpMethod('call', null) != null ||
-        classElem.lookUpGetter('call', null)?.returnType is FunctionType;
+    // For classes that implement a callable interface with nSM, we'll find
+    // the "call" when we search the type for inherited "call" members.
+    var callMethod = classElem.type.lookUpInheritedGetterOrMethod('call');
+    bool isCallable = callMethod is PropertyAccessorElement
+        ? callMethod.returnType is FunctionType
+        : callMethod != null;
 
     var body = <JS.Statement>[];
     void addConstructor(ConstructorElement element, JS.Expression jsCtor) {
       var ctorName = _constructorName(element);
       if (JS.invalidStaticFieldName(element.name)) {
         jsCtor =
             _callHelper('defineValue(#, #, #)', [className, ctorName, jsCtor]);
       } else {
         jsCtor = js.call('#.# = #', [className, ctorName, jsCtor]);
       }
@@ skipping 4122 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }