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);
-    task.precompiledFunction.add(new jsAst.FunctionDeclaration(
-        new jsAst.VariableDeclaration(constructorName),
-        js.fun(fields, fields.map(
-            (name) => js('this.$name = $name')).toList())));
+
+    // 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]))])));
     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.precompiledConstructorNames.add(js(constructorName));
+    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));
   }
 
   /// 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.toExpression);
+          .typeVariablesOf(classElement).map(js.number);
 
       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('$className.prototype.$getterName = #',
-           js.fun(args, js.return_(js('$receiver.$fieldName')))));
+        js('#.prototype.# = function(#) { return #.# }',
+           [className, getterName, args, receiver, fieldName]));
     if (backend.isNeededForReflection(member)) {
       task.precompiledFunction.add(
-          js('$className.prototype.$getterName.${namer.reflectableField} = 1'));
+          js('#.prototype.#.${namer.reflectableField} = 1',
+              [className, getterName]));
     }
   }
 
   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', 'v'] : ['v'];
+    List<String> args = backend.isInterceptedMethod(member) ? ['receiver'] : [];
     task.precompiledFunction.add(
-        js('$className.prototype.$setterName = #',
-           js.fun(args, js.return_(js('$receiver.$fieldName = v')))));
+        // TODO: remove 'return'?
+        js('#.prototype.# = function(#, v) { return #.# = v; }',
+            [className, setterName, args, receiver, fieldName]));
     if (backend.isNeededForReflection(member)) {
       task.precompiledFunction.add(
-          js('$className.prototype.$setterName.${namer.reflectableField} = 1'));
+          js('#.prototype.#.${namer.reflectableField} = 1',
+              [className, setterName]));
     }
   }
 
   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.toExpression(RuntimeTypes.getTypeVariableIndex(element));
+        js.number(RuntimeTypes.getTypeVariableIndex(element));
     jsAst.Expression computeTypeVariable;
 
     Substitution substitution =
         backend.rti.computeSubstitution(
             cls, element.enclosingElement, alwaysGenerateFunction: true);
     if (substitution != null) {
       jsAst.Expression typeArguments =
-          substitution.getCode(backend.rti, true)['apply'](
-              ['null', r'this.$builtinTypeInfo']);
-      computeTypeVariable = typeArguments[index];
+          js(r'#.apply(null, this.$builtinTypeInfo)',
+              substitution.getCode(backend.rti, true));
+      computeTypeVariable = js('#[#]', [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.fun(
-            [], [js.return_(convertRtiToRuntimeType(computeTypeVariable))]));
+    builder.addProperty(name,
+        js('function () { return #(#) }',
+            [convertRtiToRuntimeType, computeTypeVariable]));
   }
 }