Revert "JS templates"

sdk/lib/_internal/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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 128 matching lines @@
   void redirectElement(Element from, Element to) {
     assert(redirectionMapping[from] == null);
     redirectionMapping[from] = to;
     assert(isStoredInClosureField(from) || isBoxed(from));
   }
 
   HInstruction createBox() {
     // TODO(floitsch): Clean up this hack. Should we create a box-object by
     // just creating an empty object literal?
     JavaScriptBackend backend = builder.backend;
-    HInstruction box = new HForeign(js.js.parseForeignJS('{}'),
+    HInstruction box = new HForeign(new js.ObjectInitializer([]),
                                     backend.nonNullType,
                                     <HInstruction>[]);
     builder.add(box);
     return box;
   }
 
   /**
    * If the scope (function or loop) [node] has captured variables then this
    * method creates a box and sets up the redirections.
    */
@@ skipping 2891 matching lines @@
       localsHandler.updateLocal(element, checked);
     }
   }
 
   HInstruction invokeInterceptor(HInstruction receiver) {
     HInterceptor interceptor = new HInterceptor(receiver, backend.nonNullType);
     add(interceptor);
     return interceptor;
   }
 
-  HForeign createForeign(js.Template code,
+  HForeign createForeign(js.Expression code,
                          TypeMask type,
                          List<HInstruction> inputs) {
     return new HForeign(code, type, inputs);
   }
 
   HLiteralList buildLiteralList(List<HInstruction> inputs) {
     return new HLiteralList(inputs, backend.extendableArrayType);
   }
 
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   HInstruction buildTypeArgumentRepresentations(DartType type) {
     // Compute the representation of the type arguments, including access
     // to the runtime type information for type variables as instructions.
     if (type.kind == TypeKind.TYPE_VARIABLE) {
       return buildLiteralList(<HInstruction>[addTypeVariableReference(type)]);
     } else {
       assert(type.element.isClass());
       InterfaceType interface = type;
       List<HInstruction> inputs = <HInstruction>[];
       bool first = true;
       List<String> templates = <String>[];
       for (DartType argument in interface.typeArguments) {
         templates.add(rti.getTypeRepresentationWithHashes(argument, (variable) {
           HInstruction runtimeType = addTypeVariableReference(variable);
           inputs.add(runtimeType);
         }));
       }
       String template = '[${templates.join(', ')}]';
-      // TODO(sra): This is a fresh template each time.  We can't let the
-      // template manager build them.
-      js.Template code = js.js.uncachedExpressionTemplate(template);
+      js.Expression code = js.js.parseForeignJS(template);
       HInstruction representation =
         createForeign(code, backend.readableArrayType, inputs);
       return representation;
     }
   }
 
   visitOperatorSend(ast.Send node) {
     ast.Operator op = node.selector;
     if ("[]" == op.source) {
       visitDynamicSend(node);
@@ skipping 208 matching lines @@
           'At least two arguments expected.');
     }
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
-
-    if (nativeBehavior.codeTemplate.isExpression) {
-      push(new HForeign(nativeBehavior.codeTemplate, ssaType, inputs,
-                        effects: nativeBehavior.sideEffects,
-                        nativeBehavior: nativeBehavior));
-    } else {
-      push(new HForeign(nativeBehavior.codeTemplate, ssaType, inputs,
-                        isStatement: true,
-                        effects: nativeBehavior.sideEffects,
-                        nativeBehavior: nativeBehavior,
-                        canThrow: true));
-    }
+    push(new HForeign(nativeBehavior.codeAst, ssaType, inputs,
+                      effects: nativeBehavior.sideEffects,
+                      nativeBehavior: nativeBehavior));
   }
 
   void handleJsStringConcat(ast.Send node) {
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(node.arguments, inputs);
     if (inputs.length != 2) {
       compiler.internalError(node.argumentsNode, 'Two arguments expected.');
     }
     push(new HStringConcat(inputs[0], inputs[1], node, backend.stringType));
   }
 
   void handleForeignJsCurrentIsolateContext(ast.Send node) {
     if (!node.arguments.isEmpty) {
       compiler.internalError(node,
           'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT.');
     }
 
     if (!compiler.hasIsolateSupport()) {
       // If the isolate library is not used, we just generate code
       // to fetch the current isolate.
       String name = backend.namer.currentIsolate;
-      push(new HForeign(js.js.parseForeignJS(name),
+      push(new HForeign(new js.LiteralString(name),
                         backend.dynamicType,
                         <HInstruction>[]));
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       Element element = compiler.isolateHelperLibrary.find('_currentIsolate');
       if (element == null) {
         compiler.internalError(node,
             'Isolate library and compiler mismatch.');
@@ skipping 134 matching lines @@
     // and implementation signatures. Currently it is need because the
     // signatures have different elements for parameters.
     FunctionElement implementation = function.implementation;
     FunctionSignature params = implementation.functionSignature;
     if (params.optionalParameterCount != 0) {
       compiler.internalError(closure,
           '"$name" does not handle closure with optional parameters.');
     }
 
     compiler.enqueuer.codegen.registerStaticUse(element);
-    push(new HForeign(js.js.expressionTemplateYielding(
-                          backend.namer.elementAccess(element)),
+    push(new HForeign(backend.namer.elementAccess(element),
                       backend.dynamicType,
                       <HInstruction>[]));
     return params;
   }
 
   void handleForeignDartClosureToJs(ast.Send node, String name) {
     // TODO(ahe): This implements DART_CLOSURE_TO_JS and should probably take
     // care to wrap the closure in another closure that saves the current
     // isolate.
     handleForeignRawFunctionRef(node, name);
   }
 
   void handleForeignSetCurrentIsolate(ast.Send node) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       compiler.internalError(node.argumentsNode,
           'Exactly one argument required.');
     }
     visit(node.arguments.head);
     String isolateName = backend.namer.currentIsolate;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
-    push(new HForeign(js.js.parseForeignJS("$isolateName = #"),
+    push(new HForeign(js.js("$isolateName = #"),
                       backend.dynamicType,
                       <HInstruction>[pop()],
                       effects: sideEffects));
   }
 
   void handleForeignCreateIsolate(ast.Send node) {
     if (!node.arguments.isEmpty) {
       compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
     String constructorName = backend.namer.isolateName;
-    push(new HForeign(js.js.parseForeignJS("new $constructorName()"),
+    push(new HForeign(js.js("new $constructorName()"),
                       backend.dynamicType,
                       <HInstruction>[]));
   }
 
   void handleForeignDartObjectJsConstructorFunction(ast.Send node) {
     if (!node.arguments.isEmpty) {
       compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
-    push(new HForeign(js.js.expressionTemplateYielding(
-                          backend.namer.elementAccess(compiler.objectClass)),
+    String jsClassReference = backend.namer.isolateAccess(compiler.objectClass);
+    push(new HForeign(new js.LiteralString(jsClassReference),
                       backend.dynamicType,
                       <HInstruction>[]));
   }
 
   void handleForeignJsCurrentIsolate(ast.Send node) {
     if (!node.arguments.isEmpty) {
       compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
-    push(new HForeign(js.js.parseForeignJS(backend.namer.currentIsolate),
+    push(new HForeign(new js.LiteralString(backend.namer.currentIsolate),
                       backend.dynamicType,
                       <HInstruction>[]));
   }
 
   visitForeignSend(ast.Send node) {
     Selector selector = elements.getSelector(node);
     String name = selector.name;
     if (name == 'JS') {
       handleForeignJs(node);
     } else if (name == 'JS_CURRENT_ISOLATE_CONTEXT') {
@@ skipping 285 matching lines @@
     if (argument.kind == TypeKind.TYPE_VARIABLE) {
       return addTypeVariableReference(argument);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
     String template = rti.getTypeRepresentationWithHashes(argument, (variable) {
       inputs.add(addTypeVariableReference(variable));
     });
 
-    js.Template code = js.js.uncachedExpressionTemplate(template);
+    js.Expression code = js.js.parseForeignJS(template);
     HInstruction result = createForeign(code, backend.stringType, inputs);
     add(result);
     return result;
   }
 
   HInstruction handleListConstructor(InterfaceType type,
                                      ast.Node currentNode,
                                      HInstruction newObject) {
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
@@ skipping 131 matching lines @@
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
       if (!inputs[0].isNumber(compiler)) {
         HTypeConversion conversion = new HTypeConversion(
           null, HTypeConversion.ARGUMENT_TYPE_CHECK, backend.numType,
           inputs[0], null);
         add(conversion);
         inputs[0] = conversion;
       }
-      js.Template code = js.js.parseForeignJS('Array(#)');
+      js.Expression code = js.js.parseForeignJS('Array(#)');
       var behavior = new native.NativeBehavior();
       behavior.typesReturned.add(expectedType);
       // The allocation can throw only if the given length is a double
       // or negative.
       bool canThrow = true;
       if (inputs[0].isInteger(compiler) && inputs[0] is HConstant) {
         var constant = inputs[0];
         if (constant.constant.value >= 0) canThrow = false;
       }
       HForeign foreign = new HForeign(
           code, elementType, inputs, nativeBehavior: behavior,
           canThrow: canThrow);
       push(foreign);
       TypesInferrer inferrer = compiler.typesTask.typesInferrer;
       if (inferrer.isFixedArrayCheckedForGrowable(send)) {
-        js.Template code = js.js.parseForeignJS(r'#.fixed$length = init');
+        js.Expression code = js.js.parseForeignJS(r'#.fixed$length = init');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
         add(new HForeign(
               code, backend.nullType, [stack.last], canThrow: true));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
       ClassElement cls = constructor.getEnclosingClass();
@@ skipping 1276 matching lines @@
           () {},
           buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
       // a test of the target.
       void buildCondition() {
-        js.Template code = js.js.parseForeignJS('#');
+        js.Expression code = js.js.parseForeignJS('#');
         push(createForeign(code,
                            backend.boolType,
                            [localsHandler.readLocal(switchTarget)]));
       }
       handleIf(node, buildCondition, buildLoop, () => {});
     }
   }
 
   /**
    * Creates a switch statement.
@@ skipping 925 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }