Extract type inference queries from KernelAstAdapter to KernelToTypeInferenceMap

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:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
@@ skipping 127 matching lines @@
   }
 
   void assertAtResolvedAstFor(ir.Node node) {
     assert(invariant(getElement(node),
         _resolvedAst.element == getElement(node).declaration));
   }
 
   Compiler get _compiler => _backend.compiler;
   TreeElements get elements => _resolvedAst.elements;
   DiagnosticReporter get reporter => _compiler.reporter;
-  MemberElement get _target => _resolvedAst.element;
-
-  GlobalTypeInferenceResults get _globalInferenceResults =>
-      _compiler.globalInference.results;
-
-  GlobalTypeInferenceElementResult _resultOf(MemberElement e) =>
-      _globalInferenceResults
-          .resultOfMember(e is ConstructorBodyElementX ? e.constructor : e);
 
   ConstantValue getConstantForSymbol(ir.SymbolLiteral node) {
     if (kernel.syntheticNodes.contains(node)) {
       return _backend.constantSystem
           .createSymbol(_compiler.commonElements, node.value);
     }
     ast.Node astNode = getNode(node);
     ConstantValue constantValue = _backend.constants
         .getConstantValueForNode(astNode, _resolvedAst.elements);
     assert(invariant(astNode, constantValue != null,
@@ skipping 57 matching lines @@
 
   Local getLocal(ir.VariableDeclaration variable) {
     // If this is a synthetic local, return the synthetic local
     if (variable.name == null) {
       return _syntheticLocals.putIfAbsent(
           variable, () => new SyntheticLocal("x", null, null));
     }
     return getElement(variable) as LocalElement;
   }
 
-  TypeMask getReturnTypeOf(FunctionEntity function) {
-    return TypeMaskFactory.inferredReturnTypeForElement(
-        function, _globalInferenceResults);
-  }
-
   FunctionSignature getFunctionSignature(ir.FunctionNode function) {
     return getElement(function).asFunctionElement().functionSignature;
   }
 
   ir.Field getFieldFromElement(FieldElement field) {
     return kernel.fields[field];
   }
 
-  TypeMask typeOfInvocation(ir.MethodInvocation send, ClosedWorld closedWorld) {
-    ast.Node operatorNode = kernel.nodeToAstOperator[send];
-    if (operatorNode != null) {
-      return _resultOf(_target).typeOfOperator(operatorNode);
-    }
-    if (send.name.name == '[]=') {
-      return closedWorld.commonMasks.dynamicType;
-    }
-    return _resultOf(_target).typeOfSend(getNode(send));
-  }
-
-  TypeMask typeOfGet(ir.PropertyGet getter) {
-    return _resultOf(_target).typeOfSend(getNode(getter));
-  }
-
-  TypeMask typeOfSet(ir.PropertySet setter, ClosedWorld closedWorld) {
-    return closedWorld.commonMasks.dynamicType;
-  }
-
-  TypeMask typeOfSend(ir.Expression send) {
-    assert(send is ir.InvocationExpression || send is ir.PropertyGet);
-    return _resultOf(_target).typeOfSend(getNode(send));
-  }
-
-  TypeMask typeOfListLiteral(MemberElement owner, ir.ListLiteral listLiteral,
-      ClosedWorld closedWorld) {
-    ast.Node node = getNodeOrNull(listLiteral);
-    if (node == null) {
-      assertNodeIsSynthetic(listLiteral);
-      return closedWorld.commonMasks.growableListType;
-    }
-    return _resultOf(owner).typeOfListLiteral(getNode(listLiteral)) ??
-        closedWorld.commonMasks.dynamicType;
-  }
-
-  TypeMask typeOfIterator(ir.ForInStatement forInStatement) {
-    return _resultOf(_target).typeOfIterator(getNode(forInStatement));
-  }
-
-  TypeMask typeOfIteratorCurrent(ir.ForInStatement forInStatement) {
-    return _resultOf(_target).typeOfIteratorCurrent(getNode(forInStatement));
-  }
-
-  TypeMask typeOfIteratorMoveNext(ir.ForInStatement forInStatement) {
-    return _resultOf(_target).typeOfIteratorMoveNext(getNode(forInStatement));
-  }
-
-  bool isJsIndexableIterator(
-      ir.ForInStatement forInStatement, ClosedWorld closedWorld) {
-    TypeMask mask = typeOfIterator(forInStatement);
-    return mask != null &&
-        mask.satisfies(
-            _compiler.commonElements.jsIndexableClass, closedWorld) &&
-        // String is indexable but not iterable.
-        !mask.satisfies(_compiler.commonElements.jsStringClass, closedWorld);
-  }
-
   bool isFixedLength(TypeMask mask, ClosedWorld closedWorld) {
     if (mask.isContainer && (mask as ContainerTypeMask).length != null) {
       // A container on which we have inferred the length.
       return true;
     }
     // TODO(sra): Recognize any combination of fixed length indexables.
     if (mask.containsOnly(closedWorld.commonElements.jsFixedArrayClass) ||
         mask.containsOnly(
             closedWorld.commonElements.jsUnmodifiableArrayClass) ||
         mask.containsOnlyString(closedWorld) ||
         closedWorld.commonMasks.isTypedArray(mask)) {
       return true;
     }
     return false;
   }
 
-  TypeMask inferredIndexType(ir.ForInStatement forInStatement) {
-    return TypeMaskFactory.inferredTypeForSelector(new Selector.index(),
-        typeOfIterator(forInStatement), _globalInferenceResults);
-  }
-
-  TypeMask getInferredTypeOf(MemberEntity member) {
-    return TypeMaskFactory.inferredTypeForMember(
-        member, _globalInferenceResults);
-  }
-
-  TypeMask selectorTypeOf(Selector selector, TypeMask mask) {
-    return TypeMaskFactory.inferredTypeForSelector(
-        selector, mask, _globalInferenceResults);
-  }
-
-  TypeMask typeFromNativeBehavior(
-      native.NativeBehavior nativeBehavior, ClosedWorld closedWorld) {
-    return TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
-  }
-
   ConstantValue getConstantFor(ir.Node node) {
     // Some `null`s are not mapped when they correspond to errors, e.g. missing
     // `const` initializers.
     if (node is ir.NullLiteral) return new NullConstantValue();
 
     ConstantValue constantValue =
         _backend.constants.getConstantValueForNode(getNode(node), elements);
     assert(invariant(getNode(node), constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
@@ skipping 349 matching lines @@
       JumpTarget continueTarget =
           astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }
+
+class KernelAstTypeInferenceMap implements KernelToTypeInferenceMap {
+  final KernelAstAdapter _astAdapter;
+
+  KernelAstTypeInferenceMap(this._astAdapter);
+
+  MemberElement get _target => _astAdapter._resolvedAst.element;
+
+  GlobalTypeInferenceResults get _globalInferenceResults =>
+      _astAdapter._compiler.globalInference.results;
+
+  GlobalTypeInferenceElementResult _resultOf(MemberElement e) =>
+      _globalInferenceResults
+          .resultOfMember(e is ConstructorBodyElementX ? e.constructor : e);
+
+  TypeMask getReturnTypeOf(FunctionEntity function) {
+    return TypeMaskFactory.inferredReturnTypeForElement(
+        function, _globalInferenceResults);
+  }
+
+  TypeMask typeOfInvocation(ir.MethodInvocation send, ClosedWorld closedWorld) {
+    ast.Node operatorNode = _astAdapter.kernel.nodeToAstOperator[send];
+    if (operatorNode != null) {
+      return _resultOf(_target).typeOfOperator(operatorNode);
+    }
+    if (send.name.name == '[]=') {
+      return closedWorld.commonMasks.dynamicType;
+    }
+    return _resultOf(_target).typeOfSend(_astAdapter.getNode(send));
+  }
+
+  TypeMask typeOfGet(ir.PropertyGet getter) {
+    return _resultOf(_target).typeOfSend(_astAdapter.getNode(getter));
+  }
+
+  TypeMask typeOfSet(ir.PropertySet setter, ClosedWorld closedWorld) {
+    return closedWorld.commonMasks.dynamicType;
+  }
+
+  TypeMask typeOfListLiteral(MemberElement owner, ir.ListLiteral listLiteral,
+      ClosedWorld closedWorld) {
+    ast.Node node = _astAdapter.getNodeOrNull(listLiteral);
+    if (node == null) {
+      _astAdapter.assertNodeIsSynthetic(listLiteral);
+      return closedWorld.commonMasks.growableListType;
+    }
+    return _resultOf(owner)
+            .typeOfListLiteral(_astAdapter.getNode(listLiteral)) ??
+        closedWorld.commonMasks.dynamicType;
+  }
+
+  TypeMask typeOfIterator(ir.ForInStatement forInStatement) {
+    return _resultOf(_target)
+        .typeOfIterator(_astAdapter.getNode(forInStatement));
+  }
+
+  TypeMask typeOfIteratorCurrent(ir.ForInStatement forInStatement) {
+    return _resultOf(_target)
+        .typeOfIteratorCurrent(_astAdapter.getNode(forInStatement));
+  }
+
+  TypeMask typeOfIteratorMoveNext(ir.ForInStatement forInStatement) {
+    return _resultOf(_target)
+        .typeOfIteratorMoveNext(_astAdapter.getNode(forInStatement));
+  }
+
+  bool isJsIndexableIterator(
+      ir.ForInStatement forInStatement, ClosedWorld closedWorld) {
+    TypeMask mask = typeOfIterator(forInStatement);
+    return mask != null &&
+        mask.satisfies(
+            closedWorld.commonElements.jsIndexableClass, closedWorld) &&
+        // String is indexable but not iterable.
+        !mask.satisfies(closedWorld.commonElements.jsStringClass, closedWorld);
+  }
+
+  TypeMask inferredIndexType(ir.ForInStatement forInStatement) {
+    return TypeMaskFactory.inferredTypeForSelector(new Selector.index(),
+        typeOfIterator(forInStatement), _globalInferenceResults);
+  }
+
+  TypeMask getInferredTypeOf(MemberEntity member) {
+    return TypeMaskFactory.inferredTypeForMember(
+        member, _globalInferenceResults);
+  }
+
+  TypeMask selectorTypeOf(Selector selector, TypeMask mask) {
+    return TypeMaskFactory.inferredTypeForSelector(
+        selector, mask, _globalInferenceResults);
+  }
+
+  TypeMask typeFromNativeBehavior(
+      native.NativeBehavior nativeBehavior, ClosedWorld closedWorld) {
+    return TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
+  }
+}