[cfe,ddc,dart2js,vm] Add NullType

This CL is the sum of the following 5 CLs:
* https://dart-review.googlesource.com/c/sdk/+/170342/
* https://dart-review.googlesource.com/c/sdk/+/170344/
* https://dart-review.googlesource.com/c/sdk/+/170345/
* https://dart-review.googlesource.com/c/sdk/+/170346/
* https://dart-review.googlesource.com/c/sdk/+/170347/

The reason for landing the 5 CLs as one CL is to prevent potential
troubles with bisecting over the branch because the change is fully
functional only with all 5 CLs.

Closes #40122.

TEST=Verified by changes in .expect files in pkg/vm/.
Bug: #40122
Change-Id: Ib8197802fdc69694387ae47ac990c58b3aaab7a5
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/170689
Commit-Queue: Dmitry Stefantsov <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: Dmitry Stefantsov

pkg/compiler/lib/src/ir/scope_visitor.dart

@@ -700,6 +700,10 @@ class ScopeModelBuilder extends ir.Visitor<EvaluationComplexity>
   EvaluationComplexity visitNeverType(ir.NeverType node) =>
       const EvaluationComplexity.lazy();
 
+  @override
+  EvaluationComplexity visitNullType(ir.NullType node) =>
+      const EvaluationComplexity.lazy();
+
   @override
   EvaluationComplexity visitInvalidType(ir.InvalidType node) =>
       const EvaluationComplexity.lazy();

pkg/compiler/lib/src/ir/static_type.dart

@@ -195,7 +195,12 @@ abstract class StaticTypeVisitor extends StaticTypeBase {
     while (type is ir.TypeParameterType) {
       type = (type as ir.TypeParameterType).parameter.bound;
     }
-    return type is ir.InterfaceType ? type : null;
+    if (type is ir.InterfaceType) {
+      return type;
+    } else if (type is ir.NullType) {
+      return typeEnvironment.coreTypes.deprecatedNullType;
+    }
+    return null;
   }
 
   /// Returns the static type of the expression as an instantiation of
@@ -222,7 +227,7 @@ abstract class StaticTypeVisitor extends StaticTypeBase {
     while (type is ir.TypeParameterType) {
       type = (type as ir.TypeParameterType).parameter.bound;
     }
-    if (type == typeEnvironment.nullType) {
+    if (type is ir.NullType) {
       return typeEnvironment.coreTypes
           .bottomInterfaceType(superclass, currentLibrary.nullable);
     }
@@ -711,7 +716,7 @@ abstract class StaticTypeVisitor extends StaticTypeBase {
     ir.DartType promotedType = typeMap.typeOf(node, typeEnvironment);
     assert(
         node.promotedType == null ||
-            promotedType == typeEnvironment.nullType ||
+            promotedType is ir.NullType ||
             promotedType is ir.FutureOrType ||
             typeEnvironment.isSubtypeOf(promotedType, node.promotedType,
                 ir.SubtypeCheckMode.ignoringNullabilities),
@@ -1003,7 +1008,7 @@ abstract class StaticTypeVisitor extends StaticTypeBase {
   ir.DartType visitNullCheck(ir.NullCheck node) {
     ir.DartType operandType = visitNode(node.operand);
     handleNullCheck(node, operandType);
-    ir.DartType resultType = operandType == typeEnvironment.nullType
+    ir.DartType resultType = operandType is ir.NullType
         ? const ir.NeverType(ir.Nullability.nonNullable)
         : operandType.withDeclaredNullability(ir.Nullability.nonNullable);
     _staticTypeCache._expressionTypes[node] = resultType;
@@ -1502,13 +1507,13 @@ class TypeHolder {
       for (ir.DartType type in falseTypes) {
         if (typeEnvironment.isSubtypeOf(
             declaredType, type, ir.SubtypeCheckMode.ignoringNullabilities)) {
-          return typeEnvironment.nullType;
+          return const ir.NullType();
         }
       }
     }
     if (trueTypes != null) {
       for (ir.DartType type in trueTypes) {
-        if (type == typeEnvironment.nullType) {
+        if (type is ir.NullType) {
           return type;
         }
         if (typeEnvironment.isSubtypeOf(
@@ -1770,9 +1775,9 @@ class TargetInfo {
       if (candidate == null) {
         candidate = type;
       } else {
-        if (type == typeEnvironment.nullType) {
+        if (type is ir.NullType) {
           // Keep the current candidate.
-        } else if (candidate == typeEnvironment.nullType) {
+        } else if (candidate is ir.NullType) {
           candidate = type;
         } else if (typeEnvironment.isSubtypeOf(
             candidate, type, ir.SubtypeCheckMode.ignoringNullabilities)) {

pkg/compiler/lib/src/ir/static_type_base.dart

@@ -121,7 +121,7 @@ abstract class StaticTypeBase extends ir.Visitor<ir.DartType> {
   }
 
   @override
-  ir.DartType visitNullLiteral(ir.NullLiteral node) => typeEnvironment.nullType;
+  ir.DartType visitNullLiteral(ir.NullLiteral node) => const ir.NullType();
 
   @override
   ir.DartType visitIntLiteral(ir.IntLiteral node) =>

pkg/compiler/lib/src/ir/util.dart

@@ -221,6 +221,9 @@ class _FreeVariableVisitor implements ir.DartTypeVisitor<bool> {
   @override
   bool visitNeverType(ir.NeverType node) => false;
 
+  @override
+  bool visitNullType(ir.NullType node) => false;
+
   @override
   bool visitVoidType(ir.VoidType node) => false;
 

pkg/compiler/lib/src/ir/visitors.dart

@@ -181,6 +181,11 @@ class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
   DartType visitNeverType(ir.NeverType node) {
     return _convertNullability(_dartTypes.neverType(), node.nullability);
   }
+
+  @override
+  DartType visitNullType(ir.NullType node) {
+    return elementMap.commonElements.nullType;
+  }
 }
 
 class ConstantValuefier extends ir.ComputeOnceConstantVisitor<ConstantValue> {

pkg/compiler/lib/src/kernel/kernel_impact.dart

@@ -141,6 +141,12 @@ abstract class KernelImpactRegistryMixin implements ImpactRegistry {
     if (receiverType is ir.InterfaceType) {
       return new StrongModeConstraint(commonElements, _nativeBasicData,
           elementMap.getClass(receiverType.classNode), relation);
+    } else if (receiverType is ir.NullType) {
+      return new StrongModeConstraint(
+          commonElements,
+          _nativeBasicData,
+          elementMap.getClass(typeEnvironment.coreTypes.deprecatedNullClass),
+          relation);
     }
     return null;
   }

pkg/compiler/lib/src/serialization/abstract_source.dart

@@ -276,6 +276,8 @@ abstract class AbstractDataSource extends DataSourceMixin
         ir.Nullability nullability = readEnum(ir.Nullability.values);
         ir.DartType typeArgument = _readDartTypeNode(functionTypeVariables);
         return new ir.FutureOrType(typeArgument, nullability);
+      case DartTypeNodeKind.nullType:
+        return const ir.NullType();
     }
     throw new UnsupportedError("Unexpected DartTypeKind $kind");
   }

pkg/compiler/lib/src/serialization/helpers.dart

@@ -120,6 +120,7 @@ enum DartTypeNodeKind {
   doesNotComplete,
   neverType,
   futureOrType,
+  nullType,
 }
 
 const String functionTypeNodeTag = 'function-type-node';
@@ -180,6 +181,12 @@ class DartTypeNodeWriter
     _sink.writeEnum(node.nullability);
   }
 
+  @override
+  void visitNullType(
+      ir.NullType node, List<ir.TypeParameter> functionTypeVariables) {
+    _sink.writeEnum(DartTypeNodeKind.nullType);
+  }
+
   @override
   void visitInterfaceType(
       ir.InterfaceType node, List<ir.TypeParameter> functionTypeVariables) {

pkg/compiler/test/analyses/analysis_helper.dart

@@ -311,7 +311,7 @@ class DynamicVisitor extends StaticTypeVisitorBase {
     ir.DartType staticType = node?.accept(this);
     assert(
         node is! ir.Expression ||
-            staticType == typeEnvironment.nullType ||
+            staticType is ir.NullType ||
             staticType is ir.FutureOrType ||
             typeEnvironment.isSubtypeOf(
                 staticType,

pkg/compiler/test/helpers/ir_types.dart

@@ -118,6 +118,11 @@ class TypeTextVisitor implements ir.DartTypeVisitor1<void, StringBuffer> {
     sb.write('Never');
   }
 
+  @override
+  void visitNullType(ir.NullType node, StringBuffer sb) {
+    sb.write('Null');
+  }
+
   @override
   void visitVoidType(ir.VoidType node, StringBuffer sb) {
     sb.write('void');

pkg/dev_compiler/lib/src/kernel/compiler.dart

@@ -1070,7 +1070,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
             c == _coreTypes.stringClass ||
             c == _coreTypes.functionClass ||
             c == _coreTypes.intClass ||
-            c == _coreTypes.nullClass ||
+            c == _coreTypes.deprecatedNullClass ||
             c == _coreTypes.numClass ||
             c == _coreTypes.doubleClass ||
             c == _coreTypes.boolClass)) {
@@ -2567,12 +2567,16 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
 
   @override
   js_ast.Expression visitBottomType(BottomType type) =>
-      _emitType(_types.nullType);
+      _emitType(const NullType());
+
+  @override
+  js_ast.Expression visitNullType(NullType type) =>
+      _emitInterfaceType(_coreTypes.deprecatedNullType);
 
   @override
   js_ast.Expression visitNeverType(NeverType type) =>
       type.nullability == Nullability.nullable
-          ? visitInterfaceType(_coreTypes.nullType)
+          ? visitNullType(const NullType())
           : _emitNullabilityWrapper(runtimeCall('Never'), type.nullability);
 
   /// Normalizes `FutureOr` types and emits the normalized version.
@@ -2605,8 +2609,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
       // FutureOr<Never> --> Future<Never>
       return _emitInterfaceType(InterfaceType(
           _coreTypes.futureClass, futureOr.nullability, [typeArgument]));
-    } else if (typeArgument is InterfaceType &&
-        typeArgument.classNode == _coreTypes.nullClass) {
+    } else if (typeArgument is NullType) {
       // FutureOr<Null> --> Future<Null>?
       return _emitInterfaceType(InterfaceType(
           _coreTypes.futureClass, Nullability.nullable, [typeArgument]));
@@ -2690,7 +2693,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     // * The types were written in JS context or as part of the dart:_runtime
     //   library.
     if (!emitNullability ||
-        type == _coreTypes.nullType ||
+        type == _coreTypes.deprecatedNullType ||
         // TODO(38701) Remove these once the SDK has unforked and is running
         // "opted-in"
         !coreLibrary.isNonNullableByDefault &&
@@ -5134,8 +5137,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
           importUri.path == 'html_common');
 
   bool _isNull(Expression expr) =>
-      expr is NullLiteral ||
-      expr.getStaticType(_staticTypeContext) == _coreTypes.nullType;
+      expr is NullLiteral || expr.getStaticType(_staticTypeContext) is NullType;
 
   bool _doubleEqIsIdentity(Expression left, Expression right) {
     // If we statically know LHS or RHS is null we can use ==.

pkg/dev_compiler/lib/src/kernel/js_typerep.dart

@@ -39,10 +39,10 @@ class JSTypeRep extends SharedJSTypeRep<DartType> {
 
     // Note that this should be changed if Dart gets non-nullable types
     if (type == const BottomType()) return JSType.jsNull;
+    if (type == const NullType()) return JSType.jsNull;
 
     if (type is InterfaceType) {
       var c = type.classNode;
-      if (c == coreTypes.nullClass) return JSType.jsNull;
       if (c == coreTypes.numClass ||
           c == coreTypes.intClass ||
           c == coreTypes.doubleClass ||

pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart

@@ -336,6 +336,7 @@ bool isKnownDartTypeImplementor(DartType t) {
       t is InterfaceType ||
       t is InvalidType ||
       t is NeverType ||
+      t is NullType ||
       t is TypeParameterType ||
       t is TypedefType ||
       t is VoidType;

pkg/dev_compiler/lib/src/kernel/type_table.dart

@@ -119,6 +119,7 @@ class _CacheTable {
     if (type is VoidType) return 'void';
     if (type is NeverType) return 'Never$nullability';
     if (type is BottomType) return 'bottom';
+    if (type is NullType) return 'Null';
     return 'invalid';
   }
 

pkg/dev_compiler/test/nullable_inference_test.dart

@@ -52,7 +52,7 @@ void main() {
     });
     test('Map', () async {
       await expectNotNull('main() { print({"x": null}); }',
-          '<dart.core::String*, dart.core::Null?>{"x": null}, "x"');
+          '<dart.core::String*, Null>{"x": null}, "x"');
     });
 
     test('Symbol', () async {
@@ -258,7 +258,7 @@ void main() {
 
   test('function expression', () async {
     await expectNotNull(
-        'main() { () => null; f() {}; f; }', 'dart.core::Null? () => null, f');
+        'main() { () => null; f() {}; f; }', 'Null () => null, f');
   });
 
   test('cascades (kernel BlockExpression)', () async {
@@ -399,7 +399,7 @@ void main() {
       await expectNotNull('''main() {
         var x = () => 42;
         var y = (() => x = null);
-      }''', 'dart.core::int* () => 42, 42, dart.core::Null? () => x = null');
+      }''', 'dart.core::int* () => 42, 42, Null () => x = null');
     });
     test('do not depend on unrelated variables', () async {
       await expectNotNull('''main() {

pkg/front_end/lib/src/fasta/builder/class_builder.dart

@@ -16,6 +16,7 @@ import 'package:kernel/ast.dart'
         InterfaceType,
         Member,
         Name,
+        NullType,
         Nullability,
         Supertype,
         TypeParameter,
@@ -538,7 +539,7 @@ abstract class ClassBuilderImpl extends DeclarationBuilderImpl
       Nullability nullability, List<DartType> arguments) {
     assert(arguments == null || cls.typeParameters.length == arguments.length);
     if (isNullClass) {
-      nullability = Nullability.nullable;
+      return const NullType();
     }
     if (name == "FutureOr") {
       LibraryBuilder parentLibrary = parent;
@@ -781,7 +782,7 @@ abstract class ClassBuilderImpl extends DeclarationBuilderImpl
       InterfaceType requiredInterface =
           substitution.substituteSupertype(constraint).asInterfaceType;
       InterfaceType implementedInterface = hierarchy.getTypeAsInstanceOf(
-          supertype, requiredInterface.classNode, library.library, coreTypes);
+          supertype, requiredInterface.classNode, library.library);
       if (implementedInterface == null ||
           !typeEnvironment.areMutualSubtypes(
               implementedInterface,

pkg/front_end/lib/src/fasta/builder/library_builder.dart

@@ -157,6 +157,8 @@ abstract class LibraryBuilder implements ModifierBuilder {
 
   void addSyntheticDeclarationOfNever();
 
+  void addSyntheticDeclarationOfNull();
+
   /// Lookups the member [name] declared in this library.
   ///
   /// If [required] is `true` and no member is found an internal problem is
@@ -387,6 +389,9 @@ abstract class LibraryBuilderImpl extends ModifierBuilderImpl
     if (scope.lookupLocalMember("Never", setter: false) == null) {
       addSyntheticDeclarationOfNever();
     }
+    if (scope.lookupLocalMember("Null", setter: false) == null) {
+      addSyntheticDeclarationOfNull();
+    }
   }
 
   @override