Use .callMethod instead of LocalFunctionElement as key in inference

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 'closure.dart' show ClosureClassElement;
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements, ElementEnvironment;
 import 'elements/entities.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         MemberElement,
+        MethodElement,
         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';
@@ skipping 277 matching lines @@
   /// 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);
+  SideEffects getSideEffectsOfElement(FunctionEntity 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(Entity element);
+  bool getCannotThrow(FunctionEntity element);
 
   /// Returns `true` if [element] is called in a loop.
   // TODO(johnniwinther): Is this 'potentially called' or 'known to be called'?
-  bool isCalledInLoop(Entity element);
+  // TODO(johnniwinther): Change [MemberEntity] to [FunctionEntity].
+  bool isCalledInLoop(MemberEntity element);
 
   /// Returns `true` if [element] might be passed to `Function.apply`.
   // TODO(johnniwinther): Is this 'passed invocation target` or
   // `passed as argument`?
-  bool getMightBePassedToApply(Entity element);
+  bool getMightBePassedToApply(FunctionEntity 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(Entity element, SideEffects effects);
+  void registerSideEffects(FunctionEntity element, SideEffects effects);
 
   /// Registers the executing of [element] as without side effects.
-  void registerSideEffectsFree(Entity element);
+  void registerSideEffectsFree(FunctionEntity element);
 
   /// Returns the currently known side effects of executing [element].
-  SideEffects getCurrentlyKnownSideEffects(Entity element);
+  SideEffects getCurrentlyKnownSideEffects(FunctionEntity element);
 
   /// Registers that [element] might be passed to `Function.apply`.
   // TODO(johnniwinther): Is this 'passed invocation target` or
   // `passed as argument`?
-  void registerMightBePassedToApply(Entity element);
+  void registerMightBePassedToApply(FunctionEntity element);
 
   /// Returns `true` if [element] might be passed to `Function.apply` given the
   /// currently inferred information.
-  bool getCurrentlyKnownMightBePassedToApply(Entity element);
+  bool getCurrentlyKnownMightBePassedToApply(FunctionEntity element);
 
   /// Registers that [element] is called in a loop.
   // TODO(johnniwinther): Is this 'potentially called' or 'known to be called'?
-  void addFunctionCalledInLoop(Entity element);
+  void addFunctionCalledInLoop(MemberEntity element);
 
   /// Registers that [element] is guaranteed not to throw an exception.
-  void registerCannotThrow(Entity element);
+  void registerCannotThrow(FunctionEntity element);
 
   /// Adds the closure class [cls] to the inference world. The class is
   /// considered directly instantiated.
   void registerClosureClass(covariant 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 38 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<Entity> _functionsCalledInLoop = new Set<Entity>();
-  final Map<Entity, SideEffects> _sideEffects = new Map<Entity, SideEffects>();
+  final Set<MemberEntity> _functionsCalledInLoop = new Set<MemberEntity>();
+  final Map<FunctionEntity, SideEffects> _sideEffects =
+      new Map<FunctionEntity, SideEffects>();
 
-  final Set<Entity> _sideEffectsFreeElements = new Set<Entity>();
+  final Set<FunctionEntity> _sideEffectsFreeElements =
+      new Set<FunctionEntity>();
 
-  final Set<Entity> _elementsThatCannotThrow = new Set<Entity>();
+  final Set<FunctionEntity> _elementsThatCannotThrow =
+      new Set<FunctionEntity>();
 
-  final Set<Entity> _functionsThatMightBePassedToApply = new Set<Entity>();
+  final Set<FunctionEntity> _functionsThatMightBePassedToApply =
+      new Set<FunctionEntity>();
 
   CommonMasks _commonMasks;
 
   final ElementEnvironment elementEnvironment;
   final DartTypes dartTypes;
   final CommonElements commonElements;
 
   // TODO(johnniwinther): Avoid this.
   final ResolutionWorldBuilder _resolverWorld;
 
@@ skipping 630 matching lines @@
           sideEffects.setAllSideEffects();
           sideEffects.setDependsOnSomething();
         }
       } else {
         sideEffects.add(getSideEffectsOfElement(e));
       }
     }
     return sideEffects;
   }
 
-  SideEffects getSideEffectsOfElement(covariant Entity element) {
+  SideEffects getSideEffectsOfElement(FunctionEntity element) {
     assert(checkEntity(element));
     return _sideEffects.putIfAbsent(element, _makeSideEffects);
   }
 
   static SideEffects _makeSideEffects() => new SideEffects();
 
   @override
-  SideEffects getCurrentlyKnownSideEffects(Entity element) {
+  SideEffects getCurrentlyKnownSideEffects(FunctionEntity element) {
     return getSideEffectsOfElement(element);
   }
 
-  void registerSideEffects(Entity element, SideEffects effects) {
+  void registerSideEffects(FunctionEntity element, SideEffects effects) {
     assert(checkEntity(element));
     if (_sideEffectsFreeElements.contains(element)) return;
     _sideEffects[element] = effects;
   }
 
-  void registerSideEffectsFree(Entity element) {
+  void registerSideEffectsFree(FunctionEntity element) {
     assert(checkEntity(element));
     _sideEffects[element] = new SideEffects.empty();
     _sideEffectsFreeElements.add(element);
   }
 
-  void addFunctionCalledInLoop(Entity element) {
+  void addFunctionCalledInLoop(MemberEntity element) {
     assert(checkEntity(element));
     _functionsCalledInLoop.add(element);
   }
 
-  bool isCalledInLoop(Entity element) {
+  bool isCalledInLoop(MemberEntity element) {
     assert(checkEntity(element));
     return _functionsCalledInLoop.contains(element);
   }
 
-  void registerCannotThrow(Entity element) {
+  void registerCannotThrow(FunctionEntity element) {
     assert(checkEntity(element));
     _elementsThatCannotThrow.add(element);
   }
 
-  bool getCannotThrow(Entity element) {
+  bool getCannotThrow(FunctionEntity element) {
     return _elementsThatCannotThrow.contains(element);
   }
 
-  void registerMightBePassedToApply(Entity element) {
+  void registerMightBePassedToApply(FunctionEntity 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);

[Siggi Cherem (dart-lang), 2017/06/30 18:13:54]

neat to get rid of this, but this is unrelated to your change right? We simply
created everything earlier now, correct?

[Johnni Winther, 2017/06/30 19:02:02]

No, this was a fix for the same kind of discrepancy as with isCalledInLoop, only
Stephan had found this.

[Siggi Cherem (dart-lang), 2017/06/30 20:34:36]

I see - the comment above was misleading, it gave me the impression that some
elements were created after inference: they were created before but we were
using the wrong one

[Johnni Winther, 2017/07/03 07:26:07]

When the comment was written they _were_ created after inference :)

-    }
+  bool getMightBePassedToApply(FunctionEntity element) {
     return _functionsThatMightBePassedToApply.contains(element);
   }
 
   @override
-  bool getCurrentlyKnownMightBePassedToApply(Entity element) {
+  bool getCurrentlyKnownMightBePassedToApply(FunctionEntity element) {
     return getMightBePassedToApply(element);
   }
 
   @override
   String dump([ClassEntity cls]) {
     if (cls is! ClassElement) {
       // TODO(johnniwinther): Support [cls] as a [ClassEntity].
       cls = null;
     }
     StringBuffer sb = new StringBuffer();
@@ skipping 137 matching lines @@
     if (cls != commonElements.functionClass &&
         cls.implementsFunction(commonElements)) {
       ClassSet subtypeSet = getClassSet(commonElements.functionClass);
       subtypeSet.addSubtype(node);
     }
     if (!node.isInstantiated && node.parentNode != null) {
       _updateSuperClassHierarchyNodeForClass(node.parentNode);
     }
   }
 
-  SideEffects getSideEffectsOfElement(Element element) {
+  SideEffects getSideEffectsOfElement(covariant MethodElement 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 super.getSideEffectsOfElement(element);
   }
 }