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

pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart

 // Copyright (c) 2016, 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 '../constants/expressions.dart';
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
@@ skipping 45 matching lines @@
       _nodeToElement[kernel.libraries[libraryElement]] = libraryElement;
     }
     for (LocalFunctionElement localFunction in kernel.localFunctions.keys) {
       _nodeToElement[kernel.localFunctions[localFunction]] = localFunction;
     }
     _typeConverter = new DartTypeConverter(this);
   }
 
   Compiler get _compiler => _backend.compiler;
   TreeElements get elements => _resolvedAst.elements;
-  GlobalTypeInferenceResults get _inferenceResults =>
-      _compiler.globalInference.results;
   DiagnosticReporter get reporter => _compiler.reporter;
+  Element get _target => _resolvedAst.element;
+
+  GlobalTypeInferenceElementResult _resultOf(Element e) =>
+      _compiler.globalInference.results.resultOf(e);
 
   ConstantValue getConstantForSymbol(ir.SymbolLiteral node) {
     ast.Node astNode = getNode(node);
     ConstantValue constantValue = _backend.constants
         .getConstantValueForNode(astNode, _resolvedAst.elements);
     assert(invariant(astNode, constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
@@ skipping 70 matching lines @@
   }
 
   Selector getGetterSelector(ir.PropertyGet getter) {
     ir.Name irName = getter.name;
     Name name = new Name(
         irName.name, irName.isPrivate ? getElement(irName.library) : null);
     return new Selector.getter(name);
   }
 
   TypeMask typeOfInvocation(ir.Expression send) {
-    return _inferenceResults.typeOfSend(getNode(send), elements);
+    return _resultOf(_target).typeOfSend(getNode(send));
   }
 
   TypeMask typeOfGet(ir.PropertyGet getter) {
-    return _inferenceResults.typeOfSend(getNode(getter), elements);
+    return _resultOf(_target).typeOfSend(getNode(getter));
   }
 
   TypeMask typeOfSend(ir.Expression send) {
     assert(send is ir.InvocationExpression || send is ir.PropertyGet);
-    return _inferenceResults.typeOfSend(getNode(send), elements);
+    return _resultOf(_target).typeOfSend(getNode(send));
   }
 
   TypeMask typeOfNewList(Element owner, ir.ListLiteral listLiteral) {
-    return _inferenceResults.typeOfNewList(owner, getNode(listLiteral)) ??
+    return _resultOf(owner).typeOfNewList(getNode(listLiteral)) ??
         _compiler.commonMasks.dynamicType;
   }
 
   TypeMask typeOfIterator(ir.ForInStatement forInStatement) {
-    return _inferenceResults.typeOfIterator(getNode(forInStatement), elements);
+    return _resultOf(_target).typeOfIterator(getNode(forInStatement));
   }
 
   TypeMask typeOfIteratorCurrent(ir.ForInStatement forInStatement) {
-    return _inferenceResults.typeOfIteratorCurrent(
-        getNode(forInStatement), elements);
+    return _resultOf(_target).typeOfIteratorCurrent(getNode(forInStatement));
   }
 
   TypeMask typeOfIteratorMoveNext(ir.ForInStatement forInStatement) {
-    return _inferenceResults.typeOfIteratorMoveNext(
-        getNode(forInStatement), elements);
+    return _resultOf(_target).typeOfIteratorMoveNext(getNode(forInStatement));
   }
 
   bool isJsIndexableIterator(ir.ForInStatement forInStatement) {
     TypeMask mask = typeOfIterator(forInStatement);
     ClosedWorld closedWorld = _compiler.closedWorld;
     return mask != null &&
         mask.satisfies(_backend.helpers.jsIndexableClass, closedWorld) &&
         // String is indexable but not iterable.
         !mask.satisfies(_backend.helpers.jsStringClass, closedWorld);
   }
@@ skipping 431 matching lines @@
             node.arguments.positional.length + argumentNames.length,
             argumentNames),
         arguments);
   }
 
   @override
   ConstantExpression visitStringLiteral(ir.StringLiteral node) {
     return new StringConstantExpression(node.value);
   }
 }