support the JS builtin

* fix a few cases where we regressed js_ast parser interpolations
* infer correct static type for JS call expressions

[email protected]

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

Author: John Messerly

lib/src/checker/resolver.dart

@@ -363,7 +363,26 @@ class RestrictedStaticTypeAnalyzer extends StaticTypeAnalyzer {
   visitMethodInvocation(MethodInvocation node) {
     // TODO(sigmund): follow up with analyzer team - why is this needed?
     visitSimpleIdentifier(node.methodName);
-    return super.visitMethodInvocation(node);
+    super.visitMethodInvocation(node);
+
+    var e = node.methodName.staticElement;
+    if (e is FunctionElement &&
+        e.library.name == '_foreign_helper' &&
+        e.name == 'JS') {
+      // Fix types for JS builtin calls.
+      //
+      // This code was taken from analyzer. It's not super sophisticated:
+      // only looks for the type name in dart:core, so we just copy it here.
+      //
+      // TODO(jmesserly): we'll likely need something that can handle a wider
+      // variety of types, especially when we get to JS interop.
+      var args = node.argumentList.arguments;
+      if (args.isNotEmpty && args.first is SimpleStringLiteral) {
+        var coreLib = _typeProvider.objectType.element.library;
+        var classElem = coreLib.getType(args.first.stringValue);
+        if (classElem != null) node.staticType = classElem.type;
+      }
+    }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is

lib/src/codegen/js_codegen.dart

@@ -757,9 +757,12 @@ class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   JS.Block visitBlock(Block node) => new JS.Block(_visitList(node.statements));
 
   @override
-  JS.Expression visitMethodInvocation(MethodInvocation node) {
+  visitMethodInvocation(MethodInvocation node) {
     var target = node.isCascaded ? _cascadeTarget : node.target;
 
+    var result = _emitForeignJS(node);
+    if (result != null) return result;
+
     if (rules.isDynamicCall(node.methodName)) {
       var args = node.argumentList.accept(this);
       if (target != null) {
@@ -787,6 +790,25 @@ class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
     return js.call('#(#)', [targetJs, node.argumentList.accept(this)]);
   }
 
+  /// 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`
+      var code = args[1] as StringLiteral;
+
+      var template = js.parseForeignJS(code.stringValue);
+      var result = template.instantiate(_visitList(args.skip(2)));
+      // `throw` is emitted as a statement by `parseForeignJS`.
+      assert(result is JS.Expression || node.parent is ExpressionStatement);
+      return result;
+    }
+    return null;
+  }
+
   @override
   JS.Expression visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) {

lib/src/js/builder.dart

@@ -894,26 +894,10 @@ class MiniJsParser {
       // PropertyDefinition :
       //     PropertyName : AssignmentExpression
       //     MethodDefinition
+      properties.add(parseMethodOrProperty());
 
-      if (acceptCategory(HASH)) {
-        properties.add(parseInterpolatedMember());
-      } else {
-        bool isGetter = acceptString('get');
-        bool isSetter = isGetter ? false : acceptString('set');
-        Expression name = parsePropertyName();
-
-        if (lastCategory == LPAREN) {
-          Fun fun = parseFun();
-          properties.add(
-              new Method(name, fun, isGetter: isGetter, isSetter: isSetter));
-        } else {
-          expectCategory(COLON);
-          Expression value = parseAssignment();
-          properties.add(new Property(name, value));
-        }
-        if (acceptCategory(RBRACE)) break;
-        expectCategory(COMMA);
-      }
+      if (acceptCategory(RBRACE)) break;
+      expectCategory(COMMA);
     }
     return new ObjectInitializer(properties);
   }
@@ -1467,28 +1451,59 @@ class MiniJsParser {
     expectCategory(LBRACE);
     var methods = new List<Method>();
     while (lastCategory != RBRACE) {
-      methods.add(parseMethod());
+      methods.add(parseMethodOrProperty(onlyMethods: true));
     }
     expectCategory(RBRACE);
     return new ClassExpression(name, heritage, methods);
   }
 
-  Method parseMethod() {
-    if (acceptCategory(HASH)) return parseInterpolatedMember();
-
+  /**
+   * Parses a [Method] or a [Property].
+   *
+   * Most of the complexity is from supporting interpolation. Several forms
+   * are supported:
+   *
+   * - getter/setter names: `get #() { ... }`
+   * - method names: `#() { ... }`
+   * - property names: `#: ...`
+   * - entire methods: `#`
+   */
+  Property parseMethodOrProperty({bool onlyMethods: false}) {
     bool isStatic = acceptString('static');
-    bool isGetter = acceptString('get');
-    bool isSetter = isGetter ? false : acceptString('set');
-    var name = parsePropertyName();
-    var fun = parseFun();
-    return new Method(name, fun,
-        isGetter: isGetter, isSetter: isSetter, isStatic: isStatic);
-  }
 
-  InterpolatedMethod parseInterpolatedMember() {
-    var member = new InterpolatedMethod(parseHash());
-    interpolatedValues.add(member);
-    return member;
+    bool isGetter = false;
+    bool isSetter = false;
+    Expression name = null;
+    if (acceptCategory(HASH)) {
+      if (lastCategory != LPAREN && (onlyMethods || lastCategory != COLON)) {
+        // Interpolated method
+        var member = new InterpolatedMethod(parseHash());
+        interpolatedValues.add(member);
+        return member;
+      }
+      name = parseInterpolatedExpression();
+    } else {
+      name = parsePropertyName();
+    }
+
+    // Allow get or set to be followed by another property name.
+    if (lastCategory == ALPHA && name is PropertyName) {
+      PropertyName p = name;
+      isGetter = p.name == 'get';
+      isSetter = p.name == 'set';
+      if (isGetter || isSetter) {
+        name = parsePropertyName();
+      }
+    }
+
+    if (!onlyMethods && acceptCategory(COLON)) {
+      Expression value = parseAssignment();
+      return new Property(name, value);
+    } else {
+      var fun = parseFun();
+      return new Method(name, fun,
+          isGetter: isGetter, isSetter: isSetter, isStatic: isStatic);
+    }
   }
 
   Expression parsePropertyName() {
@@ -1505,13 +1520,16 @@ class MiniJsParser {
       expectCategory(RSQUARE);
       return expr;
     } else if (acceptCategory(HASH)) {
-      var nameOrPosition = parseHash();
-      var interpolatedLiteral = new InterpolatedLiteral(nameOrPosition);
-      interpolatedValues.add(interpolatedLiteral);
-      return interpolatedLiteral;
+      return parseInterpolatedExpression();
     } else {
       error('Expected property name');
       return null;
     }
   }
+
+  InterpolatedExpression parseInterpolatedExpression() {
+    var interpolated = new InterpolatedExpression(parseHash());
+    interpolatedValues.add(interpolated);
+    return interpolated;
+  }
 }

test/codegen/expect/_foreign_helper/_foreign_helper.js

@@ -119,7 +119,7 @@ var _foreign_helper;
   }
   // Function JS_STRING_CONCAT: (String, String) → String
   function JS_STRING_CONCAT(a, b) {
-    return dart.as(JS('String', '# + #', a, b), core.String);
+    return a + b;
   }
   // Exports:
   _foreign_helper.JS = JS;