[cfe] Check types of super parameters for assignability

The CL enables both the checks of the super parameter relative to the
corresponding parameter of the super constructor and the types of the
copied default values.

Part of #47525

Change-Id: I92dfa22c108bf07a69e1f8b5a210f6268ddfaa2e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/235080
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Chloe Stefantsova <[email protected]>

Author: chloestefantsova

pkg/front_end/lib/src/fasta/fasta_codes_cfe_generated.dart

@@ -4111,6 +4111,42 @@ Message _withArgumentsOptionalNonNullableWithoutInitializerError(
       arguments: {'name': name, 'type': _type});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+        Message Function(
+            DartType _type, String name, bool isNonNullableByDefault)>
+    templateOptionalSuperParameterWithoutInitializer = const Template<
+            Message Function(
+                DartType _type, String name, bool isNonNullableByDefault)>(
+        problemMessageTemplate:
+            r"""Type '#type' of the optional super-initializer parameter '#name' doesn't allow 'null', but the parameter doesn't have a default value, and the default value can't be copied from the corresponding parameter of the super constructor.""",
+        withArguments: _withArgumentsOptionalSuperParameterWithoutInitializer);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<
+        Message Function(
+            DartType _type, String name, bool isNonNullableByDefault)>
+    codeOptionalSuperParameterWithoutInitializer = const Code<
+        Message Function(
+            DartType _type, String name, bool isNonNullableByDefault)>(
+  "OptionalSuperParameterWithoutInitializer",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsOptionalSuperParameterWithoutInitializer(
+    DartType _type, String name, bool isNonNullableByDefault) {
+  TypeLabeler labeler = new TypeLabeler(isNonNullableByDefault);
+  List<Object> typeParts = labeler.labelType(_type);
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  String type = typeParts.join();
+  return new Message(codeOptionalSuperParameterWithoutInitializer,
+      problemMessage:
+          """Type '${type}' of the optional super-initializer parameter '${name}' doesn't allow 'null', but the parameter doesn't have a default value, and the default value can't be copied from the corresponding parameter of the super constructor.""" +
+              labeler.originMessages,
+      arguments: {'type': _type, 'name': name});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<
         Message Function(String name, String name2, DartType _type,

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

@@ -1965,8 +1965,10 @@ class BodyBuilder extends StackListenerImpl
             constructor.function.positionalParameters[0].name == "index" &&
             constructor.function.positionalParameters[1].name == "name");
         (positionalArguments ??= <Expression>[]).insertAll(0, [
-          new VariableGet(constructor.function.positionalParameters[0]),
-          new VariableGet(constructor.function.positionalParameters[1])
+          new VariableGetImpl(constructor.function.positionalParameters[0],
+              forNullGuardedAccess: false),
+          new VariableGetImpl(constructor.function.positionalParameters[1],
+              forNullGuardedAccess: false)
         ]);
       }
       if (positionalArguments != null || namedArguments != null) {
@@ -1997,7 +1999,14 @@ class BodyBuilder extends StackListenerImpl
         initializer = buildSuperInitializer(
             true, superTarget, arguments, builder.charOffset);
       }
-      constructor.initializers.add(initializer);
+      if (libraryBuilder.enableSuperParametersInLibrary) {
+        InitializerInferenceResult inferenceResult =
+            typeInferrer.inferInitializer(this, initializer);
+        builder.addInitializer(initializer, this,
+            inferenceResult: inferenceResult);
+      } else {
+        constructor.initializers.add(initializer);
+      }
     }
     setParents(constructor.initializers, constructor);
     libraryBuilder.loader.transformListPostInference(constructor.initializers,

pkg/front_end/lib/src/fasta/kernel/constructor_tearoff_lowering.dart

@@ -5,6 +5,7 @@
 import 'package:kernel/ast.dart';
 import 'package:kernel/type_algebra.dart';
 
+import '../builder/library_builder.dart';
 import '../source/source_library_builder.dart';
 import '../source/source_member_builder.dart';
 import 'kernel_helper.dart';
@@ -279,7 +280,8 @@ SynthesizedFunctionNode buildRedirectingFactoryTearOffBody(
     Procedure tearOff,
     Member target,
     List<DartType> typeArguments,
-    FreshTypeParameters freshTypeParameters) {
+    FreshTypeParameters freshTypeParameters,
+    LibraryBuilder libraryBuilder) {
   int fileOffset = tearOff.fileOffset;
 
   List<TypeParameter> typeParameters;
@@ -318,7 +320,7 @@ SynthesizedFunctionNode buildRedirectingFactoryTearOffBody(
   _createTearOffBody(tearOff, target, arguments);
   return new SynthesizedFunctionNode(
       substitutionMap, target.function!, tearOff.function,
-      identicalSignatures: false);
+      identicalSignatures: false, libraryBuilder: libraryBuilder);
 }
 
 /// Creates the synthesized [Procedure] node for a tear off lowering by the

pkg/front_end/lib/src/fasta/kernel/kernel_helper.dart

@@ -7,6 +7,10 @@ library fasta.kernel_target;
 import 'package:kernel/ast.dart';
 import 'package:kernel/clone.dart' show CloneVisitorNotMembers;
 import 'package:kernel/type_algebra.dart' show Substitution;
+import 'package:kernel/type_environment.dart';
+
+import '../builder/library_builder.dart';
+import '../messages.dart';
 
 /// Data for clone default values for synthesized function nodes once the
 /// original default values have been computed.
@@ -35,32 +39,45 @@ class SynthesizedFunctionNode {
   /// named parameters.
   final bool identicalSignatures;
 
-  final List<int>? _positionalSuperParameters;
+  final List<int?>? _positionalSuperParameters;
 
   final List<String>? _namedSuperParameters;
 
   bool isOutlineNode;
 
+  final LibraryBuilder _libraryBuilder;
+
+  CloneVisitorNotMembers? _cloner;
+
   SynthesizedFunctionNode(
       this._typeSubstitution, this._original, this._synthesized,
       {this.identicalSignatures: true,
-      List<int>? positionalSuperParameters: null,
+      List<int?>? positionalSuperParameters: null,
       List<String>? namedSuperParameters: null,
-      this.isOutlineNode: false})
+      this.isOutlineNode: false,
+      required LibraryBuilder libraryBuilder})
       : _positionalSuperParameters = positionalSuperParameters,
         _namedSuperParameters = namedSuperParameters,
+        _libraryBuilder = libraryBuilder,
         // Check that [positionalSuperParameters] and [namedSuperParameters] are
         // provided or omitted together.
         assert((positionalSuperParameters == null) ==
             (namedSuperParameters == null)),
         assert(positionalSuperParameters == null ||
             () {
               // Check that [positionalSuperParameters] is sorted if it's
-              // provided.
-              for (int i = 1; i < positionalSuperParameters.length; i++) {
-                if (positionalSuperParameters[i] <
-                    positionalSuperParameters[i - 1]) {
-                  return false;
+              // provided. The `null` values are allowed in-between the sorted
+              // values.
+              for (int i = -1, j = 0;
+                  j < positionalSuperParameters.length;
+                  j++) {
+                int? currentValue = positionalSuperParameters[j];
+                if (currentValue != null) {
+                  if (i == -1 || positionalSuperParameters[i]! < currentValue) {
+                    i = j;
+                  } else {
+                    return false;
+                  }
                 }
               }
               return true;
@@ -82,23 +99,11 @@ class SynthesizedFunctionNode {
               return superParameterIndex == namedSuperParameters.length;
             }());
 
-  void cloneDefaultValues() {
+  void cloneDefaultValues(TypeEnvironment typeEnvironment) {
     // TODO(ahe): It is unclear if it is legal to use type variables in
     // default values, but Fasta is currently allowing it, and the VM
     // accepts it. If it isn't legal, the we can speed this up by using a
     // single cloner without substitution.
-    CloneVisitorNotMembers? cloner;
-
-    void cloneInitializer(VariableDeclaration originalParameter,
-        VariableDeclaration clonedParameter) {
-      if (originalParameter.initializer != null) {
-        cloner ??=
-            new CloneVisitorNotMembers(typeSubstitution: _typeSubstitution);
-        clonedParameter.initializer = cloner!
-            .clone(originalParameter.initializer!)
-          ..parent = clonedParameter;
-      }
-    }
 
     // For mixin application constructors, the argument count is the same, but
     // for redirecting tear off lowerings, the argument count of the tear off
@@ -109,14 +114,21 @@ class SynthesizedFunctionNode {
       assert(_positionalSuperParameters != null ||
           _synthesized.positionalParameters.length ==
               _original.positionalParameters.length);
-      List<int>? positionalSuperParameters = _positionalSuperParameters;
+      List<int?>? positionalSuperParameters = _positionalSuperParameters;
       for (int i = 0; i < _original.positionalParameters.length; i++) {
         if (positionalSuperParameters == null) {
-          cloneInitializer(_original.positionalParameters[i],
+          _cloneInitializer(_original.positionalParameters[i],
               _synthesized.positionalParameters[i]);
         } else if (i < positionalSuperParameters.length) {
-          cloneInitializer(_original.positionalParameters[i],
-              _synthesized.positionalParameters[positionalSuperParameters[i]]);
+          int? superParameterIndex = positionalSuperParameters[i];
+          if (superParameterIndex != null) {
+            VariableDeclaration originalParameter =
+                _original.positionalParameters[i];
+            VariableDeclaration synthesizedParameter =
+                _synthesized.positionalParameters[superParameterIndex];
+            _cloneDefaultValueForSuperParameters(
+                originalParameter, synthesizedParameter, typeEnvironment);
+          }
         }
       }
 
@@ -131,7 +143,7 @@ class SynthesizedFunctionNode {
       }
       for (int i = 0; i < _synthesized.namedParameters.length; i++) {
         if (namedSuperParameters == null) {
-          cloneInitializer(
+          _cloneInitializer(
               _original.namedParameters[i], _synthesized.namedParameters[i]);
         } else if (superParameterNameIndex < namedSuperParameters.length &&
             namedSuperParameters[superParameterNameIndex] ==
@@ -141,9 +153,12 @@ class SynthesizedFunctionNode {
           int? originalNamedParameterIndex =
               originalNamedParameterIndices[superParameterName];
           if (originalNamedParameterIndex != null) {
-            cloneInitializer(
-                _original.namedParameters[originalNamedParameterIndex],
-                _synthesized.namedParameters[i]);
+            VariableDeclaration originalParameter =
+                _original.namedParameters[originalNamedParameterIndex];
+            VariableDeclaration synthesizedParameter =
+                _synthesized.namedParameters[i];
+            _cloneDefaultValueForSuperParameters(
+                originalParameter, synthesizedParameter, typeEnvironment);
           } else {
             // TODO(cstefantsova): Handle the erroneous case of missing names.
           }
@@ -155,7 +170,7 @@ class SynthesizedFunctionNode {
         VariableDeclaration synthesizedParameter =
             _synthesized.positionalParameters[i];
         if (i < _original.positionalParameters.length) {
-          cloneInitializer(
+          _cloneInitializer(
               _original.positionalParameters[i], synthesizedParameter);
         } else {
           // Error case: use `null` as initializer.
@@ -175,7 +190,7 @@ class SynthesizedFunctionNode {
           VariableDeclaration? originalParameter =
               originalParameters[synthesizedParameter.name!];
           if (originalParameter != null) {
-            cloneInitializer(originalParameter, synthesizedParameter);
+            _cloneInitializer(originalParameter, synthesizedParameter);
           } else {
             // Error case: use `null` as initializer.
             synthesizedParameter.initializer = new NullLiteral()
@@ -186,6 +201,43 @@ class SynthesizedFunctionNode {
     }
   }
 
+  void _cloneInitializer(VariableDeclaration originalParameter,
+      VariableDeclaration clonedParameter) {
+    if (originalParameter.initializer != null) {
+      CloneVisitorNotMembers cloner = _cloner ??=
+          new CloneVisitorNotMembers(typeSubstitution: _typeSubstitution);
+      clonedParameter.initializer = cloner.clone(originalParameter.initializer!)
+        ..parent = clonedParameter;
+    }
+  }
+
+  void _cloneDefaultValueForSuperParameters(
+      VariableDeclaration originalParameter,
+      VariableDeclaration synthesizedParameter,
+      TypeEnvironment typeEnvironment) {
+    Member member = _synthesized.parent as Member;
+    Expression? originalParameterInitializer = originalParameter.initializer;
+    DartType? originalParameterInitializerType = originalParameterInitializer
+        ?.getStaticType(new StaticTypeContext(member, typeEnvironment));
+    DartType synthesizedParameterType = synthesizedParameter.type;
+    if (originalParameterInitializerType != null &&
+        typeEnvironment.isSubtypeOf(originalParameterInitializerType,
+            synthesizedParameterType, SubtypeCheckMode.withNullabilities)) {
+      _cloneInitializer(originalParameter, synthesizedParameter);
+    } else {
+      if (synthesizedParameterType.isPotentiallyNonNullable) {
+        _libraryBuilder.addProblem(
+            templateOptionalSuperParameterWithoutInitializer.withArguments(
+                synthesizedParameter.type,
+                synthesizedParameter.name!,
+                _libraryBuilder.isNonNullableByDefault),
+            synthesizedParameter.fileOffset,
+            synthesizedParameter.name?.length ?? 1,
+            _libraryBuilder.fileUri);
+      }
+    }
+  }
+
   @override
   String toString() {
     return "SynthesizedFunctionNode(original=${_original.parent}, "

pkg/front_end/lib/src/fasta/kernel/kernel_target.dart

@@ -1086,7 +1086,8 @@ class KernelTarget extends TargetImplementation {
         superConstructor, new Arguments(positional, named: named));
     SynthesizedFunctionNode synthesizedFunctionNode =
         new SynthesizedFunctionNode(
-            substitutionMap, superConstructor.function, function);
+            substitutionMap, superConstructor.function, function,
+            libraryBuilder: classBuilder.library);
     if (!isConst) {
       // For constant constructors default values are computed and cloned part
       // of the outline expression and therefore passed to the
@@ -1144,7 +1145,7 @@ class KernelTarget extends TargetImplementation {
     for (SynthesizedFunctionNode synthesizedFunctionNode
         in synthesizedFunctionNodes) {
       if (!forOutline || synthesizedFunctionNode.isOutlineNode) {
-        synthesizedFunctionNode.cloneDefaultValues();
+        synthesizedFunctionNode.cloneDefaultValues(loader.typeEnvironment);
       }
     }
     if (!forOutline) {