Always store GlobalTypeInferenceElementData on the member context

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

 // Copyright (c) 2013, 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 simple_types_inferrer;
 
 import '../closure.dart' show ClosureRepresentationInfo;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 38 matching lines @@
         SemanticSendResolvedMixin<TypeInformation, dynamic>,
         CompoundBulkMixin<TypeInformation, dynamic>,
         SetIfNullBulkMixin<TypeInformation, dynamic>,
         PrefixBulkMixin<TypeInformation, dynamic>,
         PostfixBulkMixin<TypeInformation, dynamic>,
         ErrorBulkMixin<TypeInformation, dynamic>,
         NewBulkMixin<TypeInformation, dynamic>,
         SetBulkMixin<TypeInformation, dynamic>
     implements SemanticSendVisitor<TypeInformation, dynamic> {
   final Compiler compiler;
-  final AstElement analyzedElement;
+  final ExecutableElement analyzedElement;
   final ResolvedAst resolvedAst;
   final TypeSystem types;
   final Map<JumpTarget, List<LocalsHandler>> breaksFor =
       new Map<JumpTarget, List<LocalsHandler>>();
   final Map<JumpTarget, List<LocalsHandler>> continuesFor =
       new Map<JumpTarget, List<LocalsHandler>>();
   LocalsHandler locals;
   final List<TypeInformation> cascadeReceiverStack =
       new List<TypeInformation>();
 
   TypeInformation returnType;
   bool visitingInitializers = false;
   bool isConstructorRedirect = false;
   bool seenSuperConstructorCall = false;
   SideEffects sideEffects = new SideEffects.empty();
-  final Element outermostElement;
+  final MemberElement outermostElement;
   final InferrerEngine inferrer;
   final Setlet<Entity> capturedVariables = new Setlet<Entity>();
   final GlobalTypeInferenceElementData inTreeData;

[Siggi Cherem (dart-lang), 2017/06/29 21:40:09]

rename to memberData like you did for the map in the other file? or simply
`data`? (since the builder is per-member already?)

[Johnni Winther, 2017/06/30 08:14:50]

Renamed to [memberData]. The builder is created for members _and_ local
functions.

 
   ElementGraphBuilder.internal(
-      AstElement analyzedElement,
+      ExecutableElement analyzedElement,
       this.resolvedAst,
       this.outermostElement,
       InferrerEngine inferrer,
       this.compiler,
       this.locals)
       : this.analyzedElement = analyzedElement,
         this.inferrer = inferrer,
         this.types = inferrer.types,
-        this.inTreeData = analyzedElement.isLocal
-            ? inferrer.dataOfLocalFunction(analyzedElement)
-            : inferrer.dataOfMember(analyzedElement) {
+        this.inTreeData = inferrer.dataOfMember(analyzedElement.memberContext) {
     assert(outermostElement != null);
     if (locals != null) return;
     ast.Node node;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       node = resolvedAst.node;
     }
     FieldInitializationScope fieldScope =
         analyzedElement.isGenerativeConstructor
             ? new FieldInitializationScope(types)
             : null;
     locals =
         new LocalsHandler(inferrer, types, compiler.options, node, fieldScope);
   }
 
-  ElementGraphBuilder(AstElement element, ResolvedAst resolvedAst,
+  ElementGraphBuilder(ExecutableElement element, ResolvedAst resolvedAst,
       Compiler compiler, InferrerEngine inferrer, [LocalsHandler handler])
-      : this.internal(
-            element,
-            resolvedAst,
-            element.outermostEnclosingMemberOrTopLevel.implementation,
-            inferrer,
-            compiler,
-            handler);
+      : this.internal(element, resolvedAst, element.memberContext, inferrer,
+            compiler, handler);
 
   TreeElements get elements => resolvedAst.elements;
 
   bool accumulateIsChecks = false;
   bool conditionIsSimple = false;
   List<ast.Send> isChecks;
   int loopLevel = 0;
 
   bool get inLoop => loopLevel > 0;
   bool get isThisExposed {
@@ skipping 2604 matching lines @@
         element, arguments, sideEffects, inLoop);
   }
 
   TypeInformation handleDynamicSend(ast.Node node, Selector selector,
       TypeMask mask, TypeInformation receiverType, ArgumentsTypes arguments) {
     assert(receiverType != null);
     if (types.selectorNeedsUpdate(receiverType, mask)) {
       mask = receiverType == types.dynamicType
           ? null
           : types.newTypedSelector(receiverType, mask);
-      if (analyzedElement.isLocal) {
-        inferrer.updateSelectorInLocalFunction(
-            analyzedElement, node, selector, mask);
-      } else {
-        inferrer.updateSelectorInMember(analyzedElement, node, selector, mask);
-      }
+      inferrer.updateSelectorInMember(outermostElement, node, selector, mask);
     }
 
     // If the receiver of the call is a local, we may know more about
     // its type by refining it with the potential targets of the
     // calls.
     ast.Send send = node.asSend();
     if (send != null) {
       ast.Node receiver = send.receiver;
       if (receiver != null) {
         Element element = elements[receiver];
@@ skipping 189 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }