Remove Compiler.inferenceWorld

pkg/compiler/lib/src/inferrer/simple_types_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 simple_types_inferrer;
 
 import '../closure.dart' show ClosureClassMap;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart' show ConstantValue, IntConstantValue;
 import '../core_types.dart' show CoreClasses, CoreTypes;
 import '../dart_types.dart' show DartType;
 import '../elements/elements.dart';
 import '../js_backend/backend_helpers.dart';
 import '../js_backend/js_backend.dart' as js;
 import '../native/native.dart' as native;
 import '../resolution/operators.dart' as op;
-import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart' as ast;
 import '../types/types.dart' show TypeMask, GlobalTypeInferenceElementData;
 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 Link, Setlet;
-import '../world.dart' show ClosedWorld;
+import '../world.dart' show ClosedWorld, ClosedWorldRefiner;
 import 'inferrer_visitor.dart';
 
 /**
  * Common super class used by [SimpleTypeInferrerVisitor] to propagate
  * type information about visited nodes, as well as to request type
  * information of elements.
  */
 abstract class InferrerEngine<T, V extends TypeSystem>
     implements MinimalInferrerEngine<T> {
   final Compiler compiler;
   final ClosedWorld closedWorld;
+  final ClosedWorldRefiner closedWorldRefiner;
   final V types;
   final Map<ast.Node, T> concreteTypes = new Map<ast.Node, T>();
   final Set<Element> generativeConstructorsExposingThis = new Set<Element>();
 
   /// Data computed internally within elements, like the type-mask of a send a
   /// list allocation, or a for-in loop.
   final Map<Element, GlobalTypeInferenceElementData> inTreeData =
       new Map<Element, GlobalTypeInferenceElementData>();
 
-  InferrerEngine(Compiler compiler, this.types)
-      : this.compiler = compiler,
-        this.closedWorld = compiler.closedWorld;
+  InferrerEngine(
+      this.compiler, this.closedWorld, this.closedWorldRefiner, this.types);
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   CoreTypes get coreTypes => compiler.coreTypes;
 
   /**
    * Records the default type of parameter [parameter].
    */
   void setDefaultTypeOfParameter(ParameterElement parameter, T type);
 
@@ skipping 152 matching lines @@
           sideEffects.setDependsOnStaticPropertyStore();
         } else {
           sideEffects.setAllSideEffects();
           sideEffects.setDependsOnSomething();
         }
       }
     } else if (callee.isGetter && !selector.isGetter) {
       sideEffects.setAllSideEffects();
       sideEffects.setDependsOnSomething();
     } else {
-      sideEffects
-          .add(compiler.inferenceWorld.getCurrentlyKnownSideEffects(callee));
+      sideEffects.add(closedWorldRefiner.getCurrentlyKnownSideEffects(callee));
     }
   }
 
   /**
    * Returns the type for [nativeBehavior]. See documentation on
    * [native.NativeBehavior].
    */
   T typeOfNativeBehavior(native.NativeBehavior nativeBehavior) {
     if (nativeBehavior == null) return types.dynamicType;
     List typesReturned = nativeBehavior.typesReturned;
@@ skipping 300 matching lines @@
               analyzedElement, returnType, types.asyncFutureType);
           break;
 
         case AsyncMarker.ASYNC_STAR:
           returnType = inferrer.addReturnTypeFor(
               analyzedElement, returnType, types.asyncStarStreamType);
           break;
       }
     }
 
-    compiler.inferenceWorld.registerSideEffects(analyzedElement, sideEffects);
+    inferrer.closedWorldRefiner
+        .registerSideEffects(analyzedElement, sideEffects);
     assert(breaksFor.isEmpty);
     assert(continuesFor.isEmpty);
     return returnType;
   }
 
   T visitFunctionExpression(ast.FunctionExpression node) {
     // We loose track of [this] in closures (see issue 20840). To be on
     // the safe side, we mark [this] as exposed here. We could do better by
     // analyzing the closure.
     // TODO(herhut): Analyze whether closure exposes this.
@@ skipping 1695 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     T iteratorType = handleDynamicSend(node, iteratorSelector, iteratorMask,
         expressionType, new ArgumentsTypes<T>.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }