Revert "JS templates"

sdk/lib/_internal/compiler/implementation/js_emitter/container_builder.dart

 // Copyright (c) 2013, 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 dart2js.js_emitter;
 
 /// This class should morph into something that makes it easy to build
 /// JavaScript representations of libraries, class-sides, and instance-sides.
 /// Initially, it is just a placeholder for code that is moved from
 /// [CodeEmitterTask].
@@ skipping 53 matching lines @@
         new List<jsAst.Parameter>(selector.argumentCount + extraArgumentCount);
     // The arguments that will be passed to the real method.
     List<jsAst.Expression> argumentsBuffer =
         new List<jsAst.Expression>(
             parameters.parameterCount + extraArgumentCount);
 
     int count = 0;
     if (isInterceptedMethod) {
       count++;
       parametersBuffer[0] = new jsAst.Parameter(receiverArgumentName);
-      argumentsBuffer[0] = js('#', receiverArgumentName);
+      argumentsBuffer[0] = js(receiverArgumentName);
       task.interceptorEmitter.interceptorInvocationNames.add(invocationName);
     }
 
     int optionalParameterStart = positionalArgumentCount + extraArgumentCount;
     // Includes extra receiver argument when using interceptor convention
     int indexOfLastOptionalArgumentInParameters = optionalParameterStart - 1;
 
     TreeElements elements =
         compiler.enqueuer.resolution.getCachedElements(member);
 
     int parameterIndex = 0;
     parameters.orderedForEachParameter((Element element) {
       String jsName = backend.namer.safeName(element.name);
       assert(jsName != receiverArgumentName);
       if (count < optionalParameterStart) {
         parametersBuffer[count] = new jsAst.Parameter(jsName);
-        argumentsBuffer[count] = js('#', jsName);
+        argumentsBuffer[count] = js(jsName);
       } else {
         int index = names.indexOf(element.name);
         if (index != -1) {
           indexOfLastOptionalArgumentInParameters = count;
           // The order of the named arguments is not the same as the
           // one in the real method (which is in Dart source order).
-          argumentsBuffer[count] = js('#', jsName);
+          argumentsBuffer[count] = js(jsName);
           parametersBuffer[optionalParameterStart + index] =
               new jsAst.Parameter(jsName);
         } else {
           Constant value = handler.getConstantForVariable(element);
           if (value == null) {
             argumentsBuffer[count] = task.constantReference(new NullConstant());
           } else {
             if (!value.isNull) {
               // If the value is the null constant, we should not pass it
               // down to the native method.
               indexOfLastOptionalArgumentInParameters = count;
             }
             argumentsBuffer[count] = task.constantReference(value);
           }
         }
       }
       count++;
     });
 
-    var body;  // List or jsAst.Statement.
+    List body;
     if (member.hasFixedBackendName()) {
       body = task.nativeEmitter.generateParameterStubStatements(
           member, isInterceptedMethod, invocationName,
           parametersBuffer, argumentsBuffer,
           indexOfLastOptionalArgumentInParameters);
     } else if (member.isInstanceMember()) {
       if (needsSuperGetter(member)) {
         ClassElement superClass = member.getEnclosingClass();
         String methodName = namer.getNameOfInstanceMember(member);
         // When redirecting, we must ensure that we don't end up in a subclass.
         // We thus can't just invoke `this.foo$1.call(filledInArguments)`.
         // Instead we need to call the statically resolved target.
         //   `<class>.prototype.bar$1.call(this, argument0, ...)`.
-        body = js.statement(
-            'return #.prototype.#.call(this, #);',
-            [backend.namer.elementAccess(superClass), methodName,
-             argumentsBuffer]);
+        body = [js.return_(
+            backend.namer.elementAccess(superClass)['prototype'][methodName]
+            ["call"](["this"]..addAll(argumentsBuffer)))];
       } else {
-        body = js.statement(
-            'return this.#(#);',
-            [namer.getNameOfInstanceMember(member), argumentsBuffer]);
+        body = [js.return_(
+            js('this')
+            [namer.getNameOfInstanceMember(member)](argumentsBuffer))];
       }
     } else {
-      body = js.statement('return #(#)',
-          [namer.elementAccess(member), argumentsBuffer]);
+      body = [js.return_(namer.elementAccess(member)(argumentsBuffer))];
     }
 
-    jsAst.Fun function = js('function(#) { #; }', [parametersBuffer, body]);
+    jsAst.Fun function = js.fun(parametersBuffer, body);
 
     addStub(selector, function);
   }
 
   void addParameterStubs(FunctionElement member, AddStubFunction defineStub,
                          [bool canTearOff = false]) {
     if (member.enclosingElement.isClosure()) {
       ClosureClassElement cls = member.enclosingElement;
       if (cls.supertype.element == compiler.boundClosureClass) {
         compiler.internalError(cls.methodElement, 'Bound closure1.');
@@ skipping 105 matching lines @@
         backend.isInterceptorClass(member.getEnclosingClass());
 
     const String receiverArgumentName = r'$receiver';
 
     jsAst.Expression buildGetter() {
       jsAst.Expression receiver =
           js(isInterceptorClass ? receiverArgumentName : 'this');
       if (member.isGetter()) {
         String getterName = namer.getterName(member);
         if (isInterceptedMethod) {
-          return js('this.#(#)', [getterName, receiver]);
+          return js('this')[getterName](<jsAst.Expression>[receiver]);
         }
-        return js('#.#()', [receiver, getterName]);
+        return receiver[getterName](<jsAst.Expression>[]);
       } else {
         String fieldName = namer.instanceFieldPropertyName(member);
-        return js('#.#', [receiver, fieldName]);
+        return receiver[fieldName];
       }
     }
 
     // Two selectors may match but differ only in type.  To avoid generating
     // identical stubs for each we track untyped selectors which already have
     // stubs.
     Set<Selector> generatedSelectors = new Set<Selector>();
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         selector = selector.asUntyped;
         if (generatedSelectors.contains(selector)) continue;
         generatedSelectors.add(selector);
 
         String invocationName = namer.invocationName(selector);
         Selector callSelector = new Selector.callClosureFrom(selector);
         String closureCallName = namer.invocationName(callSelector);
 
         List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
         List<jsAst.Expression> arguments = <jsAst.Expression>[];
         if (isInterceptedMethod) {
           parameters.add(new jsAst.Parameter(receiverArgumentName));
         }
 
         for (int i = 0; i < selector.argumentCount; i++) {
           String name = 'arg$i';
           parameters.add(new jsAst.Parameter(name));
-          arguments.add(js('#', name));
+          arguments.add(js(name));
         }
 
-        jsAst.Fun function = js(
-            'function(#) { return #.#(#); }',
-            [ parameters, buildGetter(), closureCallName, arguments]);
+        jsAst.Fun function = js.fun(
+            parameters,
+            js.return_(buildGetter()[closureCallName](arguments)));
 
         addProperty(invocationName, function);
       }
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
@@ skipping 99 matching lines @@
     // N+4. First default argument.
     // ...
     // O.   First parameter name (if needed for reflection or Function.apply).
     // ...
     // P.   Unmangled name (if reflectable).
     // P+1. First metadata (if reflectable).
     // ...
     // TODO(ahe): Consider one of the parameter counts can be replaced by the
     // length property of the JavaScript function object.
 
-    List<jsAst.Expression> expressions = <jsAst.Expression>[];
+    List expressions = [];
 
     String callSelectorString = 'null';
     if (member.isFunction()) {
       Selector callSelector =
           new Selector.fromElement(member, compiler).toCallSelector();
       callSelectorString = '"${namer.invocationName(callSelector)}"';
     }
 
     // On [requiredParameterCount], the lower bit is set if this method can be
     // called reflectively.
     int requiredParameterCount = parameters.requiredParameterCount << 1;
     if (member.isAccessor()) requiredParameterCount++;
 
     int optionalParameterCount = parameters.optionalParameterCount << 1;
     if (parameters.optionalParametersAreNamed) optionalParameterCount++;
 
     expressions.add(code);
 
-    // TODO(sra): Don't use LiteralString for non-strings.
     List tearOffInfo = [new jsAst.LiteralString(callSelectorString)];
 
     if (needsStubs || canTearOff) {
       addParameterStubs(member, (Selector selector, jsAst.Fun function) {
         expressions.add(function);
         if (member.isInstanceMember()) {
           Set invokedSelectors =
               compiler.codegenWorld.invokedNames[member.name];
             expressions.add(js.string(namer.invocationName(selector)));
         } else {
-          expressions.add(js('null'));
+          expressions.add("null");
           // TOOD(ahe): Since we know when reading static data versus instance
           // data, we can eliminate this element.
         }
         Set<Selector> callSelectors = compiler.codegenWorld.invokedNames[
             namer.closureInvocationSelectorName];
         Selector callSelector = selector.toCallSelector();
         String callSelectorString = 'null';
         if (canTearOff && callSelectors != null &&
             callSelectors.contains(callSelector)) {
           callSelectorString = '"${namer.invocationName(callSelector)}"';
@@ skipping 10 matching lines @@
         memberType = body.constructor.type;
       } else {
         memberType = member.type;
       }
       if (memberType.containsTypeVariables) {
         jsAst.Expression thisAccess = js(r'this.$receiver');
         memberTypeExpression =
             backend.rti.getSignatureEncoding(memberType, thisAccess);
       } else {
         memberTypeExpression =
-            js.number(task.metadataEmitter.reifyType(memberType));
+            js.toExpression(task.metadataEmitter.reifyType(memberType));
       }
     } else {
       memberTypeExpression = js('null');
     }
 
     expressions
         ..addAll(tearOffInfo)
         ..add((tearOffName == null || member.isAccessor())
               ? js("null") : js.string(tearOffName))
-        ..add(js.number(requiredParameterCount))
-        ..add(js.number(optionalParameterCount))
+        ..add(requiredParameterCount)
+        ..add(optionalParameterCount)
         ..add(memberTypeExpression)
-        ..addAll(
-            task.metadataEmitter.reifyDefaultArguments(member).map(js.number));
+        ..addAll(task.metadataEmitter.reifyDefaultArguments(member));
 
     if (canBeReflected || canBeApplied) {
       parameters.forEachParameter((Element parameter) {
-        expressions.add(
-            js.number(task.metadataEmitter.reifyName(parameter.name)));
+        expressions.add(task.metadataEmitter.reifyName(parameter.name));
         if (backend.mustRetainMetadata) {
           List<MetadataAnnotation> annotations = parameter.metadata.toList();
           Iterable<int> metadataIndices =
               annotations.map((MetadataAnnotation annotation) {
             Constant constant =
                 backend.constants.getConstantForMetadata(annotation);
             backend.constants.addCompileTimeConstantForEmission(constant);
             return task.metadataEmitter.reifyMetadata(annotation);
           });
-          expressions.add(
-              new jsAst.ArrayInitializer.from(metadataIndices.map(js.number)));
+          expressions.add(metadataIndices.isNotEmpty ? metadataIndices.toList()
+                                                     : js('[]'));
         }
       });
     }
     if (canBeReflected) {
       jsAst.LiteralString reflectionName;
       if (member.isConstructor()) {
         String reflectionNameString = task.getReflectionName(member, name);
         reflectionName =
             new jsAst.LiteralString(
                 '"new ${Elements.reconstructConstructorName(member)}"');
       } else {
         reflectionName = js.string(member.name);
       }
       expressions
           ..add(reflectionName)
-          ..addAll(task.metadataEmitter.computeMetadata(member).map(js.number));
+          ..addAll(task.metadataEmitter.computeMetadata(member));
     } else if (isClosure && canBeApplied) {
       expressions.add(js.string(member.name));
     }
-    builder.addProperty(name, new jsAst.ArrayInitializer.from(expressions));
+
+    builder.addProperty(name, js.toExpression(expressions));
   }
 
   void addMemberField(VariableElement member, ClassBuilder builder) {
     // For now, do nothing.
   }
 }