dart2js cps: Handle native functions, getters, and setters.

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

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../tree/tree.dart' as ast;
 import '../types/types.dart' show TypeMask;
 import '../closure.dart' hide ClosureScope;
 import '../universe/universe.dart' show SelectorKind;
 import 'cps_ir_nodes.dart' as ir;
 import 'cps_ir_builder_task.dart' show DartCapturedVariables,
     GlobalProgramInformation;
 
 import '../common.dart' as types show TypeMask;
-import '../js/js.dart' as js show Template;
+import '../js/js.dart' as js show Template, js, LiteralStatement;
 import '../native/native.dart' show NativeBehavior;
 
 /// A mapping from variable elements to their compile-time values.
 ///
 /// Map elements denoted by parameters and local variables to the
 /// [ir.Primitive] that is their value.  Parameters and locals are
 /// assigned indexes which can be used to refer to them.
 class Environment {
   /// A map from locals to their environment index.
   final Map<Local, int> variable2index;
@@ skipping 1984 matching lines @@
               sourceInformation: sourceInformation));
       _current = null;
     } else {
       // Inside the try block of try/finally, all returns go to a join-point
       // continuation that contains the finally code.  The return value is
       // passed as an extra argument.
       jumpTo(state.returnCollector, value);
     }
   }
 
+  /// Build a call to the closure conversion helper for the [Function] typed
+  /// value in [value].
+  ir.Primitive _convertDartClosure(ir.Primitive value, FunctionType type) {
+    ir.Constant arity = buildIntegerConstant(type.computeArity());
+    return buildStaticFunctionInvocation(
+        program.closureConverter,
+        CallStructure.TWO_ARGS,
+        <ir.Primitive>[value, arity]);
+  }
+
+  final RegExp nativeRedirectionRegExp =
+      new RegExp(r'^[a-zA-Z][a-zA-Z_$0-9]*$');

[asgerf, 2015/08/12 13:15:02]

Make this static?

+
+  /// Generate the body for a native function.
+  ///
+  /// If [nativeBody] is non-null, generate a [ForeignCode] statement for the
+  /// body defined in JavaScript.  Otherwise, generate a call to the real
+  /// target, which is given by the [FunctionElement]'s `fixedBackendName`.
+  /// The target can be a function, getter, or setter.
+  void buildNativeFunctionBody(ast.Node nativeBody,
+                               SourceInformation source) {
+    FunctionElement function = state.currentElement;
+    assert(function.isNative);
+    String name = function.fixedBackendName;
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    NativeBehavior behavior = new NativeBehavior();
+    behavior.sideEffects.setAllSideEffects();
+
+    if (nativeBody != null) {

[asgerf, 2015/08/12 13:15:02]

I think it would make more sense to have this split in the builder_task file,
since that's where all other AST inspection takes place. The two cases could
then have separate methods on the builder.

Currently this is the only method taking an AST node as input. The import of ast
only exists so we can create DartStrings for use in constants.

+      ast.LiteralString jsCode = nativeBody.asLiteralString();
+      String code = jsCode.dartString.slowToString();
+      assert(invariant(nativeBody, !nativeRedirectionRegExp.hasMatch(code),
+        message: "Deprecated syntax, use @JSName('name') instead."));
+      assert(invariant(nativeBody,
+          function.functionSignature.parameterCount == 0,
+          message: 'native "..." syntax is restricted to '
+            'functions with zero parameters.'));
+      // Generate a [ForeignCode] statement from the given native code.
+      buildForeignCode(
+          js.js.statementTemplateYielding(new js.LiteralStatement(code)),
+          <ir.Primitive>[],
+          behavior);
+    } else {
+      program.addNativeMethod(function);
+      // Construct the access of the target element.
+      String code = function.isInstanceMember ? '#.$name' : name;
+      if (function.isInstanceMember) {
+        arguments.add(state.thisParameter);
+      }
+      // Collect all parameters of the function and templates for them to be
+      // inserted into the JavaScript code.
+      List<String> argumentTemplates = <String>[];
+      function.functionSignature.forEachParameter((ParameterElement parameter) {
+        ir.Primitive input = environment.lookup(parameter);
+        DartType type = program.unaliasType(parameter.type);
+        if (type is FunctionType) {
+          // The parameter type is a function type either directly or through
+          // typedef(s).
+          input = _convertDartClosure(input, type);
+        }
+        arguments.add(input);
+        argumentTemplates.add('#');
+      });
+      // Construct the application of parameters for functions and setters.
+      if (function.kind == ElementKind.FUNCTION) {
+        code = "$code(${argumentTemplates.join(', ')})";
+      } else if (function.kind == ElementKind.SETTER) {
+        code = "$code = ${argumentTemplates.single}";
+      } else {
+        assert(argumentTemplates.isEmpty);
+        assert(function.kind == ElementKind.GETTER);
+      }
+      // Generate the [ForeignCode] expression and a return statement to return
+      // its value.
+      ir.Primitive value = buildForeignCode(
+          js.js.uncachedExpressionTemplate(code),
+          arguments,
+          behavior);
+      buildReturn(value: value, sourceInformation: source);
+    }
+  }
+
   /// 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
   // `List` instead of `Link`.
   void buildBlock(var statements, BuildFunction build) {
     // Build(Block(stamements), C) = C'
     //   where C' = statements.fold(Build, C)
     assert(isOpen);
     return buildSequence(statements, build);
   }
@@ skipping 554 matching lines @@
 
   ir.Primitive buildInvocationMirror(Selector selector,
                                      List<ir.Primitive> arguments) {
     return addPrimitive(new ir.CreateInvocationMirror(selector, arguments));
   }
 
   ir.Primitive buildForeignCode(js.Template codeTemplate,
                                 List<ir.Primitive> arguments,
                                 NativeBehavior behavior,
                                 {Element dependency}) {
+    assert(behavior != null);
     types.TypeMask type = program.getTypeMaskForForeign(behavior);
     ir.Primitive result = _continueWithExpression((k) => new ir.ForeignCode(
         codeTemplate,
         type,
         arguments,
         behavior,
         k,
         dependency: dependency));
     if (!codeTemplate.isExpression) {
-      // Close the term if this is a "throw" expression.
+      // Close the term if this is a "throw" expression or native body.
       add(new ir.Unreachable());
       _current = null;
     }
     return result;
   }
 
   /// Creates a type test or type cast of [value] against [type].
   ir.Primitive buildTypeOperator(ir.Primitive value,
                                  DartType type,
                                  {bool isTypeTest}) {
@@ skipping 161 matching lines @@
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
 }