Split TypedSelector into Selector and TypeMask.

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 'elements/elements.dart';
 import 'elements/visitor.dart';
 import 'dart2jslib.dart' show
     Backend,
     CodeBuffer,
     Compiler,
     CompilerTask,
     MessageKind;
 import 'types/types.dart' show TypeMask;
 import 'deferred_load.dart' show OutputUnit;
 import 'js_backend/js_backend.dart' show JavaScriptBackend;
 import 'js/js.dart' as jsAst;
-import 'universe/universe.dart' show Selector;
+import 'universe/universe.dart' show Selector, UniverseSelector;
 import 'util/util.dart' show NO_LOCATION_SPANNABLE;
 
 /// Maps objects to an id.  Supports lookups in
 /// both directions.
 class IdMapper<T>{
   Map<int, T> _idToElement = {};
   Map<T, int> _elementToId = {};
   int _idCounter = 0;
   final String name;
 
@@ skipping 346 matching lines @@
       'inlinedCount': inlinedCount,
       'code': emittedCode == null ? null : '$emittedCode',
       'type': element.type.toString(),
       'outputUnit': mapper._outputUnit.add(outputUnit)
     };
   }
 }
 
 class Selection {
   final Element selectedElement;
-  final Selector selector;
-  Selection(this.selectedElement, this.selector);
+  final TypeMask mask;
+  Selection(this.selectedElement, this.mask);
 }
 
 class DumpInfoTask extends CompilerTask {
   DumpInfoTask(Compiler compiler)
       : super(compiler);
 
   String get name => "Dump Info";
 
   ElementToJsonVisitor infoCollector;
 
   /// 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>>{};
   // 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<Selector>> selectorsFromElement = {};
+  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>>{};
 
   /// Register the size of the generated output.
   void reportSize(int programSize) {
     _programSize = programSize;
   }
 
   void registerInlined(Element element, Element inlinedFrom) {
     inlineCount.putIfAbsent(element, () => 0);
     inlineCount[element] += 1;
     inlineMap.putIfAbsent(inlinedFrom, () => new List<Element>());
     inlineMap[inlinedFrom].add(element);
   }
 
   /**
    * Registers that a function uses a selector in the
    * function body
    */
-  void elementUsesSelector(Element element, Selector selector) {
+  void elementUsesSelector(Element element, UniverseSelector selector) {
     if (compiler.dumpInfo) {
       selectorsFromElement
-          .putIfAbsent(element, () => new Set<Selector>())
+          .putIfAbsent(element, () => new Set<UniverseSelector>())
           .add(selector);
     }
   }
 
   /**
    * 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) {
     if (!selectorsFromElement.containsKey(element)) {
       return const <Selection>[];
     } else {
       return selectorsFromElement[element].expand(
-        (selector) {
-          return compiler.world.allFunctions.filter(selector).map((element) {
-            return new Selection(element, selector);
+        (UniverseSelector selector) {
+          return compiler.world.allFunctions.filter(
+              selector.selector, selector.mask)
+              .map((element) {
+            return new Selection(element, selector.mask);
           });
         });
     }
   }
 
   // Returns true if we care about tracking the size of
   // this node.
   bool isTracking(jsAst.Node code) {
     if (compiler.dumpInfo) {
       return _tracking.contains(code);
@@ skipping 85 matching lines @@
       // 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((selection) {
               return <String, String>{
                 "id": infoCollector.idOf(selection.selectedElement),
-                "mask": selection.selector.mask.toString()
+                "mask": selection.mask.toString()
               };
             })
             // Filter non-null ids for the same reason as above.
             .where((a) => a['id'] != null)
             .toList();
         }
       }
     }
 
     // Track dependencies that come from inlining.
@@ skipping 55 matching lines @@
     ChunkedConversionSink<Object> sink =
       encoder.startChunkedConversion(
           new StringConversionSink.fromStringSink(buffer));
     sink.add(outJson);
     compiler.reportInfo(NO_LOCATION_SPANNABLE,
         const MessageKind(
             "View the dumped .info.json file at "
             "https://dart-lang.github.io/dump-info-visualizer"));
   }
 }