diff --git a/pkg/compiler/lib/src/common/backend_api.dart b/pkg/compiler/lib/src/common/backend_api.dart
index 258a38f..b93ddee 100644
--- a/pkg/compiler/lib/src/common/backend_api.dart
+++ b/pkg/compiler/lib/src/common/backend_api.dart
@@ -64,6 +64,9 @@
     return const SourceInformationStrategy();
   }
 
+  /// Common classes used by the backend.
+  BackendClasses get backendClasses;
+
   /// Interface for serialization of backend specific data.
   BackendSerialization get serialization => const BackendSerialization();
 
@@ -182,34 +185,6 @@
 
   void registerConstSymbol(String name) {}
 
-  bool isNullImplementation(ClassElement cls) {
-    return cls == compiler.coreClasses.nullClass;
-  }
-
-  ClassElement get intImplementation => compiler.coreClasses.intClass;
-  ClassElement get doubleImplementation => compiler.coreClasses.doubleClass;
-  ClassElement get numImplementation => compiler.coreClasses.numClass;
-  ClassElement get stringImplementation => compiler.coreClasses.stringClass;
-  ClassElement get listImplementation => compiler.coreClasses.listClass;
-  ClassElement get growableListImplementation => compiler.coreClasses.listClass;
-  ClassElement get fixedListImplementation => compiler.coreClasses.listClass;
-  ClassElement get constListImplementation => compiler.coreClasses.listClass;
-  ClassElement get mapImplementation => compiler.coreClasses.mapClass;
-  ClassElement get constMapImplementation => compiler.coreClasses.mapClass;
-  ClassElement get functionImplementation => compiler.coreClasses.functionClass;
-  ClassElement get typeImplementation => compiler.coreClasses.typeClass;
-  ClassElement get boolImplementation => compiler.coreClasses.boolClass;
-  ClassElement get nullImplementation => compiler.coreClasses.nullClass;
-  ClassElement get uint32Implementation => compiler.coreClasses.intClass;
-  ClassElement get uint31Implementation => compiler.coreClasses.intClass;
-  ClassElement get positiveIntImplementation => compiler.coreClasses.intClass;
-  ClassElement get syncStarIterableImplementation =>
-      compiler.coreClasses.iterableClass;
-  ClassElement get asyncFutureImplementation =>
-      compiler.coreClasses.futureClass;
-  ClassElement get asyncStarStreamImplementation =>
-      compiler.coreClasses.streamClass;
-
   ClassElement defaultSuperclass(ClassElement element) {
     return compiler.coreClasses.objectClass;
   }
@@ -411,3 +386,27 @@
   SerializerPlugin get serializer => const SerializerPlugin();
   DeserializerPlugin get deserializer => const DeserializerPlugin();
 }
+
+/// Interface providing access to core classes used by the backend.
+abstract class BackendClasses {
+  ClassElement get intImplementation;
+  ClassElement get doubleImplementation;
+  ClassElement get numImplementation;
+  ClassElement get stringImplementation;
+  ClassElement get listImplementation;
+  ClassElement get growableListImplementation;
+  ClassElement get fixedListImplementation;
+  ClassElement get constListImplementation;
+  ClassElement get mapImplementation;
+  ClassElement get constMapImplementation;
+  ClassElement get functionImplementation;
+  ClassElement get typeImplementation;
+  ClassElement get boolImplementation;
+  ClassElement get nullImplementation;
+  ClassElement get uint32Implementation;
+  ClassElement get uint31Implementation;
+  ClassElement get positiveIntImplementation;
+  ClassElement get syncStarIterableImplementation;
+  ClassElement get asyncFutureImplementation;
+  ClassElement get asyncStarStreamImplementation;
+}
diff --git a/pkg/compiler/lib/src/compiler.dart b/pkg/compiler/lib/src/compiler.dart
index 5667a4e..789cbe4 100644
--- a/pkg/compiler/lib/src/compiler.dart
+++ b/pkg/compiler/lib/src/compiler.dart
@@ -850,12 +850,16 @@
           mainMethod.computeType(resolution);
           if (mainMethod.functionSignature.parameterCount != 0) {
             // The first argument could be a list of strings.
-            backend.listImplementation.ensureResolved(resolution);
+            backend.backendClasses.listImplementation
+                .ensureResolved(resolution);
             backend.registerInstantiatedType(
-                backend.listImplementation.rawType, world, globalDependencies);
-            backend.stringImplementation.ensureResolved(resolution);
+                backend.backendClasses.listImplementation.rawType,
+                world,
+                globalDependencies);
+            backend.backendClasses.stringImplementation
+                .ensureResolved(resolution);
             backend.registerInstantiatedType(
-                backend.stringImplementation.rawType,
+                backend.backendClasses.stringImplementation.rawType,
                 world,
                 globalDependencies);
 
diff --git a/pkg/compiler/lib/src/constant_system_dart.dart b/pkg/compiler/lib/src/constant_system_dart.dart
index c42ca74..0f9a0d6 100644
--- a/pkg/compiler/lib/src/constant_system_dart.dart
+++ b/pkg/compiler/lib/src/constant_system_dart.dart
@@ -446,8 +446,10 @@
     // TODO(johnniwinther): Change the `Type` type to
     // `compiler.coreTypes.typeType` and check the backend specific value in
     // [checkConstMapKeysDontOverrideEquals] in 'members.dart'.
-    return new TypeConstantValue(type,
-        compiler.backend.typeImplementation.computeType(compiler.resolution));
+    return new TypeConstantValue(
+        type,
+        compiler.backend.backendClasses.typeImplementation
+            .computeType(compiler.resolution));
   }
 
   @override
diff --git a/pkg/compiler/lib/src/inferrer/node_tracer.dart b/pkg/compiler/lib/src/inferrer/node_tracer.dart
index cc890bf..058d36d 100644
--- a/pkg/compiler/lib/src/inferrer/node_tracer.dart
+++ b/pkg/compiler/lib/src/inferrer/node_tracer.dart
@@ -333,7 +333,8 @@
    */
   bool isParameterOfListAddingMethod(Element element) {
     if (!element.isRegularParameter) return false;
-    if (element.enclosingClass != compiler.backend.listImplementation) {
+    if (element.enclosingClass !=
+        compiler.backend.backendClasses.listImplementation) {
       return false;
     }
     Element method = element.enclosingElement;
@@ -349,7 +350,8 @@
    */
   bool isParameterOfMapAddingMethod(Element element) {
     if (!element.isRegularParameter) return false;
-    if (element.enclosingClass != compiler.backend.mapImplementation) {
+    if (element.enclosingClass !=
+        compiler.backend.backendClasses.mapImplementation) {
       return false;
     }
     Element method = element.enclosingElement;
diff --git a/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart b/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
index effe4fb..85e5dbd 100644
--- a/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
+++ b/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
@@ -1352,7 +1352,7 @@
     // In erroneous code the number of arguments in the selector might not
     // match the function element.
     // TODO(polux): return nonNullEmpty and check it doesn't break anything
-    if (!selector.applies(target, compiler.backend) ||
+    if (!selector.applies(target) ||
         (mask != null &&
             !mask.canHit(target, selector, compiler.closedWorld))) {
       return types.dynamicType;
diff --git a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
index 98e12be..ddca262 100644
--- a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
+++ b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
@@ -24,7 +24,7 @@
         ValueTypeMask;
 import '../universe/selector.dart' show Selector;
 import '../util/util.dart' show ImmutableEmptySet, Setlet;
-import '../world.dart' show ClassWorld;
+import '../world.dart' show ClosedWorld;
 import 'debug.dart' as debug;
 import 'inferrer_visitor.dart' show ArgumentsTypes;
 import 'type_graph_inferrer.dart'
@@ -867,26 +867,27 @@
    */
   TypeInformation handleIntrisifiedSelector(
       Selector selector, TypeMask mask, TypeGraphInferrerEngine inferrer) {
-    ClassWorld classWorld = inferrer.closedWorld;
-    if (!classWorld.backend.intImplementation.isResolved) return null;
+    ClosedWorld closedWorld = inferrer.closedWorld;
+    if (!closedWorld.backendClasses.intImplementation.isResolved) return null;
     if (mask == null) return null;
-    if (!mask.containsOnlyInt(classWorld)) {
+    if (!mask.containsOnlyInt(closedWorld)) {
       return null;
     }
     if (!selector.isCall && !selector.isOperator) return null;
     if (!arguments.named.isEmpty) return null;
     if (arguments.positional.length > 1) return null;
 
-    ClassElement uint31Implementation = classWorld.backend.uint31Implementation;
-    bool isInt(info) => info.type.containsOnlyInt(classWorld);
+    ClassElement uint31Implementation =
+        closedWorld.backendClasses.uint31Implementation;
+    bool isInt(info) => info.type.containsOnlyInt(closedWorld);
     bool isEmpty(info) => info.type.isEmpty;
     bool isUInt31(info) {
-      return info.type.satisfies(uint31Implementation, classWorld);
+      return info.type.satisfies(uint31Implementation, closedWorld);
     }
 
     bool isPositiveInt(info) {
-      return info.type
-          .satisfies(classWorld.backend.positiveIntImplementation, classWorld);
+      return info.type.satisfies(
+          closedWorld.backendClasses.positiveIntImplementation, closedWorld);
     }
 
     TypeInformation tryLater() => inferrer.types.nonNullEmptyType;
diff --git a/pkg/compiler/lib/src/js_backend/backend.dart b/pkg/compiler/lib/src/js_backend/backend.dart
index acc0edc1..0899d1b 100644
--- a/pkg/compiler/lib/src/js_backend/backend.dart
+++ b/pkg/compiler/lib/src/js_backend/backend.dart
@@ -11,7 +11,12 @@
 import '../closure.dart';
 import '../common.dart';
 import '../common/backend_api.dart'
-    show Backend, ImpactTransformer, ForeignResolver, NativeRegistry;
+    show
+        Backend,
+        BackendClasses,
+        ImpactTransformer,
+        ForeignResolver,
+        NativeRegistry;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
 import '../common/names.dart' show Identifiers, Selectors, Uris;
 import '../common/registry.dart' show Registry;
@@ -591,6 +596,7 @@
 
   final BackendHelpers helpers;
   final BackendImpacts impacts;
+  BackendClasses backendClasses;
 
   final JSFrontendAccess frontend;
 
@@ -630,6 +636,7 @@
     functionCompiler =
         new SsaFunctionCompiler(this, sourceInformationStrategy, useKernel);
     serialization = new JavaScriptBackendSerialization(this);
+    backendClasses = new JavaScriptBackendClasses(helpers);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
@@ -925,7 +932,7 @@
     if (elements == null) return false;
     if (elements.isEmpty) return false;
     return elements.any((element) {
-      return selector.applies(element, this) &&
+      return selector.applies(element) &&
           (mask == null ||
               mask.canHit(element, selector, compiler.closedWorld));
     });
@@ -1121,7 +1128,7 @@
         registerBackendUse(helpers.createRuntimeType);
       }
       impactBuilder.registerTypeUse(
-          new TypeUse.instantiation(typeImplementation.rawType));
+          new TypeUse.instantiation(backendClasses.typeImplementation.rawType));
     }
     lookupMapAnalysis.registerConstantKey(constant);
   }
@@ -1139,7 +1146,7 @@
             helpers.setRuntimeTypeInfo,
             null));
       }
-      if (type.element == typeImplementation) {
+      if (type.element == backendClasses.typeImplementation) {
         // If we use a type literal in a constant, the compile time
         // constant emitter will generate a call to the createRuntimeType
         // helper so we register a use of that.
@@ -1897,30 +1904,6 @@
     return compiler.closedWorld.hasOnlySubclasses(classElement);
   }
 
-  bool isNullImplementation(ClassElement cls) {
-    return cls == helpers.jsNullClass;
-  }
-
-  ClassElement get intImplementation => helpers.jsIntClass;
-  ClassElement get uint32Implementation => helpers.jsUInt32Class;
-  ClassElement get uint31Implementation => helpers.jsUInt31Class;
-  ClassElement get positiveIntImplementation => helpers.jsPositiveIntClass;
-  ClassElement get doubleImplementation => helpers.jsDoubleClass;
-  ClassElement get numImplementation => helpers.jsNumberClass;
-  ClassElement get stringImplementation => helpers.jsStringClass;
-  ClassElement get listImplementation => helpers.jsArrayClass;
-  ClassElement get constListImplementation => helpers.jsUnmodifiableArrayClass;
-  ClassElement get fixedListImplementation => helpers.jsFixedArrayClass;
-  ClassElement get growableListImplementation => helpers.jsExtendableArrayClass;
-  ClassElement get mapImplementation => helpers.mapLiteralClass;
-  ClassElement get constMapImplementation => helpers.constMapLiteralClass;
-  ClassElement get typeImplementation => helpers.typeLiteralClass;
-  ClassElement get boolImplementation => helpers.jsBoolClass;
-  ClassElement get nullImplementation => helpers.jsNullClass;
-  ClassElement get syncStarIterableImplementation => helpers.syncStarIterable;
-  ClassElement get asyncFutureImplementation => helpers.futureImplementation;
-  ClassElement get asyncStarStreamImplementation => helpers.controllerStream;
-
   void registerStaticUse(Element element, Enqueuer enqueuer) {
     if (element == helpers.disableTreeShakingMarker) {
       isTreeShakingDisabled = true;
@@ -3257,3 +3240,30 @@
     }
   }
 }
+
+class JavaScriptBackendClasses implements BackendClasses {
+  final BackendHelpers helpers;
+
+  JavaScriptBackendClasses(this.helpers);
+
+  ClassElement get intImplementation => helpers.jsIntClass;
+  ClassElement get uint32Implementation => helpers.jsUInt32Class;
+  ClassElement get uint31Implementation => helpers.jsUInt31Class;
+  ClassElement get positiveIntImplementation => helpers.jsPositiveIntClass;
+  ClassElement get doubleImplementation => helpers.jsDoubleClass;
+  ClassElement get numImplementation => helpers.jsNumberClass;
+  ClassElement get stringImplementation => helpers.jsStringClass;
+  ClassElement get listImplementation => helpers.jsArrayClass;
+  ClassElement get constListImplementation => helpers.jsUnmodifiableArrayClass;
+  ClassElement get fixedListImplementation => helpers.jsFixedArrayClass;
+  ClassElement get growableListImplementation => helpers.jsExtendableArrayClass;
+  ClassElement get mapImplementation => helpers.mapLiteralClass;
+  ClassElement get constMapImplementation => helpers.constMapLiteralClass;
+  ClassElement get typeImplementation => helpers.typeLiteralClass;
+  ClassElement get boolImplementation => helpers.jsBoolClass;
+  ClassElement get nullImplementation => helpers.jsNullClass;
+  ClassElement get syncStarIterableImplementation => helpers.syncStarIterable;
+  ClassElement get asyncFutureImplementation => helpers.futureImplementation;
+  ClassElement get asyncStarStreamImplementation => helpers.controllerStream;
+  ClassElement get functionImplementation => helpers.coreClasses.functionClass;
+}
diff --git a/pkg/compiler/lib/src/js_backend/backend_impact.dart b/pkg/compiler/lib/src/js_backend/backend_impact.dart
index e933ae5..7726ed0 100644
--- a/pkg/compiler/lib/src/js_backend/backend_impact.dart
+++ b/pkg/compiler/lib/src/js_backend/backend_impact.dart
@@ -446,7 +446,7 @@
   BackendImpact get typeLiteral {
     if (_typeLiteral == null) {
       _typeLiteral = new BackendImpact(
-          instantiatedClasses: [backend.typeImplementation],
+          instantiatedClasses: [backend.backendClasses.typeImplementation],
           staticUses: [helpers.createRuntimeType]);
     }
     return _typeLiteral;
diff --git a/pkg/compiler/lib/src/js_backend/constant_system_javascript.dart b/pkg/compiler/lib/src/js_backend/constant_system_javascript.dart
index e717466..7f86482 100644
--- a/pkg/compiler/lib/src/js_backend/constant_system_javascript.dart
+++ b/pkg/compiler/lib/src/js_backend/constant_system_javascript.dart
@@ -265,8 +265,10 @@
 
   @override
   ConstantValue createType(Compiler compiler, DartType type) {
-    return new TypeConstantValue(type,
-        compiler.backend.typeImplementation.computeType(compiler.resolution));
+    return new TypeConstantValue(
+        type,
+        compiler.backend.backendClasses.typeImplementation
+            .computeType(compiler.resolution));
   }
 
   // Integer checks report true for -0.0, INFINITY, and -INFINITY.  At
diff --git a/pkg/compiler/lib/src/js_backend/enqueuer.dart b/pkg/compiler/lib/src/js_backend/enqueuer.dart
index 8ceca0b..e4b3027 100644
--- a/pkg/compiler/lib/src/js_backend/enqueuer.dart
+++ b/pkg/compiler/lib/src/js_backend/enqueuer.dart
@@ -88,7 +88,7 @@
 
   Registry get mirrorDependencies => _compiler.mirrorDependencies;
 
-  ClassWorld get _world => _compiler.closedWorld;
+  ClosedWorld get _world => _compiler.closedWorld;
 
   bool get queueIsEmpty => queue.isEmpty;
 
diff --git a/pkg/compiler/lib/src/js_backend/lookup_map_analysis.dart b/pkg/compiler/lib/src/js_backend/lookup_map_analysis.dart
index 2045c6c..d729e56 100644
--- a/pkg/compiler/lib/src/js_backend/lookup_map_analysis.dart
+++ b/pkg/compiler/lib/src/js_backend/lookup_map_analysis.dart
@@ -277,7 +277,7 @@
         // type_lookup_map/generic_type_test
         // TODO(sigmund): can we get rid of this?
         backend.computeImpactForInstantiatedConstantType(
-            backend.typeImplementation.rawType, impactBuilder);
+            backend.backendClasses.typeImplementation.rawType, impactBuilder);
         _addGenerics(arg);
       }
     }
diff --git a/pkg/compiler/lib/src/js_emitter/class_stub_generator.dart b/pkg/compiler/lib/src/js_emitter/class_stub_generator.dart
index 1e0b6a3..96d991a 100644
--- a/pkg/compiler/lib/src/js_emitter/class_stub_generator.dart
+++ b/pkg/compiler/lib/src/js_emitter/class_stub_generator.dart
@@ -92,7 +92,7 @@
     Set<Selector> generatedSelectors = new Set<Selector>();
     for (Selector selector in selectors.keys) {
       if (generatedSelectors.contains(selector)) continue;
-      if (!selector.appliesUnnamed(member, backend)) continue;
+      if (!selector.appliesUnnamed(member)) continue;
       if (selectors[selector].applies(member, selector, compiler.closedWorld)) {
         generatedSelectors.add(selector);
 
diff --git a/pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart b/pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart
index 621d781..c63527d 100644
--- a/pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart
+++ b/pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart
@@ -248,7 +248,7 @@
           new Selector.call(member.memberName, selector.callStructure);
       renamedCallSelectors.add(renamedSelector);
 
-      if (!renamedSelector.appliesUnnamed(member, compiler.backend)) {
+      if (!renamedSelector.appliesUnnamed(member)) {
         continue;
       }
 
@@ -266,7 +266,7 @@
     // call-selectors (and they are in the renamedCallSelectors set.
     for (Selector selector in selectors.keys) {
       if (renamedCallSelectors.contains(selector)) continue;
-      if (!selector.appliesUnnamed(member, backend)) continue;
+      if (!selector.appliesUnnamed(member)) continue;
       if (!selectors[selector]
           .applies(member, selector, compiler.closedWorld)) {
         continue;
diff --git a/pkg/compiler/lib/src/native/enqueue.dart b/pkg/compiler/lib/src/native/enqueue.dart
index 1ab06fe..8e2d48b 100644
--- a/pkg/compiler/lib/src/native/enqueue.dart
+++ b/pkg/compiler/lib/src/native/enqueue.dart
@@ -483,8 +483,8 @@
           backend.registerInstantiatedType(type, world, registry);
         } else if (type == coreTypes.boolType) {
           backend.registerInstantiatedType(type, world, registry);
-        } else if (compiler.types
-            .isSubtype(type, backend.listImplementation.rawType)) {
+        } else if (compiler.types.isSubtype(
+            type, backend.backendClasses.listImplementation.rawType)) {
           backend.registerInstantiatedType(type, world, registry);
         }
         // TODO(johnniwinther): Improve spec string precision to handle type
diff --git a/pkg/compiler/lib/src/ssa/builder.dart b/pkg/compiler/lib/src/ssa/builder.dart
index 5cca521..a39f87c 100644
--- a/pkg/compiler/lib/src/ssa/builder.dart
+++ b/pkg/compiler/lib/src/ssa/builder.dart
@@ -332,7 +332,7 @@
    */
   List<HInstruction> completeDynamicSendArgumentsList(Selector selector,
       FunctionElement function, List<HInstruction> providedArguments) {
-    assert(selector.applies(function, backend));
+    assert(selector.applies(function));
     FunctionSignature signature = function.functionSignature;
     List<HInstruction> compiledArguments = new List<HInstruction>(
         signature.parameterCount + 1); // Plus one for receiver.
@@ -426,7 +426,7 @@
               element.isGenerativeConstructorBody,
           message: "Missing selector for inlining of $element."));
       if (selector != null) {
-        if (!selector.applies(function, backend)) return false;
+        if (!selector.applies(function)) return false;
         if (mask != null &&
             !mask.canHit(function, selector, compiler.closedWorld)) {
           return false;
@@ -3201,7 +3201,7 @@
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
     Selector selector = elements.getSelector(node);
-    assert(invariant(node, selector.applies(function.implementation, backend),
+    assert(invariant(node, selector.applies(function.implementation),
         message: "$selector does not apply to ${function.implementation}"));
     List<HInstruction> inputs = makeStaticArgumentList(
         selector.callStructure, node.arguments, function.implementation);
@@ -4453,8 +4453,7 @@
     List<HInstruction> setterInputs = <HInstruction>[];
     void generateSuperSendSet() {
       Selector setterSelector = elements.getSelector(node);
-      if (Elements.isUnresolved(element) ||
-          !setterSelector.applies(element, compiler.backend)) {
+      if (Elements.isUnresolved(element) || !setterSelector.applies(element)) {
         generateSuperNoSuchMethodSend(node, setterSelector, setterInputs);
         pop();
       } else {
diff --git a/pkg/compiler/lib/src/ssa/interceptor_simplifier.dart b/pkg/compiler/lib/src/ssa/interceptor_simplifier.dart
index eafe01b..1716c7f 100644
--- a/pkg/compiler/lib/src/ssa/interceptor_simplifier.dart
+++ b/pkg/compiler/lib/src/ssa/interceptor_simplifier.dart
@@ -11,7 +11,7 @@
 import '../js_backend/js_backend.dart';
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
-import '../world.dart' show ClassWorld;
+import '../world.dart' show ClosedWorld;
 import 'nodes.dart';
 import 'optimize.dart';
 
@@ -49,7 +49,7 @@
 
   BackendHelpers get helpers => backend.helpers;
 
-  ClassWorld get classWorld => compiler.closedWorld;
+  ClosedWorld get closedWorld => compiler.closedWorld;
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
@@ -109,8 +109,8 @@
 
     // All intercepted classes extend `Interceptor`, so if the receiver can't be
     // a class extending `Interceptor` then it can be called directly.
-    return new TypeMask.nonNullSubclass(helpers.jsInterceptorClass, classWorld)
-        .isDisjoint(receiver.instructionType, classWorld);
+    return new TypeMask.nonNullSubclass(helpers.jsInterceptorClass, closedWorld)
+        .isDisjoint(receiver.instructionType, closedWorld);
   }
 
   HInstruction tryComputeConstantInterceptor(
@@ -145,17 +145,17 @@
       if (type.isNull) {
         return helpers.jsNullClass;
       }
-    } else if (type.containsOnlyInt(classWorld)) {
+    } else if (type.containsOnlyInt(closedWorld)) {
       return helpers.jsIntClass;
-    } else if (type.containsOnlyDouble(classWorld)) {
+    } else if (type.containsOnlyDouble(closedWorld)) {
       return helpers.jsDoubleClass;
-    } else if (type.containsOnlyBool(classWorld)) {
+    } else if (type.containsOnlyBool(closedWorld)) {
       return helpers.jsBoolClass;
-    } else if (type.containsOnlyString(classWorld)) {
+    } else if (type.containsOnlyString(closedWorld)) {
       return helpers.jsStringClass;
-    } else if (type.satisfies(helpers.jsArrayClass, classWorld)) {
+    } else if (type.satisfies(helpers.jsArrayClass, closedWorld)) {
       return helpers.jsArrayClass;
-    } else if (type.containsOnlyNum(classWorld) &&
+    } else if (type.containsOnlyNum(closedWorld) &&
         !interceptedClasses.contains(helpers.jsIntClass) &&
         !interceptedClasses.contains(helpers.jsDoubleClass)) {
       // If the method being intercepted is not defined in [int] or [double] we
@@ -174,7 +174,7 @@
       // for a subclass or call methods defined on a subclass.  Provided the
       // code is completely insensitive to the specific instance subclasses, we
       // can use the non-leaf class directly.
-      ClassElement element = type.singleClass(classWorld);
+      ClassElement element = type.singleClass(closedWorld);
       if (element != null && backend.isNative(element)) {
         return element;
       }
diff --git a/pkg/compiler/lib/src/ssa/optimize.dart b/pkg/compiler/lib/src/ssa/optimize.dart
index 627e7195..9aa2d98 100644
--- a/pkg/compiler/lib/src/ssa/optimize.dart
+++ b/pkg/compiler/lib/src/ssa/optimize.dart
@@ -378,7 +378,7 @@
     ClosedWorld world = compiler.closedWorld;
 
     bool applies(Element element) {
-      return selector.applies(element, backend) &&
+      return selector.applies(element) &&
           (mask == null || mask.canHit(element, selector, world));
     }
 
@@ -427,7 +427,7 @@
         return result;
       }
     } else if (selector.isGetter) {
-      if (selector.applies(helpers.jsIndexableLength, backend)) {
+      if (selector.applies(helpers.jsIndexableLength)) {
         HInstruction optimized = tryOptimizeLengthInterceptedGetter(node);
         if (optimized != null) return optimized;
       }
diff --git a/pkg/compiler/lib/src/ssa/types.dart b/pkg/compiler/lib/src/ssa/types.dart
index edffc3a..18ed76c 100644
--- a/pkg/compiler/lib/src/ssa/types.dart
+++ b/pkg/compiler/lib/src/ssa/types.dart
@@ -9,7 +9,7 @@
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
-import '../world.dart' show ClassWorld;
+import '../world.dart' show ClosedWorld;
 
 class TypeMaskFactory {
   static TypeMask inferredReturnTypeForElement(
@@ -34,7 +34,7 @@
     var typesReturned = nativeBehavior.typesReturned;
     if (typesReturned.isEmpty) return compiler.commonMasks.dynamicType;
 
-    ClassWorld world = compiler.closedWorld;
+    ClosedWorld world = compiler.closedWorld;
     CommonMasks commonMasks = compiler.commonMasks;
     CoreClasses coreClasses = compiler.coreClasses;
 
diff --git a/pkg/compiler/lib/src/ssa/types_propagation.dart b/pkg/compiler/lib/src/ssa/types_propagation.dart
index e9b4c98..46beb9e 100644
--- a/pkg/compiler/lib/src/ssa/types_propagation.dart
+++ b/pkg/compiler/lib/src/ssa/types_propagation.dart
@@ -7,7 +7,7 @@
 import '../js_backend/js_backend.dart';
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
-import '../world.dart' show ClassWorld;
+import '../world.dart' show ClosedWorld;
 import 'nodes.dart';
 import 'optimize.dart';
 
@@ -18,13 +18,13 @@
       new Map<HInstruction, Function>();
 
   final Compiler compiler;
-  final ClassWorld classWorld;
+  final ClosedWorld closedWorld;
   JavaScriptBackend get backend => compiler.backend;
   String get name => 'type propagator';
 
   SsaTypePropagator(Compiler compiler)
       : this.compiler = compiler,
-        this.classWorld = compiler.closedWorld;
+        this.closedWorld = compiler.closedWorld;
 
   TypeMask computeType(HInstruction instruction) {
     return instruction.accept(this);
@@ -160,7 +160,7 @@
     TypeMask candidateType = backend.emptyType;
     for (int i = 0, length = phi.inputs.length; i < length; i++) {
       TypeMask inputType = phi.inputs[i].instructionType;
-      candidateType = candidateType.union(inputType, classWorld);
+      candidateType = candidateType.union(inputType, closedWorld);
     }
     return candidateType;
   }
@@ -173,25 +173,25 @@
       // We must make sure a type conversion for receiver or argument check
       // does not try to do an int check, because an int check is not enough.
       // We only do an int check if the input is integer or null.
-      if (checkedType.containsOnlyNum(classWorld) &&
-          !checkedType.containsOnlyDouble(classWorld) &&
+      if (checkedType.containsOnlyNum(closedWorld) &&
+          !checkedType.containsOnlyDouble(closedWorld) &&
           input.isIntegerOrNull(compiler)) {
         instruction.checkedType = backend.intType;
-      } else if (checkedType.containsOnlyInt(classWorld) &&
+      } else if (checkedType.containsOnlyInt(closedWorld) &&
           !input.isIntegerOrNull(compiler)) {
         instruction.checkedType = backend.numType;
       }
     }
 
-    TypeMask outputType = checkedType.intersection(inputType, classWorld);
+    TypeMask outputType = checkedType.intersection(inputType, closedWorld);
     if (outputType.isEmpty) {
       // Intersection of double and integer conflicts (is empty), but JS numbers
       // can be both int and double at the same time.  For example, the input
       // can be a literal double '8.0' that is marked as an integer (because 'is
       // int' will return 'true').  What we really need to do is make the
       // overlap between int and double values explicit in the TypeMask system.
-      if (inputType.containsOnlyInt(classWorld) &&
-          checkedType.containsOnlyDouble(classWorld)) {
+      if (inputType.containsOnlyInt(closedWorld) &&
+          checkedType.containsOnlyDouble(closedWorld)) {
         if (inputType.isNullable && checkedType.isNullable) {
           outputType = backend.doubleType.nullable();
         } else {
@@ -221,7 +221,7 @@
     HInstruction input = instruction.checkedInput;
     TypeMask inputType = input.instructionType;
     TypeMask outputType =
-        instruction.knownType.intersection(inputType, classWorld);
+        instruction.knownType.intersection(inputType, closedWorld);
     if (inputType != outputType) {
       input.replaceAllUsersDominatedBy(instruction.next, instruction);
     }
@@ -244,7 +244,7 @@
     // In some cases, we want the receiver to be an integer,
     // but that does not mean we will get a NoSuchMethodError
     // if it's not: the receiver could be a double.
-    if (type.containsOnlyInt(classWorld)) {
+    if (type.containsOnlyInt(closedWorld)) {
       // If the instruction's type is integer or null, the codegen
       // will emit a null check, which is enough to know if it will
       // hit a noSuchMethod.
@@ -274,12 +274,12 @@
         Element target = targets.first;
         ClassElement cls = target.enclosingClass;
         TypeMask type =
-            new TypeMask.nonNullSubclass(cls.declaration, classWorld);
+            new TypeMask.nonNullSubclass(cls.declaration, closedWorld);
         // TODO(ngeoffray): We currently only optimize on primitive
         // types.
-        if (!type.satisfies(backend.helpers.jsIndexableClass, classWorld) &&
-            !type.containsOnlyNum(classWorld) &&
-            !type.containsOnlyBool(classWorld)) {
+        if (!type.satisfies(backend.helpers.jsIndexableClass, closedWorld) &&
+            !type.containsOnlyNum(closedWorld) &&
+            !type.containsOnlyBool(closedWorld)) {
           return false;
         }
         if (!isCheckEnoughForNsmOrAe(receiver, type)) return false;
@@ -373,7 +373,7 @@
       TypeMask computeNewType() {
         newType = compiler.closedWorld.allFunctions
             .receiverType(instruction.selector, instruction.mask);
-        newType = newType.intersection(receiverType, classWorld);
+        newType = newType.intersection(receiverType, closedWorld);
         return newType;
       }
 
diff --git a/pkg/compiler/lib/src/types/container_type_mask.dart b/pkg/compiler/lib/src/types/container_type_mask.dart
index acde3b2..908996b 100644
--- a/pkg/compiler/lib/src/types/container_type_mask.dart
+++ b/pkg/compiler/lib/src/types/container_type_mask.dart
@@ -50,13 +50,13 @@
         length == other.length;
   }
 
-  TypeMask intersection(TypeMask other, ClassWorld classWorld) {
-    TypeMask forwardIntersection = forwardTo.intersection(other, classWorld);
+  TypeMask intersection(TypeMask other, ClosedWorld closedWorld) {
+    TypeMask forwardIntersection = forwardTo.intersection(other, closedWorld);
     if (forwardIntersection.isEmptyOrNull) return forwardIntersection;
     return forwardIntersection.isNullable ? nullable() : nonNullable();
   }
 
-  TypeMask union(other, ClassWorld classWorld) {
+  TypeMask union(other, ClosedWorld closedWorld) {
     if (this == other) {
       return this;
     } else if (equalsDisregardNull(other)) {
@@ -67,9 +67,9 @@
         elementType != null &&
         other.elementType != null) {
       TypeMask newElementType =
-          elementType.union(other.elementType, classWorld);
+          elementType.union(other.elementType, closedWorld);
       int newLength = (length == other.length) ? length : null;
-      TypeMask newForwardTo = forwardTo.union(other.forwardTo, classWorld);
+      TypeMask newForwardTo = forwardTo.union(other.forwardTo, closedWorld);
       return new ContainerTypeMask(
           newForwardTo,
           allocationNode == other.allocationNode ? allocationNode : null,
@@ -79,7 +79,7 @@
           newElementType,
           newLength);
     } else {
-      return forwardTo.union(other, classWorld);
+      return forwardTo.union(other, closedWorld);
     }
   }
 
diff --git a/pkg/compiler/lib/src/types/dictionary_type_mask.dart b/pkg/compiler/lib/src/types/dictionary_type_mask.dart
index c308041..fc7a8a5 100644
--- a/pkg/compiler/lib/src/types/dictionary_type_mask.dart
+++ b/pkg/compiler/lib/src/types/dictionary_type_mask.dart
@@ -47,13 +47,13 @@
             (k) => typeMap.containsKey(k) && typeMap[k] == other.typeMap[k]);
   }
 
-  TypeMask intersection(TypeMask other, ClassWorld classWorld) {
-    TypeMask forwardIntersection = forwardTo.intersection(other, classWorld);
+  TypeMask intersection(TypeMask other, ClosedWorld closedWorld) {
+    TypeMask forwardIntersection = forwardTo.intersection(other, closedWorld);
     if (forwardIntersection.isEmptyOrNull) return forwardIntersection;
     return forwardIntersection.isNullable ? nullable() : nonNullable();
   }
 
-  TypeMask union(other, ClassWorld classWorld) {
+  TypeMask union(other, ClosedWorld closedWorld) {
     if (this == other) {
       return this;
     } else if (equalsDisregardNull(other)) {
@@ -61,9 +61,9 @@
     } else if (other.isEmptyOrNull) {
       return other.isNullable ? this.nullable() : this;
     } else if (other.isDictionary) {
-      TypeMask newForwardTo = forwardTo.union(other.forwardTo, classWorld);
-      TypeMask newKeyType = keyType.union(other.keyType, classWorld);
-      TypeMask newValueType = valueType.union(other.valueType, classWorld);
+      TypeMask newForwardTo = forwardTo.union(other.forwardTo, closedWorld);
+      TypeMask newKeyType = keyType.union(other.keyType, closedWorld);
+      TypeMask newValueType = valueType.union(other.valueType, closedWorld);
       Map<String, TypeMask> mappings = <String, TypeMask>{};
       typeMap.forEach((k, v) {
         if (!other.typeMap.containsKey(k)) {
@@ -72,7 +72,7 @@
       });
       other.typeMap.forEach((k, v) {
         if (typeMap.containsKey(k)) {
-          mappings[k] = v.union(typeMap[k], classWorld);
+          mappings[k] = v.union(typeMap[k], closedWorld);
         } else {
           mappings[k] = v.nullable();
         }
@@ -82,13 +82,13 @@
     } else if (other.isMap &&
         (other.keyType != null) &&
         (other.valueType != null)) {
-      TypeMask newForwardTo = forwardTo.union(other.forwardTo, classWorld);
-      TypeMask newKeyType = keyType.union(other.keyType, classWorld);
-      TypeMask newValueType = valueType.union(other.valueType, classWorld);
+      TypeMask newForwardTo = forwardTo.union(other.forwardTo, closedWorld);
+      TypeMask newKeyType = keyType.union(other.keyType, closedWorld);
+      TypeMask newValueType = valueType.union(other.valueType, closedWorld);
       return new MapTypeMask(
           newForwardTo, null, null, newKeyType, newValueType);
     } else {
-      return forwardTo.union(other, classWorld);
+      return forwardTo.union(other, closedWorld);
     }
   }
 
diff --git a/pkg/compiler/lib/src/types/flat_type_mask.dart b/pkg/compiler/lib/src/types/flat_type_mask.dart
index 1055af2..5a3ef8e 100644
--- a/pkg/compiler/lib/src/types/flat_type_mask.dart
+++ b/pkg/compiler/lib/src/types/flat_type_mask.dart
@@ -120,25 +120,25 @@
     // The general optimization is to realize there is only one class that
     // implements [base] and [base] is not instantiated. We however do
     // not track correctly the list of truly instantiated classes.
-    Backend backend = closedWorld.backend;
+    BackendClasses backendClasses = closedWorld.backendClasses;
     if (containsOnlyString(closedWorld)) {
       return cls == closedWorld.coreClasses.stringClass ||
-          cls == backend.stringImplementation;
+          cls == backendClasses.stringImplementation;
     }
     if (containsOnlyBool(closedWorld)) {
       return cls == closedWorld.coreClasses.boolClass ||
-          cls == backend.boolImplementation;
+          cls == backendClasses.boolImplementation;
     }
     if (containsOnlyInt(closedWorld)) {
       return cls == closedWorld.coreClasses.intClass ||
-          cls == backend.intImplementation ||
-          cls == backend.positiveIntImplementation ||
-          cls == backend.uint32Implementation ||
-          cls == backend.uint31Implementation;
+          cls == backendClasses.intImplementation ||
+          cls == backendClasses.positiveIntImplementation ||
+          cls == backendClasses.uint32Implementation ||
+          cls == backendClasses.uint31Implementation;
     }
     if (containsOnlyDouble(closedWorld)) {
       return cls == closedWorld.coreClasses.doubleClass ||
-          cls == backend.doubleImplementation;
+          cls == backendClasses.doubleImplementation;
     }
     return false;
   }
@@ -180,38 +180,38 @@
   }
 
   bool containsOnlyInt(ClosedWorld closedWorld) {
-    Backend backend = closedWorld.backend;
+    BackendClasses backendClasses = closedWorld.backendClasses;
     return base == closedWorld.coreClasses.intClass ||
-        base == backend.intImplementation ||
-        base == backend.positiveIntImplementation ||
-        base == backend.uint31Implementation ||
-        base == backend.uint32Implementation;
+        base == backendClasses.intImplementation ||
+        base == backendClasses.positiveIntImplementation ||
+        base == backendClasses.uint31Implementation ||
+        base == backendClasses.uint32Implementation;
   }
 
   bool containsOnlyDouble(ClosedWorld closedWorld) {
-    Backend backend = closedWorld.backend;
+    BackendClasses backendClasses = closedWorld.backendClasses;
     return base == closedWorld.coreClasses.doubleClass ||
-        base == backend.doubleImplementation;
+        base == backendClasses.doubleImplementation;
   }
 
   bool containsOnlyNum(ClosedWorld closedWorld) {
-    Backend backend = closedWorld.backend;
+    BackendClasses backendClasses = closedWorld.backendClasses;
     return containsOnlyInt(closedWorld) ||
         containsOnlyDouble(closedWorld) ||
         base == closedWorld.coreClasses.numClass ||
-        base == backend.numImplementation;
+        base == backendClasses.numImplementation;
   }
 
   bool containsOnlyBool(ClosedWorld closedWorld) {
-    Backend backend = closedWorld.backend;
+    BackendClasses backendClasses = closedWorld.backendClasses;
     return base == closedWorld.coreClasses.boolClass ||
-        base == backend.boolImplementation;
+        base == backendClasses.boolImplementation;
   }
 
   bool containsOnlyString(ClosedWorld closedWorld) {
-    Backend backend = closedWorld.backend;
+    BackendClasses backendClasses = closedWorld.backendClasses;
     return base == closedWorld.coreClasses.stringClass ||
-        base == backend.stringImplementation;
+        base == backendClasses.stringImplementation;
   }
 
   bool containsOnly(ClassElement cls) {
@@ -543,11 +543,11 @@
    * privacy is taken into account.
    */
   bool canHit(Element element, Selector selector, ClosedWorld closedWorld) {
-    Backend backend = closedWorld.backend;
+    BackendClasses backendClasses = closedWorld.backendClasses;
     assert(element.name == selector.name);
     if (isEmpty) return false;
     if (isNull) {
-      return hasElementIn(backend.nullImplementation, selector, element);
+      return hasElementIn(backendClasses.nullImplementation, selector, element);
     }
 
     // TODO(kasperl): Can't we just avoid creating typed selectors
@@ -560,18 +560,16 @@
     }
 
     ClassElement other = element.enclosingClass;
-    if (other == backend.nullImplementation) {
+    if (other == backendClasses.nullImplementation) {
       return isNullable;
     } else if (isExact) {
       return hasElementIn(self, selector, element);
     } else if (isSubclass) {
-      assert(closedWorld.isClosed);
       return hasElementIn(self, selector, element) ||
           other.isSubclassOf(self) ||
           closedWorld.hasAnySubclassThatMixes(self, other);
     } else {
       assert(isSubtype);
-      assert(closedWorld.isClosed);
       bool result = hasElementIn(self, selector, element) ||
           other.implementsInterface(self) ||
           closedWorld.hasAnySubclassThatImplements(other, base) ||
@@ -602,7 +600,7 @@
       ClassElement enclosingClass = element.enclosingClass;
       return hasConcreteMatch(enclosingClass.superclass, selector, world);
     }
-    return selector.appliesUntyped(element, world.backend);
+    return selector.appliesUntyped(element);
   }
 
   bool needsNoSuchMethodHandling(Selector selector, ClosedWorld closedWorld) {
diff --git a/pkg/compiler/lib/src/types/forwarding_type_mask.dart b/pkg/compiler/lib/src/types/forwarding_type_mask.dart
index d886e99..cdf4f16 100644
--- a/pkg/compiler/lib/src/types/forwarding_type_mask.dart
+++ b/pkg/compiler/lib/src/types/forwarding_type_mask.dart
@@ -26,55 +26,55 @@
   bool get isValue => false;
   bool get isForwarding => true;
 
-  bool isInMask(TypeMask other, ClassWorld classWorld) {
-    return forwardTo.isInMask(other, classWorld);
+  bool isInMask(TypeMask other, ClosedWorld closedWorld) {
+    return forwardTo.isInMask(other, closedWorld);
   }
 
-  bool containsMask(TypeMask other, ClassWorld classWorld) {
-    return forwardTo.containsMask(other, classWorld);
+  bool containsMask(TypeMask other, ClosedWorld closedWorld) {
+    return forwardTo.containsMask(other, closedWorld);
   }
 
-  bool containsOnlyInt(ClassWorld classWorld) {
-    return forwardTo.containsOnlyInt(classWorld);
+  bool containsOnlyInt(ClosedWorld closedWorld) {
+    return forwardTo.containsOnlyInt(closedWorld);
   }
 
-  bool containsOnlyDouble(ClassWorld classWorld) {
-    return forwardTo.containsOnlyDouble(classWorld);
+  bool containsOnlyDouble(ClosedWorld closedWorld) {
+    return forwardTo.containsOnlyDouble(closedWorld);
   }
 
-  bool containsOnlyNum(ClassWorld classWorld) {
-    return forwardTo.containsOnlyNum(classWorld);
+  bool containsOnlyNum(ClosedWorld closedWorld) {
+    return forwardTo.containsOnlyNum(closedWorld);
   }
 
-  bool containsOnlyBool(ClassWorld classWorld) {
-    return forwardTo.containsOnlyBool(classWorld);
+  bool containsOnlyBool(ClosedWorld closedWorld) {
+    return forwardTo.containsOnlyBool(closedWorld);
   }
 
-  bool containsOnlyString(ClassWorld classWorld) {
-    return forwardTo.containsOnlyString(classWorld);
+  bool containsOnlyString(ClosedWorld closedWorld) {
+    return forwardTo.containsOnlyString(closedWorld);
   }
 
   bool containsOnly(ClassElement element) {
     return forwardTo.containsOnly(element);
   }
 
-  bool satisfies(ClassElement cls, ClassWorld classWorld) {
-    return forwardTo.satisfies(cls, classWorld);
+  bool satisfies(ClassElement cls, ClosedWorld closedWorld) {
+    return forwardTo.satisfies(cls, closedWorld);
   }
 
-  bool contains(ClassElement type, ClassWorld classWorld) {
-    return forwardTo.contains(type, classWorld);
+  bool contains(ClassElement type, ClosedWorld closedWorld) {
+    return forwardTo.contains(type, closedWorld);
   }
 
-  bool containsAll(ClassWorld classWorld) {
-    return forwardTo.containsAll(classWorld);
+  bool containsAll(ClosedWorld closedWorld) {
+    return forwardTo.containsAll(closedWorld);
   }
 
-  ClassElement singleClass(ClassWorld classWorld) {
-    return forwardTo.singleClass(classWorld);
+  ClassElement singleClass(ClosedWorld closedWorld) {
+    return forwardTo.singleClass(closedWorld);
   }
 
-  TypeMask union(other, ClassWorld classWorld) {
+  TypeMask union(other, ClosedWorld closedWorld) {
     if (this == other) {
       return this;
     } else if (equalsDisregardNull(other)) {
@@ -82,23 +82,23 @@
     } else if (other.isEmptyOrNull) {
       return other.isNullable ? this.nullable() : this;
     }
-    return forwardTo.union(other, classWorld);
+    return forwardTo.union(other, closedWorld);
   }
 
-  bool isDisjoint(TypeMask other, ClassWorld classWorld) {
-    return forwardTo.isDisjoint(other, classWorld);
+  bool isDisjoint(TypeMask other, ClosedWorld closedWorld) {
+    return forwardTo.isDisjoint(other, closedWorld);
   }
 
-  TypeMask intersection(TypeMask other, ClassWorld classWorld) {
-    return forwardTo.intersection(other, classWorld);
+  TypeMask intersection(TypeMask other, ClosedWorld closedWorld) {
+    return forwardTo.intersection(other, closedWorld);
   }
 
-  bool needsNoSuchMethodHandling(Selector selector, ClassWorld classWorld) {
-    return forwardTo.needsNoSuchMethodHandling(selector, classWorld);
+  bool needsNoSuchMethodHandling(Selector selector, ClosedWorld closedWorld) {
+    return forwardTo.needsNoSuchMethodHandling(selector, closedWorld);
   }
 
-  bool canHit(Element element, Selector selector, ClassWorld classWorld) {
-    return forwardTo.canHit(element, selector, classWorld);
+  bool canHit(Element element, Selector selector, ClosedWorld closedWorld) {
+    return forwardTo.canHit(element, selector, closedWorld);
   }
 
   Element locateSingleElement(Selector selector, Compiler compiler) {
diff --git a/pkg/compiler/lib/src/types/map_type_mask.dart b/pkg/compiler/lib/src/types/map_type_mask.dart
index 57f3c46..230db17 100644
--- a/pkg/compiler/lib/src/types/map_type_mask.dart
+++ b/pkg/compiler/lib/src/types/map_type_mask.dart
@@ -53,13 +53,13 @@
         valueType == other.valueType;
   }
 
-  TypeMask intersection(TypeMask other, ClassWorld classWorld) {
-    TypeMask forwardIntersection = forwardTo.intersection(other, classWorld);
+  TypeMask intersection(TypeMask other, ClosedWorld closedWorld) {
+    TypeMask forwardIntersection = forwardTo.intersection(other, closedWorld);
     if (forwardIntersection.isEmptyOrNull) return forwardIntersection;
     return forwardIntersection.isNullable ? nullable() : nonNullable();
   }
 
-  TypeMask union(other, ClassWorld classWorld) {
+  TypeMask union(other, ClosedWorld closedWorld) {
     if (this == other) {
       return this;
     } else if (equalsDisregardNull(other)) {
@@ -71,20 +71,21 @@
         other.keyType != null &&
         valueType != null &&
         other.valueType != null) {
-      TypeMask newKeyType = keyType.union(other.keyType, classWorld);
-      TypeMask newValueType = valueType.union(other.valueType, classWorld);
-      TypeMask newForwardTo = forwardTo.union(other.forwardTo, classWorld);
+      TypeMask newKeyType = keyType.union(other.keyType, closedWorld);
+      TypeMask newValueType = valueType.union(other.valueType, closedWorld);
+      TypeMask newForwardTo = forwardTo.union(other.forwardTo, closedWorld);
       return new MapTypeMask(
           newForwardTo, null, null, newKeyType, newValueType);
     } else if (other.isDictionary) {
       // TODO(johnniwinther): Find another way to check this invariant that
       // doesn't need the compiler.
-      assert(
-          other.keyType == classWorld.backend.compiler.commonMasks.stringType);
-      TypeMask newKeyType = keyType.union(other.keyType, classWorld);
+      assert(other.keyType ==
+          new TypeMask.nonNullExact(
+              closedWorld.backendClasses.stringImplementation, closedWorld));
+      TypeMask newKeyType = keyType.union(other.keyType, closedWorld);
       TypeMask newValueType =
-          other.typeMap.values.fold(keyType, (p, n) => p.union(n, classWorld));
-      TypeMask newForwardTo = forwardTo.union(other.forwardTo, classWorld);
+          other.typeMap.values.fold(keyType, (p, n) => p.union(n, closedWorld));
+      TypeMask newForwardTo = forwardTo.union(other.forwardTo, closedWorld);
       MapTypeMask newMapTypeMask = new MapTypeMask(
           newForwardTo,
           allocationNode == other.allocationNode ? allocationNode : null,
@@ -95,7 +96,7 @@
           newValueType);
       return newMapTypeMask;
     } else {
-      return forwardTo.union(other, classWorld);
+      return forwardTo.union(other, closedWorld);
     }
   }
 
diff --git a/pkg/compiler/lib/src/types/masks.dart b/pkg/compiler/lib/src/types/masks.dart
index b498b80..9f59ad5 100644
--- a/pkg/compiler/lib/src/types/masks.dart
+++ b/pkg/compiler/lib/src/types/masks.dart
@@ -5,7 +5,7 @@
 library masks;
 
 import '../common.dart';
-import '../common/backend_api.dart' show Backend;
+import '../common/backend_api.dart' show BackendClasses;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../elements/elements.dart';
@@ -18,7 +18,7 @@
         UniverseSelectorConstraints,
         SelectorConstraintsStrategy;
 import '../util/util.dart';
-import '../world.dart' show ClassWorld, ClosedWorld;
+import '../world.dart' show ClosedWorld;
 import 'abstract_value_domain.dart' show AbstractValue;
 
 part 'container_type_mask.dart';
@@ -37,7 +37,9 @@
 
   CommonMasks(this.compiler);
 
-  ClassWorld get classWorld => compiler.closedWorld;
+  ClosedWorld get closedWorld => compiler.closedWorld;
+
+  BackendClasses get backendClasses => closedWorld.backendClasses;
 
   TypeMask _dynamicType;
   TypeMask _nonNullType;
@@ -63,72 +65,72 @@
   TypeMask _asyncStarStreamType;
 
   TypeMask get dynamicType => _dynamicType ??=
-      new TypeMask.subclass(classWorld.coreClasses.objectClass, classWorld);
+      new TypeMask.subclass(closedWorld.coreClasses.objectClass, closedWorld);
 
   TypeMask get nonNullType => _nonNullType ??= new TypeMask.nonNullSubclass(
-      classWorld.coreClasses.objectClass, classWorld);
+      closedWorld.coreClasses.objectClass, closedWorld);
 
   TypeMask get intType => _intType ??= new TypeMask.nonNullSubclass(
-      compiler.backend.intImplementation, classWorld);
+      backendClasses.intImplementation, closedWorld);
 
   TypeMask get uint32Type => _uint32Type ??= new TypeMask.nonNullSubclass(
-      compiler.backend.uint32Implementation, classWorld);
+      backendClasses.uint32Implementation, closedWorld);
 
   TypeMask get uint31Type => _uint31Type ??= new TypeMask.nonNullExact(
-      compiler.backend.uint31Implementation, classWorld);
+      backendClasses.uint31Implementation, closedWorld);
 
   TypeMask get positiveIntType =>
       _positiveIntType ??= new TypeMask.nonNullSubclass(
-          compiler.backend.positiveIntImplementation, classWorld);
+          backendClasses.positiveIntImplementation, closedWorld);
 
   TypeMask get doubleType => _doubleType ??= new TypeMask.nonNullExact(
-      compiler.backend.doubleImplementation, classWorld);
+      backendClasses.doubleImplementation, closedWorld);
 
   TypeMask get numType => _numType ??= new TypeMask.nonNullSubclass(
-      compiler.backend.numImplementation, classWorld);
+      backendClasses.numImplementation, closedWorld);
 
-  TypeMask get boolType => _boolType ??= new TypeMask.nonNullExact(
-      compiler.backend.boolImplementation, classWorld);
+  TypeMask get boolType => _boolType ??=
+      new TypeMask.nonNullExact(backendClasses.boolImplementation, closedWorld);
 
   TypeMask get functionType => _functionType ??= new TypeMask.nonNullSubtype(
-      compiler.backend.functionImplementation, classWorld);
+      backendClasses.functionImplementation, closedWorld);
 
-  TypeMask get listType => _listType ??= new TypeMask.nonNullExact(
-      compiler.backend.listImplementation, classWorld);
+  TypeMask get listType => _listType ??=
+      new TypeMask.nonNullExact(backendClasses.listImplementation, closedWorld);
 
   TypeMask get constListType => _constListType ??= new TypeMask.nonNullExact(
-      compiler.backend.constListImplementation, classWorld);
+      backendClasses.constListImplementation, closedWorld);
 
   TypeMask get fixedListType => _fixedListType ??= new TypeMask.nonNullExact(
-      compiler.backend.fixedListImplementation, classWorld);
+      backendClasses.fixedListImplementation, closedWorld);
 
   TypeMask get growableListType =>
       _growableListType ??= new TypeMask.nonNullExact(
-          compiler.backend.growableListImplementation, classWorld);
+          backendClasses.growableListImplementation, closedWorld);
 
   TypeMask get mapType => _mapType ??= new TypeMask.nonNullSubtype(
-      compiler.backend.mapImplementation, classWorld);
+      backendClasses.mapImplementation, closedWorld);
 
   TypeMask get constMapType => _constMapType ??= new TypeMask.nonNullSubtype(
-      compiler.backend.constMapImplementation, classWorld);
+      backendClasses.constMapImplementation, closedWorld);
 
   TypeMask get stringType => _stringType ??= new TypeMask.nonNullExact(
-      compiler.backend.stringImplementation, classWorld);
+      backendClasses.stringImplementation, closedWorld);
 
-  TypeMask get typeType => _typeType ??= new TypeMask.nonNullExact(
-      compiler.backend.typeImplementation, classWorld);
+  TypeMask get typeType => _typeType ??=
+      new TypeMask.nonNullExact(backendClasses.typeImplementation, closedWorld);
 
   TypeMask get syncStarIterableType =>
       _syncStarIterableType ??= new TypeMask.nonNullExact(
-          compiler.backend.syncStarIterableImplementation, classWorld);
+          backendClasses.syncStarIterableImplementation, closedWorld);
 
   TypeMask get asyncFutureType =>
       _asyncFutureType ??= new TypeMask.nonNullExact(
-          compiler.backend.asyncFutureImplementation, classWorld);
+          backendClasses.asyncFutureImplementation, closedWorld);
 
   TypeMask get asyncStarStreamType =>
       _asyncStarStreamType ??= new TypeMask.nonNullExact(
-          compiler.backend.asyncStarStreamImplementation, classWorld);
+          backendClasses.asyncStarStreamImplementation, closedWorld);
 
   // TODO(johnniwinther): Assert that the null type has been resolved.
   TypeMask get nullType => _nullType ??= const TypeMask.empty();
diff --git a/pkg/compiler/lib/src/types/value_type_mask.dart b/pkg/compiler/lib/src/types/value_type_mask.dart
index 1ca437b..ba99b06 100644
--- a/pkg/compiler/lib/src/types/value_type_mask.dart
+++ b/pkg/compiler/lib/src/types/value_type_mask.dart
@@ -27,8 +27,8 @@
     return super.equalsDisregardNull(other) && value == other.value;
   }
 
-  TypeMask intersection(TypeMask other, ClassWorld classWorld) {
-    TypeMask forwardIntersection = forwardTo.intersection(other, classWorld);
+  TypeMask intersection(TypeMask other, ClosedWorld closedWorld) {
+    TypeMask forwardIntersection = forwardTo.intersection(other, closedWorld);
     if (forwardIntersection.isEmptyOrNull) return forwardIntersection;
     return forwardIntersection.isNullable ? nullable() : nonNullable();
   }
diff --git a/pkg/compiler/lib/src/universe/class_set.dart b/pkg/compiler/lib/src/universe/class_set.dart
index be69cc2..2dd892e 100644
--- a/pkg/compiler/lib/src/universe/class_set.dart
+++ b/pkg/compiler/lib/src/universe/class_set.dart
@@ -19,7 +19,7 @@
 
 /// Node for [cls] in a tree forming the subclass relation of [ClassElement]s.
 ///
-/// This is used by the [ClassWorld] to perform queries on subclass and subtype
+/// This is used by the [ClosedWorld] to perform queries on subclass and subtype
 /// relations.
 ///
 /// For this class hierarchy:
diff --git a/pkg/compiler/lib/src/universe/function_set.dart b/pkg/compiler/lib/src/universe/function_set.dart
index c34ae91..c05c7f9 100644
--- a/pkg/compiler/lib/src/universe/function_set.dart
+++ b/pkg/compiler/lib/src/universe/function_set.dart
@@ -125,7 +125,7 @@
   String get name => selector.name;
 
   bool applies(Element element, ClosedWorld closedWorld) {
-    if (!selector.appliesUnnamed(element, closedWorld.backend)) return false;
+    if (!selector.appliesUnnamed(element)) return false;
     return constraint.canHit(element, selector, closedWorld);
   }
 
@@ -287,7 +287,7 @@
           ClassElement cls = element.enclosingClass;
           return [cls]..addAll(closedWorld.mixinUsesOf(cls));
         }).map((cls) {
-          if (closedWorld.backend.isNullImplementation(cls)) {
+          if (closedWorld.backendClasses.nullImplementation == cls) {
             return const TypeMask.empty();
           } else if (closedWorld.isInstantiated(cls.declaration)) {
             return new TypeMask.nonNullSubclass(cls.declaration, closedWorld);
diff --git a/pkg/compiler/lib/src/universe/selector.dart b/pkg/compiler/lib/src/universe/selector.dart
index 14d8b3a..39937fb 100644
--- a/pkg/compiler/lib/src/universe/selector.dart
+++ b/pkg/compiler/lib/src/universe/selector.dart
@@ -217,12 +217,12 @@
     return kind;
   }
 
-  bool appliesUnnamed(Element element, Target target) {
+  bool appliesUnnamed(Element element) {
     assert(sameNameHack(element));
-    return appliesUntyped(element, target);
+    return appliesUntyped(element);
   }
 
-  bool appliesUntyped(Element element, Target target) {
+  bool appliesUntyped(Element element) {
     assert(sameNameHack(element));
     if (Elements.isUnresolved(element)) return false;
     if (memberName.isPrivate && memberName.library != element.library) {
@@ -230,7 +230,6 @@
       // `memberName != element.memberName`.
       return false;
     }
-    if (target.isForeign(element)) return true;
     if (element.isSetter) return isSetter;
     if (element.isGetter) return isGetter || isCall;
     if (element.isField) {
@@ -253,9 +252,9 @@
     return element.isConstructor || name == element.name;
   }
 
-  bool applies(Element element, Target target) {
+  bool applies(Element element) {
     if (!sameNameHack(element)) return false;
-    return appliesUnnamed(element, target);
+    return appliesUnnamed(element);
   }
 
   bool match(SelectorKind kind, Name memberName, CallStructure callStructure) {
diff --git a/pkg/compiler/lib/src/universe/universe.dart b/pkg/compiler/lib/src/universe/universe.dart
index 957b02b..03fc3c1 100644
--- a/pkg/compiler/lib/src/universe/universe.dart
+++ b/pkg/compiler/lib/src/universe/universe.dart
@@ -11,7 +11,7 @@
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../util/util.dart';
-import '../world.dart' show ClassWorld, ClosedWorld, OpenWorld;
+import '../world.dart' show World, ClosedWorld, OpenWorld;
 import 'selector.dart' show Selector;
 import 'use.dart' show DynamicUse, DynamicUseKind, StaticUse, StaticUseKind;
 
@@ -29,11 +29,11 @@
   /// Returns whether [element] is a potential target when being
   /// invoked on a receiver with this constraint. [selector] is used to ensure
   /// library privacy is taken into account.
-  bool canHit(Element element, Selector selector, ClassWorld classWorld);
+  bool canHit(Element element, Selector selector, World world);
 
   /// Returns whether this [TypeMask] applied to [selector] can hit a
   /// [noSuchMethod].
-  bool needsNoSuchMethodHandling(Selector selector, ClassWorld classWorld);
+  bool needsNoSuchMethodHandling(Selector selector, World world);
 }
 
 /// The combined constraints on receivers all the dynamic call sites of the same
@@ -71,7 +71,7 @@
   ///
   /// Ideally the selector constraints for calls `foo` with two positional
   /// arguments apply to `A.foo` but `B.foo`.
-  bool applies(Element element, Selector selector, ClassWorld world);
+  bool applies(Element element, Selector selector, World world);
 
   /// Returns `true` if at least one of the receivers matching these constraints
   /// in the closed [world] have no implementation matching [selector].
@@ -84,7 +84,7 @@
   ///
   /// the potential receiver `new A()` has no implementation of `foo` and thus
   /// needs to handle the call through its `noSuchMethod` handler.
-  bool needsNoSuchMethodHandling(Selector selector, ClassWorld world);
+  bool needsNoSuchMethodHandling(Selector selector, World world);
 }
 
 /// A mutable [SelectorConstraints] used in [Universe].
@@ -103,7 +103,7 @@
 }
 
 /// The [Universe] is an auxiliary class used in the process of computing the
-/// [ClassWorld]. The concepts here and in [ClassWorld] are very similar -- in
+/// [ClosedWorld]. The concepts here and in [ClosedWorld] are very similar -- in
 /// the same way that the "universe expands" you can think of this as a mutable
 /// world that is expanding as we visit and discover parts of the program.
 // TODO(sigmund): rename to "growing/expanding/mutable world"?
@@ -129,7 +129,7 @@
   Iterable<DartType> get instantiatedTypes;
 
   /// Returns `true` if [member] is invoked as a setter.
-  bool hasInvokedSetter(Element member, ClassWorld world);
+  bool hasInvokedSetter(Element member, World world);
 }
 
 abstract class ResolutionUniverse implements Universe {
@@ -299,10 +299,10 @@
   }
 
   bool _hasMatchingSelector(Map<Selector, SelectorConstraints> selectors,
-      Element member, ClassWorld world) {
+      Element member, OpenWorld world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
-      if (selector.appliesUnnamed(member, world.backend)) {
+      if (selector.appliesUnnamed(member)) {
         SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
           return true;
@@ -542,7 +542,7 @@
       Element member, ClosedWorld world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
-      if (selector.appliesUnnamed(member, world.backend)) {
+      if (selector.appliesUnnamed(member)) {
         SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
           return true;
diff --git a/pkg/compiler/lib/src/universe/use.dart b/pkg/compiler/lib/src/universe/use.dart
index a1756ed..543e2bd 100644
--- a/pkg/compiler/lib/src/universe/use.dart
+++ b/pkg/compiler/lib/src/universe/use.dart
@@ -21,7 +21,7 @@
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../util/util.dart' show Hashing;
-import '../world.dart' show ClassWorld;
+import '../world.dart' show World;
 import 'call_structure.dart' show CallStructure;
 import 'selector.dart' show Selector;
 import 'universe.dart' show ReceiverConstraint;
@@ -37,8 +37,8 @@
 
   DynamicUse(this.selector, this.mask);
 
-  bool appliesUnnamed(Element element, ClassWorld world) {
-    return selector.appliesUnnamed(element, world.backend) &&
+  bool appliesUnnamed(Element element, World world) {
+    return selector.appliesUnnamed(element) &&
         (mask == null || mask.canHit(element, selector, world));
   }
 
diff --git a/pkg/compiler/lib/src/universe/world_impact.dart b/pkg/compiler/lib/src/universe/world_impact.dart
index 723a87a..9012057 100644
--- a/pkg/compiler/lib/src/universe/world_impact.dart
+++ b/pkg/compiler/lib/src/universe/world_impact.dart
@@ -17,7 +17,7 @@
 ///
 /// The impact object can be computed locally by inspecting just the resolution
 /// information of that element alone. The compiler uses [Universe] and
-/// [ClassWorld] to combine the information discovered in the impact objects of
+/// [World] to combine the information discovered in the impact objects of
 /// all elements reachable in an application.
 class WorldImpact {
   const WorldImpact();
diff --git a/pkg/compiler/lib/src/world.dart b/pkg/compiler/lib/src/world.dart
index c348c77..40e73a5 100644
--- a/pkg/compiler/lib/src/world.dart
+++ b/pkg/compiler/lib/src/world.dart
@@ -5,7 +5,7 @@
 library dart2js.world;
 
 import 'closure.dart' show SynthesizedCallMethodElementX;
-import 'common/backend_api.dart' show Backend;
+import 'common/backend_api.dart' show BackendClasses;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'core_types.dart' show CoreClasses;
@@ -27,7 +27,10 @@
 import 'universe/side_effects.dart' show SideEffects;
 import 'util/util.dart' show Link;
 
-/// The [ClassWorld] represents the information known about a program when
+/// Common superinterface for [OpenWorld] and [ClosedWorld].
+abstract class World {}
+
+/// The [ClosedWorld] represents the information known about a program when
 /// compiling with closed-world semantics.
 ///
 /// Given the entrypoint of an application, we can track what's reachable from
@@ -35,49 +38,13 @@
 /// JavaScript types are touched, what language features are used, and so on.
 /// This precise knowledge about what's live in the program is later used in
 /// optimizations and other compiler decisions during code generation.
-abstract class ClassWorld {
-  // TODO(johnniwinther): Refine this into a `BackendClasses` interface.
-  Backend get backend;
+abstract class ClosedWorld implements World {
+  /// Access to core classes used by the backend.
+  BackendClasses get backendClasses;
 
+  /// Access to core classes used in the Dart language.
   CoreClasses get coreClasses;
 
-  /// Returns `true` if the class world is closed.
-  bool get isClosed;
-
-  /// Returns `true` if closed-world assumptions can be made, that is,
-  /// incremental compilation isn't enabled.
-  bool get hasClosedWorldAssumption;
-
-  /// Returns a string representation of the closed world.
-  ///
-  /// If [cls] is provided, the dump will contain only classes related to [cls].
-  String dump([ClassElement cls]);
-
-  /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
-  /// of known classes.
-  ///
-  /// This method is only provided for testing. For queries on classes, use the
-  /// methods defined in [ClassWorld].
-  ClassHierarchyNode getClassHierarchyNode(ClassElement cls);
-
-  /// Returns [ClassSet] for [cls] used to model the extends and implements
-  /// relations of known classes.
-  ///
-  /// This method is only provided for testing. For queries on classes, use the
-  /// methods defined in [ClassWorld].
-  ClassSet getClassSet(ClassElement cls);
-
-  // TODO(johnniwinther): Find a better strategy for caching these.
-  @deprecated
-  List<Map<ClassElement, TypeMask>> get canonicalizedTypeMasks;
-}
-
-/// The [ClosedWorld] represents the information known about a program when
-/// compiling with closed-world semantics.
-///
-/// This expands [ClassWorld] with information about live functions,
-/// side effects, and selectors with known single targets.
-abstract class ClosedWorld extends ClassWorld {
   /// Returns `true` if [cls] is either directly or indirectly instantiated.
   bool isInstantiated(ClassElement cls);
 
@@ -189,6 +156,24 @@
   /// Returns `true` if any subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassElement superclass, ClassElement type);
 
+  /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
+  /// of known classes.
+  ///
+  /// This method is only provided for testing. For queries on classes, use the
+  /// methods defined in [ClosedWorld].
+  ClassHierarchyNode getClassHierarchyNode(ClassElement cls);
+
+  /// Returns [ClassSet] for [cls] used to model the extends and implements
+  /// relations of known classes.
+  ///
+  /// This method is only provided for testing. For queries on classes, use the
+  /// methods defined in [ClosedWorld].
+  ClassSet getClassSet(ClassElement cls);
+
+  // TODO(johnniwinther): Find a better strategy for caching these.
+  @deprecated
+  List<Map<ClassElement, TypeMask>> get canonicalizedTypeMasks;
+
   /// Returns the [FunctionSet] containing all live functions in the closed
   /// world.
   FunctionSet get allFunctions;
@@ -230,6 +215,11 @@
   // TODO(johnniwinther): Is this 'passed invocation target` or
   // `passed as argument`?
   bool getMightBePassedToApply(Element element);
+
+  /// Returns a string representation of the closed world.
+  ///
+  /// If [cls] is provided, the dump will contain only classes related to [cls].
+  String dump([ClassElement cls]);
 }
 
 /// Interface for computing side effects and uses of elements. This is used
@@ -265,7 +255,7 @@
   void registerClosureClass(ClassElement cls);
 }
 
-abstract class OpenWorld implements ClassWorld {
+abstract class OpenWorld implements World {
   /// Called to add [cls] to the set of known classes.
   ///
   /// This ensures that class hierarchy queries can be performed on [cls] and
@@ -512,8 +502,8 @@
   @override
   ClassElement getLubOfInstantiatedSubclasses(ClassElement cls) {
     assert(isClosed);
-    if (backend.isJsInterop(cls)) {
-      return backend.helpers.jsJavaScriptObjectClass;
+    if (_backend.isJsInterop(cls)) {
+      return _backend.helpers.jsJavaScriptObjectClass;
     }
     ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
     return hierarchy != null
@@ -524,8 +514,8 @@
   @override
   ClassElement getLubOfInstantiatedSubtypes(ClassElement cls) {
     assert(isClosed);
-    if (backend.isJsInterop(cls)) {
-      return backend.helpers.jsJavaScriptObjectClass;
+    if (_backend.isJsInterop(cls)) {
+      return _backend.helpers.jsJavaScriptObjectClass;
     }
     ClassSet classSet = _classSets[cls.declaration];
     return classSet != null ? classSet.getLubOfInstantiatedSubtypes() : null;
@@ -669,7 +659,8 @@
   }
 
   final Compiler _compiler;
-  JavaScriptBackend get backend => _compiler.backend;
+  BackendClasses get backendClasses => _backend.backendClasses;
+  JavaScriptBackend get _backend => _compiler.backend;
   CommonMasks get commonMasks => _compiler.commonMasks;
   final FunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
@@ -704,11 +695,6 @@
 
   bool get isClosed => _closed;
 
-  // Used by selectors.
-  bool isForeign(Element element) {
-    return backend.isForeign(element);
-  }
-
   Set<ClassElement> typesImplementedBySubclassesOf(ClassElement cls) {
     return _typesImplementedBySubclasses[cls.declaration];
   }
@@ -749,7 +735,7 @@
   /// of known classes.
   ///
   /// This method is only provided for testing. For queries on classes, use the
-  /// methods defined in [ClassWorld].
+  /// methods defined in [ClosedWorld].
   ClassHierarchyNode getClassHierarchyNode(ClassElement cls) {
     return _classHierarchyNodes[cls.declaration];
   }
@@ -769,7 +755,7 @@
   /// relations of known classes.
   ///
   /// This method is only provided for testing. For queries on classes, use the
-  /// methods defined in [ClassWorld].
+  /// methods defined in [ClosedWorld].
   ClassSet getClassSet(ClassElement cls) {
     return _classSets[cls.declaration];
   }
@@ -924,7 +910,7 @@
 
   bool fieldNeverChanges(Element element) {
     if (!element.isField) return false;
-    if (backend.isNative(element)) {
+    if (_backend.isNative(element)) {
       // Some native fields are views of data that may be changed by operations.
       // E.g. node.firstChild depends on parentNode.removeBefore(n1, n2).
       // TODO(sra): Refine the effect classification so that native effects are
@@ -1024,6 +1010,4 @@
   bool getCurrentlyKnownMightBePassedToApply(Element element) {
     return getMightBePassedToApply(element);
   }
-
-  bool get hasClosedWorldAssumption => !_compiler.options.hasIncrementalSupport;
 }
diff --git a/runtime/observatory/.gitignore b/runtime/observatory/.gitignore
index 06adbfb..c73eaff 100644
--- a/runtime/observatory/.gitignore
+++ b/runtime/observatory/.gitignore
@@ -3,4 +3,3 @@
 build
 .pub
 .idea
-.packages
\ No newline at end of file
diff --git a/runtime/observatory/pubspec.lock b/runtime/observatory/pubspec.lock
new file mode 100644
index 0000000..1f8a109
--- /dev/null
+++ b/runtime/observatory/pubspec.lock
@@ -0,0 +1,251 @@
+# Generated by pub
+# See http://pub.dartlang.org/doc/glossary.html#lockfile
+packages:
+  analyzer:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/analyzer"
+      relative: true
+    source: path
+    version: "0.26.1+14"
+  args:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/args"
+      relative: true
+    source: path
+    version: "0.13.2"
+  async:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/async"
+      relative: true
+    source: path
+    version: "1.4.0"
+  barback:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/barback"
+      relative: true
+    source: path
+    version: "0.15.2+7"
+  browser:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/browser"
+      relative: true
+    source: path
+    version: "0.10.0+2"
+  charcode:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/charcode"
+      relative: true
+    source: path
+    version: "1.1.0"
+  charted:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/charted"
+      relative: true
+    source: path
+    version: "0.4.0+1"
+  cli_util:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/cli_util"
+      relative: true
+    source: path
+    version: "0.0.1+2"
+  code_transformers:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/code_transformers"
+      relative: true
+    source: path
+    version: "0.2.11"
+  collection:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/collection"
+      relative: true
+    source: path
+    version: "1.2.0"
+  csslib:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/csslib"
+      relative: true
+    source: path
+    version: "0.12.2"
+  dart_style:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/dart_style"
+      relative: true
+    source: path
+    version: "0.2.1"
+  dart_to_js_script_rewriter:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/dart_to_js_script_rewriter"
+      relative: true
+    source: path
+    version: "1.0.1"
+  glob:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/glob"
+      relative: true
+    source: path
+    version: "1.0.5"
+  html:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/html"
+      relative: true
+    source: path
+    version: "0.12.2"
+  initialize:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/initialize"
+      relative: true
+    source: path
+    version: "0.6.1+2"
+  intl:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/intl"
+      relative: true
+    source: path
+    version: "0.12.4+3"
+  logging:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/logging"
+      relative: true
+    source: path
+    version: "0.11.2"
+  matcher:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/matcher"
+      relative: true
+    source: path
+    version: "0.12.0+1"
+  observe:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/observe"
+      relative: true
+    source: path
+    version: "0.13.1+3"
+  package_config:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/package_config"
+      relative: true
+    source: path
+    version: "0.1.3"
+  path:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/path"
+      relative: true
+    source: path
+    version: "1.3.9"
+  petitparser:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/petitparser"
+      relative: true
+    source: path
+    version: "1.5.0"
+  plugin:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/plugin"
+      relative: true
+    source: path
+    version: "0.1.0"
+  pool:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/pool"
+      relative: true
+    source: path
+    version: "1.2.1"
+  quiver:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/quiver"
+      relative: true
+    source: path
+    version: "0.21.4"
+  quiver_iterables:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/quiver_iterables"
+      relative: true
+    source: path
+    version: "1.0.0"
+  smoke:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/smoke"
+      relative: true
+    source: path
+    version: "0.3.6"
+  source_maps:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/source_maps"
+      relative: true
+    source: path
+    version: "0.10.1"
+  source_span:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/source_span"
+      relative: true
+    source: path
+    version: "1.2.1"
+  stack_trace:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/stack_trace"
+      relative: true
+    source: path
+    version: "1.5.0"
+  string_scanner:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/string_scanner"
+      relative: true
+    source: path
+    version: "0.1.4"
+  template_binding:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/template_binding"
+      relative: true
+    source: path
+    version: "0.14.0+2"
+  unittest:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/unittest"
+      relative: true
+    source: path
+    version: "0.11.6+1"
+  usage:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/usage"
+      relative: true
+    source: path
+    version: "1.0.1"
+  utf:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/utf"
+      relative: true
+    source: path
+    version: "0.9.0+2"
+  watcher:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/watcher"
+      relative: true
+    source: path
+    version: "0.9.7"
+  web_components:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/web_components"
+      relative: true
+    source: path
+    version: "0.12.3"
+  when:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/when"
+      relative: true
+    source: path
+    version: "0.2.0"
+  which:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/which"
+      relative: true
+    source: path
+    version: "0.1.3"
+  yaml:
+    description:
+      path: "../../third_party/observatory_pub_packages/packages/yaml"
+      relative: true
+    source: path
+    version: "2.1.7"
+sdks:
+  dart: any
diff --git a/tests/compiler/dart2js/map_tracer_test.dart b/tests/compiler/dart2js/map_tracer_test.dart
index 6c4af67..4399798 100644
--- a/tests/compiler/dart2js/map_tracer_test.dart
+++ b/tests/compiler/dart2js/map_tracer_test.dart
@@ -211,7 +211,7 @@
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(generateTest(allocation), uri,
       expectedErrors: 0, expectedWarnings: 1);
-  var classWorld = compiler.openWorld.closeWorld();
+  var closedWorld = compiler.openWorld.closeWorld();
   asyncTest(() => compiler.run(uri).then((_) {
         var keyType, valueType;
         var commonMasks = compiler.commonMasks;
@@ -238,9 +238,9 @@
         }
 
         K(TypeMask other) =>
-            simplify(keyType.union(other, classWorld), compiler);
+            simplify(keyType.union(other, closedWorld), compiler);
         V(TypeMask other) =>
-            simplify(valueType.union(other, classWorld), compiler).nullable();
+            simplify(valueType.union(other, closedWorld), compiler).nullable();
 
         checkType('mapInField', K(aKeyType), V(commonMasks.numType));
         checkType('mapPassedToMethod', K(aKeyType), V(commonMasks.numType));
diff --git a/tests/compiler/dart2js/patch_test.dart b/tests/compiler/dart2js/patch_test.dart
index 3990949..f12c2b2 100644
--- a/tests/compiler/dart2js/patch_test.dart
+++ b/tests/compiler/dart2js/patch_test.dart
@@ -942,7 +942,7 @@
   TypeMask typeMask = new TypeMask.exact(cls, world);
   FunctionElement method = cls.implementation.lookupLocalMember('method');
   method.computeType(compiler.resolution);
-  Expect.isTrue(selector.applies(method, world.backend));
+  Expect.isTrue(selector.applies(method));
   Expect.isTrue(typeMask.canHit(method, selector, world));
 
   // Check that the declaration method in the declaration class is a target
@@ -952,7 +952,7 @@
   typeMask = new TypeMask.exact(cls, world);
   method = cls.lookupLocalMember('clear');
   method.computeType(compiler.resolution);
-  Expect.isTrue(selector.applies(method, world.backend));
+  Expect.isTrue(selector.applies(method));
   Expect.isTrue(typeMask.canHit(method, selector, world));
 
   // Check that the declaration method in the declaration class is a target
@@ -960,7 +960,7 @@
   cls = ensure(compiler, "B", compiler.commonElements.coreLibrary.find);
   cls.ensureResolved(compiler.resolution);
   typeMask = new TypeMask.exact(cls, world);
-  Expect.isTrue(selector.applies(method, world.backend));
+  Expect.isTrue(selector.applies(method));
   Expect.isTrue(typeMask.canHit(method, selector, world));
 }
 
diff --git a/tests/compiler/dart2js/simple_inferrer_final_field2_test.dart b/tests/compiler/dart2js/simple_inferrer_final_field2_test.dart
index 0bb2985..cc429df 100644
--- a/tests/compiler/dart2js/simple_inferrer_final_field2_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_final_field2_test.dart
@@ -37,9 +37,9 @@
               typesInferrer.getTypeOfElement(element).containsOnly(type));
         }
 
-        checkFieldTypeInClass(
-            'A', 'intField', compiler.backend.uint31Implementation);
-        checkFieldTypeInClass(
-            'A', 'stringField', compiler.backend.stringImplementation);
+        checkFieldTypeInClass('A', 'intField',
+            compiler.backend.backendClasses.uint31Implementation);
+        checkFieldTypeInClass('A', 'stringField',
+            compiler.backend.backendClasses.stringImplementation);
       }));
 }
diff --git a/tests/compiler/dart2js/type_mask_test.dart b/tests/compiler/dart2js/type_mask_test.dart
index 00508d1..fae28df 100644
--- a/tests/compiler/dart2js/type_mask_test.dart
+++ b/tests/compiler/dart2js/type_mask_test.dart
@@ -21,7 +21,7 @@
 main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(CODE, uri);
-  var classWorld = compiler.openWorld.closeWorld();
+  var closedWorld = compiler.openWorld.closeWorld();
 
   asyncTest(() => compiler.run(uri).then((_) {
         var classA = findElement(compiler, 'A');
@@ -29,37 +29,37 @@
         var classC = findElement(compiler, 'C');
         var classD = findElement(compiler, 'D');
 
-        var exactA = new TypeMask.nonNullExact(classA, classWorld);
-        var exactB = new TypeMask.nonNullExact(classB, classWorld);
-        var exactC = new TypeMask.nonNullExact(classC, classWorld);
-        var exactD = new TypeMask.nonNullExact(classD, classWorld);
+        var exactA = new TypeMask.nonNullExact(classA, closedWorld);
+        var exactB = new TypeMask.nonNullExact(classB, closedWorld);
+        var exactC = new TypeMask.nonNullExact(classC, closedWorld);
+        var exactD = new TypeMask.nonNullExact(classD, closedWorld);
 
-        var subclassA = new TypeMask.nonNullSubclass(classA, classWorld);
-        var subtypeA = new TypeMask.nonNullSubtype(classA, classWorld);
+        var subclassA = new TypeMask.nonNullSubclass(classA, closedWorld);
+        var subtypeA = new TypeMask.nonNullSubtype(classA, closedWorld);
 
         var subclassObject = new TypeMask.nonNullSubclass(
-            compiler.coreClasses.objectClass, classWorld);
+            compiler.coreClasses.objectClass, closedWorld);
 
         var unionABC =
-            UnionTypeMask.unionOf([exactA, exactB, exactC], classWorld);
+            UnionTypeMask.unionOf([exactA, exactB, exactC], closedWorld);
         var unionABnC = UnionTypeMask
-            .unionOf([exactA, exactB.nullable(), exactC], classWorld);
-        var unionAB = UnionTypeMask.unionOf([exactA, exactB], classWorld);
+            .unionOf([exactA, exactB.nullable(), exactC], closedWorld);
+        var unionAB = UnionTypeMask.unionOf([exactA, exactB], closedWorld);
         var unionSubtypeAC =
-            UnionTypeMask.unionOf([subtypeA, exactC], classWorld);
+            UnionTypeMask.unionOf([subtypeA, exactC], closedWorld);
         var unionSubclassAC =
-            UnionTypeMask.unionOf([subclassA, exactC], classWorld);
+            UnionTypeMask.unionOf([subclassA, exactC], closedWorld);
         var unionBCD =
-            UnionTypeMask.unionOf([exactB, exactC, exactD], classWorld);
+            UnionTypeMask.unionOf([exactB, exactC, exactD], closedWorld);
         var unionBCDn = UnionTypeMask
-            .unionOf([exactB, exactC, exactD.nullable()], classWorld);
+            .unionOf([exactB, exactC, exactD.nullable()], closedWorld);
 
         Expect.isFalse(unionABC.isNullable);
         Expect.isTrue(unionABnC.isNullable);
         Expect.isFalse(unionBCD.isNullable);
         Expect.isTrue(unionBCDn.isNullable);
 
-        rule(a, b, c) => Expect.equals(c, a.isInMask(b, classWorld));
+        rule(a, b, c) => Expect.equals(c, a.isInMask(b, closedWorld));
 
         rule(exactA, exactA, true);
         rule(exactA, exactB, false);
diff --git a/tools/VERSION b/tools/VERSION
index 59e3311..07b5836 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 1
 MINOR 20
 PATCH 0
-PRERELEASE 8
+PRERELEASE 9
 PRERELEASE_PATCH 0