Record information about constants in dump info

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/tasks.dart' show
     CompilerTask;
+import 'constants/values.dart' show ConstantValue;
 import 'compiler.dart' show
     Compiler;
 import 'diagnostics/messages.dart' show
     MessageKind;
 import 'diagnostics/spannable.dart' show
     NO_LOCATION_SPANNABLE;
 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 'js/js.dart' as jsAst;
 import 'universe/universe.dart' show
     Selector,
     UniverseSelector;
 
 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.libraryLoader.libraries.forEach(visit);
+  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);
+      _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,
   /// or because it is an element that holds dependencies to other elements.
   bool shouldKeep(Element element) {
     return compiler.dumpInfoTask.selectorsFromElement.containsKey(element) ||
@@ skipping 53 matching lines @@
         _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 || element.isConst) {
-      return null;
-    }
+    if (inferredType == null || inferredType.isEmpty) return null;
 
     int size = compiler.dumpInfoTask.sizeOf(element);
-    String code;
-    StringBuffer emittedCode = compiler.dumpInfoTask.codeOf(element);
-    if (emittedCode != null) {
-      size += emittedCode.length;
-      code = emittedCode.toString();
-    }
+    String code = compiler.dumpInfoTask.codeOf(element);
+    if (code != null) size += code.length;

[Siggi Cherem (dart-lang), 2015/08/19 04:21:08]

FYI - these lines related to `codeOf` were just cleanup, not something needed
for the CL, there were small enough that it was not worth splitting into a
separate CL

 
     FieldInfo info = new FieldInfo(
         name: element.name,
         // We use element.hashCode because it is globally unique and it is
         // available while we are doing codegen.
         coverageId: '${element.hashCode}',
         type: '${element.type}',
         inferredType: '$inferredType',
         size: size,
         code: code,
-        outputUnit: _unitInfoForElement(element));
+        outputUnit: _unitInfoForElement(element),
+        isConst: element.isConst);
     _elementToInfo[element] = info;
+    if (element.isConst) {
+      var value = compiler.backend.constantCompilerTask
+          .getConstantValueForVariable(element);
+      if (value != null) {
+        info.initializer = _constantToInfo[value];
+      }
+    }
 
     List<FunctionInfo> nestedClosures = <FunctionInfo>[];
     for (Element closure in element.nestedClosures) {
       Info child = this.process(closure);
       if (child != null) {
         ClassInfo parent = this.process(closure.enclosingElement);
         if (parent != null) {
           child.name = "${parent.name}.${child.name}";
         }
         nestedClosures.add(child);
@@ skipping 84 matching lines @@
           ? "${element.enclosingElement.name}"
           : "${element.enclosingElement.name}.${element.name}";
       kind = FunctionInfo.CONSTRUCTOR_FUNCTION_KIND;
     }
 
     FunctionModifiers modifiers = new FunctionModifiers(
         isStatic: element.isStatic,
         isConst: element.isConst,
         isFactory: element.isFactoryConstructor,
         isExternal: element.isPatched);
-    StringBuffer emittedCode = compiler.dumpInfoTask.codeOf(element);
-    String code = emittedCode == null ? null : '$emittedCode';
+    String code = compiler.dumpInfoTask.codeOf(element);
 
     List<ParameterInfo> parameters = <ParameterInfo>[];
     if (element.hasFunctionSignature) {
       FunctionSignature signature = element.functionSignature;
       signature.forEachParameter((parameter) {
         parameters.add(new ParameterInfo(
             parameter.name,
             '${compiler.typesTask.getGuaranteedTypeOfElement(parameter)}',
             '${parameter.node.type}'));
       });
@@ skipping 83 matching lines @@
   /// The size of the generated output.
   int _programSize;
 
   // A set of javascript AST nodes that we care about the size of.
   // This set is automatically populated when registerElementAst()
   // is called.
   final Set<jsAst.Node> _tracking = new Set<jsAst.Node>();
   // A mapping from Dart Elements to Javascript AST Nodes.
   final Map<Element, List<jsAst.Node>> _elementToNodes =
       <Element, List<jsAst.Node>>{};
+  final Map<ConstantValue, jsAst.Node> _constantToNode =
+      <ConstantValue, jsAst.Node>{};
   // A mapping from Javascript AST Nodes to the size of their
   // pretty-printed contents.
   final Map<jsAst.Node, int> _nodeToSize = <jsAst.Node, int>{};
 
   final Map<Element, Set<UniverseSelector>> selectorsFromElement = {};
   final Map<Element, int> inlineCount = <Element, int>{};
   // A mapping from an element to a list of elements that are
   // inlined inside of it.
   final Map<Element, List<Element>> inlineMap = <Element, List<Element>>{};
 
@@ skipping 59 matching lines @@
   // dart Element `element`.
   void registerElementAst(Element element, jsAst.Node code) {
     if (compiler.dumpInfo) {
       _elementToNodes
           .putIfAbsent(element, () => new List<jsAst.Node>())
           .add(code);
       _tracking.add(code);
     }
   }
 
+  void registerConstantAst(ConstantValue constant, jsAst.Node code) {
+    if (compiler.dumpInfo) {
+      assert(_constantToNode[constant] == null ||
+          _constantToNode[constant] == code);
+      _constantToNode[constant] = code;
+      _tracking.add(code);
+    }
+  }
+
   // Records the size of a dart AST node after it has been
   // pretty-printed into the output buffer.
   void recordAstSize(jsAst.Node node, int size) {
     if (isTracking(node)) {
       //TODO: should I be incrementing here instead?
       _nodeToSize[node] = size;
     }
   }
 
   // Returns the size of the source code that
   // was generated for an element.  If no source
   // code was produced, return 0.
   int sizeOf(Element element) {
     if (_elementToNodes.containsKey(element)) {
       return _elementToNodes[element].map(sizeOfNode).fold(0, (a, b) => a + b);
     } else {
       return 0;
     }
   }
 
-  int sizeOfNode(jsAst.Node node) {
-    if (_nodeToSize.containsKey(node)) {
-      return _nodeToSize[node];
-    } else {
-      return 0;
-    }
-  }
+  int sizeOfNode(jsAst.Node node) => _nodeToSize[node] ?? 0;
 
-  StringBuffer codeOf(Element element) {
+  String codeOf(Element element) {
     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).getText());
     }
-    return sb;
+    return sb.toString();
   }
 
   void collectInfo() {
     infoCollector = new ElementInfoCollector(compiler)..run();
   }
 
   void dumpInfo() {
     measure(() {
       if (infoCollector == null) {
         collectInfo();
@@ skipping 63 matching lines @@
 
     ChunkedConversionSink<Object> sink = encoder.startChunkedConversion(
         new StringConversionSink.fromStringSink(buffer));
     sink.add(result.toJson());
     compiler.reportInfo(NO_LOCATION_SPANNABLE, MessageKind.GENERIC, {
       'text': "View the dumped .info.json file at "
           "https://dart-lang.github.io/dump-info-visualizer"
     });
   }
 }