Split World usage into open, inference, and closed world.

pkg/compiler/lib/src/ssa/locals_handler.dart

 // Copyright (c) 2016, 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.
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
@@ skipping 249 matching lines @@
       }
       if (isInterceptorClass) {
         // Only use the extra parameter in intercepted classes.
         directLocals[closureData.thisLocal] = value;
       }
     } else if (isNativeUpgradeFactory) {
       SyntheticLocal parameter =
           new SyntheticLocal('receiver', executableContext);
       // Unlike `this`, receiver is nullable since direct calls to generative
       // constructor call the constructor with `null`.
-      ClassWorld classWorld = _compiler.world;
+      ClassWorld classWorld = _compiler.closedWorld;
       HParameterValue value =
           new HParameterValue(parameter, new TypeMask.exact(cls, classWorld));
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAtEntry(value);
     }
   }
 
   /// Returns true if the local can be accessed directly. Boxed variables or
   /// captured variables that are stored in the closure-field return [:false:].
   bool isAccessedDirectly(Local local) {
@@ skipping 337 matching lines @@
     return this;
   }
 
   TypeMask cachedTypeOfThis;
 
   TypeMask getTypeOfThis() {
     TypeMask result = cachedTypeOfThis;
     if (result == null) {
       ThisLocal local = closureData.thisLocal;
       ClassElement cls = local.enclosingClass;
-      ClassWorld classWorld = _compiler.world;
+      ClassWorld classWorld = _compiler.closedWorld;
       if (classWorld.isUsedAsMixin(cls)) {
         // If the enclosing class is used as a mixin, [:this:] can be
         // of the class that mixins the enclosing class. These two
         // classes do not have a subclass relationship, so, for
         // simplicity, we mark the type as an interface type.
-        result = new TypeMask.nonNullSubtype(cls.declaration, _compiler.world);
+        result =
+            new TypeMask.nonNullSubtype(cls.declaration, _compiler.closedWorld);
       } else {
-        result = new TypeMask.nonNullSubclass(cls.declaration, _compiler.world);
+        result = new TypeMask.nonNullSubclass(
+            cls.declaration, _compiler.closedWorld);
       }
       cachedTypeOfThis = result;
     }
     return result;
   }
 
   Map<Element, TypeMask> cachedTypesOfCapturedVariables =
       new Map<Element, TypeMask>();
 
   TypeMask getTypeOfCapturedVariable(Element element) {
     assert(element.isField);
     return cachedTypesOfCapturedVariables.putIfAbsent(element, () {
       return TypeMaskFactory.inferredTypeForElement(element, _compiler);
     });
   }
 
   /// Variables stored in the current activation. These variables are
   /// being updated in try/catch blocks, and should be
   /// accessed indirectly through [HLocalGet] and [HLocalSet].
   Map<Local, HLocalValue> activationVariables = <Local, HLocalValue>{};
 }