Use string interpolation in JS intrinsics to simplify large templates.

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, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1916 matching lines @@
     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 (isInlineJS(e)) {
       var args = node.argumentList.arguments;
       // arg[0] is static return type, used in `RestrictedStaticTypeAnalyzer`
-      var code = args[1] as StringLiteral;
+      var code = args[1];
+      var templateArgs;
+      var source;
+      if (code is StringInterpolation) {
+        if (args.length > 2) {
+          throw new ArgumentError(
+              "Can't mix template args and string interpolation in JS calls.");
+        }
+        templateArgs = <Expression>[];
+        source = code.elements.map((element) {
+          if (element is InterpolationExpression) {
+            templateArgs.add(element.expression);
+            return '#';
+          } else {
+            return (element as InterpolationString).value;
+          }
+        }).join();
+      } else {
+        templateArgs = args.skip(2);
+        source = (code as StringLiteral).stringValue;
+      }
 
-      var template = js.parseForeignJS(code.stringValue);
-      var result = template.instantiate(_visitList(args.skip(2)));
+      var template = js.parseForeignJS(source);
+      var result = template.instantiate(_visitList(templateArgs));
       // `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) {
@@ skipping 1550 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }