Generate static calls for Object fields and methods

lib/src/codegen/js_codegen.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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 50 matching lines @@
   final HashSet<FieldElement> _fieldsNeedingStorage;
 
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
 
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   ConstantEvaluator _constEvaluator;
 
+  /// Map of fields / properties / methods on Object.
+  Map<String, DartType> _objectMembers;
+
   final _exports = new Set<String>();
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashMap<String, JSTemporary>();
   final _extensionMethodNames = new HashSet<String>();
   final _pendingStatements = <JS.Statement>[];
   final _temps = new HashMap<Element, JSTemporary>();
 
   /// The name for the library's exports inside itself.
   /// This much be a constant because we interpolate it into template strings,
   /// and otherwise it would break caching for them.
   /// `exports` was chosen as the most similar to ES module patterns.
   final JSTemporary _exportsVar = new JSTemporary('exports');
   final JSTemporary _namedArgTemp = new JSTemporary('opts');
 
   /// Classes we have not emitted yet. Values can be [ClassDeclaration] or
   /// [ClassTypeAlias].
   final _pendingClasses = new HashMap<Element, CompilationUnitMember>();
 
   /// Memoized results of [_lazyClass].
   final _lazyClassMemo = new HashMap<Element, bool>();
 
   /// Memoized results of [_inLibraryCycle].
   final _libraryCycleMemo = new HashMap<LibraryElement, bool>();
 
   JSCodegenVisitor(this.options, this.rules, this.libraryInfo,
-      this._extensionMethods, this._fieldsNeedingStorage);
+      this._extensionMethods, this._fieldsNeedingStorage) {
+    _objectMembers = getObjectMemberMap(rules.provider);

[Jennifer Messerly, 2015/04/23 19:01:42]

thought here, TypeRules is our type (src/checker/rules.dart). Could we put it
there?

[vsm, 2015/04/23 20:35:55]

Yeah, I suppose that's better than here.

Done.

+  }
 
   LibraryElement get currentLibrary => libraryInfo.library;
   TypeProvider get types => rules.provider;
 
   JS.Program emitLibrary(LibraryUnit library) {
     String jsDefaultValue = null;
 
     // Modify the AST to make coercions explicit.
     new CoercionReifier(library, rules, options).reify();
 
@@ skipping 70 matching lines @@
 
     // TODO(jmesserly): scriptTag, directives.
     var body = <JS.Statement>[];
     for (var child in node.declarations) {
       // Attempt to group adjacent fields/properties.
       if (child is! TopLevelVariableDeclaration) _flushLazyFields(body);
       if (child is! FunctionDeclaration) _flushLibraryProperties(body);
 
       var code = _visit(child);
       if (code != null) {
-        if (_pendingStatements.isNotEmpty) {
-          body.addAll(_pendingStatements);
-          _pendingStatements.clear();
-        }
+        _flushPendingStatements(body);
         body.add(code);
       }
     }
 
     // Flush any unwritten fields/properties.
     _flushLazyFields(body);
     _flushLibraryProperties(body);
 
     assert(_pendingStatements.isEmpty);
     return _statement(body);
@@ skipping 917 matching lines @@
     if (type.isVoid) {
       return js.call('dart.void');
     } else if (type.isDynamic) {
       return js.call('dart.dynamic');
     }
 
     var name = type.name;
     var element = type.element;
     if (name == '' || lowerTypedef && type is FunctionType) {
       if (type is FunctionType) {
-        // TODO(vsm): Support all parameter types.
         var returnType = type.returnType;
         var parameterTypes = type.normalParameterTypes;
         var optionalTypes = type.optionalParameterTypes;
         var namedTypes = type.namedParameterTypes;
         if (namedTypes.isEmpty) {
           if (optionalTypes.isEmpty) {
             return js.call('dart.functionType(#, #)', [
               _emitTypeName(returnType),
               _emitTypeNames(parameterTypes)
             ]);
@@ skipping 129 matching lines @@
     if (target == null || isLibraryPrefix(target)) {
       if (rules.isDynamicCall(node.methodName)) {
         code = 'dart.$DCALL(#, #)';
       } else {
         code = '#(#)';
       }
       return js.call(
           code, [_visit(node.methodName), _visit(node.argumentList)]);
     }
 
+    var type = getStaticType(target);
+    var name = node.methodName.name;
+    var memberName = _emitMemberName(name, type: type);
+
     if (rules.isDynamicTarget(target)) {
       code = 'dart.$DSEND(#, #, #)';
     } else if (rules.isDynamicCall(node.methodName)) {
       // This is a dynamic call to a statically know target. For example:
       //     class Foo { Function bar; }
       //     new Foo().bar(); // dynamic call
       code = 'dart.$DCALL(#.#, #)';
+    } else if (_objectMembers.containsKey(name)) {

[Jennifer Messerly, 2015/04/23 19:05:58]

Is this only if `target` is nullable**? A test case would be: does
`this.toString()` generate using the helper? it shouldn't, `this` can't be null.

** or should the check be: "could be a JS primitive"? In which case for List
etc, the answer is "yes". But for many many types, the answer is "no".

[vsm, 2015/04/23 20:35:55]

I added a check in.  We need both checks as all types are nullable (for now
:-)).

+      assert(_objectMembers[name] is FunctionType);
+      // Object methods require a helper for null checks.
+      return js.call('dart.#(#, #)', [
+        memberName,
+        _visit(target),
+        _visit(node.argumentList)
+      ]);
     } else {
       code = '#.#(#)';
     }
-    return js.call(code, [
-      _visit(target),
-      _emitMemberName(node.methodName.name, type: getStaticType(target)),
-      _visit(node.argumentList)
-    ]);
+
+    return js.call(
+        code, [_visit(target), memberName, _visit(node.argumentList)]);
   }
 
   /// Emits code for the `JS(...)` builtin.
   _emitForeignJS(MethodInvocation node) {
     var e = node.methodName.staticElement;
     if (e is FunctionElement &&
         e.library.name == '_foreign_helper' &&
         e.name == 'JS') {
       var args = node.argumentList.arguments;
       // arg[0] is static return type, used in `RestrictedStaticTypeAnalyzer`
@@ skipping 131 matching lines @@
     return new JS.VariableInitialization(name, _visitInitializer(node));
   }
 
   JS.Expression _visitInitializer(VariableDeclaration node) {
     var value = _visit(node.initializer);
     // explicitly initialize to null, to avoid getting `undefined`.
     // TODO(jmesserly): do this only for vars that aren't definitely assigned.
     return value != null ? value : new JS.LiteralNull();
   }
 
+  void _flushPendingStatements(List<JS.Statement> body) {
+    if (_pendingStatements.isNotEmpty) {
+      body.addAll(_pendingStatements);
+      _pendingStatements.clear();
+    }
+  }
+
   void _flushLazyFields(List<JS.Statement> body) {
     var code = _emitLazyFields(_exportsVar, _lazyFields);
-    if (code != null) body.add(code);
+    if (code != null) {
+      // Ensure symbols for private fields are defined.
+      _flushPendingStatements(body);
+      body.add(code);
+    }
     _lazyFields.clear();
   }
 
   JS.Statement _emitLazyFields(
       JS.Expression objExpr, List<VariableDeclaration> fields) {
     if (fields.isEmpty) return null;
 
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
-      methods.add(new JS.Method(_propertyName(name),
-          js.call('function() { return #; }', _visit(node.initializer)),
+      var element = node.element;
+      var access = _emitMemberName(name, type: element.type, isStatic: true);
+      methods.add(new JS.Method(
+          access, js.call('function() { return #; }', _visit(node.initializer)),
           isGetter: true));
 
       // TODO(jmesserly): use a dummy setter to indicate writable.
       if (!node.isFinal) {
-        methods.add(new JS.Method(
-            _propertyName(name), js.call('function(_) {}'), isSetter: true));
+        methods.add(
+            new JS.Method(access, js.call('function(_) {}'), isSetter: true));
       }
     }
 
     return js.statement(
         'dart.defineLazyProperties(#, { # });', [objExpr, methods]);
   }
 
   void _flushLibraryProperties(List<JS.Statement> body) {
     if (_properties.isEmpty) return;
     body.add(js.statement('dart.copyProperties(#, { # });', [
@@ skipping 393 matching lines @@
   JS.Expression _emitGet(Expression target, SimpleIdentifier memberId) {
     var name = _emitMemberName(memberId.name, type: getStaticType(target));
     if (rules.isDynamicTarget(target)) {
       return js.call('dart.$DLOAD(#, #)', [_visit(target), name]);
     }
 
     String code;
     var member = memberId.staticElement;
     if (member != null && member is MethodElement) {
       // Tear-off methods: explicitly bind it.
-      if (isStateless(target, target)) {
+      if (isStateless(target, target) &&
+          !_objectMembers.containsKey(memberId.name)) {
         return js.call('#.#.bind(#)', [_visit(target), name, _visit(target)]);
       }
       code = 'dart.bind(#, #)';
+    } else if (_objectMembers.containsKey(memberId.name)) {
+      code = 'dart.#(#)';
+      return js.call(code, [name, _visit(target)]);
     } else {
       code = '#.#';
     }
 
     return js.call(code, [_visit(target), name]);
   }
 
   /// Emits a generic send, like an operator method.
   ///
   /// **Please note** this function does not support method invocation syntax
@@ skipping 576 matching lines @@
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 bool _isJsPeerInterface(DartObjectImpl value) =>
     value.type.name == 'JsPeerInterface';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;