Don't create part.js when there is no deferred loading.

dart/sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 45 matching lines @@
  */
 class CodeEmitterTask extends CompilerTask {
   bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter nativeEmitter;
   CodeBuffer mainBuffer;
-  final CodeBuffer deferredBuffer = new CodeBuffer();
+  final CodeBuffer deferredLibraries = new CodeBuffer();
+  final CodeBuffer deferredConstants = new CodeBuffer();
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   final Set<ClassElement> neededClasses = new Set<ClassElement>();
   final List<ClassElement> regularClasses = <ClassElement>[];
   final List<ClassElement> deferredClasses = <ClassElement>[];
   final List<ClassElement> nativeClasses = <ClassElement>[];
   final List<Selector> trivialNsmHandlers = <Selector>[];
   final Map<String, String> mangledFieldNames = <String, String>{};
@@ skipping 1817 matching lines @@
       emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
     }
   }
 
   final Map<Element, Element> staticGetters = new Map<Element, Element>();
 
   void emitStaticFunctionGetters(CodeBuffer eagerBuffer) {
     for (FunctionElement element in
              Elements.sortedByPosition(staticGetters.keys)) {
       Element closure = staticGetters[element];
-      // TODO(ahe): This should be emitted as a constant.  Currently,
-      // this breaks deferred loading.
-      CodeBuffer buffer = eagerBuffer;
+      CodeBuffer buffer = isDeferred(element) ? deferredConstants : eagerBuffer;
       String closureClass = namer.isolateAccess(closure);
       String name = namer.getStaticClosureName(element);
       String staticName = namer.getName(element);
 
       String closureName = namer.getStaticClosureName(element);
       jsAst.Node assignment = js('$isolateProperties.$name = '
           'new $closureClass($isolateProperties.$staticName, "$closureName")');
       buffer.write(jsAst.prettyPrint(assignment, compiler));
       buffer.write('$N');
     }
@@ skipping 1203 matching lines @@
           mainBuffer.write(
               jsAst.prettyPrint(
                   js('init.mangledNames = #', map).toStatement(), compiler));
           if (compiler.enableMinification) {
             mainBuffer.write(';');
           }
         }
         mainBuffer
             ..write(getReflectionDataParser())
             ..write('([$n');
-        emitDeferredPreambleWhenEmpty(deferredBuffer);
-        deferredBuffer.add('\$\$$_=$_{};$n');
 
-        deferredBuffer
-            ..write(getReflectionDataParser())
-            ..write('([$n');
         var sortedLibraries = Elements.sortedByPosition(libraryBuffers.keys);
         for (LibraryElement library in sortedLibraries) {
           List<CodeBuffer> buffers = libraryBuffers[library];
           var buffer = buffers[0];
           var uri = library.canonicalUri;
           if (uri.scheme == 'file' && compiler.sourceMapUri != null) {
             // TODO(ahe): It is a hack to use compiler.sourceMapUri
             // here.  It should be relative to the main JavaScript
             // output file.
             uri = relativize(
                 compiler.sourceMapUri, library.canonicalUri, false);
           }
           if (buffer != null) {
             var metadata = buildMetadataFunction(library);
             mainBuffer
                 ..write('["${library.getLibraryOrScriptName()}",$_')
                 ..write('"${uri}",$_')
                 ..write(metadata == null
                         ? "" : jsAst.prettyPrint(metadata, compiler))
                 ..write(',$_')
                 ..write('{$n')
                 ..addBuffer(buffer)
                 ..write('}],$n');
           }
           buffer = buffers[1];
           if (buffer != null) {
-            deferredBuffer
+            deferredLibraries
                 ..write('["${library.getLibraryOrScriptName()}",$_')
                 ..write('"${uri}",$_')
                 ..write('[],$_')
                 ..write('{$n')
                 ..addBuffer(buffer)
                 ..write('}],$n');
           }
           libraryBuffers[library] = const [];
         }
         mainBuffer.write('])$N');
 
-        deferredBuffer.write('])$N');
-        if (!deferredClasses.isEmpty) {
-          deferredBuffer.add('$finishClassesName(\$\$,'
-                             '$_${namer.CURRENT_ISOLATE},'
-                             '$_$isolatePropertiesName)$N');
-        }
-
-        // Reset the map.
-        deferredBuffer.add("\$\$$_=${_}null$N$n");
         emitFinishClassesInvocationIfNecessary(mainBuffer);
         classesCollector = oldClassesCollector;
       }
 
       emitStaticFunctionGetters(mainBuffer);
 
       emitRuntimeTypeSupport(mainBuffer);
       emitCompileTimeConstants(mainBuffer);
       // Static field initializations require the classes and compile-time
       // constants to be set up.
@@ skipping 13 matching lines @@
 
       emitFinishIsolateConstructorInvocation(mainBuffer);
       mainBuffer.add('var ${namer.CURRENT_ISOLATE}$_='
                      '${_}new ${namer.isolateName}()$N');
 
       emitMain(mainBuffer);
       emitInitFunction(mainBuffer);
       compiler.assembledCode = mainBuffer.getText();
       outputSourceMap(mainBuffer, compiler.assembledCode, '');
 
-      emitDeferredCode(deferredBuffer);
+      emitDeferredCode();
 
     });
     return compiler.assembledCode;
   }
 
   final Map<LibraryElement, List<CodeBuffer>> libraryBuffers =
       new Map<LibraryElement, List<CodeBuffer>>();
 
   CodeBuffer bufferForElement(Element element, CodeBuffer eagerBuffer) {
     LibraryElement library = element.getLibrary();
     List<CodeBuffer> buffers = libraryBuffers.putIfAbsent(
         library, () => <CodeBuffer>[null, null]);
     bool deferred = isDeferred(element);
     int index = deferred ? 1 : 0;
     CodeBuffer buffer = buffers[index];
     if (buffer == null) {
       buffer = buffers[index] = new CodeBuffer();
     }
     return buffer;
   }
 
-  bool firstDeferredConstant = true;
-
   /**
    * Returns the appropriate buffer for [constant].  If [constant] is
    * itself an instance of a deferred type (or built from constants
    * that are instances of deferred types) attempting to use
    * [constant] before the deferred type has been loaded will not
    * work, and [constant] itself must be deferred.
    */
   CodeBuffer bufferForConstant(Constant constant, CodeBuffer eagerBuffer) {
     var queue = new Queue()..add(constant);
     while (!queue.isEmpty) {
       constant = queue.removeFirst();
       if (isDeferred(constant.computeType(compiler).element)) {
-        emitDeferredPreambleWhenEmpty(deferredBuffer);
-        if (firstDeferredConstant) {
-          deferredBuffer.write(
-              '${namer.CURRENT_ISOLATE}$_=${_}old${namer.CURRENT_ISOLATE}$N');
-          deferredBuffer.write(
-              'old${namer.CURRENT_ISOLATE}$_=${_}${namer.CURRENT_ISOLATE}$N');
-        }
-        firstDeferredConstant = false;
-        return deferredBuffer;
+        return deferredConstants;
       }
       queue.addAll(constant.getDependencies());
     }
     return eagerBuffer;
   }
 
-  void emitDeferredCode(CodeBuffer buffer) {
-    if (buffer.isEmpty) return;
 
-    buffer.write(n);
+
+  void emitDeferredCode() {
+    if (deferredLibraries.isEmpty && deferredConstants.isEmpty) return;
+
+    var oldClassesCollector = classesCollector;
+    classesCollector = r"$$";
+
+    // It does not make sense to defer constants if there are no
+    // deferred elements.
+    assert(!deferredLibraries.isEmpty);
+
+    var buffer = new CodeBuffer()
+        ..write(buildGeneratedBy())
+        ..write('var old${namer.CURRENT_ISOLATE}$_='
+                '$_${namer.CURRENT_ISOLATE}$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.CURRENT_ISOLATE}$_='
+                '$_${namer.isolateName}.prototype$N$n'
+                // The classesCollector object ($$).
+                '$classesCollector$_=$_{};$n')
+        ..write(getReflectionDataParser())
+        ..write('([$n')
+        ..addBuffer(deferredLibraries)
+        ..write('])$N');
+
+    if (!deferredClasses.isEmpty) {
+      buffer.write(
+          '$finishClassesName($classesCollector,$_${namer.CURRENT_ISOLATE},'
+          '$_$isolatePropertiesName)$N');
+    }
 
     buffer.write(
+        // Reset the classesCollector ($$).
+        '$classesCollector$_=${_}null$N$n'
         '${namer.CURRENT_ISOLATE}$_=${_}old${namer.CURRENT_ISOLATE}$N');
 
+    classesCollector = oldClassesCollector;
+
+    if (!deferredConstants.isEmpty) {
+      buffer.addBuffer(deferredConstants);
+    }
+
     String code = buffer.getText();
     compiler.outputProvider('part', 'js')
       ..add(code)
       ..close();
     outputSourceMap(buffer, compiler.assembledCode, 'part');
   }
 
-  void emitDeferredPreambleWhenEmpty(CodeBuffer buffer) {
-    if (!buffer.isEmpty) return;
-
-    buffer.write(buildGeneratedBy());
-
-    buffer.write('var old${namer.CURRENT_ISOLATE}$_='
-                 '$_${namer.CURRENT_ISOLATE}$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.
-    buffer.write('${namer.CURRENT_ISOLATE}$_='
-                 '$_${namer.isolateName}.prototype$N$n');
-  }
-
   String buildGeneratedBy() {
     var suffix = '';
     if (compiler.hasBuildId) suffix = ' version: ${compiler.buildId}';
     return '// Generated by dart2js, the Dart to JavaScript compiler$suffix.\n';
   }
 
   String buildSourceMap(CodeBuffer buffer, SourceFile compiledFile) {
     SourceMapBuilder sourceMapBuilder =
         new SourceMapBuilder(compiler.sourceMapUri);
     buffer.forEachSourceLocation(sourceMapBuilder.addMapping);
@@ skipping 78 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;