Change TypeMask.base to be a ClassElement.

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 '../../../sdk/lib/_internal/compiler/implementation/source_file.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/types/types.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/types/concrete_types_inferrer.dart';
@@ skipping 1357 matching lines @@
       var x = "__dynamic_for_test".truncate();
       x;
     }
     """;
   return analyze(source1).then((AnalysisResult result) {
     result.checkNodeHasType('x', []);
   }).whenComplete(() {
 
     final String source2 = r"""
       import 'dart:foreign';
-  
+
       main () {
         var x = "__dynamic_for_test".truncate();
         JS('double', 'foo');
         x;
       }
       """;
     return analyze(source2).then((AnalysisResult result) {
       result.checkNodeHasType('x', [result.int]);
     });
   });
@@ skipping 84 matching lines @@
           .singletonConcreteType(new ClassBaseType(element));
     }
 
     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.rawType));
+                    new TypeMask.nonNullExact(cls));
     }
 
     for (ClassElement cls in [a, b, c, d]) {
       Expect.equals(convert(singleton(cls).union(nullSingleton)),
-                    new TypeMask.exact(cls.rawType));
+                    new TypeMask.exact(cls));
     }
 
     Expect.equals(convert(singleton(a).union(singleton(b))),
-                  new TypeMask.nonNullSubclass(a.rawType));
+                  new TypeMask.nonNullSubclass(a));
 
     Expect.equals(
         convert(singleton(a).union(singleton(b)).union(nullSingleton)),
-                  new TypeMask.subclass(a.rawType));
+                  new TypeMask.subclass(a));
 
     Expect.equals(
         convert(singleton(b).union(singleton(d))).simplify(result.compiler),
-        new TypeMask.nonNullSubtype(a.rawType));
+        new TypeMask.nonNullSubtype(a));
   });
 }
 
 testSelectors() {
   final String source = r"""
       // ABC <--- A
       //       `- BC <--- B
       //               `- C
 
       class ABC {}
@@ skipping 27 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(buildSourceString("foo"), null, 0);
 
     Expect.equals(
         inferredType(foo).simplify(result.compiler),
-        new TypeMask.nonNullSubclass(abc.rawType));
+        new TypeMask.nonNullSubclass(abc));
     Expect.equals(
-        inferredType(new TypedSelector.subclass(x.rawType, foo)),
-        new TypeMask.nonNullExact(b.rawType));
+        inferredType(new TypedSelector.subclass(x, foo)),
+        new TypeMask.nonNullExact(b));
     Expect.equals(
-        inferredType(new TypedSelector.subclass(y.rawType, foo)),
-        new TypeMask.nonNullExact(c.rawType));
+        inferredType(new TypedSelector.subclass(y, foo)),
+        new TypeMask.nonNullExact(c));
     Expect.equals(
-        inferredType(new TypedSelector.subclass(z.rawType, foo)),
-        new TypeMask.nonNullExact(a.rawType));
+        inferredType(new TypedSelector.subclass(z, foo)),
+        new TypeMask.nonNullExact(a));
     Expect.equals(
         inferredType(new TypedSelector.subclass(
-            xy.rawType, foo)).simplify(result.compiler),
-        new TypeMask.nonNullSubclass(bc.rawType));
+            xy, foo)).simplify(result.compiler),
+        new TypeMask.nonNullSubclass(bc));
 
     Selector bar = new Selector.call(buildSourceString("bar"), null, 0);
 
     Expect.isNull(inferredType(bar));
   });
 }
 
 testMixins() {
   final String source = r"""
       class A {
@@ skipping 128 matching lines @@
     testIsCheck,
     testSeenClasses,
     testIntDoubleNum,
     testConcreteTypeToTypeMask,
     testSelectors,
     testMixins,
     testClosures,
     testNestedFunctions,
   ], (f) => f()));
 }