Extract type inference queries from KernelAstAdapter to KernelToTypeInferenceMap

pkg/compiler/lib/src/ssa/builder_kernel.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 '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 65 matching lines @@
 
   final Compiler compiler;
 
   @override
   JavaScriptBackend get backend => compiler.backend;
 
   @override
   TreeElements get elements => astAdapter.elements;
 
   SourceInformationBuilder sourceInformationBuilder;
-  KernelToElementMap _elementMap;
+  final KernelToElementMap _elementMap;
+  final KernelToTypeInferenceMap _typeInferenceMap;
   LoopHandler<ir.Node> loopHandler;
   TypeBuilder typeBuilder;
 
   final Map<ir.VariableDeclaration, HInstruction> letBindings =
       <ir.VariableDeclaration, HInstruction>{};
 
   /// True if we are visiting the expression of a throw statement; we assume
   /// this is a slow path.
   bool _inExpressionOfThrow = false;
 
   KernelSsaBuilder(
       this.targetElement,
       this.compiler,
       this._elementMap,
+      this._typeInferenceMap,
       this.closedWorld,
       this.registry,
       // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
       this.sourceInformationBuilder,
       this.functionNode) {
     this.loopHandler = new KernelLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
     graph.element = targetElement;
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
@@ skipping 624 matching lines @@
   @override
   void visitCheckLibraryIsLoaded(ir.CheckLibraryIsLoaded checkLoad) {
     HInstruction prefixConstant =
         graph.addConstantString(checkLoad.import.name, closedWorld);
     var prefixElement = astAdapter.getElement(checkLoad.import);
     HInstruction uriConstant = graph.addConstantString(
         prefixElement.deferredImport.uri.toString(), closedWorld);
     _pushStaticInvocation(
         _commonElements.checkDeferredIsLoaded,
         [prefixConstant, uriConstant],
-        astAdapter.getReturnTypeOf(_commonElements.checkDeferredIsLoaded));
+        _typeInferenceMap
+            .getReturnTypeOf(_commonElements.checkDeferredIsLoaded));
   }
 
   @override
   void visitLoadLibrary(ir.LoadLibrary loadLibrary) {
     // TODO(efortuna): Source information!
     push(new HInvokeStatic(
         commonElements.loadLibraryWrapper,
         [graph.addConstantString(loadLibrary.import.name, closedWorld)],
         commonMasks.nonNullType,
         targetCanThrow: false));
@@ skipping 127 matching lines @@
         forStatement, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
   @override
   void visitForInStatement(ir.ForInStatement forInStatement) {
     if (forInStatement.isAsync) {
       _buildAsyncForIn(forInStatement);
     }
     // If the expression being iterated over is a JS indexable type, we can
     // generate an optimized version of for-in that uses indexing.
-    if (astAdapter.isJsIndexableIterator(forInStatement, closedWorld)) {
+    if (_typeInferenceMap.isJsIndexableIterator(forInStatement, closedWorld)) {
       _buildForInIndexable(forInStatement);
     } else {
       _buildForInIterator(forInStatement);
     }
   }
 
   /// Builds the graph for a for-in node with an indexable expression.
   ///
   /// In this case we build:
   ///
@@ skipping 24 matching lines @@
       // The static call checkConcurrentModificationError() is expanded in
       // codegen to:
       //
       //     array.length == _end || throwConcurrentModificationError(array)
       //
       HInstruction length = buildGetLength();
       push(new HIdentity(length, originalLength, null, commonMasks.boolType));
       _pushStaticInvocation(
           _commonElements.checkConcurrentModificationError,
           [pop(), array],
-          astAdapter.getReturnTypeOf(
+          _typeInferenceMap.getReturnTypeOf(
               _commonElements.checkConcurrentModificationError));
       pop();
     }
 
     void buildInitializer() {
       forInStatement.iterable.accept(this);
       array = pop();
       isFixed = astAdapter.isFixedLength(array.instructionType, closedWorld);
       localsHandler.updateLocal(
           indexVariable, graph.addConstantInt(0, closedWorld));
@@ skipping 13 matching lines @@
       // If we had mechanically inlined ArrayIterator.moveNext(), it would have
       // inserted the ConcurrentModificationError check as part of the
       // condition.  It is not necessary on the first iteration since there is
       // no code between calls to `get iterator` and `moveNext`, so the test is
       // moved to the loop update.
 
       // Find a type for the element. Use the element type of the indexer of the
       // array, as this is stronger than the iterator's `get current` type, for
       // example, `get current` includes null.
       // TODO(sra): The element type of a container type mask might be better.
-      TypeMask type = astAdapter.inferredIndexType(forInStatement);
+      TypeMask type = _typeInferenceMap.inferredIndexType(forInStatement);
 
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction value = new HIndex(array, index, null, type);
       add(value);
 
       Local loopVariableLocal = astAdapter.getLocal(forInStatement.variable);
       localsHandler.updateLocal(loopVariableLocal, value);
       // Hint to name loop value after name of loop variable.
       if (loopVariableLocal is! SyntheticLocal) {
         value.sourceElement ??= loopVariableLocal;
@@ skipping 27 matching lines @@
     //   Iterator<E> $iter = <iterable>.iterator;
     //   while ($iter.moveNext()) {
     //     <variable> = $iter.current;
     //     <body>
     //   }
 
     // The iterator is shared between initializer, condition and body.
     HInstruction iterator;
 
     void buildInitializer() {
-      TypeMask mask = astAdapter.typeOfIterator(forInStatement);
+      TypeMask mask = _typeInferenceMap.typeOfIterator(forInStatement);
       forInStatement.iterable.accept(this);
       HInstruction receiver = pop();
       _pushDynamicInvocation(forInStatement, mask, <HInstruction>[receiver],
           selector: Selectors.iterator);
       iterator = pop();
     }
 
     HInstruction buildCondition() {
-      TypeMask mask = astAdapter.typeOfIteratorMoveNext(forInStatement);
+      TypeMask mask = _typeInferenceMap.typeOfIteratorMoveNext(forInStatement);
       _pushDynamicInvocation(forInStatement, mask, <HInstruction>[iterator],
           selector: Selectors.moveNext);
       return popBoolified();
     }
 
     void buildBody() {
-      TypeMask mask = astAdapter.typeOfIteratorCurrent(forInStatement);
+      TypeMask mask = _typeInferenceMap.typeOfIteratorCurrent(forInStatement);
       _pushDynamicInvocation(forInStatement, mask, [iterator],
           selector: Selectors.current);
       Local loopVariableLocal = astAdapter.getLocal(forInStatement.variable);
       HInstruction value = pop();
       localsHandler.updateLocal(loopVariableLocal, value);
       // Hint to name loop value after name of loop variable.
       if (loopVariableLocal is! SyntheticLocal) {
         value.sourceElement ??= loopVariableLocal;
       }
       forInStatement.body.accept(this);
     }
 
     loopHandler.handleLoop(
         forInStatement, buildInitializer, buildCondition, () {}, buildBody);
   }
 
   void _buildAsyncForIn(ir.ForInStatement forInStatement) {
     // The async-for is implemented with a StreamIterator.
     HInstruction streamIterator;
 
     forInStatement.iterable.accept(this);
     _pushStaticInvocation(
         _commonElements.streamIteratorConstructor,
         [pop(), graph.addConstantNull(closedWorld)],
-        astAdapter.getReturnTypeOf(_commonElements.streamIteratorConstructor));
+        _typeInferenceMap
+            .getReturnTypeOf(_commonElements.streamIteratorConstructor));
     streamIterator = pop();
 
     void buildInitializer() {}
 
     HInstruction buildCondition() {
-      TypeMask mask = astAdapter.typeOfIteratorMoveNext(forInStatement);
+      TypeMask mask = _typeInferenceMap.typeOfIteratorMoveNext(forInStatement);
       _pushDynamicInvocation(forInStatement, mask, [streamIterator],
           selector: Selectors.moveNext);
       HInstruction future = pop();
       push(new HAwait(future, closedWorld.commonMasks.dynamicType));
       return popBoolified();
     }
 
     void buildBody() {
-      TypeMask mask = astAdapter.typeOfIteratorCurrent(forInStatement);
+      TypeMask mask = _typeInferenceMap.typeOfIteratorCurrent(forInStatement);
       _pushDynamicInvocation(forInStatement, mask, [streamIterator],
           selector: Selectors.current);
       localsHandler.updateLocal(
           astAdapter.getLocal(forInStatement.variable), pop());
       forInStatement.body.accept(this);
     }
 
     void buildUpdate() {}
 
     // Creates a synthetic try/finally block in case anything async goes amiss.
@@ skipping 239 matching lines @@
 
   void generateError(ir.Node node, FunctionEntity function, String message,
       TypeMask typeMask) {
     HInstruction errorMessage = graph.addConstantString(message, closedWorld);
     // TODO(sra): Associate source info from [node].
     _pushStaticInvocation(function, [errorMessage], typeMask);
   }
 
   void generateTypeError(ir.Node node, String message) {
     generateError(node, _commonElements.throwTypeError, message,
-        astAdapter.getReturnTypeOf(_commonElements.throwTypeError));
+        _typeInferenceMap.getReturnTypeOf(_commonElements.throwTypeError));
   }
 
   @override
   void visitAssertStatement(ir.AssertStatement assertStatement) {
     if (!options.enableUserAssertions) return;
     if (assertStatement.message == null) {
       assertStatement.condition.accept(this);
       _pushStaticInvocation(_commonElements.assertHelper, <HInstruction>[pop()],
-          astAdapter.getReturnTypeOf(_commonElements.assertHelper));
+          _typeInferenceMap.getReturnTypeOf(_commonElements.assertHelper));
       pop();
       return;
     }
 
     // if (assertTest(condition)) assertThrow(message);
     void buildCondition() {
       assertStatement.condition.accept(this);
       _pushStaticInvocation(_commonElements.assertTest, <HInstruction>[pop()],
-          astAdapter.getReturnTypeOf(_commonElements.assertTest));
+          _typeInferenceMap.getReturnTypeOf(_commonElements.assertTest));
     }
 
     void fail() {
       assertStatement.message.accept(this);
       _pushStaticInvocation(_commonElements.assertThrow, <HInstruction>[pop()],
-          astAdapter.getReturnTypeOf(_commonElements.assertThrow));
+          _typeInferenceMap.getReturnTypeOf(_commonElements.assertThrow));
       pop();
     }
 
     handleIf(visitCondition: buildCondition, visitThen: fail);
   }
 
   /// Creates a [JumpHandler] for a statement. The node must be a jump
   /// target. If there are no breaks or continues targeting the statement,
   /// a special "null handler" is returned.
   ///
@@ skipping 488 matching lines @@
         element.accept(this);
         elements.add(pop());
       }
       listInstruction =
           new HLiteralList(elements, commonMasks.extendableArrayType);
       add(listInstruction);
       listInstruction =
           setListRuntimeTypeInfoIfNeeded(listInstruction, listLiteral);
     }
 
-    TypeMask type =
-        astAdapter.typeOfListLiteral(targetElement, listLiteral, closedWorld);
+    TypeMask type = _typeInferenceMap.typeOfListLiteral(
+        targetElement, listLiteral, closedWorld);
     if (!type.containsAll(closedWorld)) {
       listInstruction.instructionType = type;
     }
     stack.add(listInstruction);
   }
 
   @override
   void visitMapLiteral(ir.MapLiteral mapLiteral) {
     if (mapLiteral.isConst) {
       stack.add(graph.addConstant(
@@ skipping 94 matching lines @@
     // TODO(sra): Convert the type logic here to use ir.DartType.
     ResolutionDartType dartType = _elementMap.getDartType(type);
     dartType = localsHandler.substInContext(dartType);
     HInstruction value = typeBuilder
         .analyzeTypeArgument(dartType, sourceElement, sourceInformation: null);
     _pushStaticInvocation(_commonElements.runtimeTypeToString,
         <HInstruction>[value], commonMasks.stringType);
     _pushStaticInvocation(
         _commonElements.createRuntimeType,
         <HInstruction>[pop()],
-        astAdapter.getReturnTypeOf(_commonElements.createRuntimeType));
+        _typeInferenceMap.getReturnTypeOf(_commonElements.createRuntimeType));
   }
 
   @override
   void visitStaticGet(ir.StaticGet staticGet) {
     ir.Member staticTarget = staticGet.target;
     if (staticTarget is ir.Procedure &&
         staticTarget.kind == ir.ProcedureKind.Getter) {
       FunctionEntity getter = _elementMap.getMember(staticTarget);
       // Invoke the getter
-      _pushStaticInvocation(
-          getter, const <HInstruction>[], astAdapter.getReturnTypeOf(getter));
+      _pushStaticInvocation(getter, const <HInstruction>[],
+          _typeInferenceMap.getReturnTypeOf(getter));
     } else if (staticTarget is ir.Field &&
         (staticTarget.isConst ||
             staticTarget.isFinal && !_isLazyStatic(staticTarget))) {
       stack.add(graph.addConstant(
           astAdapter.getConstantFor(staticTarget.initializer), closedWorld));
     } else {
       if (_isLazyStatic(staticTarget)) {
         FieldEntity field = _elementMap.getField(staticTarget);
-        push(new HLazyStatic(field, astAdapter.getInferredTypeOf(field)));
+        push(
+            new HLazyStatic(field, _typeInferenceMap.getInferredTypeOf(field)));
       } else {
         MemberEntity member = _elementMap.getMember(staticTarget);
-        push(new HStatic(member, astAdapter.getInferredTypeOf(member)));
+        push(new HStatic(member, _typeInferenceMap.getInferredTypeOf(member)));
       }
     }
   }
 
   bool _isLazyStatic(ir.Member target) {
     return astAdapter.isLazyStatic(target);
   }
 
   @override
   void visitStaticSet(ir.StaticSet staticSet) {
     staticSet.value.accept(this);
     HInstruction value = pop();
 
     ir.Member staticTarget = staticSet.target;
     if (staticTarget is ir.Procedure) {
       FunctionEntity setter = _elementMap.getMember(staticTarget);
       // Invoke the setter
-      _pushStaticInvocation(
-          setter, <HInstruction>[value], astAdapter.getReturnTypeOf(setter));
+      _pushStaticInvocation(setter, <HInstruction>[value],
+          _typeInferenceMap.getReturnTypeOf(setter));
       pop();
     } else {
       add(new HStaticStore(
           _elementMap.getMember(staticTarget),
           typeBuilder.potentiallyCheckOrTrustType(
               value, astAdapter.getDartTypeIfValid(staticTarget.setterType))));
     }
     stack.add(value);
   }
 
   @override
   void visitPropertyGet(ir.PropertyGet propertyGet) {
     propertyGet.receiver.accept(this);
     HInstruction receiver = pop();
 
-    _pushDynamicInvocation(propertyGet, astAdapter.typeOfGet(propertyGet),
-        <HInstruction>[receiver]);
+    _pushDynamicInvocation(propertyGet,
+        _typeInferenceMap.typeOfGet(propertyGet), <HInstruction>[receiver]);
   }
 
   @override
   void visitVariableGet(ir.VariableGet variableGet) {
     ir.VariableDeclaration variable = variableGet.variable;
     HInstruction letBinding = letBindings[variable];
     if (letBinding != null) {
       stack.add(letBinding);
       return;
     }
 
     Local local = astAdapter.getLocal(variableGet.variable);
     stack.add(localsHandler.readLocal(local));
   }
 
   @override
   void visitPropertySet(ir.PropertySet propertySet) {
     propertySet.receiver.accept(this);
     HInstruction receiver = pop();
     propertySet.value.accept(this);
     HInstruction value = pop();
 
     _pushDynamicInvocation(
         propertySet,
-        astAdapter.typeOfSet(propertySet, closedWorld),
+        _typeInferenceMap.typeOfSet(propertySet, closedWorld),
         <HInstruction>[receiver, value]);
 
     pop();
     stack.add(value);
   }
 
   @override
   void visitSuperPropertySet(ir.SuperPropertySet propertySet) {
     propertySet.value.accept(this);
     HInstruction value = pop();
@@ skipping 155 matching lines @@
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation invocation) {
     ir.Procedure target = invocation.target;
     if (astAdapter.isForeignLibrary(target.enclosingLibrary)) {
       handleInvokeStaticForeign(invocation, target);
       return;
     }
     FunctionEntity function = _elementMap.getMember(target);
-    TypeMask typeMask = astAdapter.getReturnTypeOf(function);
+    TypeMask typeMask = _typeInferenceMap.getReturnTypeOf(function);
 
     // TODO(sra): For JS interop external functions, use a different function to
     // build arguments.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
 
     // Factory constructors take type parameters; other static methods ignore
     // them.
     if (function is ConstructorEntity && function.isFactoryConstructor) {
       if (backend.rtiNeed.classNeedsRti(function.enclosingClass)) {
@@ skipping 278 matching lines @@
         invocation, 1, 'JS_EMBEDDED_GLOBAL', 'second ');
     js.Template expr = js.js.expressionTemplateYielding(
         emitter.generateEmbeddedGlobalAccess(globalName));
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehavior(invocation);
     assert(invariant(astAdapter.getNode(invocation), nativeBehavior != null,
         message: "No NativeBehavior for $invocation"));
 
     TypeMask ssaType =
-        astAdapter.typeFromNativeBehavior(nativeBehavior, closedWorld);
+        _typeInferenceMap.typeFromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(expr, ssaType, const <HInstruction>[],
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsBuiltin(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
@@ skipping 23 matching lines @@
       argument.accept(this);
       inputs.add(pop());
     }
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehavior(invocation);
     assert(invariant(astAdapter.getNode(invocation), nativeBehavior != null,
         message: "No NativeBehavior for $invocation"));
 
     TypeMask ssaType =
-        astAdapter.typeFromNativeBehavior(nativeBehavior, closedWorld);
+        _typeInferenceMap.typeFromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(template, ssaType, inputs,
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsGetFlag(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
       stack.add(
           // Result expected on stack.
           graph.addConstantBool(false, closedWorld));
       return;
@@ skipping 67 matching lines @@
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     if (native.HasCapturedPlaceholders.check(nativeBehavior.codeTemplate.ast)) {
       reporter.reportErrorMessage(
           astAdapter.getNode(invocation), MessageKind.JS_PLACEHOLDER_CAPTURE);
     }
 
     TypeMask ssaType =
-        astAdapter.typeFromNativeBehavior(nativeBehavior, closedWorld);
+        _typeInferenceMap.typeFromNativeBehavior(nativeBehavior, closedWorld);
 
     SourceInformation sourceInformation = null;
     push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
         isStatement: !nativeBehavior.codeTemplate.isExpression,
         effects: nativeBehavior.sideEffects,
         nativeBehavior: nativeBehavior)
       ..sourceInformation = sourceInformation);
   }
 
   void handleJsStringConcat(ir.StaticInvocation invocation) {
@@ skipping 29 matching lines @@
 
     bool isIntercepted =
         closedWorld.interceptorData.isInterceptedSelector(selector);
 
     if (isIntercepted) {
       HInterceptor interceptor = _interceptorFor(receiver);
       inputs.add(interceptor);
     }
     inputs.addAll(arguments);
 
-    TypeMask type = astAdapter.selectorTypeOf(selector, mask);
+    TypeMask type = _typeInferenceMap.selectorTypeOf(selector, mask);
     if (selector.isGetter) {
       push(new HInvokeDynamicGetter(selector, mask, null, inputs, type));
     } else if (selector.isSetter) {
       push(new HInvokeDynamicSetter(selector, mask, null, inputs, type));
     } else {
       push(new HInvokeDynamicMethod(
           selector, mask, inputs, type, isIntercepted));
     }
   }
 
@@ skipping 40 matching lines @@
   @override
   void visitMethodInvocation(ir.MethodInvocation invocation) {
     // Handle `x == null` specially. When these come from null-aware operators,
     // there is no mapping in the astAdapter.
     if (_handleEqualsNull(invocation)) return;
     invocation.receiver.accept(this);
     HInstruction receiver = pop();
     Selector selector = _elementMap.getSelector(invocation);
     _pushDynamicInvocation(
         invocation,
-        astAdapter.typeOfInvocation(invocation, closedWorld),
+        _typeInferenceMap.typeOfInvocation(invocation, closedWorld),
         <HInstruction>[receiver]..addAll(
             _visitArgumentsForDynamicTarget(selector, invocation.arguments)));
   }
 
   bool _handleEqualsNull(ir.MethodInvocation invocation) {
     if (invocation.name.name == '==') {
       ir.Arguments arguments = invocation.arguments;
       if (arguments.types.isEmpty &&
           arguments.positional.length == 1 &&
           arguments.named.isEmpty) {
@@ skipping 88 matching lines @@
 
     List<HInstruction> inputs = <HInstruction>[];
     if (closedWorld.interceptorData.isInterceptedSelector(selector)) {
       inputs.add(_interceptorFor(receiver));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
 
     TypeMask typeMask;
     if (target is FunctionEntity) {
-      typeMask = astAdapter.getReturnTypeOf(target);
+      typeMask = _typeInferenceMap.getReturnTypeOf(target);
     } else {
       typeMask = closedWorld.commonMasks.dynamicType;
     }
     HInstruction instruction = new HInvokeSuper(
         target, containingClass, selector, inputs, typeMask, null,
         isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects =
         closedWorld.getSideEffectsOfSelector(selector, null);
     push(instruction);
     return instruction;
@@ skipping 384 matching lines @@
     // Note that the name of this local is irrelevant.
     SyntheticLocal local = kernelBuilder.localsHandler.createLocal('exception');
     exception = new HLocalValue(local, kernelBuilder.commonMasks.nonNullType);
     kernelBuilder.add(exception);
     HInstruction oldRethrowableException = kernelBuilder.rethrowableException;
     kernelBuilder.rethrowableException = exception;
 
     kernelBuilder._pushStaticInvocation(
         kernelBuilder._commonElements.exceptionUnwrapper,
         [exception],
-        kernelBuilder.astAdapter
+        kernelBuilder._typeInferenceMap
             .getReturnTypeOf(kernelBuilder._commonElements.exceptionUnwrapper));
     HInvokeStatic unwrappedException = kernelBuilder.pop();
     tryInstruction.exception = exception;
     int catchesIndex = 0;
 
     void pushCondition(ir.Catch catchBlock) {
       // `guard` is often `dynamic`, which generates `true`.
       kernelBuilder.pushIsTest(
           catchBlock.exception, catchBlock.guard, unwrappedException);
     }
 
     void visitThen() {
       ir.Catch catchBlock = tryCatch.catches[catchesIndex];
       catchesIndex++;
       if (catchBlock.exception != null) {
         LocalVariableElement exceptionVariable =
             kernelBuilder.astAdapter.getElement(catchBlock.exception);
         kernelBuilder.localsHandler
             .updateLocal(exceptionVariable, unwrappedException);
       }
       if (catchBlock.stackTrace != null) {
         kernelBuilder._pushStaticInvocation(
             kernelBuilder._commonElements.traceFromException,
             [exception],
-            kernelBuilder.astAdapter.getReturnTypeOf(
+            kernelBuilder._typeInferenceMap.getReturnTypeOf(
                 kernelBuilder._commonElements.traceFromException));
         HInstruction traceInstruction = kernelBuilder.pop();
         LocalVariableElement traceVariable =
             kernelBuilder.astAdapter.getElement(catchBlock.stackTrace);
         kernelBuilder.localsHandler
             .updateLocal(traceVariable, traceInstruction);
       }
       catchBlock.body.accept(kernelBuilder);
     }
 
@@ skipping 43 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }