[analyzer] Represent Null as NullTypeImpl.

This change introduces the class `NullTypeImpl` to represent the
special type `Null`, which was previously represented as an ordinary
`InterfaceType`.

This class mirrors the CFE's `NullType` class. Adding it will
facilitate further code sharing between the analyzer and the CFE,
because it will allow code that's shared between the analyzer and CFE
to use `is` tests to recognize the type `Null`.

The new `NullTypeImpl` class always has a nullability suffix of
`NullabilitySuffix.none`, so it is impossible for the type `Null?` to
occur. This is a benign behavioral change; previously there were some
circumstances in which the type `Null?` might occur in the analyzer,
but the type `Null?` behaved the same as `Null` so there was no
user-visible effect. This behavioral change brings the analyzer's
treatment of `Null` into alignment with that of the CFE.

This is the first step in a planned patch series. In follow-up CLs, I
intend to:

- Introduce a public-facing `NullType` for use by clients.

- Change `NullTypeImpl` so that it no longer extends `InterfaceTypeImpl`.

- Add a base class that is common to the analyzer and CFE `NullType`
  representations.

Change-Id: I9cea84d8149347bffdee006d544af28c66eba429
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/396320
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: stereotype441

pkg/analyzer/lib/src/dart/element/element.dart

@@ -5900,11 +5900,16 @@ abstract class InterfaceElementImpl extends InstanceElementImpl
       }
     }
 
-    var result = InterfaceTypeImpl(
-      element: this,
-      typeArguments: typeArguments,
-      nullabilitySuffix: nullabilitySuffix,
-    );
+    InterfaceTypeImpl result;
+    if (name == 'Null' && library.isDartCore) {
+      result = NullTypeImpl(element: this);
+    } else {
+      result = InterfaceTypeImpl(
+        element: this,
+        typeArguments: typeArguments,
+        nullabilitySuffix: nullabilitySuffix,
+      );
+    }
 
     if (typeArguments.isEmpty) {
       switch (nullabilitySuffix) {
@@ -10240,6 +10245,11 @@ class TypeAliasElementImpl extends _ExistingElementImpl
           typeArguments: typeArguments,
         ),
       );
+    } else if (type is NullTypeImpl) {
+      return NullTypeImpl(
+          element: type.element,
+          alias: InstantiatedTypeAliasElementImpl(
+              element: this, typeArguments: typeArguments));
     } else if (type is InterfaceType) {
       return InterfaceTypeImpl(
         element: type.element,

pkg/analyzer/lib/src/dart/element/type.dart

@@ -499,6 +499,9 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
     required this.nullabilitySuffix,
     super.alias,
   }) {
+    if (element.name == 'Null' && element.library.isDartCore) {
+      throw ArgumentError('NullTypeImpl should be used for `Null`');
+    }
     if (element.augmentationTarget != null) {
       throw ArgumentError(
         'InterfaceType(s) can only be created for declarations',
@@ -516,6 +519,13 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
     }
   }
 
+  InterfaceTypeImpl._null({required this.element, super.alias})
+      : typeArguments = const [],
+        nullabilitySuffix = NullabilitySuffix.none {
+    assert(element.name == 'Null' && element.library.isDartCore);
+    assert(this is NullTypeImpl);
+  }
+
   @override
   List<PropertyAccessorElement> get accessors {
     if (_accessors == null) {
@@ -637,11 +647,6 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
     return element.name == "Map" && element.library.isDartCore;
   }
 
-  @override
-  bool get isDartCoreNull {
-    return element.name == "Null" && element.library.isDartCore;
-  }
-
   @override
   bool get isDartCoreNum {
     return element.name == "num" && element.library.isDartCore;
@@ -1135,6 +1140,18 @@ class NeverTypeImpl extends TypeImpl implements NeverType {
   }
 }
 
+/// A concrete implementation of [DartType] representing the type `Null`, with
+/// no type parameters and no nullability suffix.
+class NullTypeImpl extends InterfaceTypeImpl {
+  NullTypeImpl({required super.element, super.alias}) : super._null();
+
+  @override
+  bool get isDartCoreNull => true;
+
+  @override
+  NullTypeImpl withNullability(NullabilitySuffix nullabilitySuffix) => this;
+}
+
 abstract class RecordTypeFieldImpl implements RecordTypeField {
   @override
   final DartType type;

pkg/analyzer/lib/src/dart/element/type_provider.dart

@@ -608,10 +608,14 @@ class TypeProviderImpl extends TypeProviderBase {
       }).toList(growable: false);
     }
 
-    return InterfaceTypeImpl(
-      element: element,
-      typeArguments: typeArguments,
-      nullabilitySuffix: NullabilitySuffix.none,
-    );
+    if (element.name == 'Null' && element.library.isDartCore) {
+      return NullTypeImpl(element: element);
+    } else {
+      return InterfaceTypeImpl(
+        element: element,
+        typeArguments: typeArguments,
+        nullabilitySuffix: NullabilitySuffix.none,
+      );
+    }
   }
 }

pkg/analyzer/test/generated/elements_types_mixin.dart

@@ -74,11 +74,6 @@ mixin ElementsTypesMixin {
     return interfaceTypeNone(element) as InterfaceTypeImpl;
   }
 
-  InterfaceTypeImpl get nullQuestion {
-    var element = typeProvider.nullType.element;
-    return interfaceTypeQuestion(element) as InterfaceTypeImpl;
-  }
-
   InterfaceType get numNone {
     var element = typeProvider.numType.element;
     return interfaceTypeNone(element);

pkg/analyzer/test/src/dart/element/always_exhaustive_test.dart

@@ -36,7 +36,6 @@ class IsAlwaysExhaustiveTest extends AbstractTypeSystemTest {
 
   test_class_Null() {
     isAlwaysExhaustive(nullNone);
-    isAlwaysExhaustive(nullQuestion);
   }
 
   test_class_sealed() {

pkg/analyzer/test/src/dart/element/normalize_type_test.dart

@@ -319,7 +319,7 @@ class NormalizeTypeTest extends AbstractTypeSystemTest with StringTypes {
     // Analyzer: impossible, we have only one suffix
 
     // * if S is Null then Null
-    check(nullQuestion, nullNone);
+    // Analyzer: impossible; `Null?` is always represented as `Null`.
 
     // * if S is FutureOr<R> and R is nullable then S
     check(futureOrQuestion(intQuestion), futureOrNone(intQuestion));

pkg/analyzer/test/src/dart/element/nullable_test.dart

@@ -501,7 +501,6 @@ class IsStrictlyNonNullableTest extends AbstractTypeSystemTest {
 
   test_null() {
     isNotStrictlyNonNullable(nullNone);
-    isNotStrictlyNonNullable(nullQuestion);
   }
 
   test_typeParameter_boundNone() {

pkg/analyzer/test/src/dart/element/string_types.dart

@@ -28,7 +28,7 @@ mixin StringTypes on AbstractTypeSystemTest {
     _defineType('Never', neverNone);
     _defineType('Never?', neverQuestion);
 
-    _defineType('Null?', nullQuestion);
+    _defineType('Null', nullNone);
 
     _defineType('Object', objectNone);
     _defineType('Object?', objectQuestion);