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 167 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 (_requiresStaticDispatch(target, name)) {
+      assert(rules.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 42 matching lines @@
 
   bool _isNonNullableExpression(Expression expr) {
     // If the type is non-nullable, no further checking needed.
     if (rules.isNonNullableType(getStaticType(expr))) return true;
 
     // TODO(vsm): Revisit whether we really need this when we get
     // better non-nullability in the type system.
 
     if (expr is Literal && expr is! NullLiteral) return true;
     if (expr is IsExpression) return true;
+    if (expr is ThisExpression) return true;
+    if (expr is SuperExpression) return true;
     if (expr is ParenthesizedExpression) {
       return _isNonNullableExpression(expr.expression);
     }
     if (expr is Conversion) {
       return _isNonNullableExpression(expr.expression);
     }
     DartType type = null;
     if (expr is BinaryExpression) {
       type = getStaticType(expr.leftOperand);
     } else if (expr is PrefixExpression) {
@@ skipping 320 matching lines @@
       return _visit(node.identifier);
     } else {
       return _emitGet(node.prefix, node.identifier);
     }
   }
 
   @override
   visitPropertyAccess(PropertyAccess node) =>
       _emitGet(_getTarget(node), node.propertyName);
 
+  bool _requiresStaticDispatch(Expression target, String memberName) {
+    var type = getStaticType(target);
+    if (!rules.objectMembers.containsKey(memberName)) {
+      return false;
+    }
+    if (!type.isObject &&
+        !_isJSBuiltinType(type) &&
+        _isNonNullableExpression(target)) {
+      return false;
+    }
+    return true;
+  }
+
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   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 (_requiresStaticDispatch(target, memberId.name)) {
+        return js.call('dart.#.bind(#)', [name, _visit(target)]);
+      }
       if (isStateless(target, target)) {
         return js.call('#.#.bind(#)', [_visit(target), name, _visit(target)]);
       }
       code = 'dart.bind(#, #)';
+    } else if (_requiresStaticDispatch(target, memberId.name)) {
+      return js.call('dart.#(#)', [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;