JS templates

sdk/lib/_internal/compiler/implementation/js_emitter/code_emitter_task.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 dart2js.js_emitter;
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
@@ skipping 130 matching lines @@
     const RANGE2_SIZE = RANGE2_LAST - RANGE2_FIRST + 1;
     const RANGE1_ADJUST = - (FIRST_FIELD_CODE - RANGE1_FIRST);
     const RANGE2_ADJUST = - (FIRST_FIELD_CODE + RANGE1_SIZE - RANGE2_FIRST);
     const RANGE3_ADJUST =
         - (FIRST_FIELD_CODE + RANGE1_SIZE + RANGE2_SIZE - RANGE3_FIRST);
 
     String receiverParamName = compiler.enableMinification ? "r" : "receiver";
     String valueParamName = compiler.enableMinification ? "v" : "value";
     String reflectableField = namer.reflectableField;
 
-    // function generateAccessor(field, prototype, cls) {
-    jsAst.Fun fun = js.fun(['fieldDescriptor', 'accessors', 'cls'], [
-      js('var fieldInformation = fieldDescriptor.split("-")'),
-      js('var field = fieldInformation[0]'),
-      js('var len = field.length'),
-      js('var code = field.charCodeAt(len - 1)'),
-      js('var reflectable'),
-      js.if_('fieldInformation.length > 1', js('reflectable = true'),
-             js('reflectable = false')),
-      js('code = ((code >= $RANGE1_FIRST) && (code <= $RANGE1_LAST))'
-          '    ? code - $RANGE1_ADJUST'
-          '    : ((code >= $RANGE2_FIRST) && (code <= $RANGE2_LAST))'
-          '      ? code - $RANGE2_ADJUST'
-          '      : ((code >= $RANGE3_FIRST) && (code <= $RANGE3_LAST))'
-          '        ? code - $RANGE3_ADJUST'
-          '        : $NO_FIELD_CODE'),
+    return js.statement('''
+      function generateAccessor(fieldDescriptor, accessors, cls) {
+        var fieldInformation = fieldDescriptor.split("-");
+        var field = fieldInformation[0];
+        var len = field.length;
+        var code = field.charCodeAt(len - 1);
+        var reflectable;
+        if (fieldInformation.length > 1) reflectable = true;

[floitsch, 2014/04/22 16:11:18]

var reflectable = fieldInformation.length > 1;

[sra1, 2014/04/23 02:33:50]

I agree, but the process for this change it to change the generated output as
little as possible.

+             else reflectable = false;
+        code = ((code >= $RANGE1_FIRST) && (code <= $RANGE1_LAST))
+              ? code - $RANGE1_ADJUST
+              : ((code >= $RANGE2_FIRST) && (code <= $RANGE2_LAST))
+                ? code - $RANGE2_ADJUST
+                : ((code >= $RANGE3_FIRST) && (code <= $RANGE3_LAST))
+                  ? code - $RANGE3_ADJUST
+                  : $NO_FIELD_CODE;
 
-      // if (needsAccessor) {
-      js.if_('code', [
-        js('var getterCode = code & 3'),
-        js('var setterCode = code >> 2'),
-        js('var accessorName = field = field.substring(0, len - 1)'),
+        if (code) {  // needsAccessor
+          var getterCode = code & 3;
+          var setterCode = code >> 2;
+          var accessorName = field = field.substring(0, len - 1);
 
-        js('var divider = field.indexOf(":")'),
-        js.if_('divider > 0', [  // Colon never in first position.
-          js('accessorName = field.substring(0, divider)'),
-          js('field = field.substring(divider + 1)')
-        ]),
+          var divider = field.indexOf(":");
+          if (divider > 0) { // Colon never in first position.
+            accessorName = field.substring(0, divider);
+            field = field.substring(divider + 1);
+          }
 
-        // if (needsGetter) {
-        js.if_('getterCode', [
-          js('var args = (getterCode & 2) ? "$receiverParamName" : ""'),
-          js('var receiver = (getterCode & 1) ? "this" : "$receiverParamName"'),
-          js('var body = "return " + receiver + "." + field'),
-          js('var property ='
-             ' cls + ".prototype.${namer.getterPrefix}" + accessorName + "="'),
-          js('var fn = "function(" + args + "){" + body + "}"'),
-          js.if_(
-              'reflectable',
-              js('accessors.push(property + "\$reflectable(" + fn + ");\\n")'),
-              js('accessors.push(property + fn + ";\\n")')),
-        ]),
+          if (getterCode) {  // needsGetter
+            var args = (getterCode & 2) ? "$receiverParamName" : "";
+            var receiver = (getterCode & 1) ? "this" : "$receiverParamName";
+            var body = "return " + receiver + "." + field;
+            var property =
+                cls + ".prototype.${namer.getterPrefix}" + accessorName + "=";
+            var fn = "function(" + args + "){" + body + "}";
+            if (reflectable)
+              accessors.push(property + "\$reflectable(" + fn + ");\\n");
+            else
+              accessors.push(property + fn + ";\\n");
+          }
 
-        // if (needsSetter) {
-        js.if_('setterCode', [
-          js('var args = (setterCode & 2)'
-              '  ? "$receiverParamName,${_}$valueParamName"'
-              '  : "$valueParamName"'),
-          js('var receiver = (setterCode & 1) ? "this" : "$receiverParamName"'),
-          js('var body = receiver + "." + field + "$_=$_$valueParamName"'),
-          js('var property ='
-             ' cls + ".prototype.${namer.setterPrefix}" + accessorName + "="'),
-          js('var fn = "function(" + args + "){" + body + "}"'),
-          js.if_(
-              'reflectable',
-              js('accessors.push(property + "\$reflectable(" + fn + ");\\n")'),
-              js('accessors.push(property + fn + ";\\n")')),
-        ]),
+          if (setterCode) {  // needsSetter
+            var args = (setterCode & 2)
+                ? "$receiverParamName,${_}$valueParamName"
+                : "$valueParamName";
+            var receiver = (setterCode & 1) ? "this" : "$receiverParamName";
+            var body = receiver + "." + field + "$_=$_$valueParamName";
+            var property =
+                cls + ".prototype.${namer.setterPrefix}" + accessorName + "=";
+            var fn = "function(" + args + "){" + body + "}";
+            if (reflectable)
+              accessors.push(property + "\$reflectable(" + fn + ");\\n");
+            else
+              accessors.push(property + fn + ";\\n");
+          }
+        }
 
-      ]),
-
-      // return field;
-      js.return_('field')
-    ]);
-
-    return new jsAst.FunctionDeclaration(
-        new jsAst.VariableDeclaration('generateAccessor'),
-        fun);
+        return field;
+      }''');
   }
 
   List get defineClassFunction {
     // First the class name, then the field names in an array and the members
     // (inside an Object literal).
     // The caller can also pass in the constructor as a function if needed.
     //
     // Example:
     // defineClass("A", ["x", "y"], {
     //  foo$1: function(y) {
@@ skipping 68 matching lines @@
     //  - it contains all (local) members.
     //  - its internal prototype (__proto__) points to the superclass'
     //    prototype field.
     //  - the prototype's constructor field points to the JavaScript
     //    constructor.
     // For engines where we have access to the '__proto__' we can manipulate
     // the object literal directly. For other engines we have to create a new
     // object and copy over the members.
 
     String reflectableField = namer.reflectableField;
-    List<jsAst.Node> statements = [
-      js('var pendingClasses = {}'),
-      js.if_('!init.allClasses', js('init.allClasses = {}')),
-      js('var allClasses = init.allClasses'),
 
-      optional(
-          DEBUG_FAST_OBJECTS,
-          js('print("Number of classes: "'
-             r' + Object.getOwnPropertyNames($$).length)')),
+    return js('''
+      function(collectedClasses, isolateProperties, existingIsolateProperties) {
+        var pendingClasses = {};
+        if (!init.allClasses) init.allClasses = {};
+        var allClasses = init.allClasses;
 
-      js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
+        if (#)  // DEBUG_FAST_OBJECTS
+          print("Number of classes: " +
+              Object.getOwnPropertyNames(\$\$).length);
 
-      js.if_('typeof dart_precompiled == "function"',
-          [js('var constructors = dart_precompiled(collectedClasses)')],
+        var hasOwnProperty = Object.prototype.hasOwnProperty;
 
-          [js('var combinedConstructorFunction = "function \$reflectable(fn){'
-              'fn.$reflectableField=1;return fn};\\n"+ "var \$desc;\\n"'),
-           js('var constructorsList = []')]),
-      js.forIn('cls', 'collectedClasses', [
-        js.if_('hasOwnProperty.call(collectedClasses, cls)', [
-          js('var desc = collectedClasses[cls]'),
-          js.if_('desc instanceof Array', js('desc = desc[1]')),
+        if (typeof dart_precompiled == "function") {

[floitsch, 2014/04/22 16:11:18]

Not this CL, but I think this is a compile-time constant too ("are we in csp
mode?").

[sra1, 2014/04/23 02:33:50]

I'm not sure because the csp stuff is appended.
It would certainly be nice to get rid of it on none-csp programs.

+          var constructors = dart_precompiled(collectedClasses);
+        } else {
+          var combinedConstructorFunction =
+             "function \$reflectable(fn){fn.$reflectableField=1;return fn};\\n"+
+             "var \$desc;\\n";
+          var constructorsList = [];
+        }
 
-          /* The 'fields' are either a constructor function or a
-           * string encoding fields, constructor and superclass.  Get
-           * the superclass and the fields in the format
-           *   '[name/]Super;field1,field2'
-           * from the CLASS_DESCRIPTOR_PROPERTY property on the descriptor.
-           * The 'name/' is optional and contains the name that should be used
-           * when printing the runtime type string.  It is used, for example, to
-           * print the runtime type JSInt as 'int'.
-           */
-           js('var classData = desc["${namer.classDescriptorProperty}"], '
-              'supr, name = cls, fields = classData'),
-          optional(
-              backend.hasRetainedMetadata,
-              js.if_('typeof classData == "object" && '
-                     'classData instanceof Array',
-                     [js('classData = fields = classData[0]')])),
+        for (var cls in collectedClasses) {
+          if (hasOwnProperty.call(collectedClasses, cls)) {
+            var desc = collectedClasses[cls];
+            if (desc instanceof Array) desc = desc[1];
 
-          js.if_('typeof classData == "string"', [
-            js('var split = classData.split("/")'),
-            js.if_('split.length == 2', [
-              js('name = split[0]'),
-              js('fields = split[1]')
-            ])
-          ]),
+            /* The 'fields' are either a constructor function or a
+             * string encoding fields, constructor and superclass.  Get
+             * the superclass and the fields in the format
+             *   '[name/]Super;field1,field2'
+             * from the CLASS_DESCRIPTOR_PROPERTY property on the descriptor.
+             * The 'name/' is optional and contains the name that should be used
+             * when printing the runtime type string.  It is used, for example,
+             * to print the runtime type JSInt as 'int'.
+             */
+            var classData = desc["${namer.classDescriptorProperty}"],
+                supr, name = cls, fields = classData;
+            if (#)  // backend.hasRetainedMetadata
+              if (typeof classData == "object" &&
+                  classData instanceof Array) {
+                classData = fields = classData[0];
+              }
+            if (typeof classData == "string") {
+              var split = classData.split("/");
+              if (split.length == 2) {
+                name = split[0];
+                fields = split[1];
+              }
+            }
 
-          js('var s = fields.split(";")'),
-          js('fields = s[1] == "" ? [] : s[1].split(",")'),
-          js('supr = s[0]'),
-          js('split = supr.split(":")'),
-          js.if_('split.length == 2', [
-            js('supr = split[0]'),
-            js('var functionSignature = split[1]'),
-            js.if_('functionSignature',
-                js('desc.\$signature = #',
-                   js.fun('s',
-                       js.return_(js.fun([], js.return_('init.metadata[s]'))))(
-                           js('functionSignature'))))
-          ]),
+            var s = fields.split(";");
+            fields = s[1] == "" ? [] : s[1].split(",");
+            supr = s[0];
+            split = supr.split(":");
+            if (split.length == 2) {
+              supr = split[0];
+              var functionSignature = split[1];
+              if (functionSignature)
+                desc.\$signature = (function(s) {
+                    return function(){ return init.metadata[s]; };
+                  })(functionSignature);
+            }
 
-          optional(needsMixinSupport, js.if_('supr && supr.indexOf("+") > 0', [
-            js('s = supr.split("+")'),
-            js('supr = s[0]'),
-            js('var mixin = collectedClasses[s[1]]'),
-            js.if_('mixin instanceof Array', js('mixin = mixin[1]')),
-            js.forIn('d', 'mixin', [
-              js.if_('hasOwnProperty.call(mixin, d)'
-                     '&& !hasOwnProperty.call(desc, d)',
-                js('desc[d] = mixin[d]'))
-            ]),
-          ])),
+            if (#)  // needsMixinSupport
+              if (supr && supr.indexOf("+") > 0) {
+                s = supr.split("+");
+                supr = s[0];
+                var mixin = collectedClasses[s[1]];
+                if (mixin instanceof Array) mixin = mixin[1];
+                for(var d in mixin) {
+                  if (hasOwnProperty.call(mixin, d) &&
+                      !hasOwnProperty.call(desc, d))
+                    desc[d] = mixin[d];
+                }
+              }
 
-          js.if_('typeof dart_precompiled != "function"',
-              [js('combinedConstructorFunction +='
-                  ' defineClass(name, cls, fields)'),
-                 js('constructorsList.push(cls)')]),
-          js.if_('supr', js('pendingClasses[cls] = supr'))
-        ])
-      ]),
-      js.statement('''
-          if (typeof dart_precompiled != "function") {
-            combinedConstructorFunction +=
-               "return [\\n  " + constructorsList.join(",\\n  ") + "\\n]";
-             var constructors =
-              new Function("\$collectedClasses", combinedConstructorFunction)
-              (collectedClasses);
-            combinedConstructorFunction = null;
-          }'''),
-      js.for_('var i = 0', 'i < constructors.length', 'i++', [
-        js('var constructor = constructors[i]'),
-        js('var cls = constructor.name'),
-        js('var desc = collectedClasses[cls]'),
-        js('var globalObject = isolateProperties'),
-        js.if_('desc instanceof Array', [
-            js('globalObject = desc[0] || isolateProperties'),
-            js('desc = desc[1]')
-        ]),
-        optional(backend.isTreeShakingDisabled,
-                 js('constructor["${namer.metadataField}"] = desc')),
-        js('allClasses[cls] = constructor'),
-        js('globalObject[cls] = constructor'),
-      ]),
-      js('constructors = null'),
+            if (typeof dart_precompiled != "function") {
+              combinedConstructorFunction += defineClass(name, cls, fields);
+              constructorsList.push(cls);
+            }
+            if (supr) pendingClasses[cls] = supr;
+          }
+        }
 
-      js('var finishedClasses = {}'),
-      js('init.interceptorsByTag = Object.create(null)'),
-      js('init.leafTags = {}'),
+        if (typeof dart_precompiled != "function") {
+          combinedConstructorFunction +=
+             "return [\\n  " + constructorsList.join(",\\n  ") + "\\n]";
+           var constructors =
+            new Function("\$collectedClasses", combinedConstructorFunction)
+            (collectedClasses);
+          combinedConstructorFunction = null;
+        }
 
-      buildFinishClass(),
-    ];
+        for (var i = 0; i < constructors.length; i++) {
+          var constructor = constructors[i];
+          var cls = constructor.name;
+          var desc = collectedClasses[cls];
+          var globalObject = isolateProperties;
+          if (desc instanceof Array) {
+            globalObject = desc[0] || isolateProperties;
+            desc = desc[1];
+          }
+          if (#) //backend.isTreeShakingDisabled,
+            constructor["${namer.metadataField}"] = desc;
+          allClasses[cls] = constructor;
+          globalObject[cls] = constructor;
+        }
 
-    nsmEmitter.addTrivialNsmHandlers(statements);
+        constructors = null;
 
-    statements.add(
-        js.statement('for (var cls in pendingClasses) finishClass(cls);')
-    );
+        var finishedClasses = {};
+        init.interceptorsByTag = Object.create(null);
+        init.leafTags = {};
 
-    // function(collectedClasses,
-    //          isolateProperties,
-    //          existingIsolateProperties)
-    return js.fun(['collectedClasses', 'isolateProperties',
-                   'existingIsolateProperties'], statements);
+        #;  // buildFinishClass(),
+
+        #;  // buildTrivialNsmHandlers()
+
+        for (var cls in pendingClasses) finishClass(cls);
+      }''', [
+          DEBUG_FAST_OBJECTS, 
+          backend.hasRetainedMetadata,
+          needsMixinSupport,
+          backend.isTreeShakingDisabled,
+          buildFinishClass(),
+          nsmEmitter.buildTrivialNsmHandlers()]);
+ 
   }
 
   jsAst.Node optional(bool condition, jsAst.Node node) {
     return condition ? node : new jsAst.EmptyStatement();
   }
 
   jsAst.FunctionDeclaration buildFinishClass() {
     String specProperty = '"${namer.nativeSpecProperty}"';  // "%"
 
-    // function finishClass(cls) {
-    jsAst.Fun fun = js.fun(['cls'], [
+    return js.statement('''
+      function finishClass(cls) {
 
-      // TODO(8540): Remove this work around.
-      /* Opera does not support 'getOwnPropertyNames'. Therefore we use
-         hasOwnProperty instead. */
-      js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
+        // TODO(8540): Remove this work around.
+        // Opera does not support 'getOwnPropertyNames'. Therefore we use
+        //   hasOwnProperty instead.
+        var hasOwnProperty = Object.prototype.hasOwnProperty;
 
-      // if (hasOwnProperty.call(finishedClasses, cls)) return;
-      js.if_('hasOwnProperty.call(finishedClasses, cls)',
-             js.return_()),
+        if (hasOwnProperty.call(finishedClasses, cls)) return;
 
-      js('finishedClasses[cls] = true'),
+        finishedClasses[cls] = true;
 
-      js('var superclass = pendingClasses[cls]'),
+        var superclass = pendingClasses[cls];
 
-      // The superclass is only false (empty string) for Dart's Object class.
-      // The minifier together with noSuchMethod can put methods on the
-      // Object.prototype object, and they show through here, so we check that
-      // we have a string.
-      js.if_('!superclass || typeof superclass != "string"', js.return_()),
-      js('finishClass(superclass)'),
-      js('var constructor = allClasses[cls]'),
-      js('var superConstructor = allClasses[superclass]'),
+        // The superclass is only false (empty string) for the Dart Object
+        // class.  The minifier together with noSuchMethod can put methods on
+        // the Object.prototype object, and they show through here, so we check
+        // that we have a string.
+        if (!superclass || typeof superclass != "string") return;
+        finishClass(superclass);
+        var constructor = allClasses[cls];
+        var superConstructor = allClasses[superclass];
 
-      js.if_(js('!superConstructor'),
-             js('superConstructor ='
-                    'existingIsolateProperties[superclass]')),
+        if (!superConstructor)
+          superConstructor = existingIsolateProperties[superclass];
 
-      js('var prototype = inheritFrom(constructor, superConstructor)'),
+        var prototype = inheritFrom(constructor, superConstructor);
 
-      optional(!nativeClasses.isEmpty,
+        if (#) {  // !nativeClasses.isEmpty,
           // The property looks like this:
           //
           // HtmlElement: {
           //     "%": "HTMLDivElement|HTMLAnchorElement;HTMLElement;FancyButton"
           //
           // The first two semicolon-separated parts contain dispatch tags, the
           // third contains the JavaScript names for classes.
           //
           // The tags indicate that JavaScript objects with the dispatch tags
           // (usually constructor names) HTMLDivElement, HTMLAnchorElement and
           // HTMLElement all map to the Dart native class named HtmlElement.
           // The first set is for effective leaf nodes in the hierarchy, the
           // second set is non-leaf nodes.
           //
           // The third part contains the JavaScript names of Dart classes that
           // extend the native class. Here, FancyButton extends HtmlElement, so
           // the runtime needs to know that window.HTMLElement.prototype is the
           // prototype that needs to be extended in creating the custom element.
           //
           // The information is used to build tables referenced by
           // getNativeInterceptor and custom element support.
-          js.if_('hasOwnProperty.call(prototype, $specProperty)', [
-              js('var nativeSpec = prototype[$specProperty].split(";")'),
-              js.if_('nativeSpec[0]', [
-                  js('var tags = nativeSpec[0].split("|")'),
-                  js.for_('var i = 0', 'i < tags.length', 'i++', [
-                      js('init.interceptorsByTag[tags[i]] = constructor'),
-                      js('init.leafTags[tags[i]] = true')])]),
-              js.if_('nativeSpec[1]', [
-                  js('tags = nativeSpec[1].split("|")'),
-                  optional(true, // User subclassing of native classes?
-                      js.if_('nativeSpec[2]', [
-                          js('var subclasses = nativeSpec[2].split("|")'),
-                          js.for_('var i = 0', 'i < subclasses.length', 'i++', [
-                              js('var subclass = allClasses[subclasses[i]]'),
-                              js('subclass.\$nativeSuperclassTag = '
-                                 'tags[0]')])])),
-                  js.for_('i = 0', 'i < tags.length', 'i++', [
-                      js('init.interceptorsByTag[tags[i]] = constructor'),
-                      js('init.leafTags[tags[i]] = false')])])]))
-    ]);
-
-    return new jsAst.FunctionDeclaration(
-        new jsAst.VariableDeclaration('finishClass'),
-        fun);
+          if (hasOwnProperty.call(prototype, $specProperty)) {
+            var nativeSpec = prototype[$specProperty].split(";");
+            if (nativeSpec[0]) {
+              var tags = nativeSpec[0].split("|");
+              for (var i = 0; i < tags.length; i++) {
+                init.interceptorsByTag[tags[i]] = constructor;
+                init.leafTags[tags[i]] = true;
+              }
+            }
+            if (nativeSpec[1]) {
+              tags = nativeSpec[1].split("|");
+              if (#) {  // User subclassing of native classes?
+                if (nativeSpec[2]) {
+                  var subclasses = nativeSpec[2].split("|");
+                  for (var i = 0; i < subclasses.length; i++) {
+                    var subclass = allClasses[subclasses[i]];
+                    subclass.\$nativeSuperclassTag = tags[0];
+                  }
+                }
+                for (i = 0; i < tags.length; i++) {
+                  init.interceptorsByTag[tags[i]] = constructor;
+                  init.leafTags[tags[i]] = false;
+                }
+              }
+            }
+          }
+        }
+      }''', [!nativeClasses.isEmpty, true]);
   }
 
   jsAst.Fun get finishIsolateConstructorFunction {
     // We replace the old Isolate function with a new one that initializes
     // all its fields with the initial (and often final) value of all globals.
     //
     // We also copy over old values like the prototype, and the
     // isolateProperties themselves.
     return js('''
       function (oldIsolate) {
         var isolateProperties = oldIsolate.${namer.isolatePropertiesName};
         function Isolate() {
           var hasOwnProperty = Object.prototype.hasOwnProperty;
           for (var staticName in isolateProperties)
             if (hasOwnProperty.call(isolateProperties, staticName))
               this[staticName] = isolateProperties[staticName];
           // Use the newly created object as prototype. In Chrome,
           // this creates a hidden class for the object and makes
           // sure it is fast to access.
           function ForceEfficientMap() {}
           ForceEfficientMap.prototype = this;
           new ForceEfficientMap();
         }
         Isolate.prototype = oldIsolate.prototype;
         Isolate.prototype.constructor = Isolate;
         Isolate.${namer.isolatePropertiesName} = isolateProperties;
-        #
-        #
+        if (#)
+          Isolate.$finishClassesProperty = oldIsolate.$finishClassesProperty;
+        if (#)
+          Isolate.makeConstantList = oldIsolate.makeConstantList;
         return Isolate;
       }''',
-      [ optional(needsDefineClass,
-            js('Isolate.$finishClassesProperty ='
-               ' oldIsolate.$finishClassesProperty')),
-        optional(hasMakeConstantList,
-            js('Isolate.makeConstantList = oldIsolate.makeConstantList'))
-      ]);
+        [ needsDefineClass, hasMakeConstantList ]);
   }
 
   jsAst.Fun get lazyInitializerFunction {
-    // function(prototype, staticName, fieldName, getterName, lazyValue) {
-    var parameters = <String>['prototype', 'staticName', 'fieldName',
-                              'getterName', 'lazyValue'];
-    return js.fun(parameters, addLazyInitializerLogic());
-  }
-
-  List addLazyInitializerLogic() {
     String isolate = namer.currentIsolate;
     String cyclicThrow = namer.isolateAccess(backend.getCyclicThrowHelper());
-    var lazies = [];
-    if (backend.rememberLazies) {
-      lazies = [
-          js.if_('!init.lazies', js('init.lazies = {}')),
-          js('init.lazies[fieldName] = getterName')];
-    }
 
-    return lazies..addAll([
-      js('var sentinelUndefined = {}'),
-      js('var sentinelInProgress = {}'),
-      js('prototype[fieldName] = sentinelUndefined'),
+    return js('''
+      function (prototype, staticName, fieldName, getterName, lazyValue) {
+        if (#) {
+          if (!init.lazies) init.lazies = {};
+          init.lazies[fieldName] = getterName;
+        }
 
-      // prototype[getterName] = function()
-      js('prototype[getterName] = #', js.fun([], [
-        js('var result = $isolate[fieldName]'),
+        var sentinelUndefined = {};
+        var sentinelInProgress = {};
+        prototype[fieldName] = sentinelUndefined;
 
-        // try
-        js.try_([
-          js.if_('result === sentinelUndefined', [
-            js('$isolate[fieldName] = sentinelInProgress'),
+        prototype[getterName] = function () {
+          var result = $isolate[fieldName];
+          try {
+            if (result === sentinelUndefined) {
+              $isolate[fieldName] = sentinelInProgress;
 
-            // try
-            js.try_([
-              js('result = $isolate[fieldName] = lazyValue()'),
+              try {
+                result = $isolate[fieldName] = lazyValue();
+              } finally {
+                // Use try-finally, not try-catch/throw as it destroys the
+                // stack trace.
+                if (result === sentinelUndefined)
+                  if ($isolate[fieldName] === sentinelInProgress)
+                    $isolate[fieldName] = null;
+              }
+            } else {
+              if (result === sentinelInProgress)
+                $cyclicThrow(staticName);
+            }
 
-            ], finallyPart: [
-              // Use try-finally, not try-catch/throw as it destroys the
-              // stack trace.
-
-              // if (result === sentinelUndefined)
-              js.if_('result === sentinelUndefined', [
-                // if ($isolate[fieldName] === sentinelInProgress)
-                js.if_('$isolate[fieldName] === sentinelInProgress', [
-                  js('$isolate[fieldName] = null'),
-                ])
-              ])
-            ])
-          ], /* else */ [
-            js.if_('result === sentinelInProgress',
-              js('$cyclicThrow(staticName)')
-            )
-          ]),
-
-          // return result;
-          js.return_('result')
-
-        ], finallyPart: [
-          js('$isolate[getterName] = #',
-             js.fun([], [js.return_('this[fieldName]')]))
-        ])
-      ]))
-    ]);
+            return result;
+          } finally {
+            $isolate[getterName] = function() { return this[fieldName]; };
+          }
+        }
+      }
+    ''', [backend.rememberLazies]);
   }
 
   List buildDefineClassAndFinishClassFunctionsIfNecessary() {
     if (!needsDefineClass) return [];
     return defineClassFunction
     ..addAll(buildInheritFrom())
     ..addAll([
       js('$finishClassesName = #', finishClassesFunction)
     ]);
   }
 
   List buildLazyInitializerFunctionIfNecessary() {
     if (!needsLazyInitializer) return [];
 
-    return [js('$lazyInitializerName = #', lazyInitializerFunction)];
+    return [js('# = #', [js(lazyInitializerName), lazyInitializerFunction])];

[floitsch, 2014/04/22 16:11:18]

lazyInitializerName is a string. Do you have to run it through "js" first?

[sra1, 2014/04/23 02:33:50]

It is a String, but it is not an identifier: "Isolate.$lazy"
We should probably replace lazyInitializerName with lazyInitializerFunction (an
Expression).

   }
 
   List buildFinishIsolateConstructor() {
     return [
       js('$finishIsolateConstructorName = #', finishIsolateConstructorFunction)
     ];
   }
 
   void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
     String isolate = namer.isolateName;
@@ skipping 111 matching lines @@
 
   String namedParametersAsReflectionNames(Selector selector) {
     if (selector.getOrderedNamedArguments().isEmpty) return '';
     String names = selector.getOrderedNamedArguments().join(':');
     return ':$names';
   }
 
   jsAst.FunctionDeclaration buildPrecompiledFunction() {
     // TODO(ahe): Compute a hash code.
     String name = 'dart_precompiled';
-
-    precompiledFunction.add(
-        js.return_(
-            new jsAst.ArrayInitializer.from(precompiledConstructorNames)));
-    precompiledFunction.insert(0, js(r'var $desc'));
-    return new jsAst.FunctionDeclaration(
-        new jsAst.VariableDeclaration(name),
-        js.fun([r'$collectedClasses'], precompiledFunction));
+    return js.statement('''

[floitsch, 2014/04/22 16:11:18]

This should not be cached.
Write TODO, that this should only be cached when declaration names are allowed
with #.

[sra1, 2014/04/23 02:33:50]

The name is dart_precompiled, from the previous line :-)
I'll substitute to make it obvious, since it is written out in other places.

+      function $name(\$collectedClasses) {
+        var \$desc;
+        #;
+        return #;
+      }''', [
+          precompiledFunction,
+          new jsAst.ArrayInitializer.from(precompiledConstructorNames)]);
   }
 
   void generateClass(ClassElement classElement, ClassBuilder properties) {
     compiler.withCurrentElement(classElement, () {
       classEmitter.generateClass(
           classElement, properties, additionalProperties[classElement]);
     });
   }
 
   /**
@@ skipping 70 matching lines @@
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
       // [:interceptedNames:] is handled in [emitInterceptedNames].
       if (element == backend.interceptedNames) continue;
       // `mapTypeToInterceptor` is handled in [emitMapTypeToInterceptor].
       if (element == backend.mapTypeToInterceptor) continue;
       compiler.withCurrentElement(element, () {
         Constant initialValue = handler.getInitialValueFor(element);
         jsAst.Expression init =
-          js('$isolateProperties.${namer.getNameOfGlobalField(element)} = #',
-              constantEmitter.referenceInInitializationContext(initialValue));
+          js('$isolateProperties.# = #',
+              [namer.getNameOfGlobalField(element),
+               constantEmitter.referenceInInitializationContext(initialValue)]);
         buffer.write(jsAst.prettyPrint(init, compiler));
         buffer.write('$N');
       });
     }
   }
 
   void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
     JavaScriptConstantCompiler handler = backend.constants;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (!lazyFields.isEmpty) {
       needsLazyInitializer = true;
       for (VariableElement element in Elements.sortedByPosition(lazyFields)) {
         jsAst.Expression code = backend.generatedCode[element];
         // The code is null if we ended up not needing the lazily
         // initialized field after all because of constant folding
         // before code generation.
         if (code == null) continue;
         // The code only computes the initial value. We build the lazy-check
         // here:
         //   lazyInitializer(prototype, 'name', fieldName, getterName, initial);
         // The name is used for error reporting. The 'initial' must be a
         // closure that constructs the initial value.
-        List<jsAst.Expression> arguments = <jsAst.Expression>[];
-        arguments.add(js(isolateProperties));
-        arguments.add(js.string(element.name));
-        arguments.add(js.string(namer.getNameX(element)));
-        arguments.add(js.string(namer.getLazyInitializerName(element)));
-        arguments.add(code);
         jsAst.Expression getter = buildLazyInitializedGetter(element);
-        if (getter != null) {
-          arguments.add(getter);
-        }
-        jsAst.Expression init = js(lazyInitializerName)(arguments);
+        jsAst.Expression init = js('#(#,#,#,#,#,#)',
+            [js(lazyInitializerName),

[floitsch, 2014/04/22 16:11:18]

lazyInitializerName is a String. Why do we need to run it through "js" ?

[sra1, 2014/04/23 02:33:50]

It is "Isolate.$lazy"

Only strings in the form of an identifier are allowed.  We don't want the
template substitution to have to decide if a complex expression should be
cached.

+                js(isolateProperties),
+                js.string(element.name),
+                js.string(namer.getNameX(element)),
+                js.string(namer.getLazyInitializerName(element)),
+                code,
+                getter == null ? [] : [getter]]);
         buffer.write(jsAst.prettyPrint(init, compiler));
         buffer.write("$N");
       }
     }
   }
 
   jsAst.Expression buildLazyInitializedGetter(VariableElement element) {
     // Nothing to do, the 'lazy' function will create the getter.
     return null;
   }
@@ skipping 14 matching lines @@
           && constantUnit == null) {
         // The back-end introduces some constants, like "InterceptorConstant" or
         // some list constants. They are emitted in the main output-unit, and
         // ignored otherwise.
         // TODO(sigurdm): We should track those constants.
         continue;
       }
 
       String name = namer.constantName(constant);
       if (constant.isList) emitMakeConstantListIfNotEmitted(buffer);
-      jsAst.Expression init = js(
-          '${namer.globalObjectForConstant(constant)}.$name = #',
-          constantInitializerExpression(constant));
+      jsAst.Expression init = js('#.# = #',
+          [namer.globalObjectForConstant(constant), name,
+           constantInitializerExpression(constant)]);
       buffer.write(jsAst.prettyPrint(init, compiler));
       buffer.write('$N');
     }
   }
 
   bool isConstantInlinedOrAlreadyEmitted(Constant constant) {
     if (constant.isFunction) return true;    // Already emitted.
     if (constant.isPrimitive) return true;   // Inlined.
     if (constant.isDummy) return true;       // Inlined.
     // The name is null when the constant is already a JS constant.
@@ skipping 243 matching lines @@
       } else {
         outputClassLists.putIfAbsent(
             compiler.deferredLoadTask.outputUnitForElement(element),
             () => new List<ClassElement>())
             .add(element);
       }
     }
   }
 
   void emitInitFunction(CodeBuffer buffer) {
-    jsAst.Fun fun = js.fun([], [
-      js('$isolateProperties = {}'),
-    ]
-    ..addAll(buildDefineClassAndFinishClassFunctionsIfNecessary())
-    ..addAll(buildLazyInitializerFunctionIfNecessary())
-    ..addAll(buildFinishIsolateConstructor())
-    );
-    jsAst.FunctionDeclaration decl = new jsAst.FunctionDeclaration(
-        new jsAst.VariableDeclaration('init'), fun);
+    jsAst.FunctionDeclaration decl = js.statement('''
+      function init() {
+        $isolateProperties = {};
+        #; #; #;
+      }''', [
+          buildDefineClassAndFinishClassFunctionsIfNecessary(),
+          buildLazyInitializerFunctionIfNecessary(),
+          buildFinishIsolateConstructor()]);
+
     buffer.write(jsAst.prettyPrint(decl, compiler).getText());
     if (compiler.enableMinification) buffer.write('\n');
   }
 
   void emitConvertToFastObjectFunction() {
     // Create an instance that uses 'properties' as prototype. This should make
     // 'properties' a fast object.
     mainBuffer.add(r'''function convertToFastObject(properties) {
   function MyClass() {};
   MyClass.prototype = properties;
@@ skipping 166 matching lines @@
           var keys = mangledFieldNames.keys.toList();
           keys.sort();
           var properties = [];
           for (String key in keys) {
             var value = js.string('${mangledFieldNames[key]}');
             properties.add(new jsAst.Property(js.string(key), value));
           }
           var map = new jsAst.ObjectInitializer(properties);
           mainBuffer.write(
               jsAst.prettyPrint(
-                  js('init.mangledNames = #', map).toStatement(), compiler));
+                  js.statement('init.mangledNames = #', map), compiler));
           if (compiler.enableMinification) {
             mainBuffer.write(';');
           }
         }
         if (!mangledGlobalFieldNames.isEmpty) {
           var keys = mangledGlobalFieldNames.keys.toList();
           keys.sort();
           var properties = [];
           for (String key in keys) {
             var value = js.string('${mangledGlobalFieldNames[key]}');
             properties.add(new jsAst.Property(js.string(key), value));
           }
           var map = new jsAst.ObjectInitializer(properties);
           mainBuffer.write(
               jsAst.prettyPrint(
-                  js('init.mangledGlobalNames = #', map).toStatement(),
+                  js.statement('init.mangledGlobalNames = #', map),
                   compiler));
           if (compiler.enableMinification) {
             mainBuffer.write(';');
           }
         }
         mainBuffer
             ..write('(')
             ..write(
                 jsAst.prettyPrint(
                     getReflectionDataParser(classesCollector, backend),
@@ skipping 310 matching lines @@
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
   void registerReadTypeVariable(TypeVariableElement element) {
     readTypeVariables.add(element);
   }
 }