Partial fix for call methods #542

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';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 683 matching lines @@
     if (findAnnotation(classElem, isPublicJSAnnotation) != null) return null;
 
     // 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>[];
+
+    // The "call" method or getter, if one exists. This can also be
+    // "noSuchMethod" method, because nSM could implement "call".
+    ExecutableElement callMethod;
     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);
+        var name = member.name.name;
+        if (name == 'call' && !member.isSetter) {
+          callMethod = member.element;
+        } else if (name == 'noSuchMethod' &&
+            !member.isGetter &&
+            !member.isSetter &&
+            // Exclude SDK because we know they don't use nSM to implement call.
+            !classElem.library.source.isInSystemLibrary) {
+          callMethod ??= member.element;
+        }
       }
     }
 
     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);
@@ skipping 10 matching lines @@
     var classExpr = _emitClassExpression(classElem,
         _emitClassMethods(node, ctors, fields, superclasses, virtualFields),
         fields: allFields);
 
     var body = <JS.Statement>[];
     var extensions = _extensionsToImplement(classElem);
     _initExtensionSymbols(classElem, methods, fields, body);
     _emitSuperHelperSymbols(_superHelperSymbols, body);
 
     // Emit the class, e.g. `core.Object = class Object { ... }`
-    _defineClass(classElem, className, classExpr, body);
+    _defineClass(classElem, className, classExpr, callMethod, body);
 
     // Emit things that come after the ES6 `class ... { ... }`.
     var jsPeerName = _getJSPeerName(classElem);
     _setBaseClass(classElem, className, jsPeerName, body);
 
     _emitClassTypeTests(classElem, className, body);
 
-    _defineNamedConstructors(ctors, body, className);
+    _defineNamedConstructors(ctors, body, className, callMethod);
     _emitVirtualFieldSymbols(virtualFieldSymbols, body);
     _emitClassSignature(methods, 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) {
       classDef = _defineClassTypeArguments(classElem, typeFormals, classDef);
     }
 
     body = <JS.Statement>[classDef];
     _emitStaticFields(staticFields, staticFieldOverrides, classElem, body);
     _registerExtensionType(classElem, jsPeerName, body);
     return _statement(body);
   }
 
+  /// Emits code to support a class with a "call" method and an unnamed
+  /// constructor.
+  ///
+  /// This ensures instances created by the unnamed constructor are functions.
+  /// Named constructors are handled elsewhere, see [_defineNamedConstructors].
+  JS.Expression _emitCallableClass(JS.ClassExpression classExpr,
+      ConstructorElement unnamedCtor, ExecutableElement callMethod) {
+    var ctor = new JS.NamedFunction(
+        classExpr.name, _emitCallableClassConstructor(unnamedCtor, callMethod));
+
+    // Name the constructor function the same as the class.
+    return js.call('dart.callableClass(#, #)', [ctor, classExpr]);
+  }
+
+  JS.Fun _emitCallableClassConstructor(
+      ConstructorElement ctor, ExecutableElement callMethod) {
+    bool dynamicCall = false;
+    if (callMethod is PropertyAccessorElement) {
+      assert(callMethod.isGetter);
+      dynamicCall = callMethod.returnType is! FunctionType;

[vsm, 2016/06/15 19:52:26]

Do we need a dcall here if one of the param types is dynamic?  _isDynamicCall in
the analyzer checker does this.

[Jennifer Messerly, 2016/06/15 20:16:51]

I don't think so. Those dcalls will be handled by the caller:

    typedef F(x);
    F f = new C();
    f(42); // dcall here


Actually, now that I think about this, I'm not sure what case will use this ...
I was thinking about test cases like:

    class C {
       get call => ...;
    }
    Int2Int f = new C();

... but that will fail at runtime to cast to Int2Int. And if we replace with
Function (or dynamic):

    class C {
       Function get call => ...;
    }
    Function f = new C();
    f();

... then it should be a caller side dcall. Same with the noSuchMethod case. We
will not allow you to assign it anywhere a typed function is expected, so only
the typed path needs to be supported.

Yeah, I'll revert the "dynamicCall" support. And change "callMethod" back to
"isCallable"...

+    } else if (callMethod.name == 'noSuchMethod') {
+      dynamicCall = true;
+    }
+
+    var callCall =
+        dynamicCall ? 'dart.dcall(self, args)' : 'self.call.apply(self, args)';
+    return js.call(
+        r'''function (...args) {
+          const self = this;
+          function call(...args) {
+            return #;
+          }
+          call.__proto__ = this.__proto__;
+          call.#.apply(call, args);
+          return call;
+        }''',
+        [js.call(callCall), _constructorName(ctor)]);
+  }
+
   void _emitClassTypeTests(ClassElement classElem, JS.Expression className,
       List<JS.Statement> body) {
     if (classElem == objectClass) {
       // We rely on ES6 static inheritance.  All types that are represented by
       // class constructor functions will see these definitions, with [this]
       // being bound to the class constructor.
 
       // The 'instanceof' checks don't work for primitive types (which have fast
       // definitions below) and don't work for native types. In those cases we
       // fall through to the general purpose checking code.
@@ skipping 194 matching lines @@
             virtualFields[field.element] = virtualField;
             virtualFieldSymbols.add(js.statement(
                 'const # = Symbol(#.name + "." + #.toString());',
                 [virtualField, className, fieldName]));
           }
         }
       }
     }
   }
 
-  void _defineClass(ClassElement classElem, JS.Expression className,
-      JS.ClassExpression classExpr, List<JS.Statement> body) {
+  void _defineClass(
+      ClassElement classElem,
+      JS.Expression className,
+      JS.ClassExpression classExpr,
+      ExecutableElement callMethod,
+      List<JS.Statement> body) {
+    JS.Expression callableClass;
+    if (callMethod != null && classElem.unnamedConstructor != null) {
+      callableClass = _emitCallableClass(
+          classExpr, classElem.unnamedConstructor, callMethod);
+    }
+
     if (classElem.typeParameters.isNotEmpty) {
-      body.add(new JS.ClassDeclaration(classExpr));
+      if (callableClass != null) {
+        body.add(js.statement('const # = #;', [classExpr.name, callableClass]));
+      } else {
+        body.add(new JS.ClassDeclaration(classExpr));
+      }
     } else {
-      body.add(js.statement('# = #;', [className, classExpr]));
+      body.add(js.statement('# = #;', [className, callableClass ?? classExpr]));
     }
   }
 
   void _emitVirtualFieldSymbols(
       List<JS.Statement> virtualFields, List<JS.Statement> body) {
     body.addAll(virtualFields);
   }
 
   List<JS.Identifier> _emitTypeFormals(List<TypeParameterElement> typeFormals) {
     return typeFormals
@@ skipping 396 matching lines @@
       body.add(js.statement(
           'dart.setExtensionBaseClass(#, #);', [className, newBaseClass]));
     } else if (_hasDeferredSupertype.contains(classElem)) {
       var newBaseClass = _emitType(classElem.type.superclass,
           nameType: false, subClass: classElem, className: className);
       body.add(
           js.statement('dart.setBaseClass(#, #);', [className, newBaseClass]));
     }
   }
 
-  void _defineNamedConstructors(List<ConstructorDeclaration> ctors,
-      List<JS.Statement> body, JS.Expression className) {
+  void _defineNamedConstructors(
+      List<ConstructorDeclaration> ctors,
+      List<JS.Statement> body,
+      JS.Expression className,
+      ExecutableElement callMethod) {
+    var code = callMethod != null
+        ? 'dart.defineNamedConstructorCallable(#, #, #);'
+        : 'dart.defineNamedConstructor(#, #)';
+
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null && member.factoryKeyword == null) {
-        body.add(js.statement('dart.defineNamedConstructor(#, #);',
-            [className, _constructorName(member.element)]));
+        var args = [className, _constructorName(member.element)];
+        if (callMethod != null) {
+          args.add(_emitCallableClassConstructor(member.element, callMethod));
+        }
+
+        body.add(js.statement(code, args));
       }
     }
   }
 
   /// Emits static fields for a class, and initialize them eagerly if possible,
   /// otherwise define them as lazy properties.
   void _emitStaticFields(
       List<FieldDeclaration> staticFields,
       Set<FieldElement> staticFieldOverrides,
       ClassElement classElem,
@@ skipping 3714 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';