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

pkg/compiler/lib/src/world.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.
 
 library dart2js.world;
 
 import 'closure.dart' show SynthesizedCallMethodElementX;
 import 'common/backend_api.dart' show Backend;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'core_types.dart' show CoreClasses;
 import 'dart_types.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         FunctionElement,
         MixinApplicationElement,
         TypedefElement,
         VariableElement;
 import 'ordered_typeset.dart';
-import 'types/types.dart' as ti;
+import 'types/masks.dart' show TypeMask, FlatTypeMask;
 import 'universe/class_set.dart';
 import 'universe/function_set.dart' show FunctionSet;
 import 'universe/selector.dart' show Selector;
 import 'universe/side_effects.dart' show SideEffects;
 import 'util/util.dart' show Link;
 
 /// The [ClassWorld] represents the information known about a program when
 /// compiling with closed-world semantics.
 ///
 /// Given the entrypoint of an application, we can track what's reachable from
@@ skipping 150 matching lines @@
 class World implements ClassWorld {
   ClassElement get objectClass => coreClasses.objectClass;
   ClassElement get functionClass => coreClasses.functionClass;
   ClassElement get boolClass => coreClasses.boolClass;
   ClassElement get numClass => coreClasses.numClass;
   ClassElement get intClass => coreClasses.intClass;
   ClassElement get doubleClass => coreClasses.doubleClass;
   ClassElement get stringClass => coreClasses.stringClass;
   ClassElement get nullClass => coreClasses.nullClass;
 
-  /// Cache of [ti.FlatTypeMask]s grouped by the 8 possible values of the
-  /// [ti.FlatTypeMask.flags] property.
-  List<Map<ClassElement, ti.TypeMask>> canonicalizedTypeMasks =
-      new List<Map<ClassElement, ti.TypeMask>>.filled(8, null);
+  /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
+  /// `FlatTypeMask.flags` property.
+  List<Map<ClassElement, TypeMask>> canonicalizedTypeMasks =
+      new List<Map<ClassElement, TypeMask>>.filled(8, null);
 
   bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     return invariant(cls, cls.isDeclaration,
                 message: '$cls must be the declaration.') &&
             invariant(cls, cls.isResolved,
                 message:
                     '$cls must be resolved.') /* &&
       // TODO(johnniwinther): Reinsert this or similar invariant.
       (!mustBeInstantiated ||
        invariant(cls, isInstantiated(cls),
@@ skipping 496 matching lines @@
   void registerMixinUse(
       MixinApplicationElement mixinApplication, ClassElement mixin) {
     // TODO(johnniwinther): Add map restricted to live classes.
     // We don't support patch classes as mixin.
     assert(mixin.isDeclaration);
     Set<MixinApplicationElement> users =
         _mixinUses.putIfAbsent(mixin, () => new Set<MixinApplicationElement>());
     users.add(mixinApplication);
   }
 
-  bool hasAnyUserDefinedGetter(Selector selector, ti.TypeMask mask) {
+  bool hasAnyUserDefinedGetter(Selector selector, TypeMask mask) {
     return allFunctions.filter(selector, mask).any((each) => each.isGetter);
   }
 
   void registerUsedElement(Element element) {
     if (element.isInstanceMember && !element.isAbstract) {
       allFunctions.add(element);
     }
   }
 
-  VariableElement locateSingleField(Selector selector, ti.TypeMask mask) {
+  VariableElement locateSingleField(Selector selector, TypeMask mask) {
     Element result = locateSingleElement(selector, mask);
     return (result != null && result.isField) ? result : null;
   }
 
-  Element locateSingleElement(Selector selector, ti.TypeMask mask) {
-    mask = mask == null ? compiler.typesTask.dynamicType : mask;
+  Element locateSingleElement(Selector selector, TypeMask mask) {
+    mask ??= compiler.commonMasks.dynamicType;
     return mask.locateSingleElement(selector, mask, compiler);
   }
 
-  ti.TypeMask extendMaskIfReachesAll(Selector selector, ti.TypeMask mask) {
+  TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask) {
     bool canReachAll = true;
     if (mask != null) {
       canReachAll = compiler.enabledInvokeOn &&
           mask.needsNoSuchMethodHandling(selector, this);
     }
-    return canReachAll ? compiler.typesTask.dynamicType : mask;
+    return canReachAll ? compiler.commonMasks.dynamicType : mask;
   }
 
   void addFunctionCalledInLoop(Element element) {
     functionsCalledInLoop.add(element.declaration);
   }
 
   bool isCalledInLoop(Element element) {
     return functionsCalledInLoop.contains(element.declaration);
   }
 
@@ skipping 34 matching lines @@
   void registerSideEffects(Element element, SideEffects effects) {
     if (sideEffectsFreeElements.contains(element)) return;
     sideEffects[element.declaration] = effects;
   }
 
   void registerSideEffectsFree(Element element) {
     sideEffects[element.declaration] = new SideEffects.empty();
     sideEffectsFreeElements.add(element);
   }
 
-  SideEffects getSideEffectsOfSelector(Selector selector, ti.TypeMask mask) {
+  SideEffects getSideEffectsOfSelector(Selector selector, TypeMask mask) {
     // We're not tracking side effects of closures.
     if (selector.isClosureCall) return new SideEffects();
     SideEffects sideEffects = new SideEffects.empty();
     for (Element e in allFunctions.filter(selector, mask)) {
       if (e.isField) {
         if (selector.isGetter) {
           if (!fieldNeverChanges(e)) {
             sideEffects.setDependsOnInstancePropertyStore();
           }
         } else if (selector.isSetter) {
@@ skipping 30 matching lines @@
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   bool get hasClosedWorldAssumption => !compiler.options.hasIncrementalSupport;
 }