Remove ClosedWorld.allFunctions

pkg/compiler/lib/src/universe/function_set.dart

 // Copyright (c) 2012, 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 universe.function_set;
 
 import '../common/names.dart' show Identifiers, Selectors;
 import '../elements/entities.dart';
 import '../types/types.dart';
 import '../util/util.dart' show Hashing, Setlet;
@@ skipping 17 matching lines @@
   void remove(MemberEntity element) {
     assert(element.isInstanceMember);
     assert(!element.isAbstract);
     String name = element.name;
     FunctionSetNode node = nodes[name];
     if (node != null) {
       node.remove(element);
     }
   }
 
-  FunctionSet close(ClosedWorld closedWorld) {
-    return new FunctionSet(closedWorld, nodes);
+  FunctionSet close() {
+    return new FunctionSet(nodes);
   }
 }
 
 // TODO(kasperl): This actually holds getters and setters just fine
 // too and stricly they aren't functions. Maybe this needs a better
 // name -- something like ElementSet seems a bit too generic.
 class FunctionSet {
-  final ClosedWorld closedWorld;
-  final Map<String, FunctionSetNode> nodes;
+  final Map<String, FunctionSetNode> _nodes;
 
-  FunctionSet(this.closedWorld, this.nodes);
+  FunctionSet(this._nodes);
 
   bool contains(MemberEntity element) {
     assert(element.isInstanceMember);
     assert(!element.isAbstract);
     String name = element.name;
-    FunctionSetNode node = nodes[name];
+    FunctionSetNode node = _nodes[name];
     return (node != null) ? node.contains(element) : false;
   }
 
   /// Returns all the functions that may be invoked with the [selector] on a
   /// receiver with the given [constraint]. The returned elements may include
   /// noSuchMethod handlers that are potential targets indirectly through the
   /// noSuchMethod mechanism.
-  Iterable<MemberEntity> filter(
-      Selector selector, ReceiverConstraint constraint) {
-    return query(selector, constraint).functions;
+  Iterable<MemberEntity> filter(Selector selector,
+      ReceiverConstraint constraint, ClosedWorld closedWorld) {
+    return query(selector, constraint, closedWorld).functions;
   }
 
   /// Returns the mask for the potential receivers of a dynamic call to
   /// [selector] on [constraint].
   ///
   /// This will narrow the constraints of [constraint] to a [TypeMask] of the
   /// set of classes that actually implement the selected member or implement
   /// the handling 'noSuchMethod' where the selected member is unimplemented.
-  TypeMask receiverType(Selector selector, ReceiverConstraint constraint) {
-    return query(selector, constraint).computeMask(closedWorld);
+  TypeMask receiverType(Selector selector, ReceiverConstraint constraint,
+      ClosedWorld closedWorld) {
+    return query(selector, constraint, closedWorld).computeMask(closedWorld);
   }
 
   SelectorMask _createSelectorMask(Selector selector,
       ReceiverConstraint constraint, ClosedWorld closedWorld) {
     return constraint != null
         ? new SelectorMask(selector, constraint)
         : new SelectorMask(
             selector,
             new TypeMask.subclass(
                 closedWorld.commonElements.objectClass, closedWorld));
   }
 
   /// Returns the set of functions that can be the target of a call to
   /// [selector] on a receiver constrained by [constraint] including
   /// 'noSuchMethod' methods where applicable.
-  FunctionSetQuery query(Selector selector, ReceiverConstraint constraint) {
+  FunctionSetQuery query(Selector selector, ReceiverConstraint constraint,
+      ClosedWorld closedWorld) {
     String name = selector.name;
     SelectorMask selectorMask =
         _createSelectorMask(selector, constraint, closedWorld);
     SelectorMask noSuchMethodMask =
         new SelectorMask(Selectors.noSuchMethod_, selectorMask.constraint);
-    FunctionSetNode node = nodes[name];
-    FunctionSetNode noSuchMethods = nodes[Identifiers.noSuchMethod_];
+    FunctionSetNode node = _nodes[name];
+    FunctionSetNode noSuchMethods = _nodes[Identifiers.noSuchMethod_];
     if (node != null) {
       return node.query(
           selectorMask, closedWorld, noSuchMethods, noSuchMethodMask);
     }
     // If there is no method that matches [selector] we know we can
     // only hit [:noSuchMethod:].
     if (noSuchMethods == null) {
       return const EmptyFunctionSetQuery();
     }
     return noSuchMethods.query(noSuchMethodMask, closedWorld);
   }
 
-  void forEach(Function action) {
-    nodes.forEach((String name, FunctionSetNode node) {
+  void forEach(void action(MemberEntity member)) {
+    _nodes.forEach((String name, FunctionSetNode node) {
       node.forEach(action);
     });
   }
 }
 
 /// A selector/constraint pair representing the dynamic invocation of [selector]
 /// on a receiver constrained by [constraint].
 class SelectorMask {
   final Selector selector;
   final ReceiverConstraint constraint;
@@ skipping 27 matching lines @@
 }
 
 /// A node in the [FunctionSet] caching all [FunctionSetQuery] object for
 /// selectors with the same [name].
 class FunctionSetNode {
   final String name;
   final Map<SelectorMask, FunctionSetQuery> cache =
       <SelectorMask, FunctionSetQuery>{};
 
   // Initially, we keep the elements in a list because it is more
   // compact than a hash set. Once we get enough elements, we change

[Siggi Cherem (dart-lang), 2017/05/03 17:03:24]

do you know if this is still the case, or does hashset now has this kind of
optimizations built in?

[Johnni Winther, 2017/05/08 09:10:53]

I think this is built in now, I'll check at update later.

   // the representation to be a set to get faster contains checks.
   static const int MAX_ELEMENTS_IN_LIST = 8;
-  var elements = <MemberEntity>[];
+  Iterable<MemberEntity> elements = <MemberEntity>[];
   bool isList = true;
 
   FunctionSetNode(this.name);
 
   void add(MemberEntity element) {
     assert(element.name == name);
     // We try to avoid clearing the cache unless we have to. For that
     // reason we keep the explicit contains check even though the add
     // method ends up doing the work again (for sets).
     if (!elements.contains(element)) {
       if (isList && elements.length >= MAX_ELEMENTS_IN_LIST) {
         elements = elements.toSet();
         isList = false;
       }
-      elements.add(element);
+      if (isList) {
+        List list = elements;
+        list.add(element);
+      } else {
+        Set set = elements;
+        set.add(element);
+      }
       if (!cache.isEmpty) cache.clear();
     }
   }
 
   void remove(MemberEntity element) {
     assert(element.name == name);
     if (isList) {
       List list = elements;
       int index = list.indexOf(element);
       if (index < 0) return;
@@ skipping 11 matching lines @@
         if (!cache.isEmpty) cache.clear();
       }
     }
   }
 
   bool contains(MemberEntity element) {
     assert(element.name == name);
     return elements.contains(element);
   }
 
-  void forEach(Function action) {
+  void forEach(void action(MemberEntity member)) {
     elements.forEach(action);
   }
 
   /// Returns the set of functions that can be the target of [selectorMask]
   /// including no such method handling where applicable.
   FunctionSetQuery query(SelectorMask selectorMask, ClosedWorld closedWorld,
       [FunctionSetNode noSuchMethods, SelectorMask noSuchMethodMask]) {
     assert(selectorMask.name == name);
     FunctionSetQuery result = cache[selectorMask];
     if (result != null) return result;
@@ skipping 80 matching lines @@
           } else if (closedWorld.isInstantiated(cls)) {
             return new TypeMask.nonNullSubclass(cls, closedWorld);
           } else {
             // TODO(johnniwinther): Avoid the need for this case.
             return const TypeMask.empty();
           }
         }),
         closedWorld);
   }
 }