Remove Object.dynamic.

lib/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 2380 matching lines @@
     inputs.add(closureTarget);
     addDynamicSendArgumentsToList(node, inputs);
     pushWithPosition(new HInvokeClosure(selector, inputs), node);
   }
 
   void handleForeignJs(Send node) {
     Link<Node> link = node.arguments;
     // If the invoke is on foreign code, don't visit the first
     // argument, which is the type, and the second argument,
     // which is the foreign code.
-    if (link.isEmpty() || link.isEmpty()) {
+    if (link.isEmpty() || link.tail.isEmpty()) {
       compiler.cancel('At least two arguments expected',
                       node: node.argumentsNode);
     }
-    link = link.tail.tail;
     List<HInstruction> inputs = <HInstruction>[];
-    addGenericSendArgumentsToList(link, inputs);
-    Node type = node.arguments.head;
-    Node literal = node.arguments.tail.head;
-    if (literal is !StringNode || literal.dynamic.isInterpolation) {
-      compiler.cancel('JS code must be a string literal', node: literal);
+    Node type = link.head;
+    Node code = link.tail.head;
+    addGenericSendArgumentsToList(link.tail.tail, inputs);
+
+    if (type is !LiteralString) {
+      // The type must not be a juxtaposition or interpolation.
+      compiler.cancel('The type of a JS expression must be a string literal',
+                      node: type);
     }
-    if (type is !LiteralString) {
-      compiler.cancel(
-          'The type of a JS expression must be a string literal', node: type);
+    LiteralString typeString = type;
+
+    if (code is StringNode) {
+      StringNode codeString = code;
+      if (!codeString.isInterpolation) {
+        // codeString may not be an interpolation, but may be a juxtaposition.
+        push(new HForeign(codeString.dartString,
+                          typeString.dartString,
+                          inputs));
+        return;
+      }
     }
-    push(new HForeign(
-        literal.dynamic.dartString, type.dynamic.dartString, inputs));
+    compiler.cancel('JS code must be a string literal', node: literal);
   }
 
   void handleForeignUnintercepted(Send node) {
     Link<Node> link = node.arguments;
     if (!link.tail.isEmpty()) {
       compiler.cancel(
           'More than one expression in UNINTERCEPTED()', node: node);
     }
     Expression expression = link.head;
     disableMethodInterception();
@@ skipping 1761 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }