Extract ClosedWorldRefiner implementation from ClosedWorldImpl to ClosedWorldBase

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/backend_api.dart' show BackendClasses;
 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,
-        FunctionElement,
         MemberElement,
         MixinApplicationElement,
         TypedefElement;
 import 'elements/resolution_types.dart';
 import 'elements/types.dart';
 import 'js_backend/backend.dart' show JavaScriptBackend;
 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;
@@ skipping 264 matching lines @@
   /// Returns the single [Element] 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(Element element);
+  SideEffects getSideEffectsOfElement(Entity element);
 
   /// Returns the side effects of calling [selector] on a receiver of type
   /// [mask].
   SideEffects getSideEffectsOfSelector(Selector selector, TypeMask mask);
 
   /// Returns `true` if [element] is guaranteed not to throw an exception.
-  bool getCannotThrow(Element element);
+  bool getCannotThrow(Entity element);
 
   /// Returns `true` if [element] is called in a loop.
   // TODO(johnniwinther): Is this 'potentially called' or 'known to be called'?
-  bool isCalledInLoop(Element element);
+  bool isCalledInLoop(Entity element);
 
   /// Returns `true` if [element] might be passed to `Function.apply`.
   // TODO(johnniwinther): Is this 'passed invocation target` or
   // `passed as argument`?
-  bool getMightBePassedToApply(Element element);
+  bool getMightBePassedToApply(Entity element);
 
   /// Returns a string representation of the closed world.
   ///
   /// If [cls] is provided, the dump will contain only classes related to [cls].
   String dump([ClassEntity cls]);
 }
 
 /// Interface for computing side effects and uses of elements. This is used
 /// during type inference to compute the [ClosedWorld] for code generation.
 abstract class ClosedWorldRefiner {
   /// The closed world being refined.
   ClosedWorld get closedWorld;
 
   /// Registers the side [effects] of executing [element].
-  void registerSideEffects(Element element, SideEffects effects);
+  void registerSideEffects(Entity element, SideEffects effects);
 
   /// Registers the executing of [element] as without side effects.
-  void registerSideEffectsFree(Element element);
+  void registerSideEffectsFree(Entity element);
 
   /// Returns the currently known side effects of executing [element].
-  SideEffects getCurrentlyKnownSideEffects(Element element);
+  SideEffects getCurrentlyKnownSideEffects(Entity element);
 
   /// Registers that [element] might be passed to `Function.apply`.
   // TODO(johnniwinther): Is this 'passed invocation target` or
   // `passed as argument`?
-  void registerMightBePassedToApply(Element element);
+  void registerMightBePassedToApply(Entity element);
 
   /// Returns `true` if [element] might be passed to `Function.apply` given the
   /// currently inferred information.
-  bool getCurrentlyKnownMightBePassedToApply(Element element);
+  bool getCurrentlyKnownMightBePassedToApply(Entity element);
 
   /// Registers that [element] is called in a loop.
   // TODO(johnniwinther): Is this 'potentially called' or 'known to be called'?
-  void addFunctionCalledInLoop(Element element);
+  void addFunctionCalledInLoop(Entity element);
 
   /// Registers that [element] is guaranteed not to throw an exception.
-  void registerCannotThrow(Element element);
+  void registerCannotThrow(Entity element);
 
   /// Adds the closure class [cls] to the inference world. The class is
   /// considered directly instantiated.
   void registerClosureClass(ClassElement cls);
 }
 
 abstract class OpenWorld implements World {
   /// Called to add [cls] to the set of known classes.
   ///
   /// This ensures that class hierarchy queries can be performed on [cls] and
@@ skipping 36 matching lines @@
   final Map<ClassEntity, Set<ClassEntity>> _typesImplementedBySubclasses;
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   final Map<ClassEntity, ClassHierarchyNode> _classHierarchyNodes;
   final Map<ClassEntity, ClassSet> _classSets;
 
   final Map<ClassEntity, Map<ClassEntity, bool>> _subtypeCoveredByCache =
       <ClassEntity, Map<ClassEntity, bool>>{};
 
-  final Set<Element> functionsCalledInLoop = new Set<Element>();
-  final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
+  final Set<Entity> _functionsCalledInLoop = new Set<Entity>();
+  final Map<Entity, SideEffects> _sideEffects = new Map<Entity, SideEffects>();
 
-  final Set<Element> sideEffectsFreeElements = new Set<Element>();
+  final Set<Entity> _sideEffectsFreeElements = new Set<Entity>();
 
-  final Set<Element> elementsThatCannotThrow = new Set<Element>();
+  final Set<Entity> _elementsThatCannotThrow = new Set<Entity>();
 
-  final Set<Element> functionsThatMightBePassedToApply =
-      new Set<FunctionElement>();
+  final Set<Entity> _functionsThatMightBePassedToApply = new Set<Entity>();
 
   CommonMasks _commonMasks;
 
   final CommonElements commonElements;
 
   final ResolutionWorldBuilder _resolverWorld;
 
   ClosedWorldBase(
       {JavaScriptBackend backend,
       this.commonElements,
@@ skipping 32 matching lines @@
   }
 
   ConstantSystem get constantSystem => _backend.constantSystem;
 
   TypeMask getCachedMask(ClassEntity base, int flags, TypeMask createMask()) {
     Map<ClassEntity, TypeMask> cachedMasks =
         _canonicalizedTypeMasks[flags] ??= <ClassEntity, TypeMask>{};
     return cachedMasks.putIfAbsent(base, createMask);
   }
 
+  bool _checkEntity(Entity element);
+
   bool _checkClass(ClassEntity cls);
 
   bool _checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true});
 
   @override
   bool isInstantiated(ClassEntity cls) {
     assert(_checkClass(cls));
     ClassHierarchyNode node = _classHierarchyNodes[cls];
     return node != null && node.isInstantiated;
   }
@@ skipping 412 matching lines @@
           assert(selector.isCall);
           sideEffects.setAllSideEffects();
           sideEffects.setDependsOnSomething();
         }
       } else {
         sideEffects.add(getSideEffectsOfElement(e));
       }
     }
     return sideEffects;
   }
+
+  SideEffects getSideEffectsOfElement(Entity element) {

[Emily Fortuna, 2017/04/12 18:07:18]

getSideEffectsOfEntity?

[Johnni Winther, 2017/04/18 07:36:08]

I'll stick with the name for now. I think needs to be split into member/locals
anyway.

+    assert(_checkEntity(element));
+    return _sideEffects.putIfAbsent(element, () {
+      return new SideEffects();
+    });
+  }
+
+  @override
+  SideEffects getCurrentlyKnownSideEffects(Entity element) {
+    return getSideEffectsOfElement(element);
+  }
+
+  void registerSideEffects(Entity element, SideEffects effects) {
+    assert(_checkEntity(element));
+    if (_sideEffectsFreeElements.contains(element)) return;
+    _sideEffects[element] = effects;
+  }
+
+  void registerSideEffectsFree(Entity element) {
+    assert(_checkEntity(element));
+    _sideEffects[element] = new SideEffects.empty();
+    _sideEffectsFreeElements.add(element);
+  }
+
+  void addFunctionCalledInLoop(Entity element) {
+    assert(_checkEntity(element));
+    _functionsCalledInLoop.add(element);
+  }
+
+  bool isCalledInLoop(Entity element) {
+    assert(_checkEntity(element));
+    return _functionsCalledInLoop.contains(element);
+  }
+
+  void registerCannotThrow(Entity element) {
+    assert(_checkEntity(element));
+    _elementsThatCannotThrow.add(element);
+  }
+
+  bool getCannotThrow(Entity element) {
+    return _elementsThatCannotThrow.contains(element);
+  }
+
+  void registerMightBePassedToApply(Entity element) {
+    _functionsThatMightBePassedToApply.add(element);
+  }
+
+  bool getMightBePassedToApply(Entity element) {
+    // We have to check whether the element we look at was created after
+    // type inference ran. This is currently only the case for the call
+    // method of function classes that were generated for function
+    // expressions. In such a case, we have to look at the original
+    // function expressions's element.
+    // TODO(herhut): Generate classes for function expressions earlier.
+    if (element is SynthesizedCallMethodElementX) {
+      return getMightBePassedToApply(element.expression);
+    }
+    return _functionsThatMightBePassedToApply.contains(element);
+  }
+
+  @override
+  bool getCurrentlyKnownMightBePassedToApply(Entity element) {
+    return getMightBePassedToApply(element);
+  }
 }
 
 class ClosedWorldImpl extends ClosedWorldBase {
   ClosedWorldImpl(
       {JavaScriptBackend backend,
       CommonElements commonElements,
       ResolutionWorldBuilder resolutionWorldBuilder,
       FunctionSetBuilder functionSetBuilder,
       Iterable<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
             backend: backend,
             commonElements: commonElements,
             resolutionWorldBuilder: resolutionWorldBuilder,
             functionSetBuilder: functionSetBuilder,
             allTypedefs: allTypedefs,
             mixinUses: mixinUses,
             typesImplementedBySubclasses: typesImplementedBySubclasses,
             classHierarchyNodes: classHierarchyNodes,
             classSets: classSets);
 
   bool _checkClass(ClassElement cls) => cls.isDeclaration;
+  bool _checkEntity(Element element) => element.isDeclaration;
 
   bool _checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     return invariant(cls, cls.isDeclaration,
                 message: '$cls must be the declaration.') &&
             invariant(cls, cls.isResolved,
                 message:
                     '$cls must be resolved.') /* &&
       // TODO(johnniwinther): Reinsert this or similar invariant. Currently
       // various call sites use uninstantiated classes for isSubtypeOf or
       // isSubclassOf. Some are valid, some are not. Work out better invariants
@@ skipping 205 matching lines @@
 
   SideEffects getSideEffectsOfElement(Element element) {
     // The type inferrer (where the side effects are being computed),
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
     // contain the side effects of the initializers.
     assert(!element.isGenerativeConstructorBody);
     assert(!element.isField);
-    return sideEffects.putIfAbsent(element.declaration, () {
-      return new SideEffects();
-    });
-  }
-
-  @override
-  SideEffects getCurrentlyKnownSideEffects(Element element) {
-    return getSideEffectsOfElement(element);
-  }
-
-  void registerSideEffects(Element element, SideEffects effects) {
-    if (sideEffectsFreeElements.contains(element)) return;
-    sideEffects[element.declaration] = effects;
-  }
-
-  void registerSideEffectsFree(Element element) {
-    sideEffects[element.declaration] = new SideEffects.empty();
-    sideEffectsFreeElements.add(element);
-  }
-
-  void addFunctionCalledInLoop(Element element) {
-    functionsCalledInLoop.add(element.declaration);
-  }
-
-  bool isCalledInLoop(Element element) {
-    return functionsCalledInLoop.contains(element.declaration);
-  }
-
-  void registerCannotThrow(Element element) {
-    elementsThatCannotThrow.add(element);
-  }
-
-  bool getCannotThrow(Element element) {
-    return elementsThatCannotThrow.contains(element);
-  }
-
-  void registerMightBePassedToApply(Element element) {
-    functionsThatMightBePassedToApply.add(element);
-  }
-
-  bool getMightBePassedToApply(Element element) {
-    // We have to check whether the element we look at was created after
-    // type inference ran. This is currently only the case for the call
-    // method of function classes that were generated for function
-    // expressions. In such a case, we have to look at the original
-    // function expressions's element.
-    // TODO(herhut): Generate classes for function expressions earlier.
-    if (element is SynthesizedCallMethodElementX) {
-      return getMightBePassedToApply(element.expression);
-    }
-    return functionsThatMightBePassedToApply.contains(element);
-  }
-
-  @override
-  bool getCurrentlyKnownMightBePassedToApply(Element element) {
-    return getMightBePassedToApply(element);
+    return super.getSideEffectsOfElement(element);
   }
 }