Redo "Add more MiniJsParser functionality."

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 252 matching lines @@
     // defineClassFunction (it's a local declaration in init()).
     return [
         generateAccessorFunction,
         js('$generateAccessorHolder = generateAccessor'),
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('defineClass'), defineClass) ];
   }
 
   /** Needs defineClass to be defined. */
   List buildInheritFrom() {
-    return [
-      js('var inheritFrom = #',
-          js.fun([], [
-              new jsAst.FunctionDeclaration(
-                  new jsAst.VariableDeclaration('tmp'), js.fun([], [])),
-              js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
-              js.return_(js.fun(['constructor', 'superConstructor'], [
-                  js('tmp.prototype = superConstructor.prototype'),
-                  js('var object = new tmp()'),
-                  js('var properties = constructor.prototype'),
-                  js.forIn('member', 'properties',
-                    js.if_('hasOwnProperty.call(properties, member)',
-                           js('object[member] = properties[member]'))),
-                  js('object.constructor = constructor'),
-                  js('constructor.prototype = object'),
-                  js.return_('object')
-              ]))])())];
+    return [js(r'''
+        var inheritFrom = function() {
+          function tmp() {}
+          var hasOwnProperty = Object.prototype.hasOwnProperty;
+          return function (constructor, superConstructor) {
+            tmp.prototype = superConstructor.prototype;
+            var object = new tmp();
+            var properties = constructor.prototype;
+            for (var member in properties)
+              if (hasOwnProperty.call(properties, member))
+                object[member] = properties[member];
+            object.constructor = constructor;
+            constructor.prototype = object;
+            return object;
+          };
+        }()
+      ''')];
   }
 
   jsAst.Fun get finishClassesFunction {
     // Class descriptions are collected in a JS object.
     // 'finishClasses' takes all collected descriptions and sets up
     // the prototype.
     // Once set up, the constructors prototype field satisfy:
     //  - it contains all (local) members.
     //  - its internal prototype (__proto__) points to the superclass'
     //    prototype field.
@@ skipping 78 matching lines @@
             ]),
           ])),
 
           js.if_('typeof dart_precompiled != "function"',
               [js('combinedConstructorFunction +='
                   ' defineClass(name, cls, fields)'),
                  js('constructorsList.push(cls)')]),
           js.if_('supr', js('pendingClasses[cls] = supr'))
         ])
       ]),
-      js.if_('typeof dart_precompiled != "function"',
-          [js('combinedConstructorFunction +='
-              ' "return [\\n  " + constructorsList.join(",\\n  ") + "\\n]"'),
-           js('var constructors ='
-              ' new Function("\$collectedClasses", combinedConstructorFunction)'
-              '(collectedClasses)'),
-           js('combinedConstructorFunction = null')]),
+      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'),
 
       js('var finishedClasses = {}'),
       js('init.interceptorsByTag = Object.create(null)'),
       js('init.leafTags = {}'),
 
       buildFinishClass(),
     ];
 
     nsmEmitter.addTrivialNsmHandlers(statements);
 
     statements.add(
-      js.forIn('cls', 'pendingClasses', js('finishClass(cls)'))
+        js.statement('for (var cls in pendingClasses) finishClass(cls);')
     );
+
     // function(collectedClasses,
     //          isolateProperties,
     //          existingIsolateProperties)
     return js.fun(['collectedClasses', 'isolateProperties',
                    'existingIsolateProperties'], statements);
   }
 
   jsAst.Node optional(bool condition, jsAst.Node node) {
     return condition ? node : new jsAst.EmptyStatement();
   }
@@ skipping 79 matching lines @@
         new jsAst.VariableDeclaration('finishClass'),
         fun);
   }
 
   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.fun('oldIsolate', [
-      js('var isolateProperties = oldIsolate.${namer.isolatePropertiesName}'),
-      new jsAst.FunctionDeclaration(
-        new jsAst.VariableDeclaration('Isolate'),
-          js.fun([], [
-            js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
-            js.forIn('staticName', 'isolateProperties',
-              js.if_('hasOwnProperty.call(isolateProperties, staticName)',
-                js('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.
-            new jsAst.FunctionDeclaration(
-              new jsAst.VariableDeclaration('ForceEfficientMap'),
-              js.fun([], [])),
-            js('ForceEfficientMap.prototype = this'),
-            js('new ForceEfficientMap()')])),
-      js('Isolate.prototype = oldIsolate.prototype'),
-      js('Isolate.prototype.constructor = Isolate'),
-      js('Isolate.${namer.isolatePropertiesName} = isolateProperties'),
-      optional(needsDefineClass,
-               js('Isolate.$finishClassesProperty ='
-                  ' oldIsolate.$finishClassesProperty')),
-      optional(hasMakeConstantList,
-               js('Isolate.makeConstantList = oldIsolate.makeConstantList')),
-      js.return_('Isolate')]);
+    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;
+        #
+        #
+        return Isolate;
+      }''',
+      [ optional(needsDefineClass,
+            js('Isolate.$finishClassesProperty ='
+               ' oldIsolate.$finishClassesProperty')),
+        optional(hasMakeConstantList,
+            js('Isolate.makeConstantList = oldIsolate.makeConstantList'))
+      ]);
   }
 
   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() {
@@ skipping 427 matching lines @@
     String mainAccess = "${namer.isolateStaticClosureAccess(appMain)}";
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
     return "(function(a){${namer.isolateAccess(isolateMain)}($mainAccess,a)})";
   }
 
   /**
    * Emits code that sets `init.isolateTag` to a unique string.
    */
   jsAst.Expression generateIsolateAffinityTagInitialization() {
-    return js('!#', js.fun([], [
-
+    return js('''
+      !function() {
         // On V8, the 'intern' function converts a string to a symbol, which
         // makes property access much faster.
-        new jsAst.FunctionDeclaration(new jsAst.VariableDeclaration('intern'),
-            js.fun(['s'], [
-                js('var o = {}'),
-                js('o[s] = 1'),
-                js.return_(js('Object.keys(convertToFastObject(o))[0]'))])),
+        function intern(s) {
+          var o = {};
+          o[s] = 1;
+          return Object.keys(convertToFastObject(o))[0];
+        }
 
-
-        js('init.getIsolateTag = #',
-            js.fun(['name'],
-                js.return_('intern("___dart_" + name + init.isolateTag)'))),
+        init.getIsolateTag = function(name) {
+          return intern("___dart_" + name + init.isolateTag);
+        };
 
         // To ensure that different programs loaded into the same context (page)
         // use distinct dispatch properies, we place an object on `Object` to
         // contain the names already in use.
-        js('var tableProperty = "___dart_isolate_tags_"'),
-        js('var usedProperties = Object[tableProperty] ||'
-            '(Object[tableProperty] = Object.create(null))'),
+        var tableProperty = "___dart_isolate_tags_";
+        var usedProperties = Object[tableProperty] ||
+            (Object[tableProperty] = Object.create(null));
 
-        js('var rootProperty = "_${generateIsolateTagRoot()}"'),
-        js.for_('var i = 0', null, 'i++', [
-            js('var property = intern(rootProperty + "_" + i + "_")'),
-            js.if_('!(property in usedProperties)', [
-                js('usedProperties[property] = 1'),
-                js('init.isolateTag = property'),
-                new jsAst.Break(null)])])])
-        ());
-
+        var rootProperty = "_${generateIsolateTagRoot()}";
+        for (var i = 0; ; i++) {
+          var property = intern(rootProperty + "_" + i + "_");
+          if (!(property in usedProperties)) {
+            usedProperties[property] = 1;
+            init.isolateTag = property;
+            break;
+          }
+        }
+      }()
+    ''');
   }
 
   jsAst.Expression generateDispatchPropertyNameInitialization() {
     return js(
         'init.dispatchPropertyName = init.getIsolateTag("dispatch_record")');
   }
 
   String generateIsolateTagRoot() {
     // TODO(sra): MD5 of contributing source code or URIs?
     return 'ZxYxX';
@@ skipping 363 matching lines @@
           var map = new jsAst.ObjectInitializer(properties);
           mainBuffer.write(
               jsAst.prettyPrint(
                   js('init.mangledGlobalNames = #', map).toStatement(),
                   compiler));
           if (compiler.enableMinification) {
             mainBuffer.write(';');
           }
         }
         mainBuffer
-            ..write(getReflectionDataParser(classesCollector, backend))
+            ..write('(')
+            ..write(
+                jsAst.prettyPrint(
+                    getReflectionDataParser(classesCollector, backend),
+                    compiler))
+            ..write(')')
             ..write('([$n');
 
         List<Element> sortedElements =
             Elements.sortedByPosition(elementDescriptors.keys);
 
         Iterable<Element> pendingStatics = sortedElements.where((element) {
             return !element.isLibrary() &&
                 elementDescriptors[element].values.any((descriptor) =>
                     descriptor != null);
         });
@@ skipping 237 matching lines @@
         ..write('var old${namer.currentIsolate}$_='
                 '$_${namer.currentIsolate}$N'
                 // TODO(ahe): This defines a lot of properties on the
                 // Isolate.prototype object.  We know this will turn it into a
                 // slow object in V8, so instead we should do something similar
                 // to Isolate.$finishIsolateConstructor.
                 '${namer.currentIsolate}$_='
                 '$_${namer.isolateName}.prototype$N$n'
                 // The classesCollector object ($$).
                 '$classesCollector$_=$_{};$n')
-        ..write(getReflectionDataParser(classesCollector, backend))
+        ..write('(')
+        ..write(
+            jsAst.prettyPrint(
+                getReflectionDataParser(classesCollector, backend),
+                compiler))
+        ..write(')')
         ..write('([$n')
         ..addBuffer(outputBuffer)
         ..write('])$N');
 
       if (outputClassLists.containsKey(outputUnit)) {
         buffer.write(
             '$finishClassesName($classesCollector,$_${namer.currentIsolate},'
             '$_$isolatePropertiesName)$N');
       }
 
@@ skipping 35 matching lines @@
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
   void registerReadTypeVariable(TypeVariableElement element) {
     readTypeVariables.add(element);
   }
 }