Always store GlobalTypeInferenceElementData on the member context

pkg/compiler/lib/src/inferrer/inferrer_engine.dart

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 59 matching lines @@
   /// Parallel structure for concreteTypes.
   // TODO(efortuna): Remove concreteTypes and/or parameterize InferrerEngine by
   // ir.Node or ast.Node type. Then remove this in favor of `concreteTypes`.
   final Map<ir.Node, TypeInformation> concreteKernelTypes =
       new Map<ir.Node, TypeInformation>();
   final Set<ConstructorElement> generativeConstructorsExposingThis =
       new Set<ConstructorElement>();
 
   /// Data computed internally within elements, like the type-mask of a send a
   /// list allocation, or a for-in loop.
-  final Map<Element, GlobalTypeInferenceElementData> inTreeData =
-      new Map<Element, GlobalTypeInferenceElementData>();
+  final Map<MemberElement, GlobalTypeInferenceElementData> _memberData =
+      new Map<MemberElement, GlobalTypeInferenceElementData>();
 
   InferrerEngine(this.compiler, ClosedWorld closedWorld,
       this.closedWorldRefiner, this.mainElement)
       : this.types = new TypeSystem(closedWorld),
         this.closedWorld = closedWorld;
 
   CommonElements get commonElements => closedWorld.commonElements;
 
   /// Returns `true` if [element] has an `@AssumeDynamic()` annotation.
   bool assumeDynamic(Element element) {
@@ skipping 11 matching lines @@
    * [selector] and [mask]. If [f] returns false, aborts the iteration.
    */
   void forEachElementMatching(
       Selector selector, TypeMask mask, bool f(Element element)) {
     Iterable<MemberEntity> elements = closedWorld.locateMembers(selector, mask);
     for (MemberElement e in elements) {
       if (!f(e.implementation)) return;
     }
   }
 
-  GlobalTypeInferenceElementData dataOfLocalFunction(
-          LocalFunctionElement element) =>
-      _dataOf(element);
-
   // TODO(johnniwinther): Make this private again.
   GlobalTypeInferenceElementData dataOfMember(MemberElement element) =>
-      _dataOf(element);
+      _memberData.putIfAbsent(
+          element, () => new GlobalTypeInferenceElementData());
 
-  GlobalTypeInferenceElementData _dataOf(AstElement element) => inTreeData

[Johnni Winther, 2017/06/29 17:00:28]

It turned out that we never (after type inference) read the data stored on a
local function. 

After investigating this, it turned out that the addition of [_dataOf] in
https://codereview.chromium.org/2468303003 actually unintentionally introduced
this (local functions share the TreeElements with their member context).

Surprisingly, this didn't show any regression back then (as far as i know) -
though I suspect the inference might have become slower; taking more iterations
to reach the same fixed-point by starting from scratch instead of using the data
collected in the local function data.

-      .putIfAbsent(element, () => new GlobalTypeInferenceElementData());
+  GlobalTypeInferenceElementData lookupDataOfMember(MemberElement element) =>
+      _memberData[element];
 
   /**
    * Update [sideEffects] with the side effects of [callee] being
    * called with [selector].
    */
   void updateSideEffects(
       SideEffects sideEffects, Selector selector, Element callee) {
     if (callee.isField) {
       if (callee.isInstanceMember) {
         if (selector.isSetter) {
@@ skipping 58 matching lines @@
         mappedType = types.nonNullSubtype(type.element);
       }
       returnType = types.computeLUB(returnType, mappedType);
       if (returnType == types.dynamicType) {
         break;
       }
     }
     return returnType;
   }
 
-  @deprecated
-  void updateSelectorInLocalFunction(LocalFunctionElement owner, Spannable node,
-      Selector selector, TypeMask mask) {
-    GlobalTypeInferenceElementData data = dataOfLocalFunction(owner);
-    _updateSelectorInTree(data, node, selector, mask);
-  }
-
   void updateSelectorInMember(
       MemberElement owner, Spannable node, Selector selector, TypeMask mask) {
     GlobalTypeInferenceElementData data = dataOfMember(owner);
-    _updateSelectorInTree(data, node, selector, mask);
-  }
-
-  void _updateSelectorInTree(GlobalTypeInferenceElementData data,
-      Spannable node, Selector selector, TypeMask mask) {
     ast.Node astNode = node;
     if (astNode.asSendSet() != null) {
       if (selector.isSetter || selector.isIndexSet) {
         data.setTypeMask(node, mask);
       } else if (selector.isGetter || selector.isIndex) {
         data.setGetterTypeMaskInComplexSendSet(node, mask);
       } else {
         assert(selector.isOperator);
         data.setOperatorTypeMaskInComplexSendSet(node, mask);
       }
@@ skipping 689 matching lines @@
    * [sideEffects] will be updated to incorporate [callee]'s side
    * effects.
    *
    * [inLoop] tells whether the call happens in a loop.
    */
   @deprecated
   TypeInformation registerCalledLocalFunction(
       Spannable node,
       Selector selector,
       TypeMask mask,
-      Element caller,
+      MemberElement caller,
       LocalFunctionElement callee,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     CallSiteTypeInformation info = new LocalFunctionCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         callee,
         selector,
@@ skipping 10 matching lines @@
    *
    * [sideEffects] will be updated to incorporate [callee]'s side
    * effects.
    *
    * [inLoop] tells whether the call happens in a loop.
    */
   TypeInformation registerCalledMember(
       Spannable node,
       Selector selector,
       TypeMask mask,
-      Element caller,
+      MemberElement caller,
       MemberElement callee,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     CallSiteTypeInformation info = new StaticCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         callee,
         selector,
@@ skipping 39 matching lines @@
    * [sideEffects] will be updated to incorporate the potential
    * callees' side effects.
    *
    * [inLoop] tells whether the call happens in a loop.
    */
   TypeInformation registerCalledSelector(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
-      Element caller,
+      MemberElement caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     if (selector.isClosureCall) {
       return registerCalledClosure(node, selector, mask, receiverType, caller,
           arguments, sideEffects, inLoop);
     }
 
     closedWorld.locateMembers(selector, mask).forEach((_callee) {
       MemberElement callee = _callee;
@@ skipping 45 matching lines @@
    * [sideEffects] will be updated to incorporate the potential
    * callees' side effects.
    *
    * [inLoop] tells whether the call happens in a loop.
    */
   TypeInformation registerCalledClosure(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation closure,
-      Element caller,
+      MemberElement caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     sideEffects.setDependsOnSomething();
     sideEffects.setAllSideEffects();
     CallSiteTypeInformation info = new ClosureCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         selector,
@@ skipping 143 matching lines @@
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local) {}
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }