dart2js: add OutputUnit info for constants

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 HtmlEscape, JsonEncoder, StringConversionSink, ChunkedConversionSink;
 
 import 'package:dart2js_info/info.dart';
 
 import 'common.dart';
-import 'common/tasks.dart' show
-    CompilerTask;
-import 'constants/values.dart' show ConstantValue;
-import 'compiler.dart' show
-    Compiler;
+import 'common/tasks.dart' show CompilerTask;
+import 'constants/values.dart' show ConstantValue, InterceptorConstantValue;
+import 'compiler.dart' show Compiler;
 import 'elements/elements.dart';
 import 'elements/visitor.dart';
-import 'types/types.dart' show
-    TypeMask;
-import 'deferred_load.dart' show
-    OutputUnit;
-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 'deferred_load.dart' show OutputUnit;
+import 'js_backend/js_backend.dart' show JavaScriptBackend;
+import 'js_emitter/full_emitter/emitter.dart' as full show Emitter;
 import 'js/js.dart' as jsAst;
-import 'universe/universe.dart' show
-    UniverseSelector;
+import 'universe/universe.dart' show UniverseSelector;
 import 'info/send_info.dart' show collectSendMeasurements;
 
 class ElementInfoCollector extends BaseElementVisitor<Info, dynamic> {
   final Compiler compiler;
 
   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);
 
   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).getText();
-      var info = new ConstantInfo(size: size, code: code);
+      var info = new ConstantInfo(
+          size: size, code: code, outputUnit: _unitInfoForConstant(constant));
       _constantToInfo[constant] = info;
       result.constants.add(info);
-
     });
     compiler.libraryLoader.libraries.forEach(visit);
   }
 
   Info visit(Element e, [_]) => e.accept(this, null);
 
   /// Whether to emit information about [element].
   ///
   /// By default we emit information for any element that contributes to the
   /// output size. Either becuase the it is a function being emitted or inlined,
@@ skipping 13 matching lines @@
   Info visitElement(Element element, _) => null;
 
   FunctionInfo visitConstructorBodyElement(ConstructorBodyElement e, _) {
     return visitFunctionElement(e.constructor, _);
   }
 
   LibraryInfo visitLibraryElement(LibraryElement element, _) {
     String libname = element.hasLibraryName ? element.libraryName : "<unnamed>";
     int size = compiler.dumpInfoTask.sizeOf(element);
     LibraryInfo info =
-      new LibraryInfo(libname, element.canonicalUri, null, size);
+        new LibraryInfo(libname, element.canonicalUri, null, size);
     _elementToInfo[element] = info;
 
     LibraryElement realElement = element.isPatched ? element.patch : element;
     realElement.forEachLocalMember((Element member) {
       Info child = this.process(member);
       if (child is ClassInfo) {
         info.classes.add(child);
         child.parent = info;
       } else if (child is FunctionInfo) {
         info.topLevelFunctions.add(child);
@@ skipping 10 matching lines @@
       }
     });
 
     if (info.isEmpty && !shouldKeep(element)) return null;
     result.libraries.add(info);
     return info;
   }
 
   TypedefInfo visitTypedefElement(TypedefElement element, _) {
     if (!element.isResolved) return null;
-    TypedefInfo info = new TypedefInfo(element.name, '${element.alias}',
-        _unitInfoForElement(element));
+    TypedefInfo info = new TypedefInfo(
+        element.name, '${element.alias}', _unitInfoForElement(element));
     _elementToInfo[element] = info;
     result.typedefs.add(info);
     return info;
   }
 
   FieldInfo visitFieldElement(FieldElement element, _) {
     TypeMask inferredType =
         compiler.typesTask.getGuaranteedTypeOfElement(element);
     // If a field has an empty inferred type it is never used.
     if (inferredType == null || inferredType.isEmpty) return null;
@@ skipping 149 matching lines @@
     }
     String inferredReturnType =
         '${compiler.typesTask.getGuaranteedReturnTypeOfElement(element)}';
     String sideEffects = '${compiler.world.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}',
         modifiers: modifiers,
         size: size,
         returnType: returnType,
         inferredReturnType: inferredReturnType,
         parameters: parameters,
         sideEffects: sideEffects,
         inlinedCount: inlinedCount,
@@ skipping 21 matching lines @@
     info.closures = nestedClosures;
     result.functions.add(info);
     if (const bool.fromEnvironment('send_stats')) {
       info.measurements = collectSendMeasurements(element, compiler);
     }
     return info;
   }
 
   OutputUnitInfo _unitInfoForElement(Element element) {
     OutputUnit outputUnit =
-      compiler.deferredLoadTask.outputUnitForElement(element);
+        compiler.deferredLoadTask.outputUnitForElement(element);
     return _outputToInfo.putIfAbsent(outputUnit, () {
       // Dump-info currently only works with the full emitter. If another
       // emitter is used it will fail here.
+      JavaScriptBackend backend = compiler.backend;
+      full.Emitter emitter = backend.emitter.emitter;
+      OutputUnitInfo info = new OutputUnitInfo(
+          outputUnit.name, emitter.outputBuffers[outputUnit].length);
+      result.outputUnits.add(info);
+      return info;
+    });
+  }
+
+  OutputUnitInfo _unitInfoForConstant(ConstantValue constant) {
+    OutputUnit outputUnit =
+        compiler.deferredLoadTask.outputUnitForConstant(constant);
+    if (outputUnit == null) {
+      assert(constant is InterceptorConstantValue);
+      return null;
+    }
+    return _outputToInfo.putIfAbsent(outputUnit, () {

[Siggi Cherem (dart-lang), 2015/11/03 02:30:18]

nit: let's factor out this common part of the code to avoid the duplication

[Harry Terkelsen, 2015/11/03 02:43:34]

Done.

+      // Dump-info currently only works with the full emitter. If another
+      // emitter is used it will fail here.
       JavaScriptBackend backend = compiler.backend;
       full.Emitter emitter = backend.emitter.emitter;
       OutputUnitInfo info = new OutputUnitInfo(
           outputUnit.name, emitter.outputBuffers[outputUnit].length);
       result.outputUnits.add(info);
       return info;
     });
   }
 }
 
@@ skipping 198 matching lines @@
         outerInfo.uses.add(new DependencyInfo(inlinedInfo, 'inlined'));
       }
     }
 
     AllInfo result = infoCollector.result;
 
     for (Element element in _dependencies.keys) {
       var a = infoCollector._elementToInfo[element];
       if (a == null) continue;
       result.dependencies[a] = _dependencies[element]
-        .map((o) => infoCollector._elementToInfo[o])
-        .where((o) => o != null)
-        .toList();
+          .map((o) => infoCollector._elementToInfo[o])
+          .where((o) => o != null)
+          .toList();
     }
 
     result.deferredFiles = compiler.deferredLoadTask.computeDeferredMap();
     stopwatch.stop();
     result.program = new ProgramInfo(
         entrypoint: infoCollector._elementToInfo[compiler.mainFunction],
         size: _programSize,
         dart2jsVersion: compiler.hasBuildId ? compiler.buildId : null,
         compilationMoment: new DateTime.now(),
         compilationDuration: compiler.totalCompileTime.elapsed,
         toJsonDuration: stopwatch.elapsedMilliseconds,
         dumpInfoDuration: this.timing,
         noSuchMethodEnabled: compiler.backend.enabledNoSuchMethod,
         minified: compiler.enableMinification);
 
     ChunkedConversionSink<Object> sink = encoder.startChunkedConversion(
         new StringConversionSink.fromStringSink(buffer));
     sink.add(new AllInfoJsonCodec().encode(result));
     reporter.reportInfo(NO_LOCATION_SPANNABLE, MessageKind.GENERIC, {
       'text': "View the dumped .info.json file at "
           "https://dart-lang.github.io/dump-info-visualizer"
     });
   }
 }