support the JS builtin

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 ddc.src.codegen.js_codegen;
 
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 739 matching lines @@
     var initArgs = _emitArgumentInitializers(_parametersOf(node.parent));
     var block = visitBlock(node.block);
     if (initArgs != null) return new JS.Block([initArgs, block]);
     return block;
   }
 
   @override
   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) {
         return js.call('dart.dinvoke(#, #, #)', [
           target.accept(this),
           js.string(node.methodName.name, "'"),
           args
         ]);
       } else {
         return js.call(
             'dart.dinvokef(#, #)', [node.methodName.accept(this), args]);
       }
     }
 
     // TODO(jmesserly): if this resolves to a getter returning a function with
     // a call method, we don't generate the `.call` correctly.
 
     var targetJs;
     if (target != null) {
       targetJs = js.call('#.#', [target.accept(this), node.methodName.name]);
     } else {
       targetJs = node.methodName.accept(this);
     }
 
     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) {
     var code;
     if (rules.isDynamicCall(node.function)) {
       code = 'dart.dinvokef(#, #)';
     } else {
       code = '#(#)';
     }
     return js.call(
@@ skipping 913 matching lines @@
 /// Choose a canonical name from the library element.
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
 
 /// Path to file that will be generated for [info].
 // TODO(jmesserly): library directory should be relative to its package
 // root. For example, "package:dev_compiler/src/codegen/js_codegen.dart" would be:
 // "ddc/src/codegen/js_codegen.js" under the output directory.
 String jsOutputPath(LibraryInfo info) => '${info.name}/${info.name}.js';