dart2js OldEmitter: inline FinishClasses.

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, 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 OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
 
   final ContainerBuilder containerBuilder = new ContainerBuilder();
   final ClassEmitter classEmitter = new ClassEmitter();
   final NsmEmitter nsmEmitter = new NsmEmitter();
   final TypeTestEmitter typeTestEmitter = new TypeTestEmitter();
   final InterceptorEmitter interceptorEmitter = new InterceptorEmitter();
   final MetadataEmitter metadataEmitter = new MetadataEmitter();
 
   final Set<ConstantValue> cachedEmittedConstants;
   final CodeBuffer cachedEmittedConstantsBuffer = new CodeBuffer();
   final Map<Element, ClassBuilder> cachedClassBuilders;
   final Set<Element> cachedElements;
 
-  bool needsDefineClass = false;
+  bool needsClassSupport = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter get nativeEmitter => task.nativeEmitter;
   TypeTestRegistry get typeTestRegistry => task.typeTestRegistry;
 
   // The full code that is written to each hunk part-file.
   Map<OutputUnit, CodeBuffer> outputBuffers = new Map<OutputUnit, CodeBuffer>();
   final CodeBuffer deferredConstants = new CodeBuffer();
@@ skipping 105 matching lines @@
   jsAst.Expression constantReference(ConstantValue value) {
     return constantEmitter.reference(value);
   }
 
   jsAst.Expression constantInitializerExpression(ConstantValue value) {
     return constantEmitter.initializationExpression(value);
   }
 
   String get name => 'CodeEmitter';
 
-  String get currentGenerateAccessorName
-      => '${namer.currentIsolate}.\$generateAccessor';
-  String get generateAccessorHolder
-      => '$isolatePropertiesName.\$generateAccessor';
-  String get finishClassesProperty
-      => r'$finishClasses';
-  String get finishClassesName
-      => '${namer.isolateName}.$finishClassesProperty';
   String get finishIsolateConstructorName
       => '${namer.isolateName}.\$finishIsolateConstructor';
   String get isolatePropertiesName
       => '${namer.isolateName}.${namer.isolatePropertiesName}';
   String get lazyInitializerProperty
       => r'$lazy';
   String get lazyInitializerName
       => '${namer.isolateName}.${lazyInitializerProperty}';
   String get initName => 'init';
   String get makeConstListProperty
@@ skipping 46 matching lines @@
   }
 
   jsAst.PropertyAccess classAccess(Element element) {
         return globalPropertyAccess(element);
   }
 
   jsAst.PropertyAccess typedefAccess(Element element) {
        return globalPropertyAccess(element);
   }
 
+  List<jsAst.Statement> buildTrivialNsmHandlers(){
+    return nsmEmitter.buildTrivialNsmHandlers();
+  }
+
   jsAst.FunctionDeclaration get generateAccessorFunction {
     const RANGE1_SIZE = RANGE1_LAST - RANGE1_FIRST + 1;
     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";
@@ skipping 105 matching lines @@
           }
           if (#hasIsolateSupport) {
             str += name + ".$fieldNamesProperty=[" + fieldNames + "];\\n";
           }
           str += accessors.join("");
     
           return str;
         }''', { 'hasIsolateSupport': hasIsolateSupport });
 
     // Declare a function called "generateAccessor".  This is used in
-    // defineClassFunction (it's a local declaration in init()).
+    // defineClassFunction.
     List result = <jsAst.Node>[
         generateAccessorFunction,
-        js('$generateAccessorHolder = generateAccessor'),
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('defineClass'), defineClass) ];
 
     if (compiler.hasIncrementalSupport) {
       result.add(
           js(r'#.defineClass = defineClass', [namer.accessIncrementalHelper]));
     }
 
     if (hasIsolateSupport) {
       jsAst.Expression classIdExtractorAccess =
@@ skipping 73 matching lines @@
           };
         }()
       ''');
     if (compiler.hasIncrementalSupport) {
       result = js(
           r'#.inheritFrom = #', [namer.accessIncrementalHelper, result]);
     }
     return js(r'var inheritFrom = #', [result]);
   }
 
-  /// Code that needs to be run before first invocation of
-  /// [finishClassesFunction], but should only be run once.
-  jsAst.Expression get initFinishClasses {
-    jsAst.Expression allClassesAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
-    jsAst.Expression interceptorsByTagAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
-    jsAst.Expression leafTagsAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
-    jsAst.Expression finishedClassesAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
-
-    return js('''
-        (function(){
-         #allClasses = Object.create(null);
-         #interceptorsByTag = Object.create(null);
-         #leafTags = Object.create(null);
-         #finishedClasses = Object.create(null);
-        })()
-      ''', {'allClasses': allClassesAccess,
-            'interceptorsByTag': interceptorsByTagAccess,
-            'leafTags': leafTagsAccess,
-            'finishedClasses': finishedClassesAccess});
-  }
-
-  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.
-    //  - 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;
-    jsAst.Expression allClassesAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
-    jsAst.Expression metadataAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.METADATA);
-    String signaturePropertyName = namer.operatorSignature;
-
-    return js('''
-      function(collectedClasses, isolateProperties, existingIsolateProperties) {
-        var pendingClasses = Object.create(null);
-        var allClasses = #allClasses;
-        var constructors;
-
-        if (#debugFastObjects)
-          print("Number of classes: " +
-              Object.getOwnPropertyNames(\$\$).length);
-
-        var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-        if (#inCspMode) {
-          constructors = dart_precompiled(collectedClasses);
-        }
-
-        if (#notInCspMode) {
-          var combinedConstructorFunction =
-             "function \$reflectable(fn){fn.$reflectableField=1;return fn};\\n"+
-             "var \$desc;\\n";
-          var constructorsList = [];
-        }
-
-        for (var cls in collectedClasses) {
-          var desc = collectedClasses[cls];
-          if (desc instanceof Array) desc = desc[1];
-
-          /* The 'fields' are either a constructor function or a
-           * string encoding fields, constructor and superclass. Gets the
-           * superclass and fields in the format
-           *   'Super;field1,field2'
-           * from the CLASS_DESCRIPTOR_PROPERTY property on the descriptor.
-           */
-          var classData = desc["${namer.classDescriptorProperty}"],
-              supr, fields = classData;
-          if (#hasRetainedMetadata)
-            if (typeof classData == "object" &&
-                classData instanceof Array) {
-              classData = fields = classData[0];
-            }
-          // ${ClassBuilder.fieldEncodingDescription}.
-          var s = fields.split(";");
-          fields = s[1] == "" ? [] : s[1].split(",");
-          supr = s[0];
-          // ${ClassBuilder.functionTypeEncodingDescription}.
-          split = supr.split(":");
-          if (split.length == 2) {
-            supr = split[0];
-            var functionSignature = split[1];
-            if (functionSignature)
-              desc.$signaturePropertyName = (function(s) {
-                  return function(){ return #metadata[s]; };
-                })(functionSignature);
-          }
-
-          if (#notInCspMode) {
-            combinedConstructorFunction += defineClass(cls, fields);
-            constructorsList.push(cls);
-          }
-          if (supr) pendingClasses[cls] = supr;
-        }
-
-        if (#notInCspMode) {
-          combinedConstructorFunction +=
-            "return [\\n  " + constructorsList.join(",\\n  ") + "\\n]";
-          var constructors =
-            new Function("\$collectedClasses", combinedConstructorFunction)
-            (collectedClasses);
-          combinedConstructorFunction = null;
-        }
-
-        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 (#isTreeShakingDisabled)
-            constructor["${namer.metadataField}"] = desc;
-          allClasses[cls] = constructor;
-          globalObject[cls] = constructor;
-        }
-
-        constructors = null;
-
-        #finishClassFunction;
-
-        #trivialNsmHandlers;
-
-        for (var cls in pendingClasses) finishClass(cls);
-      }''', { 'allClasses': allClassesAccess,
-              'debugFastObjects': DEBUG_FAST_OBJECTS,
-              'hasRetainedMetadata': backend.hasRetainedMetadata,
-              'metadata': metadataAccess,
-              'isTreeShakingDisabled': backend.isTreeShakingDisabled,
-              'finishClassFunction': buildFinishClass(),
-              'trivialNsmHandlers': nsmEmitter.buildTrivialNsmHandlers(),
-              'inCspMode': compiler.useContentSecurityPolicy,
-              'notInCspMode': !compiler.useContentSecurityPolicy});
-  }
-
   jsAst.Statement buildFinishClass() {
     String specProperty = '"${namer.nativeSpecProperty}"';  // "%"
 
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
 
     return js.statement('''
     {
       var finishedClasses = #finishedClassesAccess;
 
       function finishClass(cls) {
 
         if (finishedClasses[cls]) return;
         finishedClasses[cls] = true;
 
-        var superclass = pendingClasses[cls];
+        var superclass = processedClasses.pending[cls];
 
         if (#needsMixinSupport) {
           if (superclass && superclass.indexOf("+") > 0) {
             var s = superclass.split("+");
             superclass = s[0];
             var mixinClass = s[1];
             finishClass(mixinClass);
             var mixin = allClasses[mixinClass];
             // TODO(21896): this test shouldn't be necessary. Without it
             // we have a crash in language/mixin_only_for_rti and
@@ skipping 78 matching lines @@
         }
       }
     }''', {'finishedClassesAccess': finishedClassesAccess,
            'needsMixinSupport': needsMixinSupport,
            'hasNativeClasses': nativeClasses.isNotEmpty,
            'interceptorsByTagAccess': interceptorsByTagAccess,
            'leafTagsAccess': leafTagsAccess,
            'allowNativesSubclassing': 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.#isolatePropertiesName;
-        function Isolate() {
-          var hasOwnProperty = Object.prototype.hasOwnProperty;
-          for (var staticName in isolateProperties)
-            if (hasOwnProperty.call(isolateProperties, staticName))
-              this[staticName] = isolateProperties[staticName];
-
-          // Reset lazy initializers to null.
-          // When forcing the object to fast mode (below) v8 will consider
-          // functions as part the object's map. Since we will change them
-          // (after the first call to the getter), we would have a map
-          // transition.
-          var lazies = init.lazies;
-          for (var lazyInit in lazies) {
-             this[lazies[lazyInit]] = null;
-          }
-
-          // 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();
-
-          // Now, after being a fast map we can set the lazies again.
-          for (var lazyInit in lazies) {
-            var lazyInitName = lazies[lazyInit];
-            this[lazyInitName] = isolateProperties[lazyInitName];
-          }
-        }
-        Isolate.prototype = oldIsolate.prototype;
-        Isolate.prototype.constructor = Isolate;
-        Isolate.#isolatePropertiesName = isolateProperties;
-        if (#needsDefineClass)
-          Isolate.#finishClassesProperty = oldIsolate.#finishClassesProperty;
-        if (#outputContainsConstantList)
-          Isolate.#makeConstListProperty = oldIsolate.#makeConstListProperty;
-        if (#hasIncrementalSupport)
-          Isolate.#lazyInitializerProperty =
-              oldIsolate.#lazyInitializerProperty;
-         return Isolate;
-      }
-""",
-        { 'isolatePropertiesName': namer.isolatePropertiesName,
-          'needsDefineClass': needsDefineClass,
-          'finishClassesProperty': finishClassesProperty,
-          'outputContainsConstantList': task.outputContainsConstantList,
-          'makeConstListProperty': makeConstListProperty,
-          'hasIncrementalSupport': compiler.hasIncrementalSupport,
-          'lazyInitializerProperty': lazyInitializerProperty,
-        });
-  }
-
-  jsAst.Fun get lazyInitializerFunction {
-    String isolate = namer.currentIsolate;
-    jsAst.Expression cyclicThrow =
-        staticFunctionAccess(backend.getCyclicThrowHelper());
-    jsAst.Expression laziesAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
-
-    return js('''
-      function (prototype, staticName, fieldName, getterName, lazyValue) {
-        if (!#lazies) #lazies = Object.create(null);
-        #lazies[fieldName] = getterName;
-
-        var sentinelUndefined = {};
-        var sentinelInProgress = {};
-        prototype[fieldName] = sentinelUndefined;
-
-        prototype[getterName] = function () {
-          var result = $isolate[fieldName];
-          try {
-            if (result === sentinelUndefined) {
-              $isolate[fieldName] = sentinelInProgress;
-
-              try {
-                result = $isolate[fieldName] = lazyValue();
-              } finally {
-                // Use try-finally, not try-catch/throw as it destroys the
-                // stack trace.
-                if (result === sentinelUndefined)
-                  $isolate[fieldName] = null;
-              }
-            } else {
-              if (result === sentinelInProgress)
-                #cyclicThrow(staticName);
-            }
-
-            return result;
-          } finally {
-            $isolate[getterName] = function() { return this[fieldName]; };
-          }
-        }
-      }
-    ''', {'lazies': laziesAccess, 'cyclicThrow': cyclicThrow});
-  }
-
-  List buildDefineClassAndFinishClassFunctionsIfNecessary() {
-    if (!needsDefineClass) return [];
-    return defineClassFunction
-        ..add(buildInheritFrom())
-        ..add(js('$finishClassesName = #', finishClassesFunction))
-        ..add(initFinishClasses);
-  }
-
-  List buildLazyInitializerFunctionIfNecessary() {
-    if (!needsLazyInitializer) return [];
-
-    return [js('# = #', [js(lazyInitializerName), lazyInitializerFunction])];
-  }
-
-  List buildFinishIsolateConstructor() {
-    return [
-      js('$finishIsolateConstructorName = #', finishIsolateConstructorFunction)
-    ];
-  }
-
   void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
     String isolate = namer.isolateName;
     buffer.write("$isolate = $finishIsolateConstructorName($isolate)$N");
   }
 
   /// In minified mode we want to keep the name for the most common core types.
   bool _isNativeTypeNeedingReflectionName(Element element) {
     if (!element.isClass) return false;
     return (element == compiler.intClass ||
             element == compiler.doubleClass ||
@@ skipping 154 matching lines @@
         invariant(classElement, builder.functionType == null);
         invariant(classElement, builder.fieldMetadata == null);
         properties.properties.addAll(builder.properties);
       } else {
         classEmitter.generateClass(
             classElement, properties, additionalProperties[classElement]);
       }
     });
   }
 
-  void emitFinishClassesInvocationIfNecessary(CodeBuffer buffer) {
-    if (needsDefineClass) {
-      buffer.write('$finishClassesName($classesCollector,'
-                   '$_$isolateProperties,'
-                   '${_}null)$N');
-
-      // Reset the map.
-      buffer.write("$classesCollector$_=${_}null$N$n");
-    }
-  }
-
   void emitStaticFunctions(List<Element> staticFunctions) {
     for (Element element in staticFunctions) {
       ClassBuilder builder = new ClassBuilder(element, namer);
       containerBuilder.addMember(element, builder);
       getElementDescriptor(element).properties.addAll(builder.properties);
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer,
                                               OutputUnit outputUnit) {
@@ skipping 295 matching lines @@
         'mainCallClosure': mainCallClosure});
 
     buffer.write(';');
     buffer.write(jsAst.prettyPrint(invokeMain,
                  compiler, monitor: compiler.dumpInfoTask));
     buffer.write(N);
     addComment('END invoke [main].', buffer);
   }
 
   void emitInitFunction(CodeBuffer buffer) {
+    String isolate = namer.currentIsolate;
+    jsAst.Expression allClassesAccess =
+        generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
+    jsAst.Expression interceptorsByTagAccess =
+        generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
+    jsAst.Expression leafTagsAccess =
+        generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
+    jsAst.Expression finishedClassesAccess =
+        generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
+    jsAst.Expression cyclicThrow =
+        staticFunctionAccess(backend.getCyclicThrowHelper());
+    jsAst.Expression laziesAccess =
+        generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
+
     jsAst.FunctionDeclaration decl = js.statement('''
       function init() {
         $isolateProperties = Object.create(null);
-        #; #; #;
-      }''', [
-          buildDefineClassAndFinishClassFunctionsIfNecessary(),
-          buildLazyInitializerFunctionIfNecessary(),
-          buildFinishIsolateConstructor()]);
+        (function(){
+         #allClasses = Object.create(null);
+         #interceptorsByTag = Object.create(null);
+         #leafTags = Object.create(null);
+         #finishedClasses = Object.create(null);
+        })();
+
+        if (#needsLazyInitializer) {
+          $lazyInitializerName = function (prototype, staticName, fieldName,
+                                           getterName, lazyValue) {
+            if (!#lazies) #lazies = Object.create(null);
+            #lazies[fieldName] = getterName;
+  
+            var sentinelUndefined = {};
+            var sentinelInProgress = {};
+            prototype[fieldName] = sentinelUndefined;
+  
+            prototype[getterName] = function () {
+              var result = $isolate[fieldName];
+              try {
+                if (result === sentinelUndefined) {
+                  $isolate[fieldName] = sentinelInProgress;
+  
+                  try {
+                    result = $isolate[fieldName] = lazyValue();
+                  } finally {
+                    // Use try-finally, not try-catch/throw as it destroys the
+                    // stack trace.
+                    if (result === sentinelUndefined)
+                      $isolate[fieldName] = null;
+                  }
+                } else {
+                  if (result === sentinelInProgress)
+                    #cyclicThrow(staticName);
+                }
+  
+                return result;
+              } finally {
+                $isolate[getterName] = function() { return this[fieldName]; };
+              }
+            }
+          }
+        }
+
+        // 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.
+        $finishIsolateConstructorName = function (oldIsolate) {
+          var isolateProperties = oldIsolate.#isolatePropertiesName;
+          function Isolate() {
+            var hasOwnProperty = Object.prototype.hasOwnProperty;
+            for (var staticName in isolateProperties)
+              if (hasOwnProperty.call(isolateProperties, staticName))
+                this[staticName] = isolateProperties[staticName];
+
+            // Reset lazy initializers to null.
+            // When forcing the object to fast mode (below) v8 will consider
+            // functions as part the object's map. Since we will change them
+            // (after the first call to the getter), we would have a map
+            // transition.
+            var lazies = init.lazies;
+            for (var lazyInit in lazies) {
+               this[lazies[lazyInit]] = null;
+            }
+
+            // 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();
+
+            // Now, after being a fast map we can set the lazies again.
+            for (var lazyInit in lazies) {
+              var lazyInitName = lazies[lazyInit];
+              this[lazyInitName] = isolateProperties[lazyInitName];
+            }
+          }
+          Isolate.prototype = oldIsolate.prototype;
+          Isolate.prototype.constructor = Isolate;
+          Isolate.#isolatePropertiesName = isolateProperties;
+          if (#outputContainsConstantList) {
+            Isolate.#makeConstListProperty = oldIsolate.#makeConstListProperty;
+          }
+          if (#hasIncrementalSupport) {
+            Isolate.#lazyInitializerProperty =
+                oldIsolate.#lazyInitializerProperty;
+          }
+          return Isolate;
+      }
+        
+      }''', {'allClasses': allClassesAccess,
+            'interceptorsByTag': interceptorsByTagAccess,
+            'leafTags': leafTagsAccess,
+            'finishedClasses': finishedClassesAccess,
+            'needsLazyInitializer': needsLazyInitializer,
+            'lazies': laziesAccess, 'cyclicThrow': cyclicThrow,
+            'isolatePropertiesName': namer.isolatePropertiesName,
+            'outputContainsConstantList': task.outputContainsConstantList,
+            'makeConstListProperty': makeConstListProperty,
+            'hasIncrementalSupport': compiler.hasIncrementalSupport,
+            'lazyInitializerProperty': lazyInitializerProperty,});
 
     buffer.write(jsAst.prettyPrint(decl,
                  compiler, monitor: compiler.dumpInfoTask).getText());
     if (compiler.enableMinification) buffer.write('\n');
   }
 
   void emitConvertToFastObjectFunction() {
     List<jsAst.Statement> debugCode = <jsAst.Statement>[];
     if (DEBUG_FAST_OBJECTS) {
       debugCode.add(js.statement(r'''
@@ skipping 301 matching lines @@
       mainBuffer
         .write('${globalsHolder}.${namer.isolateName}$_=$_'
                '${namer.isolateName}$N'
                '${globalsHolder}.$initName$_=${_}$initName$N');
     }
     mainBuffer.write('init()$N$n');
     mainBuffer.write('$isolateProperties$_=$_$isolatePropertiesName$N');
 
     emitStaticFunctions(task.outputStaticLists[mainOutputUnit]);
 
-    // Only output the classesCollector if we actually have any classes.
-    if (needsDefineClass ||
-        !(nativeClasses.isEmpty &&
-          compiler.codegenWorld.staticFunctionsNeedingGetter.isEmpty &&
-          outputClassLists.values.every((classList) => classList.isEmpty) &&
-          typedefsNeededForReflection.isEmpty)) {
-      // Shorten the code by using "$$" as temporary.
-      classesCollector = r"$$";
-      mainBuffer.write('var $classesCollector$_=${_}Object.create(null)$N$n');
-    }
-
     List<ClassElement> classes = task.outputClassLists[mainOutputUnit];
     if (classes != null) {
       for (ClassElement element in classes) {
         generateClass(element, getElementDescriptor(element));
       }
     }
 
     if (compiler.enableMinification) {
       mainBuffer.write(';');
     }
@@ skipping 11 matching lines @@
       CodeBuffer libraryBuffer = new CodeBuffer();
       for (LibraryElement library in Elements.sortedByPosition(libraries)) {
         writeLibraryDescriptors(libraryBuffer, library);
         elementDescriptors.remove(library);
       }
 
       mainBuffer
           ..write('(')
           ..write(
               jsAst.prettyPrint(
-                  getReflectionDataParser(classesCollector, backend),
+                  getReflectionDataParser(this, backend),
                   compiler))
           ..write(')')
           ..write('([$n')
           ..write(libraryBuffer)
           ..write('])$N');
-
-      emitFinishClassesInvocationIfNecessary(mainBuffer);
     }
 
     interceptorEmitter.emitGetInterceptorMethods(mainBuffer);
     interceptorEmitter.emitOneShotInterceptors(mainBuffer);
 
     if (task.outputContainsConstantList) {
       emitMakeConstantList(mainBuffer);
     }
 
     // Constants in checked mode call into RTI code to set type information
@@ skipping 272 matching lines @@
     nativeEmitter.finishGenerateNativeClasses();
     nativeEmitter.assembleCode(nativeBuffer);
 
     return nativeBuffer;
   }
 
   void emitProgram(Program program) {
     // Shorten the code by using [namer.currentIsolate] as temporary.
     isolateProperties = namer.currentIsolate;
 
-    classesCollector = r"$$";
-
     // Emit deferred units first, so we have their hashes.
     // Map from OutputUnit to a hash of its content. The hash uniquely
     // identifies the code of the output-unit. It does not include
     // boilerplate JS code, like the sourcemap directives or the hash
     // itself.
     Map<OutputUnit, String> deferredLoadHashes = emitDeferredOutputUnits();
     CodeBuffer nativeBuffer = buildNativesBuffer();
     emitMainOutputUnit(deferredLoadHashes, nativeBuffer);
 
     if (backend.requiresPreamble &&
@@ skipping 127 matching lines @@
       outputBuffer
           ..write('var init$_=$_${globalsHolder}.init$N')
           ..write('var ${namer.isolateName}$_=$_'
                     '${globalsHolder}.${namer.isolateName}$N');
       if (libraryDescriptorBuffer != null) {
       // 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.
          outputBuffer
-           ..write('var ${namer.currentIsolate}$_=$_$isolatePropertiesName$N')
-           // The classesCollector object ($$).
-           ..write('$classesCollector$_=${_}Object.create(null);$n')
+           ..write('var ${namer.currentIsolate}$_=$_$isolatePropertiesName;$n')
            ..write('(')
            ..write(
                jsAst.prettyPrint(
-                   getReflectionDataParser(classesCollector, backend),
+                   getReflectionDataParser(this, backend),
                    compiler, monitor: compiler.dumpInfoTask))
            ..write(')')
            ..write('([$n')
            ..addBuffer(libraryDescriptorBuffer)
            ..write('])$N');
 
-        if (outputClassLists.containsKey(outputUnit)) {
-          outputBuffer.write(
-              '$finishClassesName($classesCollector,$_${namer.currentIsolate},'
-              '$_$isolatePropertiesName)$N');
-        }
-
       }
 
       // Set the currentIsolate variable to the current isolate (which is
       // provided as second argument).
       // We need to do this, because we use the same variable for setting up
       // the isolate-properties and for storing the current isolate. During
       // the setup (the code above this lines) we must set the variable to
       // the isolate-properties.
-      // After we have done the setup (finishing with `finishClasses`) it must
-      // point to the current Isolate. Otherwise all methods/functions
-      // accessing isolate variables will access the wrong object.
+      // After we have done the setup it must point to the current Isolate.
+      // Otherwise all methods/functions accessing isolate variables will
+      // access the wrong object.
       outputBuffer.write("${namer.currentIsolate}$_=${_}arguments[1]$N");
 
       emitCompileTimeConstants(outputBuffer, outputUnit);
       emitStaticNonFinalFieldInitializations(outputBuffer, outputUnit);
       outputBuffer.write('}$N');
 
       if (compiler.useContentSecurityPolicy) {
         jsAst.FunctionDeclaration precompiledFunctionAst =
             buildCspPrecompiledFunctionFor(outputUnit);
 
@@ skipping 76 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }