Split TypedSelector into Selector and TypeMask.

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/src/types/types.dart';
 import 'package:compiler/src/inferrer/concrete_types_inferrer.dart';
 
@@ skipping 126 matching lines @@
    * Checks that [: className#fieldName :]'s inferred type is the unknown
    * concrete type.
    */
   void checkFieldHasUknownType(String className, String fieldName) {
     Expect.isTrue(
         inferrer.inferredFieldTypes[findField(className, fieldName)]
                 .isUnknown());
   }
 
   /** Checks that the inferred type for [selector] is [mask]. */
-  void checkSelectorHasType(Selector selector, TypeMask mask) {
-    Expect.equals(mask, inferrer.getTypeOfSelector(selector));
+  void checkSelectorHasType(Selector selector,
+                            TypeMask mask,
+                            TypeMask expectedMask) {
+    Expect.equals(expectedMask, inferrer.getTypeOfSelector(selector, mask));
   }
 }
 
 const String DYNAMIC = '"__dynamic_for_test"';
 
 Future<AnalysisResult> analyze(String code, {int maxConcreteTypeSize: 1000}) {
   Uri uri = new Uri(scheme: 'dart', path: 'test');
   MockCompiler compiler = new MockCompiler.internal(
       enableConcreteTypeInference: true,
       maxConcreteTypeSize: maxConcreteTypeSize);
@@ skipping 1482 matching lines @@
     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,
+        null,
         new TypeMask.unionOf([a, b, c]
             .map((cls) => new TypeMask.nonNullExact(cls, world)),
             result.compiler.world));
     result.checkSelectorHasType(
-        new TypedSelector.subclass(x, foo, world),
+        foo,
+        new TypeMask.subclass(x, world),
         new TypeMask.nonNullExact(b, world));
     result.checkSelectorHasType(
-        new TypedSelector.subclass(y, foo, world),
+        foo,
+        new TypeMask.subclass(y, world),
         new TypeMask.nonNullExact(c, world));
     result.checkSelectorHasType(
-        new TypedSelector.subclass(z, foo, world),
+        foo,
+        new TypeMask.subclass(z, world),
         new TypeMask.nonNullExact(a, world));
     result.checkSelectorHasType(
-        new TypedSelector.subclass(xy, foo, world),
+        foo,
+        new TypeMask.subclass(xy, world),
         new TypeMask.unionOf([b, c].map((cls) =>
             new TypeMask.nonNullExact(cls, world)), world));
 
-    result.checkSelectorHasType(new Selector.call("bar", null, 0), null);
+    result.checkSelectorHasType(new Selector.call("bar", null, 0), null, 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('=='),
+                                null,
                                 new TypeMask.nonNullExact(bool,
                                     result.compiler.world));
   });
 }
 
 testMixins() {
   final String source = r"""
       class A {
         foo() => "abc";
         get x => 42;
@@ skipping 444 matching lines @@
     testClosures10,
     testClosures11,
     testClosures12,
     testRefinement,
     testDefaultArguments,
     testSuperConstructorCall,
     testSuperConstructorCall2,
     testSuperConstructorCall3,
   ], (f) => f()));
 }