Move remaining functionality from ClassWorld to ClosedWorld

pkg/compiler/lib/src/types/masks.dart

Index: pkg/compiler/lib/src/types/masks.dart
diff --git a/pkg/compiler/lib/src/types/masks.dart b/pkg/compiler/lib/src/types/masks.dart
index b498b80f726288bc1a47a64f49c119486e60c61c..ba090f69064ba8929d6f998df7a91198327ab6e2 100644
--- a/pkg/compiler/lib/src/types/masks.dart
+++ b/pkg/compiler/lib/src/types/masks.dart
@@ -18,7 +18,7 @@ import '../universe/universe.dart'
         UniverseSelectorConstraints,
         SelectorConstraintsStrategy;
 import '../util/util.dart';
-import '../world.dart' show ClassWorld, ClosedWorld;
+import '../world.dart' show ClosedWorld, ClosedWorld;
 import 'abstract_value_domain.dart' show AbstractValue;
 
 part 'container_type_mask.dart';
@@ -37,7 +37,7 @@ class CommonMasks {
 
   CommonMasks(this.compiler);
 
-  ClassWorld get classWorld => compiler.closedWorld;
+  ClosedWorld get closedWorld => compiler.closedWorld;
 
   TypeMask _dynamicType;
   TypeMask _nonNullType;
@@ -63,72 +63,72 @@ class CommonMasks {
   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);
+      compiler.backend.intImplementation, closedWorld);
 
   TypeMask get uint32Type => _uint32Type ??= new TypeMask.nonNullSubclass(
-      compiler.backend.uint32Implementation, classWorld);
+      compiler.backend.uint32Implementation, closedWorld);
 
   TypeMask get uint31Type => _uint31Type ??= new TypeMask.nonNullExact(
-      compiler.backend.uint31Implementation, classWorld);
+      compiler.backend.uint31Implementation, closedWorld);
 
   TypeMask get positiveIntType =>
       _positiveIntType ??= new TypeMask.nonNullSubclass(
-          compiler.backend.positiveIntImplementation, classWorld);
+          compiler.backend.positiveIntImplementation, closedWorld);
 
   TypeMask get doubleType => _doubleType ??= new TypeMask.nonNullExact(
-      compiler.backend.doubleImplementation, classWorld);
+      compiler.backend.doubleImplementation, closedWorld);
 
   TypeMask get numType => _numType ??= new TypeMask.nonNullSubclass(
-      compiler.backend.numImplementation, classWorld);
+      compiler.backend.numImplementation, closedWorld);
 
   TypeMask get boolType => _boolType ??= new TypeMask.nonNullExact(
-      compiler.backend.boolImplementation, classWorld);
+      compiler.backend.boolImplementation, closedWorld);
 
   TypeMask get functionType => _functionType ??= new TypeMask.nonNullSubtype(
-      compiler.backend.functionImplementation, classWorld);
+      compiler.backend.functionImplementation, closedWorld);
 
   TypeMask get listType => _listType ??= new TypeMask.nonNullExact(
-      compiler.backend.listImplementation, classWorld);
+      compiler.backend.listImplementation, closedWorld);
 
   TypeMask get constListType => _constListType ??= new TypeMask.nonNullExact(
-      compiler.backend.constListImplementation, classWorld);
+      compiler.backend.constListImplementation, closedWorld);
 
   TypeMask get fixedListType => _fixedListType ??= new TypeMask.nonNullExact(
-      compiler.backend.fixedListImplementation, classWorld);
+      compiler.backend.fixedListImplementation, closedWorld);
 
   TypeMask get growableListType =>
       _growableListType ??= new TypeMask.nonNullExact(
-          compiler.backend.growableListImplementation, classWorld);
+          compiler.backend.growableListImplementation, closedWorld);
 
   TypeMask get mapType => _mapType ??= new TypeMask.nonNullSubtype(
-      compiler.backend.mapImplementation, classWorld);
+      compiler.backend.mapImplementation, closedWorld);
 
   TypeMask get constMapType => _constMapType ??= new TypeMask.nonNullSubtype(
-      compiler.backend.constMapImplementation, classWorld);
+      compiler.backend.constMapImplementation, closedWorld);
 
   TypeMask get stringType => _stringType ??= new TypeMask.nonNullExact(
-      compiler.backend.stringImplementation, classWorld);
+      compiler.backend.stringImplementation, closedWorld);
 
   TypeMask get typeType => _typeType ??= new TypeMask.nonNullExact(
-      compiler.backend.typeImplementation, classWorld);
+      compiler.backend.typeImplementation, closedWorld);
 
   TypeMask get syncStarIterableType =>
       _syncStarIterableType ??= new TypeMask.nonNullExact(
-          compiler.backend.syncStarIterableImplementation, classWorld);
+          compiler.backend.syncStarIterableImplementation, closedWorld);
 
   TypeMask get asyncFutureType =>
       _asyncFutureType ??= new TypeMask.nonNullExact(
-          compiler.backend.asyncFutureImplementation, classWorld);
+          compiler.backend.asyncFutureImplementation, closedWorld);
 
   TypeMask get asyncStarStreamType =>
       _asyncStarStreamType ??= new TypeMask.nonNullExact(
-          compiler.backend.asyncStarStreamImplementation, classWorld);
+          compiler.backend.asyncStarStreamImplementation, closedWorld);
 
   // TODO(johnniwinther): Assert that the null type has been resolved.
   TypeMask get nullType => _nullType ??= const TypeMask.empty();