implement user-defined nSM, Object members on functions

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 237 matching lines @@
     // any nodes.
     var nodes = new HashMap<Element, AstNode>.identity();
     var sdkBootstrappingFns = new List<FunctionElement>();
     for (var unit in compilationUnits) {
       if (_isDartRuntime(unit.element.library)) {
         sdkBootstrappingFns.addAll(unit.element.functions);
       }
       _collectElements(unit, nodes);
     }
     _loader = new ElementLoader(nodes);
+    if (compilationUnits.isNotEmpty) {
+      _constField = new ConstFieldVisitor(types,
+          dummySource: compilationUnits.first.element.source);
+    }
 
     // Add implicit dart:core dependency so it is first.
     emitLibraryName(dartCoreLibrary);
 
     // Emit SDK bootstrapping functions first, if any.
     sdkBootstrappingFns.forEach(_emitDeclaration);
 
     // Visit each compilation unit and emit its code.
     //
     // NOTE: declarations are not necessarily emitted in this order.
     // Order will be changed as needed so the resulting code can execute.
     // This is done by forward declaring items.
-    compilationUnits.forEach(visitCompilationUnit);
+    compilationUnits.forEach(_finishDeclarationsInUnit);
 
     // Declare imports
     _finishImports(items);
 
     // Discharge the type table cache variables and
     // hoisted definitions.
     items.addAll(_typeTable.discharge());
 
     // Add the module's code (produced by visiting compilation units, above)
     _copyAndFlattenBlocks(items, _moduleItems);
@@ skipping 151 matching lines @@
       return _visit(node);
     });
 
     if (item != null) _moduleItems.add(item);
   }
 
   void _declareBeforeUse(Element e) {
     _loader.declareBeforeUse(e, _emitDeclaration);
   }
 
-  @override
-  void visitCompilationUnit(CompilationUnit unit) {
-    _constField = new ConstFieldVisitor(types, unit.element.source);
-
+  void _finishDeclarationsInUnit(CompilationUnit unit) {
+    // NOTE: this method isn't the right place to initialize
+    // per-compilation-unit state. Declarations can be visited out of order,
+    // this is only to catch things that haven't been emitted yet.
+    //
+    // See _emitDeclaration.
     for (var declaration in unit.declarations) {
       var element = declaration.element;
       if (element != null) {
         _emitDeclaration(element);
       } else {
         declaration.accept(this);
       }
     }
     for (var directive in unit.directives) {
       directive.accept(this);
@@ skipping 239 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. This can also be
-    // "noSuchMethod" method, because nSM could implement "call".
+    // True if a "call" method or getter exists.
     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);
-        var name = member.name.name;
-        if (name == 'call' && !member.isSetter) {
-          isCallable = true;
-        } 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) {
-          isCallable = true;
+        if (member.name.name == 'call' && !member.isSetter) {

[Jennifer Messerly, 2016/06/21 20:21:46]

When I merged, I had to fix how recently implemented "call" interacted with
"noSuchMethod". Comment below attempts to describe it :)

+          //
+          // 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;
         }
       }
     }
 
     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 {
@@ skipping 51 matching lines @@
   /// Named constructors are handled elsewhere, see [_defineNamedConstructors].
   JS.Expression _emitCallableClass(JS.ClassExpression classExpr,
       ConstructorElement unnamedCtor) {
     var ctor = new JS.NamedFunction(
         classExpr.name, _emitCallableClassConstructor(unnamedCtor));
 
     // Name the constructor function the same as the class.
     return js.call('dart.callableClass(#, #)', [ctor, classExpr]);
   }
 
-  JS.Fun _emitCallableClassConstructor(
-      ConstructorElement ctor) {
+  /// Emits a constructor that ensures instances of this class are callable as
+  /// functions in JavaScript.
+  JS.Fun _emitCallableClassConstructor(ConstructorElement ctor) {
 
     return js.call(
         r'''function (...args) {
           const self = this;
           function call(...args) {
             return self.call.apply(self, args);
           }
           call.__proto__ = this.__proto__;
           call.#.apply(call, args);
           return call;
@@ skipping 3497 matching lines @@
   /// For example `null.toString()` is legal in Dart, so we need to generate
   /// that as `dart.toString(obj)`.
   bool _isObjectMemberCall(Expression target, String memberName) {
     if (!isObjectMember(memberName)) {
       return false;
     }
 
     // Check if the target could be `null`, is dynamic, or may be an extension
     // native type. In all of those cases we need defensive code generation.
     var type = getStaticType(target);
+
     return isNullable(target) ||
+        type is FunctionType ||
         type.isDynamic ||
         (_extensionTypes.hasNativeSubtype(type) && target is! SuperExpression);
   }
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   JS.Expression _emitAccess(
       Expression target, SimpleIdentifier memberId, DartType resultType) {
     Element member = memberId.staticElement;
     if (member is PropertyAccessorElement) {
       member = (member as PropertyAccessorElement).variable;
@@ skipping 877 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';