Revert "JS templates"

sdk/lib/_internal/compiler/implementation/js_emitter/class_emitter.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;
 
 class ClassEmitter extends CodeEmitterHelper {
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 52 matching lines @@
                   (Element member,
                    String name,
                    String accessorName,
                    bool needsGetter,
                    bool needsSetter,
                    bool needsCheckedSetter) {
         fields.add(name);
       });
     }
     String constructorName = namer.getNameOfClass(classElement);
-
-    // TODO(sra): Implement placeholders in VariableDeclaration position:
-    //     task.precompiledFunction.add(js.statement('function #(#) { #; }',
-    //        [ constructorName, fields,
-    //            fields.map(
-    //                (name) => js('this.# = #', [name, name]))]));
-    task.precompiledFunction.add(
-        new jsAst.FunctionDeclaration(
-            new jsAst.VariableDeclaration(constructorName),
-            js('function(#) { #; }',
-                [fields,
-                 fields.map((name) => js('this.# = #', [name, name]))])));
+    task.precompiledFunction.add(new jsAst.FunctionDeclaration(
+        new jsAst.VariableDeclaration(constructorName),
+        js.fun(fields, fields.map(
+            (name) => js('this.$name = $name')).toList())));
     if (runtimeName == null) {
       runtimeName = constructorName;
     }
+    task.precompiledFunction.addAll([
+        js('$constructorName.builtin\$cls = "$runtimeName"'),
+        js.if_('!"name" in $constructorName',
+              js('$constructorName.name = "$constructorName"')),
+        js('\$desc=\$collectedClasses.$constructorName'),
+        js.if_('\$desc instanceof Array', js('\$desc = \$desc[1]')),
+        js('$constructorName.prototype = \$desc'),
+    ]);
 
-    task.precompiledFunction.add(
-        js.statement(r'''{
-          #.builtin$cls = #;
-          if (!"name" in #)
-              #.name = #;
-          $desc=$collectedClasses.#;
-          if ($desc instanceof Array) $desc = $desc[1];
-          #.prototype = $desc;
-        }''',
-            [   constructorName, js.string(runtimeName),
-                constructorName,
-                constructorName, js.string(constructorName),
-                constructorName,
-                constructorName
-             ]));
-
-    task.precompiledConstructorNames.add(js('#', constructorName));
+    task.precompiledConstructorNames.add(js(constructorName));
   }
 
   /// Returns `true` if fields added.
   bool emitFields(Element element,
                   ClassBuilder builder,
                   String superName,
                   { bool classIsNative: false,
                     bool emitStatics: false,
                     bool onlyForRti: false }) {
     assert(!emitStatics || !onlyForRti);
@@ skipping 195 matching lines @@
                                           ClassBuilder classBuilder,
                                           ClassBuilder enclosingBuilder) {
     var metadata = task.metadataEmitter.buildMetadataFunction(classElement);
     if (metadata != null) {
       classBuilder.addProperty("@", metadata);
     }
 
     if (backend.isNeededForReflection(classElement)) {
       Link typeVars = classElement.typeVariables;
       Iterable typeVariableProperties = task.typeVariableHandler
-          .typeVariablesOf(classElement).map(js.number);
+          .typeVariablesOf(classElement).map(js.toExpression);
 
       ClassElement superclass = classElement.superclass;
       bool hasSuper = superclass != null;
       if ((!typeVariableProperties.isEmpty && !hasSuper) ||
           (hasSuper && superclass.typeVariables != typeVars)) {
         classBuilder.addProperty('<>',
             new jsAst.ArrayInitializer.from(typeVariableProperties));
       }
     }
 
@@ skipping 197 matching lines @@
   }
 
   void generateGetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String getterName = namer.getterNameFromAccessorName(accessorName);
     ClassElement cls = member.getEnclosingClass();
     String className = namer.getNameOfClass(cls);
     String receiver = backend.isInterceptorClass(cls) ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member) ? ['receiver'] : [];
     task.precompiledFunction.add(
-        js('#.prototype.# = function(#) { return #.# }',
-           [className, getterName, args, receiver, fieldName]));
+        js('$className.prototype.$getterName = #',
+           js.fun(args, js.return_(js('$receiver.$fieldName')))));
     if (backend.isNeededForReflection(member)) {
       task.precompiledFunction.add(
-          js('#.prototype.#.${namer.reflectableField} = 1',
-              [className, getterName]));
+          js('$className.prototype.$getterName.${namer.reflectableField} = 1'));
     }
   }
 
   void generateSetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String setterName = namer.setterNameFromAccessorName(accessorName);
     ClassElement cls = member.getEnclosingClass();
     String className = namer.getNameOfClass(cls);
     String receiver = backend.isInterceptorClass(cls) ? 'receiver' : 'this';
-    List<String> args = backend.isInterceptedMethod(member) ? ['receiver'] : [];
+    List<String> args =
+        backend.isInterceptedMethod(member) ? ['receiver', 'v'] : ['v'];
     task.precompiledFunction.add(
-        // TODO: remove 'return'?
-        js('#.prototype.# = function(#, v) { return #.# = v; }',
-            [className, setterName, args, receiver, fieldName]));
+        js('$className.prototype.$setterName = #',
+           js.fun(args, js.return_(js('$receiver.$fieldName = v')))));
     if (backend.isNeededForReflection(member)) {
       task.precompiledFunction.add(
-          js('#.prototype.#.${namer.reflectableField} = 1',
-              [className, setterName]));
+          js('$className.prototype.$setterName.${namer.reflectableField} = 1'));
     }
   }
 
   void generateReflectionDataForFieldGetterOrSetter(Element member,
                                                     String name,
                                                     ClassBuilder builder,
                                                     {bool isGetter}) {
     Selector selector = isGetter
         ? new Selector.getter(member.name, member.getLibrary())
         : new Selector.setter(member.name, member.getLibrary());
@@ skipping 16 matching lines @@
       }
       superclass = superclass.superclass;
     }
   }
 
   void emitTypeVariableReader(ClassElement cls,
                               ClassBuilder builder,
                               TypeVariableElement element) {
     String name = namer.readTypeVariableName(element);
     jsAst.Expression index =
-        js.number(RuntimeTypes.getTypeVariableIndex(element));
+        js.toExpression(RuntimeTypes.getTypeVariableIndex(element));
     jsAst.Expression computeTypeVariable;
 
     Substitution substitution =
         backend.rti.computeSubstitution(
             cls, element.enclosingElement, alwaysGenerateFunction: true);
     if (substitution != null) {
       jsAst.Expression typeArguments =
-          js(r'#.apply(null, this.$builtinTypeInfo)',
-              substitution.getCode(backend.rti, true));
-      computeTypeVariable = js('#[#]', [typeArguments, index]);
+          substitution.getCode(backend.rti, true)['apply'](
+              ['null', r'this.$builtinTypeInfo']);
+      computeTypeVariable = typeArguments[index];
     } else {
       // TODO(ahe): These can be generated dynamically.
       computeTypeVariable =
           js(r'this.$builtinTypeInfo && this.$builtinTypeInfo[#]', index);
     }
     jsAst.Expression convertRtiToRuntimeType =
         namer.elementAccess(compiler.findHelper('convertRtiToRuntimeType'));
-    builder.addProperty(name,
-        js('function () { return #(#) }',
-            [convertRtiToRuntimeType, computeTypeVariable]));
+    builder.addProperty(
+        name, js.fun(
+            [], [js.return_(convertRtiToRuntimeType(computeTypeVariable))]));
   }
 }