Remove Compiler.inferenceWorld

pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart

 // Copyright (c) 2013, 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 type_graph_inferrer;
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
 import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart' show ConstantExpression;
 import '../constants/values.dart';
 import '../dart_types.dart' show DartType;
 import '../elements/elements.dart';
 import '../js_backend/js_backend.dart' show Annotations, JavaScriptBackend;
 import '../resolution/tree_elements.dart' show TreeElementMapping;
 import '../tree/dartstring.dart' show DartString;
 import '../tree/tree.dart' as ast show Node, LiteralBool, TryStatement;
 import '../types/constants.dart' show computeTypeMask;
 import '../types/masks.dart'
     show CommonMasks, ContainerTypeMask, MapTypeMask, TypeMask;
 import '../types/types.dart' show TypesInferrer;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart' show Setlet;
-import '../world.dart' show ClosedWorld;
+import '../world.dart' show ClosedWorld, ClosedWorldRefiner;
 import 'closure_tracer.dart';
 import 'debug.dart' as debug;
 import 'inferrer_visitor.dart' show ArgumentsTypes, TypeSystem;
 import 'list_tracer.dart';
 import 'map_tracer.dart';
 import 'simple_types_inferrer.dart';
 import 'type_graph_dump.dart';
 import 'type_graph_nodes.dart';
 
 class TypeInformationSystem extends TypeSystem<TypeInformation> {
-  final Compiler compiler;
   final ClosedWorld closedWorld;
-  final CommonMasks commonMasks;
 
   /// [ElementTypeInformation]s for elements.
   final Map<Element, TypeInformation> typeInformations =
       new Map<Element, TypeInformation>();
 
   /// [ListTypeInformation] for allocated lists.
   final Map<ast.Node, TypeInformation> allocatedLists =
       new Map<ast.Node, TypeInformation>();
 
   /// [MapTypeInformation] for allocated Maps.
@@ skipping 13 matching lines @@
 
   Iterable<TypeInformation> get allTypes => [
         typeInformations.values,
         allocatedLists.values,
         allocatedMaps.values,
         allocatedClosures,
         concreteTypes.values,
         allocatedTypes
       ].expand((x) => x);
 
-  TypeInformationSystem(Compiler compiler, this.commonMasks)
-      : this.compiler = compiler,
-        this.closedWorld = compiler.closedWorld {
-    nonNullEmptyType = getConcreteTypeFor(const TypeMask.nonNullEmpty());
+  TypeInformationSystem(this.closedWorld) {
+    nonNullEmptyType = getConcreteTypeFor(commonMasks.emptyType);
   }
 
+  CommonMasks get commonMasks => closedWorld.commonMasks;
+
   /// Used to group [TypeInformation] nodes by the element that triggered their
   /// creation.
   MemberTypeInformation _currentMember = null;
   MemberTypeInformation get currentMember => _currentMember;
 
   void withMember(MemberElement element, action) {
     assert(invariant(element, _currentMember == null,
         message: "Already constructing graph for $_currentMember."));
     _currentMember = getInferredTypeOf(element);
     action();
@@ skipping 267 matching lines @@
     return nonNullEmptyType;
   }
 
   bool isNull(TypeInformation type) {
     return type == nullType;
   }
 
   TypeInformation allocateList(
       TypeInformation type, ast.Node node, Element enclosing,
       [TypeInformation elementType, int length]) {
-    ClassElement typedDataClass = compiler.commonElements.typedDataClass;
+    ClassElement typedDataClass = closedWorld.commonElements.typedDataClass;
     bool isTypedArray = typedDataClass != null &&
         closedWorld.isInstantiated(typedDataClass) &&
         type.type.satisfies(typedDataClass, closedWorld);
     bool isConst = (type.type == commonMasks.constListType);
     bool isFixed =
         (type.type == commonMasks.fixedListType) || isConst || isTypedArray;
     bool isElementInferred = isConst || isTypedArray;
 
     int inferredLength = isFixed ? length : null;
     TypeMask elementTypeMask =
@@ skipping 183 matching lines @@
  *
  */
 class TypeGraphInferrerEngine
     extends InferrerEngine<TypeInformation, TypeInformationSystem> {
   final Map<Element, TypeInformation> defaultTypeOfParameter =
       new Map<Element, TypeInformation>();
   final List<CallSiteTypeInformation> allocatedCalls =
       <CallSiteTypeInformation>[];
   final WorkQueue workQueue = new WorkQueue();
   final Element mainElement;
-  final CommonMasks commonMasks;
   final Set<Element> analyzedElements = new Set<Element>();
 
   /// The maximum number of times we allow a node in the graph to
   /// change types. If a node reaches that limit, we give up
   /// inferencing on it and give it the dynamic type.
   final int MAX_CHANGE_COUNT = 6;
 
   int overallRefineCount = 0;
   int addedInGraph = 0;
 
-  TypeGraphInferrerEngine(
-      Compiler compiler, CommonMasks commonMasks, this.mainElement)
-      : commonMasks = commonMasks,
-        super(compiler, new TypeInformationSystem(compiler, commonMasks));
+  TypeGraphInferrerEngine(Compiler compiler, ClosedWorld closedWorld,
+      ClosedWorldRefiner closedWorldRefiner, this.mainElement)
+      : super(compiler, closedWorld, closedWorldRefiner,
+            new TypeInformationSystem(closedWorld));
 
   JavaScriptBackend get backend => compiler.backend;
   Annotations get annotations => backend.annotations;
   DiagnosticReporter get reporter => compiler.reporter;
+  CommonMasks get commonMasks => closedWorld.commonMasks;
 
   /**
    * A set of selector names that [List] implements, that we know return
    * their element type.
    */
   final Set<Selector> returnsListElementTypeSet =
       new Set<Selector>.from(<Selector>[
     new Selector.getter(const PublicName('first')),
     new Selector.getter(const PublicName('last')),
     new Selector.getter(const PublicName('single')),
@@ skipping 95 matching lines @@
 
     Set<FunctionElement> bailedOutOn = new Set<FunctionElement>();
 
     // Trace closures to potentially infer argument types.
     types.allocatedClosures.forEach((info) {
       void trace(
           Iterable<FunctionElement> elements, ClosureTracerVisitor tracer) {
         tracer.run();
         if (!tracer.continueAnalyzing) {
           elements.forEach((FunctionElement e) {
-            compiler.inferenceWorld.registerMightBePassedToApply(e);
+            closedWorldRefiner.registerMightBePassedToApply(e);
             if (debug.VERBOSE) print("traced closure $e as ${true} (bail)");
             e.functionSignature.forEachParameter((parameter) {
               types
                   .getInferredTypeOf(parameter)
                   .giveUp(this, clearAssignments: false);
             });
           });
           bailedOutOn.addAll(elements);
           return;
         }
         elements
             .where((e) => !bailedOutOn.contains(e))
             .forEach((FunctionElement e) {
           e.functionSignature.forEachParameter((parameter) {
             var info = types.getInferredTypeOf(parameter);
             info.maybeResume();
             workQueue.add(info);
           });
           if (tracer.tracedType.mightBePassedToFunctionApply) {
-            compiler.inferenceWorld.registerMightBePassedToApply(e);
+            closedWorldRefiner.registerMightBePassedToApply(e);
           }
           if (debug.VERBOSE) {
             print("traced closure $e as "
-                "${compiler.inferenceWorld
+                "${closedWorldRefiner
                     .getCurrentlyKnownMightBePassedToApply(e)}");
           }
         });
       }
 
       if (info is ClosureTypeInformation) {
         Iterable<FunctionElement> elements = [info.element];
         trace(elements, new ClosureTracerVisitor(elements, info, this));
       } else if (info is CallSiteTypeInformation) {
         if (info is StaticCallSiteTypeInformation &&
@@ skipping 166 matching lines @@
       }
     } else {
       recordReturnType(element, type);
     }
   }
 
   void processLoopInformation() {
     allocatedCalls.forEach((info) {
       if (!info.inLoop) return;
       if (info is StaticCallSiteTypeInformation) {
-        compiler.inferenceWorld.addFunctionCalledInLoop(info.calledElement);
+        closedWorldRefiner.addFunctionCalledInLoop(info.calledElement);
       } else if (info.mask != null && !info.mask.containsAll(closedWorld)) {
         // For instance methods, we only register a selector called in a
         // loop if it is a typed selector, to avoid marking too many
         // methods as being called from within a loop. This cuts down
         // on the code bloat.
-        info.targets.forEach(compiler.inferenceWorld.addFunctionCalledInLoop);
+        info.targets.forEach(closedWorldRefiner.addFunctionCalledInLoop);
       }
     });
   }
 
   void refine() {
     while (!workQueue.isEmpty) {
       if (compiler.shouldPrintProgress) {
         reporter.log('Inferred $overallRefineCount types.');
         compiler.progress.reset();
       }
@@ skipping 413 matching lines @@
   }
 
   void recordCapturedLocalRead(Local local) {}
 
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }
 
 class TypeGraphInferrer implements TypesInferrer {
   TypeGraphInferrerEngine inferrer;
   final Compiler compiler;
-  final CommonMasks commonMasks;
-  TypeGraphInferrer(this.compiler, this.commonMasks);
+  final ClosedWorld closedWorld;
+  final ClosedWorldRefiner closedWorldRefiner;
+
+  TypeGraphInferrer(this.compiler, this.closedWorld, this.closedWorldRefiner);
 
   String get name => 'Graph inferrer';
+
+  CommonMasks get commonMasks => closedWorld.commonMasks;
+
   TypeMask get _dynamicType => commonMasks.dynamicType;
 
   void analyzeMain(Element main) {
-    inferrer = new TypeGraphInferrerEngine(compiler, commonMasks, main);
+    inferrer = new TypeGraphInferrerEngine(
+        compiler, closedWorld, closedWorldRefiner, main);
     inferrer.runOverAllElements();
   }
 
   TypeMask getReturnTypeOfElement(Element element) {
     if (compiler.disableTypeInference) return _dynamicType;
     // Currently, closure calls return dynamic.
     if (element is! FunctionElement) return _dynamicType;
     return inferrer.types.getInferredTypeOf(element).type;
   }
 
@@ skipping 57 matching lines @@
   bool isCalledOnce(Element element) {
     if (compiler.disableTypeInference) return false;
     MemberTypeInformation info = inferrer.types.getInferredTypeOf(element);
     return info.isCalledOnce();
   }
 
   void clear() {
     inferrer.clear();
   }
 }