Even less reliance on Compiler.closedWorld

pkg/compiler/lib/src/inferrer/inferrer_visitor.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 inferrer_visitor;
 
 import 'dart:collection' show IterableMixin;
 
 import '../common.dart';
+import '../options.dart' show CompilerOptions;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../resolution/operators.dart';
 import '../resolution/semantic_visitor.dart';
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart';
 import '../types/constants.dart' show computeTypeMask;
@@ skipping 344 matching lines @@
 
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local);
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, T type);
+
+  /// The [ClosedWorld] on which inference reasoning is based.
+  ClosedWorld get closedWorld;
 }
 
 /**
  * Placeholder for inferred types of local variables.
  */
 class LocalsHandler<T> {
-  final Compiler compiler;
+  final CompilerOptions options;
   final TypeSystem<T> types;
   final MinimalInferrerEngine<T> inferrer;
   final VariableScope<T> locals;
   final Map<Local, Element> captured;
   final Map<Local, Element> capturedAndBoxed;
   final FieldInitializationScope<T> fieldScope;
   LocalsHandler<T> tryBlock;
   bool seenReturnOrThrow = false;
   bool seenBreakOrContinue = false;
 
   bool get aborts {
     return seenReturnOrThrow || seenBreakOrContinue;
   }
 
   bool get inTryBlock => tryBlock != null;
 
-  LocalsHandler(this.inferrer, this.types, this.compiler, Node block,
+  LocalsHandler(this.inferrer, this.types, this.options, Node block,
       [this.fieldScope])
       : locals = new VariableScope<T>(block),
         captured = new Map<Local, Element>(),
         capturedAndBoxed = new Map<Local, Element>(),
         tryBlock = null;
 
   LocalsHandler.from(LocalsHandler<T> other, Node block,
       {bool useOtherTryBlock: true})
       : locals = new VariableScope<T>(block, other.locals),
         fieldScope = new FieldInitializationScope<T>.from(other.fieldScope),
         captured = other.captured,
         capturedAndBoxed = other.capturedAndBoxed,
         types = other.types,
         inferrer = other.inferrer,
-        compiler = other.compiler {
+        options = other.options {
     tryBlock = useOtherTryBlock ? other.tryBlock : this;
   }
 
   LocalsHandler.deepCopyOf(LocalsHandler<T> other)
       : locals = new VariableScope<T>.deepCopyOf(other.locals),
         fieldScope = new FieldInitializationScope<T>.from(other.fieldScope),
         captured = other.captured,
         capturedAndBoxed = other.capturedAndBoxed,
         tryBlock = other.tryBlock,
         types = other.types,
         inferrer = other.inferrer,
-        compiler = other.compiler;
+        options = other.options;
 
   LocalsHandler.topLevelCopyOf(LocalsHandler<T> other)
       : locals = new VariableScope<T>.topLevelCopyOf(other.locals),
         fieldScope = new FieldInitializationScope<T>.from(other.fieldScope),
         captured = other.captured,
         capturedAndBoxed = other.capturedAndBoxed,
         tryBlock = other.tryBlock,
         types = other.types,
         inferrer = other.inferrer,
-        compiler = other.compiler;
+        options = other.options;
 
   T use(Local local) {
     if (capturedAndBoxed.containsKey(local)) {
       return inferrer.typeOfElement(capturedAndBoxed[local]);
     } else {
       if (captured.containsKey(local)) {
         inferrer.recordCapturedLocalRead(local);
       }
       return locals[local];
     }
   }
 
   void update(LocalElement local, T type, Node node) {
     assert(type != null);
-    if (compiler.options.trustTypeAnnotations ||
-        compiler.options.enableTypeAssertions) {
+    if (options.trustTypeAnnotations || options.enableTypeAssertions) {
       type = types.narrowType(type, local.type);
     }
     updateLocal() {
       T currentType = locals[local];
 
       SendSet send = node != null ? node.asSendSet() : null;
       if (send != null && send.isIfNullAssignment && currentType != null) {
         // If-null assignments may return either the new or the original value
         // narrowed to non-null.
         type = types.addPhiInput(
@@ skipping 278 matching lines @@
         this.locals = handler {
     if (handler != null) return;
     Node node;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       node = resolvedAst.node;
     }
     FieldInitializationScope<T> fieldScope =
         analyzedElement.isGenerativeConstructor
             ? new FieldInitializationScope<T>(types)
             : null;
-    locals = new LocalsHandler<T>(inferrer, types, compiler, node, fieldScope);
+    locals = new LocalsHandler<T>(
+        inferrer, types, compiler.options, node, fieldScope);
   }
 
   DiagnosticReporter get reporter => compiler.reporter;
 
-  ClosedWorld get closedWorld => compiler.closedWorld;
+  ClosedWorld get closedWorld => inferrer.closedWorld;
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   @override
   T apply(Node node, _) => visit(node);
 
   T handleSendSet(SendSet node);
 
   T handleDynamicInvoke(Send node);
@@ skipping 115 matching lines @@
   }
 
   T visitLiteralNull(LiteralNull node) {
     return types.nullType;
   }
 
   T visitLiteralSymbol(LiteralSymbol node) {
     // TODO(kasperl): We should be able to tell that the type of a literal
     // symbol is always a non-null exact symbol implementation -- not just
     // any non-null subtype of the symbol interface.
-    return types.nonNullSubtype(compiler.coreClasses.symbolClass);
+    return types.nonNullSubtype(closedWorld.coreClasses.symbolClass);
   }
 
   @override
   void previsitDeferredAccess(Send node, PrefixElement prefix, _) {
     // Deferred access does not affect inference.
   }
 
   T handleTypeLiteralGet() {
     return types.typeType;
   }
@@ skipping 130 matching lines @@
             (operator == '!=' && !usePositive)) {
           // Type the elements as null.
           if (Elements.isLocal(receiverElement)) {
             locals.update(receiverElement, types.nullType, node);
           }
           if (Elements.isLocal(argumentElement)) {
             locals.update(argumentElement, types.nullType, node);
           }
         } else {
           // Narrow the elements to a non-null type.
-          DartType objectType = compiler.coreTypes.objectType;
+          DartType objectType = closedWorld.coreTypes.objectType;
           if (Elements.isLocal(receiverElement)) {
             narrow(receiverElement, objectType, node);
           }
           if (Elements.isLocal(argumentElement)) {
             narrow(argumentElement, objectType, node);
           }
         }
       }
     }
   }
@@ skipping 439 matching lines @@
     return type;
   }
 
   T visitCascade(Cascade node) {
     // Ignore the result of the cascade send and return the type of the cascade
     // receiver.
     visit(node.expression);
     return cascadeReceiverStack.removeLast();
   }
 }