Rename the global inference task and reduce it's API surface by introducing the

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

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 665 matching lines @@
       // Generative constructors of native classes should not be called directly
       // and have an extra argument that causes problems with inlining.
       if (element.isGenerativeConstructor &&
           backend.isNativeOrExtendsNative(element.enclosingClass)) {
         return false;
       }
 
       // A generative constructor body is not seen by global analysis,
       // so we should not query for its type.
       if (!element.isGenerativeConstructorBody) {
-        // Don't inline if the return type was inferred to be non-null empty.
-        // This means that the function always throws an exception.
-        TypeMask returnType =
-            compiler.typesTask.getGuaranteedReturnTypeOfElement(element);
-        if (returnType != null && returnType.isEmpty) {
+        if (compiler.globalInference.throwsAlways(element)) {
           isReachable = false;
           return false;
         }
       }
 
       return true;
     }
 
     bool doesNotContainCode() {
       // A function with size 1 does not contain any code.
@@ skipping 116 matching lines @@
 
   bool get allInlinedFunctionsCalledOnce {
     return inliningStack.isEmpty || inliningStack.last.allFunctionsCalledOnce;
   }
 
   bool isFunctionCalledOnce(Element element) {
     if (element is ConstructorBodyElement) {
       // ConstructorBodyElements are not in the type inference graph.
       return false;
     }
-    TypesInferrer inferrer = compiler.typesTask.typesInferrer;
-    return inferrer.isCalledOnce(element);
+    return compiler.globalInference.isCalledOnce(element);
   }
 
   bool isCalledOnce(Element element) {
     return allInlinedFunctionsCalledOnce && isFunctionCalledOnce(element);
   }
 
   inlinedFrom(ResolvedAst resolvedAst, f()) {
     Element element = resolvedAst.element;
     assert(element is FunctionElement || element is VariableElement);
     return reporter.withCurrentElement(element.implementation, () {
@@ skipping 3383 matching lines @@
         var constant = inputs[0];
         int value = constant.constant.primitiveValue;
         if (0 <= value && value < 0x100000000) canThrow = false;
       }
       HForeignCode foreign = new HForeignCode(code, elementType, inputs,
           nativeBehavior: behavior,
           throwBehavior: canThrow
               ? native.NativeThrowBehavior.MAY
               : native.NativeThrowBehavior.NEVER);
       push(foreign);
-      TypesInferrer inferrer = compiler.typesTask.typesInferrer;
-      if (inferrer.isFixedArrayCheckedForGrowable(send)) {
+      if (compiler.globalInference.isFixedArrayCheckedForGrowable(send)) {
         js.Template code = js.js.parseForeignJS(r'#.fixed$length = Array');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
         add(new HForeignCode(code, backend.nullType, [stack.last],
             throwBehavior: native.NativeThrowBehavior.MAY));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
@@ skipping 3600 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }