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;
+  final GlobalTypeInferenceElementData memberData;
 
   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.memberData = 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 1105 matching lines @@
   }
 
   TypeInformation handleSendSet(ast.SendSet node) {
     Element element = elements[node];
     if (!Elements.isUnresolved(element) && element.impliesType) {
       node.visitChildren(this);
       return types.dynamicType;
     }
 
     Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
-    TypeMask getterMask = inTreeData.typeOfGetter(node);
-    TypeMask operatorMask = inTreeData.typeOfOperator(node);
+    TypeMask getterMask = memberData.typeOfGetter(node);
+    TypeMask operatorMask = memberData.typeOfOperator(node);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = inTreeData.typeOfSend(node);
+    TypeMask setterMask = memberData.typeOfSend(node);
 
     String op = node.assignmentOperator.source;
     bool isIncrementOrDecrement = op == '++' || op == '--';
 
     TypeInformation receiverType;
     bool isCallOnThis = false;
     if (node.receiver == null) {
       if (treatAsInstanceMember(element)) {
         receiverType = thisType;
         isCallOnThis = true;
@@ skipping 93 matching lines @@
   }
 
   /// Handle compound index set, like `foo[0] += 42` or `foo[0]++`.
   TypeInformation handleCompoundIndexSet(
       ast.SendSet node,
       TypeInformation receiverType,
       TypeInformation indexType,
       TypeInformation rhsType) {
     Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
 
-    TypeMask getterMask = inTreeData.typeOfGetter(node);
+    TypeMask getterMask = memberData.typeOfGetter(node);
     Selector operatorSelector =
         elements.getOperatorSelectorInComplexSendSet(node);
-    TypeMask operatorMask = inTreeData.typeOfOperator(node);
+    TypeMask operatorMask = memberData.typeOfOperator(node);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = inTreeData.typeOfSend(node);
+    TypeMask setterMask = memberData.typeOfSend(node);
 
     TypeInformation getterType = handleDynamicSend(node, getterSelector,
         getterMask, receiverType, new ArgumentsTypes([indexType], null));
 
     TypeInformation returnType;
     if (node.isIfNullAssignment) {
       returnType = types.allocateDiamondPhi(getterType, rhsType);
     } else {
       returnType = handleDynamicSend(node, operatorSelector, operatorMask,
           getterType, new ArgumentsTypes([rhsType], null));
@@ skipping 76 matching lines @@
     TypeInformation indexType = visit(index);
     TypeInformation rhsType = visit(rhs);
     return _handleSuperCompoundIndexSet(
         node, getter, setter, indexType, rhsType);
   }
 
   TypeInformation _handleSuperCompoundIndexSet(ast.SendSet node, Element getter,
       Element setter, TypeInformation indexType, TypeInformation rhsType) {
     Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
 
-    TypeMask getterMask = inTreeData.typeOfGetter(node);
+    TypeMask getterMask = memberData.typeOfGetter(node);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = inTreeData.typeOfSend(node);
+    TypeMask setterMask = memberData.typeOfSend(node);
 
     TypeInformation getterType = handleSuperSend(node, getterSelector,
         getterMask, getter, new ArgumentsTypes([indexType], null));
 
     TypeInformation returnType;
     if (node.isIfNullAssignment) {
       returnType = types.allocateDiamondPhi(getterType, rhsType);
     } else {
       Selector operatorSelector =
           elements.getOperatorSelectorInComplexSendSet(node);
-      TypeMask operatorMask = inTreeData.typeOfOperator(node);
+      TypeMask operatorMask = memberData.typeOfOperator(node);
       returnType = handleDynamicSend(node, operatorSelector, operatorMask,
           getterType, new ArgumentsTypes([rhsType], null));
     }
     handleSuperSend(node, setterSelector, setterMask, setter,
         new ArgumentsTypes([indexType, returnType], null));
 
     return node.isPostfix ? getterType : returnType;
   }
 
   TypeInformation handleSuperSend(ast.Node node, Selector selector,
@@ skipping 402 matching lines @@
   }
 
   TypeInformation handleSuperPrefixPostfix(
       ast.SendSet node, Element getter, Element setter) {
     return _handleSuperCompound(node, getter, setter, types.uint31Type);
   }
 
   TypeInformation _handleSuperCompound(ast.SendSet node, Element getter,
       Element setter, TypeInformation rhsType) {
     Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
-    TypeMask getterMask = inTreeData.typeOfGetter(node);
+    TypeMask getterMask = memberData.typeOfGetter(node);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = inTreeData.typeOfSend(node);
+    TypeMask setterMask = memberData.typeOfSend(node);
 
     TypeInformation getterType =
         handleSuperSend(node, getterSelector, getterMask, getter, null);
 
     TypeInformation returnType;
     if (node.isIfNullAssignment) {
       returnType = types.allocateDiamondPhi(getterType, rhsType);
     } else {
       Selector operatorSelector =
           elements.getOperatorSelectorInComplexSendSet(node);
-      TypeMask operatorMask = inTreeData.typeOfOperator(node);
+      TypeMask operatorMask = memberData.typeOfOperator(node);
       returnType = handleDynamicSend(node, operatorSelector, operatorMask,
           getterType, new ArgumentsTypes([rhsType], null));
     }
     handleSuperSend(node, setterSelector, setterMask, setter,
         new ArgumentsTypes([returnType], null));
 
     return node.isPostfix ? getterType : returnType;
   }
 
   /// Handle index set, like `foo[0] = 42`.
   TypeInformation handleIndexSet(ast.SendSet node, TypeInformation receiverType,
       TypeInformation indexType, TypeInformation rhsType) {
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = inTreeData.typeOfSend(node);
+    TypeMask setterMask = memberData.typeOfSend(node);
     handleDynamicSend(node, setterSelector, setterMask, receiverType,
         new ArgumentsTypes([indexType, rhsType], null));
     return rhsType;
   }
 
   @override
   TypeInformation visitIndexSet(
       ast.SendSet node, ast.Node receiver, ast.Node index, ast.Node rhs, _) {
     TypeInformation receiverType = visit(receiver);
     TypeInformation indexType = visit(index);
     TypeInformation rhsType = visit(rhs);
     return handleIndexSet(node, receiverType, indexType, rhsType);
   }
 
   /// Handle super index set, like `super[42] = true`.
   TypeInformation handleSuperIndexSet(
       ast.SendSet node, Element element, ast.Node index, ast.Node rhs) {
     TypeInformation indexType = visit(index);
     TypeInformation rhsType = visit(rhs);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = inTreeData.typeOfSend(node);
+    TypeMask setterMask = memberData.typeOfSend(node);
     handleStaticSend(node, setterSelector, setterMask, element,
         new ArgumentsTypes([indexType, rhsType], null));
     return rhsType;
   }
 
   @override
   TypeInformation visitSuperIndexSet(ast.SendSet node, FunctionElement function,
       ast.Node index, ast.Node rhs, _) {
     return handleSuperIndexSet(node, function, index, rhs);
   }
@@ skipping 54 matching lines @@
       locals.update(element, rhsType, node);
     }
     return rhsType;
   }
 
   /// Handle a super access or invocation that results in a `noSuchMethod` call.
   TypeInformation handleErroneousSuperSend(ast.Send node) {
     ArgumentsTypes arguments =
         node.isPropertyAccess ? null : analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     // TODO(herhut): We could do better here if we knew what we
     // are calling does not expose this.
     // TODO(johnniwinther): Do we still need this when calling directly?
     isThisExposed = true;
     return handleSuperNoSuchMethod(node, selector, mask, arguments);
   }
 
   TypeInformation handleSuperNoSuchMethod(ast.Send node, Selector selector,
       TypeMask mask, ArgumentsTypes arguments) {
     // Ensure we create a node, to make explicit the call to the
     // `noSuchMethod` handler.
     ClassElement cls = outermostElement.enclosingClass;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
       ClassElement objectClass = closedWorld.commonElements.objectClass;
       element = objectClass.lookupMember(Identifiers.noSuchMethod_);
     }
     return handleStaticSend(node, selector, mask, element, arguments);
   }
 
   /// Handle a .call invocation on the values retrieved from the super
   /// [element]. For instance `super.foo(bar)` where `foo` is a field or getter.
   TypeInformation handleSuperClosureCall(
       ast.Send node, MemberElement element, ast.NodeList arguments) {
     ArgumentsTypes argumentTypes = analyzeArguments(arguments.nodes);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     // TODO(herhut): We could do better here if we knew what we
     // are calling does not expose this.
     isThisExposed = true;
     return inferrer.registerCalledClosure(
         node,
         selector,
         mask,
         inferrer.typeOfMember(element),
         outermostElement,
         argumentTypes,
         sideEffects,
         inLoop);
   }
 
   /// Handle an invocation of super [method].
   TypeInformation handleSuperMethodInvoke(
       ast.Send node, MethodElement method, ArgumentsTypes arguments) {
     // TODO(herhut): We could do better here if we knew what we
     // are calling does not expose this.
     isThisExposed = true;
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, method, arguments);
   }
 
   /// Handle access to a super field or getter [element].
   TypeInformation handleSuperGet(ast.Send node, Element element) {
     // TODO(herhut): We could do better here if we knew what we
     // are calling does not expose this.
     isThisExposed = true;
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, element, null);
   }
 
   /// Handle update to a super field or setter [element].
   TypeInformation handleSuperSet(ast.Send node, Element element, ast.Node rhs) {
     TypeInformation rhsType = visit(rhs);
     // TODO(herhut): We could do better here if we knew what we
     // are calling does not expose this.
     isThisExposed = true;
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     handleStaticSend(
         node, selector, mask, element, new ArgumentsTypes([rhsType], null));
     return rhsType;
   }
 
   @override
   TypeInformation visitSuperFieldSet(
       ast.Send node, FieldElement method, ast.Node rhs, _) {
     return handleSuperSet(node, method, rhs);
   }
@@ skipping 209 matching lines @@
     // TODO(herhut): Remove the loop once effectiveTarget forwards to patches.
     while (target.isFactoryConstructor) {
       if (!target.isRedirectingFactory) break;
       target = target.effectiveTarget.implementation;
     }
     if (compiler.backend.isForeign(closedWorld.commonElements, target)) {
       return handleForeignSend(node, target);
     }
     Selector selector = elements.getSelector(node);
     CallStructure callStructure = selector.callStructure;
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     // In erroneous code the number of arguments in the selector might not
     // match the function element.
     // TODO(polux): return nonNullEmpty and check it doesn'TypeInformation break anything
     if (target.isMalformed ||
         !callStructure.signatureApplies(target.parameterStructure)) {
       return types.dynamicType;
     }
 
     TypeInformation returnType =
         handleStaticSend(node, selector, mask, target, arguments);
@@ skipping 46 matching lines @@
       CallStructure callStructure,
       _) {
     return bulkHandleNew(node, _);
   }
 
   /// Handle invocation of a top level or static field or getter [element].
   TypeInformation handleStaticFieldOrGetterInvoke(
       ast.Send node, MemberElement element) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     handleStaticSend(node, selector, mask, element, arguments);
     return inferrer.registerCalledClosure(
         node,
         selector,
         mask,
         inferrer.typeOfMember(element),
         outermostElement,
         arguments,
         sideEffects,
         inLoop);
   }
 
   /// Handle invocation of a top level or static [function].
   TypeInformation handleStaticFunctionInvoke(
       ast.Send node, MethodElement function) {
     if (compiler.backend.isForeign(closedWorld.commonElements, function)) {
       return handleForeignSend(node, function);
     }
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, function, arguments);
   }
 
   /// Handle an static invocation of an unresolved target or with incompatible
   /// arguments to a resolved target.
   TypeInformation handleInvalidStaticInvoke(ast.Send node) {
     analyzeArguments(node.arguments);
     return types.dynamicType;
   }
 
@@ skipping 75 matching lines @@
 
   @override
   TypeInformation visitUnresolvedInvoke(ast.Send node, Element element,
       ast.NodeList arguments, Selector selector, _) {
     return handleInvalidStaticInvoke(node);
   }
 
   TypeInformation handleForeignSend(ast.Send node, Element element) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     String name = element.name;
     handleStaticSend(node, selector, mask, element, arguments);
     if (name == JavaScriptBackend.JS ||
         name == JavaScriptBackend.JS_EMBEDDED_GLOBAL ||
         name == JavaScriptBackend.JS_BUILTIN) {
       native.NativeBehavior nativeBehavior = elements.getNativeData(node);
       sideEffects.add(nativeBehavior.sideEffects);
       return inferrer.typeOfNativeBehavior(nativeBehavior);
     } else if (name == 'JS_OPERATOR_AS_PREFIX' || name == 'JS_STRING_CONCAT') {
       return types.stringType;
@@ skipping 24 matching lines @@
 
   /// Read a local variable, function or parameter.
   TypeInformation handleLocalGet(ast.Send node, LocalElement local) {
     assert(locals.use(local) != null);
     return locals.use(local);
   }
 
   /// Read a static or top level field.
   TypeInformation handleStaticFieldGet(ast.Send node, FieldElement field) {
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, field, null);
   }
 
   /// Invoke a static or top level getter.
   TypeInformation handleStaticGetterGet(ast.Send node, GetterElement getter) {
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, getter, null);
   }
 
   /// Closurize a static or top level function.
   TypeInformation handleStaticFunctionGet(
       ast.Send node, MethodElement function) {
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, function, null);
   }
 
   @override
   TypeInformation visitDynamicPropertyGet(
       ast.Send node, ast.Node receiver, Name name, _) {
     return handleDynamicGet(node);
   }
 
   @override
@@ skipping 71 matching lines @@
 
   @override
   TypeInformation visitUnresolvedGet(ast.Send node, Element element, _) {
     return types.dynamicType;
   }
 
   /// Handle .call invocation on [closure].
   TypeInformation handleCallInvoke(ast.Send node, TypeInformation closure) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     return inferrer.registerCalledClosure(node, selector, mask, closure,
         outermostElement, arguments, sideEffects, inLoop);
   }
 
   @override
   TypeInformation visitExpressionInvoke(ast.Send node, ast.Node expression,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleCallInvoke(node, expression.accept(this));
   }
 
@@ skipping 25 matching lines @@
 
   @override
   TypeInformation visitLocalFunctionInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     ArgumentsTypes argumentTypes = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     // This only works for function statements. We need a
     // more sophisticated type system with function types to support
     // more.
     return inferrer.registerCalledLocalFunction(node, selector, mask,
         outermostElement, function, argumentTypes, sideEffects, inLoop);
   }
 
   @override
   TypeInformation visitLocalFunctionIncompatibleInvoke(
       ast.Send node,
@@ skipping 18 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 26 matching lines @@
         isCallOnThis = true;
         receiverType = thisType;
       }
     } else {
       ast.Node receiver = node.receiver;
       isCallOnThis = isThisOrSuper(receiver);
       receiverType = visit(receiver);
     }
 
     Selector selector = elements.getSelector(node);
-    TypeMask mask = inTreeData.typeOfSend(node);
+    TypeMask mask = memberData.typeOfSend(node);
     if (!isThisExposed && isCallOnThis) {
       checkIfExposesThis(selector, types.newTypedSelector(receiverType, mask));
     }
 
     ArgumentsTypes arguments =
         node.isPropertyAccess ? null : analyzeArguments(node.arguments);
     if (selector.name == '==' || selector.name == '!=') {
       if (types.isNull(receiverType)) {
         potentiallyAddNullCheck(node, node.arguments.head);
         return types.boolType;
@@ skipping 91 matching lines @@
 
     if (node.expression.isThis()) {
       // Any reasonable implementation of an iterator would expose
       // this, so we play it safe and assume it will.
       isThisExposed = true;
     }
 
     ast.Node identifier = node.declaredIdentifier;
     Element element = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
-    TypeMask mask = inTreeData.typeOfSend(identifier.asSend());
+    TypeMask mask = memberData.typeOfSend(identifier.asSend());
 
     TypeInformation receiverType;
     if (element != null && element.isInstanceMember) {
       receiverType = thisType;
     } else {
       receiverType = types.dynamicType;
     }
 
     handlePlainAssignment(identifier, element, selector, mask, receiverType,
         currentType, node.expression);
     return handleLoop(node, () {
       visit(node.body);
     });
   }
 
   TypeInformation visitAsyncForIn(ast.AsyncForIn node) {
     TypeInformation expressionType = visit(node.expression);
 
     Selector currentSelector = Selectors.current;
-    TypeMask currentMask = inTreeData.typeOfIteratorCurrent(node);
+    TypeMask currentMask = memberData.typeOfIteratorCurrent(node);
     Selector moveNextSelector = Selectors.moveNext;
-    TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
+    TypeMask moveNextMask = memberData.typeOfIteratorMoveNext(node);
 
     ConstructorElement ctor =
         closedWorld.commonElements.streamIteratorConstructor;
 
     /// Synthesize a call to the [StreamIterator] constructor.
     TypeInformation iteratorType = handleStaticSend(
         node, null, null, ctor, new ArgumentsTypes([expressionType], null));
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 
   TypeInformation visitSyncForIn(ast.SyncForIn node) {
     TypeInformation expressionType = visit(node.expression);
     Selector iteratorSelector = Selectors.iterator;
-    TypeMask iteratorMask = inTreeData.typeOfIterator(node);
+    TypeMask iteratorMask = memberData.typeOfIterator(node);
     Selector currentSelector = Selectors.current;
-    TypeMask currentMask = inTreeData.typeOfIteratorCurrent(node);
+    TypeMask currentMask = memberData.typeOfIteratorCurrent(node);
     Selector moveNextSelector = Selectors.moveNext;
-    TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
+    TypeMask moveNextMask = memberData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }