cpsir: implementation of jsinterop in cps ir

R=jacobr@google.com

Review URL: https://codereview.chromium.org/1688433006 .

Author: sigmundch

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

@@ -20,8 +20,10 @@ import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js show
     js,
+    objectLiteral,
     LiteralStatement,
     Template,
+    InterpolatedExpression,
     isIdentityTemplate;
 import '../native/native.dart' show
     NativeBehavior;
@@ -691,6 +693,9 @@ class IrBuilder {
     assert(!element.isLocal);
     assert(!element.isInstanceMember);
     assert(isOpen);
+    if (program.isJsInterop(element)) {
+      return buildInvokeJsInteropMember(element, arguments);
+    }
     return addPrimitive(
         new ir.InvokeStatic(element, selector, arguments, sourceInformation));
   }
@@ -2066,6 +2071,86 @@ class IrBuilder {
     buildReturn(value: value, sourceInformation: source);
   }
 
+  static _isNotNull(ir.Primitive value) =>
+      value is! ir.Constant || !value.value.isNull;
+
+  /// Builds a call to a resolved js-interop element.
+  ir.Primitive buildInvokeJsInteropMember(FunctionElement element,
+      List<ir.Primitive> arguments) {
+    program.addNativeMethod(element);
+    String target = program.getJsInteropTargetPath(element);
+    // Strip off trailing arguments that were not specified.
+    // TODO(jacobr,sigmund): assert that the trailing arguments are all null.
+    // TODO(jacobr): rewrite named arguments to an object literal matching
+    // the factory constructor case.
+    var inputs = arguments.where(_isNotNull).toList();
+
+    var behavior = new NativeBehavior()..sideEffects.setAllSideEffects();
+    DartType type = element.isConstructor ?
+        element.enclosingClass.thisType : element.type.returnType;
+    // Native behavior effects here are similar to native/behavior.dart.
+    // The return type is dynamic if we don't trust js-interop type
+    // declarations.
+    behavior.typesReturned.add(
+        program.trustJSInteropTypeAnnotations ? type : const DynamicType());
+
+    // The allocation effects include the declared type if it is native (which
+    // includes js interop types).
+    if (type.element != null && program.isNative(type.element)) {
+      behavior.typesInstantiated.add(type);
+    }
+
+    // It also includes any other JS interop type if we don't trust the
+    // annotation or if is declared too broad.
+    if (!program.trustJSInteropTypeAnnotations || type.isObject ||
+        type.isDynamic) {
+      behavior.typesInstantiated.add(program.jsJavascriptObjectType);
+    }
+
+    String code;
+    if (element.isGetter) {
+      code = target;
+    } else if (element.isSetter) {
+      code = "$target = #";
+    } else {
+      var args = new List.filled(inputs.length, '#').join(',');
+      code = element.isConstructor ? "new $target($args)" : "$target($args)";
+    }
+    return buildForeignCode(js.js.parseForeignJS(code), inputs, behavior);
+    // TODO(sigmund): should we record the source-information here?
+  }
+
+  /// Builds an object literal that results from invoking a factory constructor
+  /// of a js-interop anonymous type.
+  ir.Primitive buildJsInteropObjectLiteral(ConstructorElement constructor,
+      List<ir.Primitive> arguments, {SourceInformation source}) {
+    assert(program.isJsInteropAnonymous(constructor));
+    program.addNativeMethod(constructor);
+    FunctionSignature params = constructor.functionSignature;
+    int i = 0;
+    var filteredArguments = <ir.Primitive>[];
+    var entries = new Map<String, js.Expression>();
+    params.orderedForEachParameter((ParameterElement parameter) {
+      // TODO(jacobr): throw if parameter names do not match names of property
+      // names in the class.
+      assert (parameter.isNamed);
+      ir.Primitive argument = arguments[i++];
+      if (_isNotNull(argument)) {
+        filteredArguments.add(argument);
+        entries[parameter.name] =
+            new js.InterpolatedExpression(filteredArguments.length - 1);
+      }
+    });
+    var code = new js.Template(null, js.objectLiteral(entries));
+    var behavior = new NativeBehavior();
+    if (program.trustJSInteropTypeAnnotations) {
+      behavior.typesReturned.add(constructor.enclosingClass.thisType);
+    }
+
+    // TODO(sigmund): should we record the source-information here?
+    return buildForeignCode(code, filteredArguments, behavior);
+  }
+
   /// Create a blocks of [statements] by applying [build] to all reachable
   /// statements. The first statement is assumed to be reachable.
   // TODO(johnniwinther): Type [statements] as `Iterable` when `NodeList` uses
@@ -2551,6 +2636,13 @@ class IrBuilder {
     Selector selector =
         new Selector(SelectorKind.CALL, element.memberName, callStructure);
     ClassElement cls = element.enclosingClass;
+    if (program.isJsInterop(element)) {
+      if (program.isJsInteropAnonymous(element)) {
+        return buildJsInteropObjectLiteral(element, arguments,
+            source: sourceInformation);
+      }
+      return buildInvokeJsInteropMember(element, arguments);
+    }
     if (program.requiresRuntimeTypesFor(cls)) {
       InterfaceType interface = type;
       Iterable<ir.Primitive> typeArguments =

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

@@ -796,7 +796,10 @@ class IrBuilderVisitor extends ast.Visitor<ir.Primitive>
 
   /// Creates a primitive for the default value of [parameter].
   ir.Primitive translateDefaultValue(ParameterElement parameter) {
-    if (parameter.initializer == null) {
+    if (parameter.initializer == null ||
+        // TODO(sigmund): JS doesn't support default values, so this should be
+        // reported as an error earlier (Issue #25759).
+        backend.isJsInterop(parameter.functionDeclaration)) {
       return irBuilder.buildNullConstant();
     } else {
       return inlineConstant(parameter.executableContext, parameter.initializer);
@@ -4018,4 +4021,22 @@ class GlobalProgramInformation {
   void addNativeMethod(FunctionElement function) {
     _backend.emitter.nativeEmitter.nativeMethods.add(function);
   }
+
+  bool get trustJSInteropTypeAnnotations =>
+      _compiler.trustJSInteropTypeAnnotations;
+
+  bool isNative(ClassElement element) => _backend.isNative(element);
+
+  bool isJsInterop(FunctionElement element) => _backend.isJsInterop(element);
+
+  bool isJsInteropAnonymous(FunctionElement element) =>
+    _backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass);
+
+  String getJsInteropTargetPath(FunctionElement element) {
+    return '${_backend.namer.fixedBackendPath(element)}.'
+      '${_backend.getFixedBackendName(element)}';
+  }
+
+  DartType get jsJavascriptObjectType =>
+    _backend.helpers.jsJavaScriptObjectClass.thisType;
 }

pkg/compiler/lib/src/cps_ir/inline.dart

@@ -395,6 +395,7 @@ class InliningVisitor extends TrampolineRecursiveVisitor {
     // AST node, targets that are asynchronous or generator functions, or
     // targets containing a try statement.
     if (!target.hasNode) return null;
+    if (backend.isJsInterop(target)) return null;
     if (target.asyncMarker != AsyncMarker.SYNC) return null;
     // V8 does not optimize functions containing a try statement.  Inlining
     // code containing a try statement will make the optimizable calling code

tests/html/html.status

@@ -51,6 +51,7 @@ custom/element_upgrade_test: Fail # Issue 17298
 [ $compiler == dart2js && $browser ]
 custom/created_callback_test: Fail # Support for created constructor. Issue 14835
 fontface_loaded_test: Fail # Support for promises.
+js_typed_interop_default_arg_test/default_value: MissingCompileTimeError # Issue #25759
 
 [ $compiler == dart2js && ($runtime == safari || $runtime == safarimobilesim || $runtime == ff  || $ie) ]
 custom/entered_left_view_test/viewless_document: Fail # Polyfill does not handle this
@@ -441,20 +442,9 @@ custom_elements_23127_test/c2t: RuntimeError # Need custom element support #2548
 custom_elements_test/innerHtml: RuntimeError # Need custom element support #25484
 custom_elements_test/register: RuntimeError # Need custom element support #25484
 
-# New js-interop support via package:js is only implemented in SSA:
-js_array_test: RuntimeError # Need package:js support #24978
-js_dart_to_string_test: RuntimeError # Need package:js support #24978
-js_function_getter_test/call: RuntimeError # Need package:js support #24978
-js_function_getter_test: RuntimeError # Need package:js support #24978
-js_function_getter_trust_types_test: RuntimeError # Need package:js support #24978
-js_typed_interop_anonymous2_exp_test: RuntimeError # Need package:js support #24978
-js_typed_interop_anonymous2_test: RuntimeError # Need package:js support #24978
-js_typed_interop_anonymous_exp_test: RuntimeError # Need package:js support #24978
-js_typed_interop_anonymous_test: RuntimeError # Need package:js support #24978
-js_typed_interop_side_cast_exp_test: RuntimeError # Need package:js support #24978
-js_typed_interop_side_cast_test: RuntimeError # Need package:js support #24978
-js_typed_interop_test: RuntimeError # Need package:js support #24978
-mirrors_js_typed_interop_test: RuntimeError # Need package:js support #24978
+js_typed_interop_side_cast_exp_test: RuntimeError # Corner case in package:js that we might want to remove (See comment in #24978).
+js_typed_interop_test/static_method_tearoff_1: RuntimeError # Tree-shaking a used tear-off (#24978, #25720).
+js_typed_interop_default_arg_test/explicit_argument: RuntimeError # Tree-shaking a used tear-off (#24978, #25720).
 
 # These are raw dart:js tests that fail due to bugs in the CPS IR:
 js_test/Dart_functions: RuntimeError # Tree-shaking an escaping closure #25720

tests/html/js_typed_interop_default_arg_test.dart

@@ -0,0 +1,58 @@
+// 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.
+
+@JS()
+library js_typed_interop_test;
+
+import 'dart:html';
+
+import 'package:expect/expect.dart' show NoInline;
+import 'package:js/js.dart';
+import 'package:unittest/unittest.dart';
+import 'package:unittest/html_config.dart';
+
+_injectJs() {
+  document.body.append(new ScriptElement()
+    ..type = 'text/javascript'
+    ..innerHtml = r"""
+  var Foo = {
+    get42: function(b) { return arguments.length >= 1 ? b : 42; },
+    get43: function(b) { return arguments.length >= 1 ? b : 43; }
+  };
+""");
+}
+
+@JS()
+class Foo {
+  // Note: it's invalid to provide a default value.
+  external static num get42([num b
+      = 3  /// default_value: compile-time error
+  ]);
+  external static num get43([num b]);
+}
+
+main() {
+  _injectJs();
+  useHtmlConfiguration();
+
+  test('call directly from dart', () {
+    expect(Foo.get42(2), 2);
+    expect(Foo.get42(), 42);
+  });
+
+  test('call tearoff from dart with arg', () {
+    var f = Foo.get42;
+    expect(f(2), 2); /// explicit_argument: ok
+  });
+
+  test('call tearoff from dart with default', () {
+    var f = Foo.get42;
+    // Note: today both SSA and CPS remove the extra argument on static calls,
+    // but they fail to do so on tearoffs.
+    expect(f(), 3); /// default_value: continued
+
+    f = Foo.get43;
+    expect(f(), 43);
+  });
+}

tests/html/js_typed_interop_test.dart

@@ -124,6 +124,7 @@ class Foo {
   external callClosureWithArg1(Function closure, arg1);
   external callClosureWithArg2(Function closure, arg1, arg2);
   external Bar getBar();
+
   external static num multiplyDefault2(num a, [num b]);
 }
 
@@ -277,14 +278,26 @@ main() {
     });
   });
 
-  group('static method', () {
-    test('call from dart', () {
+  group('static_method_call', () {
+    test('call directly from dart', () {
       expect(Foo.multiplyDefault2(6, 7), equals(42));
       expect(Foo.multiplyDefault2(6), equals(12));
+    });
+  });
+
+  // Note: these extra groups are added to be able to mark each test
+  // individually in status files. This should be split as separate test files.
+  group('static_method_tearoff_1', () {
+    test('call tearoff from dart', () {
       MultiplyWithDefault tearOffMethod = Foo.multiplyDefault2;
       expect(tearOffMethod(6, 6), equals(36));
+    });
+  });
+
+  group('static_method_tearoff_2', () {
+    test('call tearoff from dart', () {
+      MultiplyWithDefault tearOffMethod = Foo.multiplyDefault2;
       expect(tearOffMethod(6), equals(12));
-      Function untypedTearOff = Foo.multiplyDefault2;
     });
   });