dart2js: move type-mask intermediate data from tree-elements into the global

pkg/compiler/lib/src/inferrer/simple_types_inferrer.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 ClosureClassMap;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart' show ConstantValue, IntConstantValue;
 import '../core_types.dart' show CoreClasses, CoreTypes;
 import '../dart_types.dart' show DartType;
 import '../elements/elements.dart';
 import '../js_backend/backend_helpers.dart';
 import '../js_backend/js_backend.dart' as js;
 import '../native/native.dart' as native;
 import '../resolution/operators.dart' as op;
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart' as ast;
-import '../types/types.dart' show TypeMask;
+import '../types/types.dart' show TypeMask, GlobalTypeInferenceElementData;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart' show Link, Setlet;
 import '../world.dart' show ClosedWorld;
 import 'inferrer_visitor.dart';
 
 /**
  * Common super class used by [SimpleTypeInferrerVisitor] to propagate
  * type information about visited nodes, as well as to request type
  * information of elements.
  */
 abstract class InferrerEngine<T, V extends TypeSystem>
     implements MinimalInferrerEngine<T> {
   final Compiler compiler;
   final ClosedWorld closedWorld;
   final V types;
   final Map<ast.Node, T> concreteTypes = new Map<ast.Node, T>();
   final Set<Element> generativeConstructorsExposingThis = new Set<Element>();
 
+  /// 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>();
+
   InferrerEngine(Compiler compiler, this.types)
       : this.compiler = compiler,
         this.closedWorld = compiler.closedWorld;
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   CoreTypes get coreTypes => compiler.coreTypes;
 
   /**
    * Records the default type of parameter [parameter].
@@ skipping 122 matching lines @@
    */
   void forEachElementMatching(
       Selector selector, TypeMask mask, bool f(Element element)) {
     Iterable<Element> elements =
         compiler.closedWorld.allFunctions.filter(selector, mask);
     for (Element e in elements) {
       if (!f(e.implementation)) return;
     }
   }
 
+  GlobalTypeInferenceElementData _dataOf(AstElement element) => inTreeData
+      .putIfAbsent(element, () => new GlobalTypeInferenceElementData());
+
   /**
    * 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) {
           sideEffects.setChangesInstanceProperty();
@@ skipping 60 matching lines @@
         break;
       }
     }
     return returnType;
   }
 
   // TODO(johnniwinther): Pass the [ResolvedAst] instead of [owner].
   void updateSelectorInTree(
       AstElement owner, Spannable node, Selector selector, TypeMask mask) {
     ast.Node astNode = node;
-    TreeElements elements = owner.resolvedAst.elements;
+    GlobalTypeInferenceElementData data = _dataOf(owner);
     if (astNode.asSendSet() != null) {
       if (selector.isSetter || selector.isIndexSet) {
-        elements.setTypeMask(node, mask);
+        data.setTypeMask(node, mask);
       } else if (selector.isGetter || selector.isIndex) {
-        elements.setGetterTypeMaskInComplexSendSet(node, mask);
+        data.setGetterTypeMaskInComplexSendSet(node, mask);
       } else {
         assert(selector.isOperator);
-        elements.setOperatorTypeMaskInComplexSendSet(node, mask);
+        data.setOperatorTypeMaskInComplexSendSet(node, mask);
       }
     } else if (astNode.asSend() != null) {
-      elements.setTypeMask(node, mask);
+      data.setTypeMask(node, mask);
     } else {
       assert(astNode.asForIn() != null);
       if (selector == Selectors.iterator) {
-        elements.setIteratorTypeMask(node, mask);
+        data.setIteratorTypeMask(node, mask);
       } else if (selector == Selectors.current) {
-        elements.setCurrentTypeMask(node, mask);
+        data.setCurrentTypeMask(node, mask);
       } else {
         assert(selector == Selectors.moveNext);
-        elements.setMoveNextTypeMask(node, mask);
+        data.setMoveNextTypeMask(node, mask);
       }
     }
   }
 
   bool isNativeElement(Element element) {
     return compiler.backend.isNative(element);
   }
 
   void analyze(ResolvedAst resolvedAst, ArgumentsTypes arguments);
 
@@ skipping 22 matching lines @@
 class SimpleTypeInferrerVisitor<T>
     extends InferrerVisitor<T, InferrerEngine<T, TypeSystem<T>>> {
   T returnType;
   bool visitingInitializers = false;
   bool isConstructorRedirect = false;
   bool seenSuperConstructorCall = false;
   SideEffects sideEffects = new SideEffects.empty();
   final Element outermostElement;
   final InferrerEngine<T, TypeSystem<T>> inferrer;
   final Setlet<Entity> capturedVariables = new Setlet<Entity>();
+  final GlobalTypeInferenceElementData inTreeData;
 
   SimpleTypeInferrerVisitor.internal(
       AstElement analyzedElement,
       ResolvedAst resolvedAst,
       this.outermostElement,
       inferrer,
       compiler,
       locals)
       : super(analyzedElement, resolvedAst, inferrer, inferrer.types, compiler,
             locals),
-        this.inferrer = inferrer {
+        this.inferrer = inferrer,
+        this.inTreeData = inferrer._dataOf(analyzedElement) {
     assert(outermostElement != null);
   }
 
   SimpleTypeInferrerVisitor(Element element, ResolvedAst resolvedAst,
       Compiler compiler, InferrerEngine<T, TypeSystem<T>> inferrer,
       [LocalsHandler<T> handler])
       : this.internal(
             element,
             resolvedAst,
             element.outermostEnclosingMemberOrTopLevel.implementation,
@@ skipping 338 matching lines @@
 
   @override
   T 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 = elements.getGetterTypeMaskInComplexSendSet(node);
-    TypeMask operatorMask = elements.getOperatorTypeMaskInComplexSendSet(node);
+    TypeMask getterMask = inTreeData.typeOfGetter(node);
+    TypeMask operatorMask = inTreeData.typeOfOperator(node);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = elements.getTypeMask(node);
+    TypeMask setterMask = inTreeData.typeOfSend(node);
 
     String op = node.assignmentOperator.source;
     bool isIncrementOrDecrement = op == '++' || op == '--';
 
     T receiverType;
     bool isCallOnThis = false;
     if (node.receiver == null) {
       if (treatAsInstanceMember(element)) {
         receiverType = thisType;
         isCallOnThis = true;
@@ skipping 89 matching lines @@
       }
 
       return node.isPostfix ? getterType : newType;
     }
   }
 
   /// Handle compound index set, like `foo[0] += 42` or `foo[0]++`.
   T handleCompoundIndexSet(
       ast.SendSet node, T receiverType, T indexType, T rhsType) {
     Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
-    TypeMask getterMask = elements.getGetterTypeMaskInComplexSendSet(node);
+
+    TypeMask getterMask = inTreeData.typeOfGetter(node);
     Selector operatorSelector =
         elements.getOperatorSelectorInComplexSendSet(node);
-    TypeMask operatorMask = elements.getOperatorTypeMaskInComplexSendSet(node);
+    TypeMask operatorMask = inTreeData.typeOfOperator(node);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = elements.getTypeMask(node);
+    TypeMask setterMask = inTreeData.typeOfSend(node);
 
     T getterType = handleDynamicSend(node, getterSelector, getterMask,
         receiverType, new ArgumentsTypes<T>([indexType], null));
 
     T returnType;
     if (node.isIfNullAssignment) {
       returnType = types.allocateDiamondPhi(getterType, rhsType);
     } else {
       returnType = handleDynamicSend(node, operatorSelector, operatorMask,
           getterType, new ArgumentsTypes<T>([rhsType], null));
@@ skipping 74 matching lines @@
       Element setter, ast.Node index, ast.Node rhs) {
     T indexType = visit(index);
     T rhsType = visit(rhs);
     return _handleSuperCompoundIndexSet(
         node, getter, setter, indexType, rhsType);
   }
 
   T _handleSuperCompoundIndexSet(ast.SendSet node, Element getter,
       Element setter, T indexType, T rhsType) {
     Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
-    TypeMask getterMask = elements.getGetterTypeMaskInComplexSendSet(node);
+
+    TypeMask getterMask = inTreeData.typeOfGetter(node);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = elements.getTypeMask(node);
+    TypeMask setterMask = inTreeData.typeOfSend(node);
 
     T getterType = handleSuperSend(node, getterSelector, getterMask, getter,
         new ArgumentsTypes<T>([indexType], null));
 
     T returnType;
     if (node.isIfNullAssignment) {
       returnType = types.allocateDiamondPhi(getterType, rhsType);
     } else {
       Selector operatorSelector =
           elements.getOperatorSelectorInComplexSendSet(node);
-      TypeMask operatorMask =
-          elements.getOperatorTypeMaskInComplexSendSet(node);
+      TypeMask operatorMask = inTreeData.typeOfOperator(node);
       returnType = handleDynamicSend(node, operatorSelector, operatorMask,
           getterType, new ArgumentsTypes<T>([rhsType], null));
     }
     handleSuperSend(node, setterSelector, setterMask, setter,
         new ArgumentsTypes<T>([indexType, returnType], null));
 
     return node.isPostfix ? getterType : returnType;
   }
 
   T handleSuperSend(ast.Node node, Selector selector, TypeMask mask,
@@ skipping 327 matching lines @@
     return handleSuperPrefixPostfix(node, getter, setter);
   }
 
   T handleSuperPrefixPostfix(ast.SendSet node, Element getter, Element setter) {
     return _handleSuperCompound(node, getter, setter, types.uint31Type);
   }
 
   T _handleSuperCompound(
       ast.SendSet node, Element getter, Element setter, T rhsType) {
     Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
-    TypeMask getterMask = elements.getGetterTypeMaskInComplexSendSet(node);
+    TypeMask getterMask = inTreeData.typeOfGetter(node);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = elements.getTypeMask(node);
+    TypeMask setterMask = inTreeData.typeOfSend(node);
 
     T getterType =
         handleSuperSend(node, getterSelector, getterMask, getter, null);
 
     T returnType;
     if (node.isIfNullAssignment) {
       returnType = types.allocateDiamondPhi(getterType, rhsType);
     } else {
       Selector operatorSelector =
           elements.getOperatorSelectorInComplexSendSet(node);
-      TypeMask operatorMask =
-          elements.getOperatorTypeMaskInComplexSendSet(node);
+      TypeMask operatorMask = inTreeData.typeOfOperator(node);
       returnType = handleDynamicSend(node, operatorSelector, operatorMask,
           getterType, new ArgumentsTypes<T>([rhsType], null));
     }
     handleSuperSend(node, setterSelector, setterMask, setter,
         new ArgumentsTypes<T>([returnType], null));
 
     return node.isPostfix ? getterType : returnType;
   }
 
   /// Handle index set, like `foo[0] = 42`.
   T handleIndexSet(ast.SendSet node, T receiverType, T indexType, T rhsType) {
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = elements.getTypeMask(node);
+    TypeMask setterMask = inTreeData.typeOfSend(node);
     handleDynamicSend(node, setterSelector, setterMask, receiverType,
         new ArgumentsTypes<T>([indexType, rhsType], null));
     return rhsType;
   }
 
   @override
   T visitIndexSet(
       ast.SendSet node, ast.Node receiver, ast.Node index, ast.Node rhs, _) {
     T receiverType = visit(receiver);
     T indexType = visit(index);
     T rhsType = visit(rhs);
     return handleIndexSet(node, receiverType, indexType, rhsType);
   }
 
   /// Handle super index set, like `super[42] = true`.
   T handleSuperIndexSet(
       ast.SendSet node, Element element, ast.Node index, ast.Node rhs) {
     T indexType = visit(index);
     T rhsType = visit(rhs);
     Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = elements.getTypeMask(node);
+    TypeMask setterMask = inTreeData.typeOfSend(node);
     handleStaticSend(node, setterSelector, setterMask, element,
         new ArgumentsTypes<T>([indexType, rhsType], null));
     return rhsType;
   }
 
   @override
   T visitSuperIndexSet(ast.SendSet node, FunctionElement function,
       ast.Node index, ast.Node rhs, _) {
     return handleSuperIndexSet(node, function, index, rhs);
   }
@@ skipping 55 matching lines @@
       locals.update(element, rhsType, node);
     }
     return rhsType;
   }
 
   /// Handle a super access or invocation that results in a `noSuchMethod` call.
   T handleErroneousSuperSend(ast.Send node) {
     ArgumentsTypes arguments =
         node.isPropertyAccess ? null : analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.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);
   }
 
   T 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.declaration;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
       element = compiler.coreClasses.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.
   T handleSuperClosureCall(
       ast.Send node, Element element, ast.NodeList arguments) {
     ArgumentsTypes argumentTypes = analyzeArguments(arguments.nodes);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.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.typeOfElement(element),
         outermostElement,
         argumentTypes,
         sideEffects,
         inLoop);
   }
 
   /// Handle an invocation of super [method].
   T 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 = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, method, arguments);
   }
 
   /// Handle access to a super field or getter [element].
   T 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 = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, element, null);
   }
 
   /// Handle update to a super field or setter [element].
   T handleSuperSet(ast.Send node, Element element, ast.Node rhs) {
     T 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 = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     return handleStaticSend(
         node, selector, mask, element, new ArgumentsTypes<T>([rhsType], null));
   }
 
   @override
   T visitSuperFieldSet(ast.Send node, FieldElement method, ast.Node rhs, _) {
     return handleSuperSet(node, method, rhs);
   }
 
   @override
@@ skipping 191 matching lines @@
     // forward the call to the effective target of the factory.
     // 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(target)) {
       return handleForeignSend(node, target);
     }
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.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't break anything
     if (!selector.applies(target) ||
         (mask != null &&
             !mask.canHit(target, selector, compiler.closedWorld))) {
       return types.dynamicType;
     }
 
     T returnType = handleStaticSend(node, selector, mask, target, arguments);
@@ skipping 38 matching lines @@
   @override
   T errorNonConstantConstructorInvoke(ast.NewExpression node, Element element,
       DartType type, ast.NodeList arguments, CallStructure callStructure, _) {
     return bulkHandleNew(node, _);
   }
 
   /// Handle invocation of a top level or static field or getter [element].
   T handleStaticFieldOrGetterInvoke(ast.Send node, Element element) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     handleStaticSend(node, selector, mask, element, arguments);
     return inferrer.registerCalledClosure(
         node,
         selector,
         mask,
         inferrer.typeOfElement(element),
         outermostElement,
         arguments,
         sideEffects,
         inLoop);
   }
 
   /// Handle invocation of a top level or static [function].
   T handleStaticFunctionInvoke(ast.Send node, MethodElement function) {
     if (compiler.backend.isForeign(function)) {
       return handleForeignSend(node, function);
     }
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.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.
   T handleInvalidStaticInvoke(ast.Send node) {
     analyzeArguments(node.arguments);
     return types.dynamicType;
   }
 
@@ skipping 63 matching lines @@
 
   @override
   T visitUnresolvedInvoke(ast.Send node, Element element,
       ast.NodeList arguments, Selector selector, _) {
     return handleInvalidStaticInvoke(node);
   }
 
   T handleForeignSend(ast.Send node, Element element) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     String name = element.name;
     handleStaticSend(node, selector, mask, element, arguments);
     if (name == BackendHelpers.JS ||
         name == BackendHelpers.JS_EMBEDDED_GLOBAL ||
         name == BackendHelpers.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.
   T handleLocalGet(ast.Send node, LocalElement local) {
     assert(locals.use(local) != null);
     return locals.use(local);
   }
 
   /// Read a static or top level field.
   T handleStaticFieldGet(ast.Send node, FieldElement field) {
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, field, null);
   }
 
   /// Invoke a static or top level getter.
   T handleStaticGetterGet(ast.Send node, MethodElement getter) {
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, getter, null);
   }
 
   /// Closurize a static or top level function.
   T handleStaticFunctionGet(ast.Send node, MethodElement function) {
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, function, null);
   }
 
   @override
   T visitDynamicPropertyGet(ast.Send node, ast.Node receiver, Name name, _) {
     return handleDynamicGet(node);
   }
 
   @override
   T visitIfNotNullDynamicPropertyGet(
@@ skipping 63 matching lines @@
 
   @override
   T visitUnresolvedGet(ast.Send node, Element element, _) {
     return types.dynamicType;
   }
 
   /// Handle .call invocation on [closure].
   T handleCallInvoke(ast.Send node, T closure) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     return inferrer.registerCalledClosure(node, selector, mask, closure,
         outermostElement, arguments, sideEffects, inLoop);
   }
 
   @override
   T visitExpressionInvoke(ast.Send node, ast.Node expression,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleCallInvoke(node, expression.accept(this));
   }
 
@@ skipping 13 matching lines @@
   T visitLocalVariableInvoke(ast.Send node, LocalVariableElement variable,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleCallInvoke(node, locals.use(variable));
   }
 
   @override
   T visitLocalFunctionInvoke(ast.Send node, LocalFunctionElement function,
       ast.NodeList arguments, CallStructure callStructure, _) {
     ArgumentsTypes argumentTypes = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.typeOfSend(node);
     // This only works for function statements. We need a
     // more sophisticated type system with function types to support
     // more.
     return inferrer.registerCalledElement(node, selector, mask,
         outermostElement, function, argumentTypes, sideEffects, inLoop);
   }
 
   @override
   T visitLocalFunctionIncompatibleInvoke(
       ast.Send node,
@@ skipping 65 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 = elements.getTypeMask(node);
+    TypeMask mask = inTreeData.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 74 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 = elements.getTypeMask(identifier);
+    TypeMask mask = inTreeData.typeOfSend(identifier);
 
     T 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);
     });
   }
 
   T visitAsyncForIn(ast.AsyncForIn node) {
     T expressionType = visit(node.expression);
 
     Selector currentSelector = Selectors.current;
-    TypeMask currentMask = elements.getCurrentTypeMask(node);
+    TypeMask currentMask = inTreeData.typeOfIteratorCurrent(node);
     Selector moveNextSelector = Selectors.moveNext;
-    TypeMask moveNextMask = elements.getMoveNextTypeMask(node);
+    TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     js.JavaScriptBackend backend = compiler.backend;
     Element ctor = backend.helpers.streamIteratorConstructor;
 
     /// Synthesize a call to the [StreamIterator] constructor.
     T iteratorType = handleStaticSend(
         node, null, null, ctor, new ArgumentsTypes<T>([expressionType], null));
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 
   T visitSyncForIn(ast.SyncForIn node) {
     T expressionType = visit(node.expression);
     Selector iteratorSelector = Selectors.iterator;
-    TypeMask iteratorMask = elements.getIteratorTypeMask(node);
+    TypeMask iteratorMask = inTreeData.typeOfIterator(node);
     Selector currentSelector = Selectors.current;
-    TypeMask currentMask = elements.getCurrentTypeMask(node);
+    TypeMask currentMask = inTreeData.typeOfIteratorCurrent(node);
     Selector moveNextSelector = Selectors.moveNext;
-    TypeMask moveNextMask = elements.getMoveNextTypeMask(node);
+    TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     T iteratorType = handleDynamicSend(node, iteratorSelector, iteratorMask,
         expressionType, new ArgumentsTypes<T>.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }