Better dependency tracking

sdk/lib/_internal/compiler/implementation/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 'elements/elements.dart';
 import 'elements/visitor.dart';
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     CodeBuffer;
 import 'dart_types.dart' show DartType;
 import 'types/types.dart' show TypeMask;
-import 'util/util.dart' show modifiersToString;
+import 'util/util.dart' show modifiersToString, SpannableAssertionFailure;
 import 'deferred_load.dart' show OutputUnit;
 import 'js_backend/js_backend.dart' show JavaScriptBackend;
 import 'js/js.dart' as jsAst;
-import 'compilation_info.dart' show CompilationInformation;
+import 'universe/universe.dart' show Selector;
 
 /// Maps elements to an id.  Supports lookups in
 /// both directions.
 class ElementMapper {
   Map<int, Element> _idToElement = {};
   Map<Element, int> _elementToId = {};
   int _idCounter = 0;
   String name;
 
   ElementMapper(this.name);
 
+  Iterable<Element> get elements => _elementToId.keys;
+
   String add(Element e) {
     if (_elementToId.containsKey(e)) {
       return name + "/${_elementToId[e]}";
     }
 
     _idToElement[_idCounter] = e;
     _elementToId[e] = _idCounter;
     _idCounter += 1;
     return name + "/${_idCounter - 1}";
   }
 }
 
 class DividedElementMapper {
   // Mappers for specific kinds of elements.
   ElementMapper _library = new ElementMapper('library');
   ElementMapper _typedef = new ElementMapper('typedef');
   ElementMapper _field = new ElementMapper('field');
   ElementMapper _class = new ElementMapper('class');
   ElementMapper _function = new ElementMapper('function');
 
+  Iterable<Element> get functions => _function.elements;
+
   // Convert this database of elements into JSON for rendering
   Map<String, dynamic> _toJson(ElementToJsonVisitor elementToJson) {
     Map<String, dynamic> json = {};
     var m = [_library, _typedef, _field, _class, _function];
     for (ElementMapper mapper in m) {
       Map<String, dynamic> innerMapper = {};
       mapper._idToElement.forEach((k, v) {
         // All these elements are already cached in the
         // jsonCache, so this is just an access.
         var elementJson = elementToJson.process(v);
         if (elementJson != null) {
           innerMapper["$k"] = elementJson;
         }
       });
       json[mapper.name] = innerMapper;
     }
     return json;
   }
 }
 
 class ElementToJsonVisitor extends ElementVisitor<Map<String, dynamic>> {
   DividedElementMapper mapper = new DividedElementMapper();
   Compiler compiler;
 
-  CompilationInformation compilationInfo;
-
   Map<Element, Map<String, dynamic>> jsonCache = {};
   Map<Element, jsAst.Expression> codeCache;
 
   int programSize;
   DateTime compilationMoment;
   String dart2jsVersion;
   Duration compilationDuration;
   Duration dumpInfoDuration;
 
   ElementToJsonVisitor(Compiler compiler) {
     this.compiler = compiler;
-    this.compilationInfo = compiler.enqueuer.codegen.compilationInfo;
 
     programSize = compiler.assembledCode.length;
     compilationMoment = new DateTime.now();
     dart2jsVersion = compiler.hasBuildId ? compiler.buildId : null;
     compilationDuration = compiler.totalCompileTime.elapsed;
 
     for (var library in compiler.libraryLoader.libraries.toList()) {
       library.accept(this);
     }
 
     dumpInfoDuration = new DateTime.now().difference(compilationMoment);
   }
 
   // If keeping the element is in question (like if a function has a size
   // of zero), only keep it if it holds dependencies to elsewhere.
   bool shouldKeep(Element element) {
-    return compilationInfo.addsToWorkListMap.containsKey(element) ||
-           compilationInfo.enqueuesMap.containsKey(element);
+    return compiler.dumpInfoTask.selectorsFromElement.containsKey(element);
   }
 
   Map<String, dynamic> toJson() {
     return mapper._toJson(this);
   }
 
   // Memoization of the JSON creating process.
   Map<String, dynamic> process(Element element) {
     return jsonCache.putIfAbsent(element, () => element.accept(this));
   }
 
+  // Returns the id of an [element] if it has already been processed.
+  // If the element has not been processed, this function does not
+  // process it, and simply returns null instead.
+  String idOf(Element element) {
+    if (jsonCache.containsKey(element) && jsonCache[element] != null) {
+      return jsonCache[element]['id'];
+    } else {
+      return null;
+    }
+  }
+
   Map<String, dynamic> visitElement(Element element) {
     return null;
   }
 
   Map<String, dynamic> visitConstructorBodyElement(ConstructorBodyElement e) {
     return visitFunctionElement(e.constructor);
   }
 
   Map<String, dynamic> visitLibraryElement(LibraryElement element) {
     var id = mapper._library.add(element);
@@ skipping 207 matching lines @@
   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>>{};
   // 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<jsAst.Node, int> _nodeBeforeSize = <jsAst.Node, int>{};
   final Map<Element, int> _fieldNameToSize = <Element, int>{};
 
+  final Map<Element, Set<Selector>> selectorsFromElement = {};
+
+  /**
+   * Registers that a function uses a selector in the
+   * function body
+   */
+  void elementUsesSelector(Element element, Selector selector) {
+    if (compiler.dumpInfo) {
+      selectorsFromElement
+          .putIfAbsent(element, () => new Set<Selector>())
+          .add(selector);
+    }
+  }
+
+  /**
+   * Returns an iterable of [Element]s that are used by
+   * [element].
+   */
+  Iterable<Element> getRetaining(Element element) {
+    if (!selectorsFromElement.containsKey(element)) {
+      return const <Element>[];
+    } else {
+      return selectorsFromElement[element].expand(
+          (s) => compiler.world.allFunctions.filter(s));
+    }
+  }
+
   /**
    * A callback that can be called before a jsAst [node] is
    * pretty-printed. The size of the code buffer ([aftersize])
    * is also passed.
    */
   void enteringAst(jsAst.Node node, int beforeSize) {
     if (isTracking(node)) {
       _nodeBeforeSize[node] = beforeSize;
     }
   }
@@ skipping 95 matching lines @@
       dumpInfoJson(jsonBuffer);
       compiler.outputProvider('', 'info.json')
         ..add(jsonBuffer.toString())
         ..close();
     });
   }
 
 
   void dumpInfoJson(StringSink buffer) {
     JsonEncoder encoder = const JsonEncoder();
-
-    // `A` uses and depends on the functions `Bs`.
-    //     A         Bs
-    Map<String, List<String>> holding = <String, List<String>>{};
-
     DateTime startToJsonTime = new DateTime.now();
 
-    CompilationInformation compilationInfo =
-      infoCollector.compiler.enqueuer.codegen.compilationInfo;
-    compilationInfo.addsToWorkListMap.forEach((func, deps) {
-      if (func != null) {
-        var funcJson = infoCollector.process(func);
-        if (funcJson != null) {
-          var funcId = funcJson['id'];
-
-          List<String> heldList = <String>[];
-
-          for (var held in deps) {
-            // "process" to get the ids of the elements.
-            var heldJson = infoCollector.process(held);
-            if (heldJson != null) {
-              var heldId = heldJson['id'];
-              heldList.add(heldId);
-            }
-          }
-          holding[funcId] = heldList;
+    Map<String, List<String>> holding = <String, List<String>>{};
+    for (Element fn in infoCollector.mapper.functions) {
+      Iterable<Element> pulling = getRetaining(fn);
+      // Don't bother recording an empty list of dependencies.
+      if (pulling.length > 0) {
+        String fnId = infoCollector.idOf(fn);
+        // Some dart2js builtin functions are not
+        // recorded.  Don't register these.
+        if (fnId != null) {
+          holding[fnId] = pulling
+            .map((a) => infoCollector.idOf(a))
+            // Filter non-null ids for the same reason as above.
+            .where((a) => a != null)
+            .toList();
         }
       }
-    });
+    }
 
     Map<String, dynamic> outJson = {
       'elements': infoCollector.toJson(),
       'holding': holding,
       'dump_version': 1,
     };
 
     Duration toJsonDuration = new DateTime.now().difference(startToJsonTime);
 
     Map<String, dynamic> generalProgramInfo = <String, dynamic> {
       'size': infoCollector.programSize,
       'dart2jsVersion': infoCollector.dart2jsVersion,
       'compilationMoment': infoCollector.compilationMoment.toString(),
       'compilationDuration': infoCollector.compilationDuration.toString(),
       'toJsonDuration': toJsonDuration.toString(),
       'dumpInfoDuration': infoCollector.dumpInfoDuration.toString(),
       'noSuchMethodEnabled': compiler.enabledNoSuchMethod
     };
 
     outJson['program'] = generalProgramInfo;
 
     ChunkedConversionSink<Object> sink =
       encoder.startChunkedConversion(
           new StringConversionSink.fromStringSink(buffer));
     sink.add(outJson);
   }
 }