Remove Compiler.inferenceWorld

pkg/compiler/lib/src/closure.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 closureToClassMapper;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show ParsingContext, Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
 import 'dart_types.dart';
 import 'elements/elements.dart';
 import 'elements/modelx.dart'
     show BaseFunctionElementX, ClassElementX, ElementX;
 import 'elements/visitor.dart' show ElementVisitor;
 import 'js_backend/js_backend.dart' show JavaScriptBackend;
 import 'resolution/tree_elements.dart' show TreeElements;
 import 'tokens/token.dart' show Token;
 import 'tree/tree.dart';
 import 'util/util.dart';
+import 'world.dart' show ClosedWorldRefiner;
 
 class ClosureTask extends CompilerTask {
   Map<Element, ClosureClassMap> _closureMappingCache =
       <Element, ClosureClassMap>{};
   Compiler compiler;
   ClosureTask(Compiler compiler)
       : compiler = compiler,
         super(compiler.measurer);
 
   String get name => "Closure Simplifier";
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   /// Returns the [ClosureClassMap] computed for [resolvedAst].
   ClosureClassMap getClosureToClassMapping(ResolvedAst resolvedAst) {
     return measure(() {
       Element element = resolvedAst.element;
       if (element.isGenerativeConstructorBody) {
         ConstructorBodyElement constructorBody = element;
         element = constructorBody.constructor;
       }
       ClosureClassMap closureClassMap = _closureMappingCache[element];
       assert(invariant(resolvedAst.element, closureClassMap != null,
           message: "No ClosureClassMap computed for ${element}."));
       return closureClassMap;
     });
   }
 
   /// Create [ClosureClassMap]s for all live members.
-  void createClosureClasses() {
+  void createClosureClasses(ClosedWorldRefiner closedWorldRefiner) {
     compiler.enqueuer.resolution.processedEntities
         .forEach((AstElement element) {
       // TODO(johnniwinther): Typedefs should never be in processedElements.
       if (element.isTypedef) return;
       ResolvedAst resolvedAst = element.resolvedAst;
       if (element.isAbstract) return;
       if (element.isField &&
           !element.isInstanceMember &&
           resolvedAst.body == null) {
         // Skip top-level/static fields without an initializer.
         return;
       }
-      computeClosureToClassMapping(resolvedAst);
+      computeClosureToClassMapping(resolvedAst, closedWorldRefiner);
     });
   }
 
-  ClosureClassMap computeClosureToClassMapping(ResolvedAst resolvedAst) {
+  ClosureClassMap computeClosureToClassMapping(
+      ResolvedAst resolvedAst, ClosedWorldRefiner closedWorldRefiner) {
     return measure(() {
       Element element = resolvedAst.element;
       ClosureClassMap cached = _closureMappingCache[element];
       if (cached != null) return cached;
       if (resolvedAst.kind != ResolvedAstKind.PARSED) {
         return _closureMappingCache[element] =
             new ClosureClassMap(null, null, null, new ThisLocal(element));
       }
       return reporter.withCurrentElement(element.implementation, () {
         Node node = resolvedAst.node;
         TreeElements elements = resolvedAst.elements;
 
-        ClosureTranslator translator =
-            new ClosureTranslator(compiler, elements, _closureMappingCache);
+        ClosureTranslator translator = new ClosureTranslator(
+            compiler, closedWorldRefiner, elements, _closureMappingCache);
 
         // The translator will store the computed closure-mappings inside the
         // cache. One for given node and one for each nested closure.
         if (node is FunctionExpression) {
           translator.translateFunction(element, node);
         } else if (element.isSynthesized) {
           reporter.internalError(
               element, "Unexpected synthesized element: $element");
           _closureMappingCache[element] =
               new ClosureClassMap(null, null, null, new ThisLocal(element));
@@ skipping 444 matching lines @@
       f(variable, copy);
     });
     capturingScopes.values.forEach((ClosureScope scope) {
       scope.forEachCapturedVariable(f);
     });
   }
 }
 
 class ClosureTranslator extends Visitor {
   final Compiler compiler;
+  final ClosedWorldRefiner closedWorldRefiner;
   final TreeElements elements;
   int closureFieldCounter = 0;
   int boxedFieldCounter = 0;
   bool inTryStatement = false;
 
   final Map<Element, ClosureClassMap> closureMappingCache;
 
   // Map of captured variables. Initially they will map to `null`. If
   // a variable needs to be boxed then the scope declaring the variable
   // will update this to mapping to the capturing [BoxFieldElement].
@@ skipping 11 matching lines @@
   Set<LocalVariableElement> mutatedVariables = new Set<LocalVariableElement>();
 
   MemberElement outermostElement;
   ExecutableElement executableContext;
 
   // The closureData of the currentFunctionElement.
   ClosureClassMap closureData;
 
   bool insideClosure = false;
 
-  ClosureTranslator(this.compiler, this.elements, this.closureMappingCache);
+  ClosureTranslator(this.compiler, this.closedWorldRefiner, this.elements,
+      this.closureMappingCache);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   /// Generate a unique name for the [id]th closure field, with proposed name
   /// [name].
   ///
   /// The result is used as the name of [ClosureFieldElement]s, and must
   /// therefore be unique to avoid breaking an invariant in the element model
   /// (classes cannot declare multiple fields with the same name).
   ///
@@ skipping 473 matching lines @@
   }
 
   JavaScriptBackend get backend => compiler.backend;
 
   ClosureClassMap globalizeClosure(
       FunctionExpression node, LocalFunctionElement element) {
     String closureName = computeClosureName(element);
     ClosureClassElement globalizedElement =
         new ClosureClassElement(node, closureName, compiler, element);
     // Extend [globalizedElement] as an instantiated class in the closed world.
-    compiler.inferenceWorld.registerClosureClass(globalizedElement);
+    closedWorldRefiner.registerClosureClass(globalizedElement);
     FunctionElement callElement = new SynthesizedCallMethodElementX(
         Identifiers.call, element, globalizedElement, node, elements);
     backend.maybeMarkClosureAsNeededForReflection(
         globalizedElement, callElement, element);
     MemberElement enclosing = element.memberContext;
     enclosing.nestedClosures.add(callElement);
     globalizedElement.addMember(callElement, reporter);
     globalizedElement.computeAllClassMembers(compiler.resolution);
     // The nested function's 'this' is the same as the one for the outer
     // function. It could be [null] if we are inside a static method.
@@ skipping 126 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements Entity {
   Entity get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }