Even less reliance on Compiler.closedWorld

pkg/compiler/lib/src/dump_info.dart

 // Copyright (c) 2013, 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.
 
 library dump_info;
 
 import 'dart:convert'
     show ChunkedConversionSink, JsonEncoder, StringConversionSink;
 
 import 'package:dart2js_info/info.dart';
 
 import 'closure.dart';
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/values.dart' show ConstantValue, InterceptorConstantValue;
 import 'deferred_load.dart' show OutputUnit;
 import 'elements/elements.dart';
 import 'elements/visitor.dart';
 import 'js/js.dart' as jsAst;
 import 'js_backend/js_backend.dart' show JavaScriptBackend;
 import 'js_emitter/full_emitter/emitter.dart' as full show Emitter;
 import 'types/types.dart' show TypeMask;
 import 'universe/world_builder.dart' show ReceiverConstraint;
 import 'universe/world_impact.dart'
     show ImpactUseCase, WorldImpact, WorldImpactVisitorImpl;
+import 'world.dart' show ClosedWorld;
 
 class ElementInfoCollector extends BaseElementVisitor<Info, dynamic> {
   final Compiler compiler;
+  final ClosedWorld closedWorld;
 
   final AllInfo result = new AllInfo();
   final Map<Element, Info> _elementToInfo = <Element, Info>{};
   final Map<ConstantValue, Info> _constantToInfo = <ConstantValue, Info>{};
   final Map<OutputUnit, OutputUnitInfo> _outputToInfo = {};
 
-  ElementInfoCollector(this.compiler);
+  ElementInfoCollector(this.compiler, this.closedWorld);
 
   void run() {
     compiler.dumpInfoTask._constantToNode.forEach((constant, node) {
       // TODO(sigmund): add dependencies on other constants
       var size = compiler.dumpInfoTask._nodeToSize[node];
       var code = jsAst.prettyPrint(node, compiler);
       var info = new ConstantInfo(
           size: size, code: code, outputUnit: _unitInfoForConstant(constant));
       _constantToInfo[constant] = info;
       result.constants.add(info);
@@ skipping 206 matching lines @@
       signature.forEachParameter((parameter) {
         parameters.add(new ParameterInfo(parameter.name,
             '${_resultOf(parameter).type}', '${parameter.node.type}'));
       });
     }
 
     String returnType = null;
     // TODO(sigmund): why all these checks?
     if (element.isInstanceMember &&
         !element.isAbstract &&
-        compiler.closedWorld.allFunctions.contains(element)) {
+        closedWorld.allFunctions.contains(element)) {
       returnType = '${element.type.returnType}';
     }
     String inferredReturnType = '${_resultOf(element).returnType}';
-    String sideEffects =
-        '${compiler.closedWorld.getSideEffectsOfElement(element)}';
+    String sideEffects = '${closedWorld.getSideEffectsOfElement(element)}';
 
     int inlinedCount = compiler.dumpInfoTask.inlineCount[element];
     if (inlinedCount == null) inlinedCount = 0;
 
     FunctionInfo info = new FunctionInfo(
         name: name,
         functionKind: kind,
         // We use element.hashCode because it is globally unique and it is
         // available while we are doing codegen.
         coverageId: '${element.hashCode}',
@@ skipping 156 matching lines @@
 
   void unregisterImpact(var impactSource) {
     impacts.remove(impactSource);
   }
 
   /**
    * Returns an iterable of [Selection]s that are used by
    * [element].  Each [Selection] contains an element that is
    * used and the selector that selected the element.
    */
-  Iterable<Selection> getRetaining(Element element) {
+  Iterable<Selection> getRetaining(Element element, ClosedWorld closedWorld) {
     WorldImpact impact = impacts[element];
     if (impact == null) return const <Selection>[];
 
     var selections = <Selection>[];
     compiler.impactStrategy.visitImpact(
         element,
         impact,
         new WorldImpactVisitorImpl(visitDynamicUse: (dynamicUse) {
-          selections.addAll(compiler.closedWorld.allFunctions
+          selections.addAll(closedWorld.allFunctions
               .filter(dynamicUse.selector, dynamicUse.mask)
               .map((e) => new Selection(e, dynamicUse.mask)));
         }, visitStaticUse: (staticUse) {
           selections.add(new Selection(staticUse.element, null));
         }),
         IMPACT_USE);
     return selections;
   }
 
   // Returns true if we care about tracking the size of
@@ skipping 56 matching lines @@
     List<jsAst.Node> code = _elementToNodes[element];
     if (code == null) return null;
     // Concatenate rendered ASTs.
     StringBuffer sb = new StringBuffer();
     for (jsAst.Node ast in code) {
       sb.writeln(jsAst.prettyPrint(ast, compiler));
     }
     return sb.toString();
   }
 
-  void dumpInfo() {
+  void dumpInfo(ClosedWorld closedWorld) {
     measure(() {
-      infoCollector = new ElementInfoCollector(compiler)..run();
+      infoCollector = new ElementInfoCollector(compiler, closedWorld)..run();
       StringBuffer jsonBuffer = new StringBuffer();
-      dumpInfoJson(jsonBuffer);
+      dumpInfoJson(jsonBuffer, closedWorld);
       compiler.outputProvider('', 'info.json')
         ..add(jsonBuffer.toString())
         ..close();
     });
   }
 
-  void dumpInfoJson(StringSink buffer) {
+  void dumpInfoJson(StringSink buffer, ClosedWorld closedWorld) {
     JsonEncoder encoder = const JsonEncoder.withIndent('  ');
     Stopwatch stopwatch = new Stopwatch();
     stopwatch.start();
 
     // Recursively build links to function uses
     Iterable<Element> functionElements =
         infoCollector._elementToInfo.keys.where((k) => k is FunctionElement);
     for (FunctionElement element in functionElements) {
       FunctionInfo info = infoCollector._elementToInfo[element];
-      Iterable<Selection> uses = getRetaining(element);
+      Iterable<Selection> uses = getRetaining(element, closedWorld);
       // Don't bother recording an empty list of dependencies.
       for (Selection selection in uses) {
         // Don't register dart2js builtin functions that are not recorded.
         Info useInfo = infoCollector._elementToInfo[selection.selectedElement];
         if (useInfo == null) continue;
         info.uses.add(new DependencyInfo(useInfo, '${selection.mask}'));
       }
     }
     // Notify the impact strategy impacts are no longer needed for dump info.
     compiler.impactStrategy.onImpactUsed(IMPACT_USE);
@@ skipping 37 matching lines @@
 
     ChunkedConversionSink<Object> sink = encoder.startChunkedConversion(
         new StringConversionSink.fromStringSink(buffer));
     sink.add(new AllInfoJsonCodec().encode(result));
     compiler.reporter.reportInfo(NO_LOCATION_SPANNABLE, MessageKind.GENERIC, {
       'text': "View the dumped .info.json file at "
           "https://dart-lang.github.io/dump-info-visualizer"
     });
   }
 }