Avoid inlining constants that are used via a deferred import.

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 15 matching lines @@
   NativeEmitter nativeEmitter;
   Map<OutputUnit, CodeBuffer> outputBuffers = new Map<OutputUnit, 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 Map<OutputUnit, List<ClassElement>> outputClassLists =
       new Map<OutputUnit, List<ClassElement>>();
+  final Map<OutputUnit, List<Constant>> outputConstantLists =
+      new Map<OutputUnit, List<Constant>>();
   final List<ClassElement> nativeClasses = <ClassElement>[];
   final Map<String, String> mangledFieldNames = <String, String>{};
   final Map<String, String> mangledGlobalFieldNames = <String, String>{};
   final Set<String> recordedMangledNames = new Set<String>();
 
   final Map<ClassElement, Map<String, jsAst.Expression>> additionalProperties =
       new Map<ClassElement, Map<String, jsAst.Expression>>();
 
   /// Records if a type variable is read dynamically for type tests.
   final Set<TypeVariableElement> readTypeVariables =
@@ skipping 363 matching lines @@
         var finishedClasses = {};
         init.interceptorsByTag = Object.create(null);
         init.leafTags = {};
 
         #;  // buildFinishClass(),
 
         #;  // buildTrivialNsmHandlers()
 
         for (var cls in pendingClasses) finishClass(cls);
       }''', [
-          DEBUG_FAST_OBJECTS, 
+          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}"';  // "%"
 
     return js.statement('''
@@ skipping 434 matching lines @@
       }
     }
   }
 
   jsAst.Expression buildLazyInitializedGetter(VariableElement element) {
     // Nothing to do, the 'lazy' function will create the getter.
     return null;
   }
 
   void emitCompileTimeConstants(CodeBuffer buffer, OutputUnit outputUnit) {
-    JavaScriptConstantCompiler handler = backend.constants;
-    List<Constant> constants = handler.getConstantsForEmission(
-        compareConstants);
-    Set<Constant> outputUnitConstants = null;
-    // TODO(sigurdm): We shouldn't run through all constants for every
-    // outputUnit.
+    List<Constant> constants = outputConstantLists[outputUnit];
+    if (constants == null) return;
     for (Constant constant in constants) {
-      if (isConstantInlinedOrAlreadyEmitted(constant)) continue;
-      OutputUnit constantUnit =
-          compiler.deferredLoadTask.outputUnitForConstant(constant);
-      if (constantUnit != outputUnit && constantUnit != null) continue;
-      if (outputUnit != compiler.deferredLoadTask.mainOutputUnit
-          && 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)]);
       buffer.write(jsAst.prettyPrint(init, compiler));
       buffer.write('$N');
     }
   }
 
@@ skipping 160 matching lines @@
   if (typeof dartMainRunner === "function") {
     dartMainRunner(${mainCallClosure}, []);
   } else {
     ${mainCallClosure}([]);
   }
 })$N''');
     addComment('END invoke [main].', buffer);
   }
 
   /**
+   * Compute all the constants that must be emitted.
+   */
+  void computeNeededConstants() {
+    JavaScriptConstantCompiler handler = backend.constants;
+    List<Constant> constants = handler.getConstantsForEmission(
+        compareConstants);
+    for (Constant constant in constants) {
+      if (isConstantInlinedOrAlreadyEmitted(constant)) continue;
+      OutputUnit constantUnit =
+          compiler.deferredLoadTask.outputUnitForConstant(constant);
+      if (constantUnit == null) {
+        // The back-end introduces some constants, like "InterceptorConstant" or
+        // some list constants. They are emitted in the main output-unit.
+        // TODO(sigurdm): We should track those constants.
+        constantUnit = compiler.deferredLoadTask.mainOutputUnit;
+      }
+      outputConstantLists.putIfAbsent(constantUnit, () => new List<Constant>())
+          .add(constant);
+    }
+  }
+
+  /**
    * Compute all the classes that must be emitted.
    */
   void computeNeededClasses() {
     instantiatedClasses =
         compiler.codegenWorld.instantiatedClasses.where(computeClassFilter())
             .toSet();
 
     void addClassWithSuperclasses(ClassElement cls) {
       neededClasses.add(cls);
       for (ClassElement superclass = cls.superclass;
@@ skipping 329 matching lines @@
         classesCollector = oldClassesCollector;
       }
       OutputUnit mainOutputUnit = compiler.deferredLoadTask.mainOutputUnit;
       typeTestEmitter.emitRuntimeTypeSupport(mainBuffer, mainOutputUnit);
       interceptorEmitter.emitGetInterceptorMethods(mainBuffer);
       interceptorEmitter.emitOneShotInterceptors(mainBuffer);
       // Constants in checked mode call into RTI code to set type information
       // which may need getInterceptor (and one-shot interceptor) methods, so
       // we have to make sure that [emitGetInterceptorMethods] and
       // [emitOneShotInterceptors] have been called.
+      computeNeededConstants();
       emitCompileTimeConstants(mainBuffer, mainOutputUnit);
 
       // Write a javascript mapping from Deferred import load ids (derrived from
       // the import prefix.) to a list of lists of js hunks to load.
       // TODO(sigurdm): Create a syntax tree for this.
       // TODO(sigurdm): Also find out where to place it.
       mainBuffer.write("\$.libraries_to_load = {");
       for (String loadId in compiler.deferredLoadTask.hunksToLoad.keys) {
         // TODO(sigurdm): Escape these strings.
         mainBuffer.write('"$loadId":[');
@@ skipping 261 matching lines @@
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
   void registerReadTypeVariable(TypeVariableElement element) {
     readTypeVariables.add(element);
   }
 }