NullabilityEliminator - Never to Null*, remove required from formal parameters.

Change-Id: I3ad2cf15c2ed1e8eb347ac84c9dc401e807e2e7e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/127203
Reviewed-by: Paul Berry <paulberry@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

Author: scheglov

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

@@ -593,7 +593,8 @@ abstract class Member implements Element {
   /// Otherwise, return the type unchanged.
   DartType _toLegacyType(DartType type) {
     if (isLegacy) {
-      return NullabilityEliminator.perform(type);
+      var typeProvider = declaration.library.typeProvider;
+      return NullabilityEliminator.perform(typeProvider, type);
     } else {
       return type;
     }

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

@@ -8,12 +8,19 @@ import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
+import 'package:analyzer/src/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/element/type_visitor.dart';
+import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/type_system.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
 
 class NullabilityEliminator extends DartTypeVisitor<DartType> {
+  final TypeProviderImpl _typeProvider;
+
   int _counter = 0;
 
+  NullabilityEliminator(this._typeProvider);
+
   @override
   DartType defaultDartType(DartType type) {
     throw UnimplementedError('(${type.runtimeType}) $type');
@@ -35,10 +42,7 @@ class NullabilityEliminator extends DartTypeVisitor<DartType> {
 
     type = _freshTypeParameters(type);
 
-    var parameters = type.parameters.map((parameter) {
-      var type = visit(parameter.type);
-      return _parameterElement(parameter, type);
-    }).toList();
+    var parameters = type.parameters.map(_parameterElement).toList();
 
     var returnType = visit(type.returnType);
     var typeArguments = type.typeArguments.map(visit).toList();
@@ -79,7 +83,8 @@ class NullabilityEliminator extends DartTypeVisitor<DartType> {
 
   @override
   DartType visitNeverType(NeverTypeImpl type) {
-    return type.withNullability(NullabilitySuffix.star);
+    _counter++;
+    return _typeProvider.nullStar;
   }
 
   @override
@@ -159,28 +164,33 @@ class NullabilityEliminator extends DartTypeVisitor<DartType> {
     }
   }
 
-  /// If the [type] itself, or any of its components, has any nullability,
-  /// return a new type with legacy nullability suffixes. Otherwise return the
-  /// original instance.
-  static T perform<T extends DartType>(T type) {
-    if (type == null) {
-      return type;
-    }
+  ParameterElementImpl _parameterElement(ParameterElement parameter) {
+    var type = visit(parameter.type);
 
-    return NullabilityEliminator().visit(type);
-  }
+    // ignore: deprecated_member_use_from_same_package
+    var parameterKind = parameter.parameterKind;
+    if (parameter.isRequiredNamed) {
+      parameterKind = ParameterKind.NAMED;
+      _counter++;
+    }
 
-  static ParameterElementImpl _parameterElement(
-    ParameterElement parameter,
-    DartType type,
-  ) {
     var result = ParameterElementImpl.synthetic(
       parameter.name,
       type,
-      // ignore: deprecated_member_use_from_same_package
-      parameter.parameterKind,
+      parameterKind,
     );
     result.isExplicitlyCovariant = parameter.isCovariant;
     return result;
   }
+
+  /// If the [type] itself, or any of its components, has any nullability,
+  /// return a new type with legacy nullability suffixes. Otherwise return the
+  /// original instance.
+  static T perform<T extends DartType>(TypeProviderImpl typeProvider, T type) {
+    if (type == null) {
+      return type;
+    }
+
+    return NullabilityEliminator(typeProvider).visit(type);
+  }
 }

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

@@ -93,6 +93,8 @@ class TypeProviderImpl extends TypeProviderBase {
   InterfaceType _symbolType;
   InterfaceType _typeType;
 
+  InterfaceTypeImpl _nullStar;
+
   InterfaceType _iterableForSetMapDisambiguation;
   InterfaceType _mapForSetMapDisambiguation;
 
@@ -359,6 +361,13 @@ class TypeProviderImpl extends TypeProviderBase {
     return _nullElement ??= _getClassElement(_coreLibrary, 'Null');
   }
 
+  InterfaceTypeImpl get nullStar {
+    return _nullStar ??= nullElement.instantiate(
+      typeArguments: const [],
+      nullabilitySuffix: NullabilitySuffix.star,
+    );
+  }
+
   @override
   DartObjectImpl get nullObject {
     if (_nullObject == null) {

pkg/analyzer/lib/src/generated/error_verifier.dart

@@ -5984,7 +5984,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
   /// Otherwise, return the original type.
   DartType _toLegacyType(DartType type) {
     if (_isNonNullable) return type;
-    return NullabilityEliminator.perform(type);
+    return NullabilityEliminator.perform(_typeProvider, type);
   }
 
   /**

pkg/analyzer/lib/src/generated/resolver.dart

@@ -762,7 +762,7 @@ class ResolverVisitor extends ScopedVisitor {
   /// Otherwise, return the original type.
   DartType toLegacyTypeIfOptOut(DartType type) {
     if (_nonNullableEnabled) return type;
-    return NullabilityEliminator.perform(type);
+    return NullabilityEliminator.perform(typeProvider, type);
   }
 
   @override

pkg/analyzer/lib/src/generated/type_system.dart

@@ -2888,7 +2888,7 @@ class GenericInferrer {
   /// Otherwise, return the original type.
   DartType _toLegacyType(DartType type) {
     if (isNonNullableByDefault) return type;
-    return NullabilityEliminator.perform(type);
+    return NullabilityEliminator.perform(typeProvider, type);
   }
 
   static String _formatConstraints(Iterable<_TypeConstraint> constraints) {

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

@@ -95,6 +95,53 @@ class NullabilityEliminatorTest with ElementsTypesMixin {
     );
   }
 
+  test_functionType_parameters_named() {
+    _verify(
+      functionTypeStar(
+        parameters: [
+          namedParameter(name: 'a', type: intNone),
+        ],
+        returnType: voidNone,
+      ),
+      functionTypeStar(
+        parameters: [
+          namedParameter(name: 'a', type: intStar),
+        ],
+        returnType: voidNone,
+      ),
+    );
+
+    _verify(
+      functionTypeStar(
+        parameters: [
+          namedRequiredParameter(name: 'a', type: intNone),
+        ],
+        returnType: voidNone,
+      ),
+      functionTypeStar(
+        parameters: [
+          namedParameter(name: 'a', type: intStar),
+        ],
+        returnType: voidNone,
+      ),
+    );
+
+    _verify(
+      functionTypeStar(
+        parameters: [
+          namedRequiredParameter(name: 'a', type: intStar),
+        ],
+        returnType: voidNone,
+      ),
+      functionTypeStar(
+        parameters: [
+          namedParameter(name: 'a', type: intStar),
+        ],
+        returnType: voidNone,
+      ),
+    );
+  }
+
   test_functionType_returnType() {
     _verify(
       functionTypeStar(returnType: intNone),
@@ -216,9 +263,13 @@ class NullabilityEliminatorTest with ElementsTypesMixin {
   }
 
   test_neverType() {
-    _verify(neverNone, neverStar);
-    _verify(neverQuestion, neverStar);
-    _verifySame(neverStar);
+    _verify(neverNone, nullStar);
+    _verify(neverQuestion, nullStar);
+    _verify(neverStar, nullStar);
+
+    _verify(listNone(neverNone), listStar(nullStar));
+    _verify(listQuestion(neverNone), listStar(nullStar));
+    _verify(listStar(neverNone), listStar(nullStar));
   }
 
   test_typeParameterType() {
@@ -245,20 +296,20 @@ class NullabilityEliminatorTest with ElementsTypesMixin {
   }
 
   void _verify(DartType input, DartType expected) {
-    var result = NullabilityEliminator.perform(input);
+    var result = NullabilityEliminator.perform(typeProvider, input);
     expect(result, isNot(same(input)));
     expect(result, expected);
   }
 
   void _verifySame(DartType input) {
-    var result = NullabilityEliminator.perform(input);
+    var result = NullabilityEliminator.perform(typeProvider, input);
     expect(result, same(input));
   }
 
   void _verifyStr(DartType input, String inputStr, String expectedStr) {
     expect(_typeToString(input), inputStr);
 
-    var result = NullabilityEliminator.perform(input);
+    var result = NullabilityEliminator.perform(typeProvider, input);
     expect(result, isNot(same(input)));
     expect(_typeToString(result), expectedStr);
   }