Remove ClosedWorld.allFunctions

pkg/compiler/lib/src/world.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 dart2js.world;
 
 import 'closure.dart' show ClosureClassElement, SynthesizedCallMethodElementX;
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements;
 import 'elements/entities.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         MemberElement,
         MixinApplicationElement,
         TypedefElement;
 import 'elements/resolution_types.dart';
 import 'elements/types.dart';
 import 'js_backend/backend_usage.dart' show BackendUsage;
 import 'js_backend/interceptor_data.dart' show InterceptorData;
 import 'js_backend/native_data.dart' show NativeData;
 import 'ordered_typeset.dart';
 import 'types/masks.dart' show CommonMasks, FlatTypeMask, TypeMask;
 import 'universe/class_set.dart';
-import 'universe/function_set.dart' show FunctionSet, FunctionSetBuilder;
+import 'universe/function_set.dart' show FunctionSet;
 import 'universe/selector.dart' show Selector;
 import 'universe/side_effects.dart' show SideEffects;
 import 'universe/world_builder.dart' show ResolutionWorldBuilder;
 import 'util/util.dart' show Link;
 
 /// Common superinterface for [OpenWorld] and [ClosedWorld].
 abstract class World {}
 
 /// The [ClosedWorld] represents the information known about a program when
 /// compiling with closed-world semantics.
@@ skipping 225 matching lines @@
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClosedWorld].
   ClassSet getClassSet(ClassEntity cls);
 
   /// Return the cached mask for [base] with the given flags, or
   /// calls [createMask] to create the mask and cache it.
   // TODO(johnniwinther): Find a better strategy for caching these?
   TypeMask getCachedMask(ClassEntity base, int flags, TypeMask createMask());
 
-  /// Returns the [FunctionSet] containing all live functions in the closed
-  /// world.
-  FunctionSet get allFunctions;
-
   /// Returns `true` if the field [element] is known to be effectively final.
   bool fieldNeverChanges(MemberEntity element);
 
   /// Extends the receiver type [mask] for calling [selector] to take live
   /// `noSuchMethod` handlers into account.
   TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask);
 
   /// Returns all resolved typedefs.
   Iterable<TypedefElement> get allTypedefs;
 
-  /// Returns the single [Element] that matches a call to [selector] on a
+  /// Returns the mask for the potential receivers of a dynamic call to
+  /// [selector] on [mask].
+  ///
+  /// This will narrow the constraints of [mask] 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 computeReceiverType(Selector selector, TypeMask mask);
+
+  /// Returns all the instance members that may be invoked with the
+  /// [selector] on a receiver with the given [mask]. The returned elements may
+  /// include noSuchMethod handlers that are potential targets indirectly
+  /// through the noSuchMethod mechanism.
+  Iterable<MemberEntity> locateMembers(Selector selector, TypeMask mask);
+
+  /// Returns the single [MemberEntity] that matches a call to [selector] on a
   /// receiver of type [mask]. If multiple targets exist, `null` is returned.
   MemberEntity locateSingleElement(Selector selector, TypeMask mask);
 
   /// Returns the single field that matches a call to [selector] on a
   /// receiver of type [mask]. If multiple targets exist or the single target
   /// is not a field, `null` is returned.
   FieldEntity locateSingleField(Selector selector, TypeMask mask);
 
   /// Returns the side effects of executing [element].
   SideEffects getSideEffectsOfElement(Entity element);
@@ skipping 84 matching lines @@
   /// are included.
   SUBTYPE,
 }
 
 abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   final ConstantSystem constantSystem;
   final NativeData nativeData;
   final InterceptorData interceptorData;
   final BackendUsage _backendUsage;
 
-  FunctionSet _allFunctions;
+  final FunctionSet _allFunctions;
 
   final Iterable<TypedefElement> _allTypedefs;
 
   final Map<ClassEntity, Set<ClassEntity>> _mixinUses;
   Map<ClassEntity, List<ClassEntity>> _liveMixinUses;
 
   final Map<ClassEntity, Set<ClassEntity>> _typesImplementedBySubclasses;
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
@@ skipping 18 matching lines @@
 
   final ResolutionWorldBuilder _resolverWorld;
 
   ClosedWorldBase(
       {this.commonElements,
       this.constantSystem,
       this.nativeData,
       this.interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
-      FunctionSetBuilder functionSetBuilder,
+      FunctionSet functionSet,
       Iterable<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : this._backendUsage = backendUsage,
         this._resolverWorld = resolutionWorldBuilder,
+        this._allFunctions = functionSet,
         this._allTypedefs = allTypedefs,
         this._mixinUses = mixinUses,
         this._typesImplementedBySubclasses = typesImplementedBySubclasses,
         this._classHierarchyNodes = classHierarchyNodes,
         this._classSets = classSets {
     _commonMasks = new CommonMasks(this);
-    _allFunctions = functionSetBuilder.close(this);
   }
 
   @override
   ClosedWorld get closedWorld => this;
 
   /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
   /// `FlatTypeMask.flags` property.
   final List<Map<ClassEntity, TypeMask>> _canonicalizedTypeMasks =
       new List<Map<ClassEntity, TypeMask>>.filled(8, null);
 
-  FunctionSet get allFunctions => _allFunctions;
-
   CommonMasks get commonMasks {
     return _commonMasks;
   }
 
   TypeMask getCachedMask(ClassEntity base, int flags, TypeMask createMask()) {
     Map<ClassEntity, TypeMask> cachedMasks =
         _canonicalizedTypeMasks[flags] ??= <ClassEntity, TypeMask>{};
     return cachedMasks.putIfAbsent(base, createMask);
   }
 
@@ skipping 494 matching lines @@
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClosedWorld].
   ClassSet getClassSet(ClassEntity cls) {
     assert(_checkClass(cls));
     return _classSets[cls];
   }
 
   Iterable<TypedefElement> get allTypedefs => _allTypedefs;
 
+  TypeMask computeReceiverType(Selector selector, TypeMask mask) {
+    return _allFunctions.receiverType(selector, mask, this);
+  }
+
+  Iterable<MemberEntity> locateMembers(Selector selector, TypeMask mask) {
+    return _allFunctions.filter(selector, mask, this);
+  }
+
   bool hasAnyUserDefinedGetter(Selector selector, TypeMask mask) {
-    return allFunctions.filter(selector, mask).any((each) => each.isGetter);
+    return _allFunctions
+        .filter(selector, mask, this)
+        .any((each) => each.isGetter);
   }
 
   FieldEntity locateSingleField(Selector selector, TypeMask mask) {
     MemberEntity result = locateSingleElement(selector, mask);
     return (result != null && result.isField) ? result : null;
   }
 
   MemberEntity locateSingleElement(Selector selector, TypeMask mask) {
     mask ??= commonMasks.dynamicType;
     return mask.locateSingleElement(selector, this);
@@ skipping 25 matching lines @@
       return !_resolverWorld.hasInvokedSetter(element) &&
           !_resolverWorld.fieldSetters.contains(element);
     }
     return false;
   }
 
   SideEffects getSideEffectsOfSelector(Selector selector, TypeMask mask) {
     // We're not tracking side effects of closures.
     if (selector.isClosureCall) return new SideEffects();
     SideEffects sideEffects = new SideEffects.empty();
-    for (MemberElement e in allFunctions.filter(selector, mask)) {
+    for (MemberElement e in _allFunctions.filter(selector, mask, this)) {
       if (e.isField) {
         if (selector.isGetter) {
           if (!fieldNeverChanges(e)) {
             sideEffects.setDependsOnInstancePropertyStore();
           }
         } else if (selector.isSetter) {
           sideEffects.setChangesInstanceProperty();
         } else {
           assert(selector.isCall);
           sideEffects.setAllSideEffects();
@@ skipping 87 matching lines @@
 }
 
 class ClosedWorldImpl extends ClosedWorldBase {
   ClosedWorldImpl(
       {CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
-      FunctionSetBuilder functionSetBuilder,
+      FunctionSet functionSet,
       Iterable<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
             commonElements: commonElements,
             constantSystem: constantSystem,
             nativeData: nativeData,
             interceptorData: interceptorData,
             backendUsage: backendUsage,
             resolutionWorldBuilder: resolutionWorldBuilder,
-            functionSetBuilder: functionSetBuilder,
+            functionSet: functionSet,
             allTypedefs: allTypedefs,
             mixinUses: mixinUses,
             typesImplementedBySubclasses: typesImplementedBySubclasses,
             classHierarchyNodes: classHierarchyNodes,
             classSets: classSets);
 
   bool _checkClass(ClassElement cls) => cls.isDeclaration;
 
   bool _checkEntity(Element element) => element.isDeclaration;
 
@@ skipping 112 matching lines @@
 }
 
 class KernelClosedWorld extends ClosedWorldBase {
   KernelClosedWorld(
       {CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
-      FunctionSetBuilder functionSetBuilder,
+      FunctionSet functionSet,
       Iterable<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
             commonElements: commonElements,
             constantSystem: constantSystem,
             nativeData: nativeData,
             interceptorData: interceptorData,
             backendUsage: backendUsage,
             resolutionWorldBuilder: resolutionWorldBuilder,
-            functionSetBuilder: functionSetBuilder,
+            functionSet: functionSet,
             allTypedefs: allTypedefs,
             mixinUses: mixinUses,
             typesImplementedBySubclasses: typesImplementedBySubclasses,
             classHierarchyNodes: classHierarchyNodes,
             classSets: classSets);
 
   @override
   bool hasConcreteMatch(ClassEntity cls, Selector selector,
       {ClassEntity stopAtSuperclass}) {
     throw new UnimplementedError('KernelClosedWorld.hasConcreteMatch');
@@ skipping 42 matching lines @@
   @override
   void registerClosureClass(ClassElement cls) {
     throw new UnimplementedError('KernelClosedWorld.registerClosureClass');
   }
 
   @override
   bool hasElementIn(ClassEntity cls, Selector selector, Entity element) {
     throw new UnimplementedError('KernelClosedWorld.hasElementIn');
   }
 }