dart2js OldEmitter: name anonymous function so it does not need to be copied in deferred parts.

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;
@@ skipping 139 matching lines @@
 
   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';
+  // TODO(zarah): Rename this when renaming reflection_data_parser.dart.
+  String get parseReflectionDataName => 'parseReflectionData';
   String get makeConstListProperty
       => namer.getMappedInstanceName('makeConstantList');
 
   /// The name of the property that contains all field names.
   ///
   /// This property is added to constructors when isolate support is enabled.
   static const String FIELD_NAMES_PROPERTY_NAME = r"$__fields__";
 
   /// For deferred loading we communicate the initializers via this global var.
   final String deferredInitializers = r"$dart_deferred_initializers";
@@ skipping 1323 matching lines @@
         mainBuffer.write('${globalsHolder}.$globalObject$_=${_}');
       }
       mainBuffer.write('new dart$N');
     }
 
     mainBuffer.write('function ${namer.isolateName}()$_{}\n');
     if (isProgramSplit) {
       mainBuffer
         .write('${globalsHolder}.${namer.isolateName}$_=$_'
                '${namer.isolateName}$N'
-               '${globalsHolder}.$initName$_=${_}$initName$N');
+               '${globalsHolder}.$initName$_=${_}$initName$N'
+               '${globalsHolder}.$parseReflectionDataName$_=$_'
+               '$parseReflectionDataName$N');

[floitsch, 2015/01/05 13:46:19]

indent that line.

[zarah, 2015/01/05 14:00:26]

OK, then I'm also indenting the one two lines above.

[floitsch, 2015/01/05 14:41:07]

or even better:

mainBuffer.write(
    '${globalsHolder} ...'

Ideally it fits on one line then.

[zarah, 2015/01/06 11:45:07]

Done.

     }
     mainBuffer.write('init()$N$n');
     mainBuffer.write('$isolateProperties$_=$_$isolatePropertiesName$N');
 
     emitStaticFunctions(task.outputStaticLists[mainOutputUnit]);
 
     List<ClassElement> classes = task.outputClassLists[mainOutputUnit];
     if (classes != null) {
       for (ClassElement element in classes) {
         generateClass(element, getElementDescriptor(element));
@@ skipping 14 matching lines @@
 
       checkEverythingEmitted(elementDescriptors.keys);
 
       CodeBuffer libraryBuffer = new CodeBuffer();
       for (LibraryElement library in Elements.sortedByPosition(libraries)) {
         writeLibraryDescriptors(libraryBuffer, library);
         elementDescriptors.remove(library);
       }
 
       mainBuffer
-          ..write('(')
           ..write(
               jsAst.prettyPrint(
                   getReflectionDataParser(this, backend),
                   compiler))
-          ..write(')')
-          ..write('([$n')
-          ..write(libraryBuffer)
-          ..write('])$N');
+          ..write(n);
+
+      mainBuffer..write('$parseReflectionDataName([$n')
+                ..write(libraryBuffer)
+                ..write('])$N');
     }
 
     interceptorEmitter.emitGetInterceptorMethods(mainBuffer);
     interceptorEmitter.emitOneShotInterceptors(mainBuffer);
 
     if (task.outputContainsConstantList) {
       emitMakeConstantList(mainBuffer);
     }
 
     // Constants in checked mode call into RTI code to set type information
@@ skipping 411 matching lines @@
       outputBuffer..write(buildGeneratedBy())
         ..write('${deferredInitializers}.current$_=$_'
                 'function$_(${globalsHolder}) {$N');
       for (String globalObject in Namer.reservedGlobalObjectNames) {
         outputBuffer
             .write('var $globalObject$_=$_'
                    '${globalsHolder}.$globalObject$N');
       }
       outputBuffer
           ..write('var init$_=$_${globalsHolder}.init$N')
+          ..write('var $parseReflectionDataName$_=$_'
+                    '$globalsHolder.$parseReflectionDataName$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')
-           ..write('(')
-           ..write(
-               jsAst.prettyPrint(
-                   getReflectionDataParser(this, backend),
-                   compiler, monitor: compiler.dumpInfoTask))
-           ..write(')')
-           ..write('([$n')
+           ..write('var ${namer.currentIsolate}$_=$_$isolatePropertiesName$N')
+           ..write('$parseReflectionDataName([$n')
            ..addBuffer(libraryDescriptorBuffer)
            ..write('])$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
@@ skipping 90 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }