Support callable classes where call is inherited

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 734 matching lines @@
 
     // If this is a JavaScript type, emit it now and then exit.
     var jsTypeDef = _emitJsType(classElem);
     if (jsTypeDef != null) return jsTypeDef;
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     var methods = <MethodDeclaration>[];
 
-    // True if a "call" method or getter exists.
+    // True if a "call" method or getter exists directly on this class.
+    // If so, we need to install a Function prototype.
     bool isCallable = false;
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
         (member.isStatic ? staticFields : fields).add(member);
       } else if (member is MethodDeclaration) {
         methods.add(member);
         if (member.name.name == 'call' && !member.isSetter) {
           //
           // Make sure "call" has 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.
           //
           isCallable = !member.isGetter || member.returnType is FunctionType;
         }
       }
     }
 
+    // True if a "call" method or getter exists directly or indirectly on this
+    // class.  If so, we need special constructor handling.
+    bool isCallableTransitive =
+        classElem.lookUpMethod('call', currentLibrary) != null;
+    if (!isCallableTransitive) {
+      var callGetter = classElem.lookUpGetter('call', currentLibrary);
+      isCallableTransitive =
+          callGetter != null && callGetter.returnType is FunctionType;
+    }
+
     JS.Expression className;
     if (classElem.typeParameters.isNotEmpty) {
       // Generic classes will be defined inside a function that closes over the
       // type parameter. So we can use their local variable name directly.
       className = new JS.Identifier(classElem.name);
     } else {
       className = _emitTopLevelName(classElem);
     }
 
     var allFields = fields.toList()..addAll(staticFields);
@@ skipping 16 matching lines @@
     // Emit the class, e.g. `core.Object = class Object { ... }`
     _defineClass(classElem, className, classExpr, isCallable, body);
 
     // Emit things that come after the ES6 `class ... { ... }`.
     var jsPeerNames = _getJSPeerNames(classElem);
     JS.Statement deferredBaseClass =
         _setBaseClass(classElem, className, jsPeerNames, body);
 
     _emitClassTypeTests(classElem, className, body);
 
-    _defineNamedConstructors(ctors, body, className, isCallable);
+    _defineNamedConstructors(ctors, body, className, isCallableTransitive);
     body.addAll(virtualFieldSymbols);
     _emitClassSignature(
         methods, allFields, classElem, ctors, extensions, className, body);
     _defineExtensionMembers(extensions, className, body);
     _emitClassMetadata(node.metadata, className, body);
 
     JS.Statement classDef = _statement(body);
 
     var typeFormals = classElem.typeParameters;
     if (typeFormals.isNotEmpty) {
@@ skipping 4969 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;
 }