Adapt TypeMask tests to new TypeMask interface.

tests/compiler/dart2js/cpa_inference_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 import "package:expect/expect.dart";
 import "package:async_helper/async_helper.dart";
 import 'package:compiler/implementation/types/types.dart';
 import 'package:compiler/implementation/inferrer/concrete_types_inferrer.dart';
 
@@ skipping 1560 matching lines @@
 
     final nullSingleton =
         result.compiler.typesTask.concreteTypesInferrer.singletonConcreteType(
             new NullBaseType());
 
     singleton(ClassElement element) {
       return result.compiler.typesTask.concreteTypesInferrer
           .singletonConcreteType(new ClassBaseType(element));
     }
 
+    var world = result.compiler.world;
+
     ClassElement a = findElement(result.compiler, 'A');
     ClassElement b = findElement(result.compiler, 'B');
     ClassElement c = findElement(result.compiler, 'C');
     ClassElement d = findElement(result.compiler, 'D');
 
     for (ClassElement cls in [a, b, c, d]) {
       Expect.equals(convert(singleton(cls)),
-                    new TypeMask.nonNullExact(cls));
+                    new TypeMask.nonNullExact(cls, world));
     }
 
     for (ClassElement cls in [a, b, c, d]) {
       Expect.equals(convert(singleton(cls).union(nullSingleton)),
-                    new TypeMask.exact(cls));
+                    new TypeMask.exact(cls, world));
     }
 
     Expect.equals(convert(singleton(a).union(singleton(b))),
-                  new TypeMask.nonNullSubclass(a, result.compiler.world));
+                  new TypeMask.nonNullSubclass(a, world));
 
     Expect.equals(
         convert(singleton(a).union(singleton(b)).union(nullSingleton)),
-                  new TypeMask.subclass(a, result.compiler.world));
+                  new TypeMask.subclass(a, world));
 
     Expect.equals(
         simplify(convert(singleton(b).union(singleton(d))), result.compiler),
-        new TypeMask.nonNullSubtype(a, result.compiler.world));
+        new TypeMask.nonNullSubtype(a, world));
   });
 }
 
 testSelectors() {
   final String source = r"""
       // ABC <--- A
       //       `- BC <--- B
       //               `- C
 
       class ABC {}
       class A extends ABC {}
       class BC extends ABC {}
       class B extends BC {}
       class C extends BC {}
 
       class XY {}
       class X extends XY { foo() => new B(); }
       class Y extends XY { foo() => new C(); }
       class Z { foo() => new A(); }
 
       main() {
         new X().foo();
         new Y().foo();
         new Z().foo();
       }
       """;
   return analyze(source).then((result) {
 
-
+    var world = result.compiler.world;
 
     ClassElement a = findElement(result.compiler, 'A');
     ClassElement b = findElement(result.compiler, 'B');
     ClassElement c = findElement(result.compiler, 'C');
     ClassElement xy = findElement(result.compiler, 'XY');
     ClassElement x = findElement(result.compiler, 'X');
     ClassElement y = findElement(result.compiler, 'Y');
     ClassElement z = findElement(result.compiler, 'Z');
 
     Selector foo = new Selector.call("foo", null, 0);
 
     result.checkSelectorHasType(
         foo,
         new TypeMask.unionOf([a, b, c]
-            .map((cls) => new TypeMask.nonNullExact(cls)),
+            .map((cls) => new TypeMask.nonNullExact(cls, world)),
             result.compiler.world));
     result.checkSelectorHasType(
-        new TypedSelector.subclass(x, foo, result.compiler.world),
-        new TypeMask.nonNullExact(b));
+        new TypedSelector.subclass(x, foo, world),
+        new TypeMask.nonNullExact(b, world));
     result.checkSelectorHasType(
-        new TypedSelector.subclass(y, foo, result.compiler.world),
-        new TypeMask.nonNullExact(c));
+        new TypedSelector.subclass(y, foo, world),
+        new TypeMask.nonNullExact(c, world));
     result.checkSelectorHasType(
-        new TypedSelector.subclass(z, foo, result.compiler.world),
-        new TypeMask.nonNullExact(a));
+        new TypedSelector.subclass(z, foo, world),
+        new TypeMask.nonNullExact(a, world));
     result.checkSelectorHasType(
-        new TypedSelector.subclass(xy, foo, result.compiler.world),
+        new TypedSelector.subclass(xy, foo, world),
         new TypeMask.unionOf([b, c].map((cls) =>
-            new TypeMask.nonNullExact(cls)), result.compiler.world));
+            new TypeMask.nonNullExact(cls, world)), world));
 
     result.checkSelectorHasType(new Selector.call("bar", null, 0), null);
   });
 }
 
 testEqualsNullSelector() {
   final String source = r"""
       main() {
         1 == null;
       }
       """;
   return analyze(source).then((result) {
     ClassElement bool = result.compiler.backend.boolImplementation;
     result.checkSelectorHasType(new Selector.binaryOperator('=='),
-                                new TypeMask.nonNullExact(bool));
+                                new TypeMask.nonNullExact(bool,
+                                    result.compiler.world));
   });
 }
 
 testMixins() {
   final String source = r"""
       class A {
         foo() => "abc";
         get x => 42;
       }
       class B extends Object with A {
@@ skipping 442 matching lines @@
     testClosures10,
     testClosures11,
     testClosures12,
     testRefinement,
     testDefaultArguments,
     testSuperConstructorCall,
     testSuperConstructorCall2,
     testSuperConstructorCall3,
   ], (f) => f()));
 }