[cfe] Support generic inline class constructors

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

Author: johnniwinther

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

@@ -7,6 +7,7 @@ library fasta.formal_parameter_builder;
 import 'package:_fe_analyzer_shared/src/parser/formal_parameter_kind.dart'
     show FormalParameterKind, FormalParameterKindExtension;
 import 'package:_fe_analyzer_shared/src/scanner/scanner.dart' show Token;
+import 'package:front_end/src/fasta/source/constructor_declaration.dart';
 import 'package:kernel/ast.dart'
     show DartType, DynamicType, Expression, NullLiteral, VariableDeclaration;
 import 'package:kernel/class_hierarchy.dart';
@@ -221,10 +222,14 @@ class FormalParameterBuilder extends ModifierBuilderImpl
   }
 
   void finalizeInitializingFormal(
-      DeclarationBuilder declarationBuilder, ClassHierarchyBase hierarchy) {
+      DeclarationBuilder declarationBuilder,
+      ConstructorDeclaration constructorDeclaration,
+      ClassHierarchyBase hierarchy) {
     Builder? fieldBuilder = declarationBuilder.lookupLocalMember(name);
     if (fieldBuilder is SourceFieldBuilder) {
-      type.registerInferredType(fieldBuilder.inferType(hierarchy));
+      DartType fieldType = fieldBuilder.inferType(hierarchy);
+      fieldType = constructorDeclaration.substituteFieldType(fieldType);
+      type.registerInferredType(fieldType);
     } else {
       type.registerInferredType(const DynamicType());
     }

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

@@ -1887,14 +1887,14 @@ class BodyBuilder extends StackListenerImpl
     return arguments;
   }
 
-  void finishConstructor(ConstructorDeclaration builder,
+  void finishConstructor(ConstructorDeclaration constructorDeclaration,
       AsyncMarker asyncModifier, Statement? body,
       {required List<Object /* Expression | NamedExpression */ >?
           superParametersAsArguments}) {
     /// Quotes below are from [Dart Programming Language Specification, 4th
     /// Edition](
     /// https://ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf).
-    assert(builder == this.member);
+    assert(constructorDeclaration == this.member);
     assert(() {
       if (superParametersAsArguments == null) {
         return true;
@@ -1933,9 +1933,9 @@ class BodyBuilder extends StackListenerImpl
         "Expected 'superParametersAsArguments' "
         "to be sorted by occurrence in file.");
 
-    Member member = builder.member;
-    FunctionNode function = builder.function;
-    List<FormalParameterBuilder>? formals = builder.formals;
+    Member member = constructorDeclaration.member;
+    FunctionNode function = constructorDeclaration.function;
+    List<FormalParameterBuilder>? formals = constructorDeclaration.formals;
     if (formals != null) {
       for (int i = 0; i < formals.length; i++) {
         FormalParameterBuilder parameter = formals[i];
@@ -1992,7 +1992,7 @@ class BodyBuilder extends StackListenerImpl
       if (initializers.last is SuperInitializer) {
         SuperInitializer superInitializer =
             initializers.last as SuperInitializer;
-        if (builder.classDeclaration.isEnum) {
+        if (constructorDeclaration.classDeclaration.isEnum) {
           initializers[initializers.length - 1] = buildInvalidInitializer(
               buildProblem(fasta.messageEnumConstructorSuperInitializer,
                   superInitializer.fileOffset, noLength))
@@ -2054,19 +2054,19 @@ class BodyBuilder extends StackListenerImpl
       List<InitializerInferenceResult> inferenceResults =
           new List<InitializerInferenceResult>.generate(
               initializers.length,
-              (index) =>
-                  typeInferrer.inferInitializer(this, initializers[index]),
+              (index) => typeInferrer.inferInitializer(
+                  this, constructorDeclaration, initializers[index]),
               growable: false);
 
-      if (!builder.isExternal) {
+      if (!constructorDeclaration.isExternal) {
         for (int i = 0; i < initializers.length; i++) {
-          builder.addInitializer(initializers[i], this,
+          constructorDeclaration.addInitializer(initializers[i], this,
               inferenceResult: inferenceResults[i]);
         }
       }
     }
 
-    List<Initializer> builtInitializers = builder.initializers;
+    List<Initializer> builtInitializers = constructorDeclaration.initializers;
     if (asyncModifier != AsyncMarker.Sync) {
       builtInitializers.add(buildInvalidInitializer(buildProblem(
           fasta.messageConstructorNotSync, body!.fileOffset, noLength)));
@@ -2110,29 +2110,29 @@ class BodyBuilder extends StackListenerImpl
 
       if (superTarget == null ||
           checkArgumentsForFunction(superTarget.function, arguments,
-                  builder.charOffset, const <TypeParameter>[]) !=
+                  constructorDeclaration.charOffset, const <TypeParameter>[]) !=
               null) {
         String superclass =
             sourceClassBuilder!.supertypeBuilder!.fullNameForErrors;
-        int length = builder.name.length;
+        int length = constructorDeclaration.name.length;
         if (length == 0) {
           length = sourceClassBuilder!.cls.name.length;
         }
         initializer = buildInvalidInitializer(
             buildProblem(
                 fasta.templateSuperclassHasNoDefaultConstructor
                     .withArguments(superclass),
-                builder.charOffset,
+                constructorDeclaration.charOffset,
                 length),
-            builder.charOffset);
+            constructorDeclaration.charOffset);
       } else {
         initializer = buildSuperInitializer(
-            true, superTarget, arguments, builder.charOffset);
+            true, superTarget, arguments, constructorDeclaration.charOffset);
       }
       if (libraryFeatures.superParameters.isEnabled) {
-        InitializerInferenceResult inferenceResult =
-            typeInferrer.inferInitializer(this, initializer);
-        builder.addInitializer(initializer, this,
+        InitializerInferenceResult inferenceResult = typeInferrer
+            .inferInitializer(this, constructorDeclaration, initializer);
+        constructorDeclaration.addInitializer(initializer, this,
             inferenceResult: inferenceResult);
       } else {
         builtInitializers.add(initializer);
@@ -7895,10 +7895,14 @@ class BodyBuilder extends StackListenerImpl
             ..fileOffset = assignmentOffset
         ];
       } else {
+        ConstructorDeclaration constructorBuilder =
+            member as ConstructorDeclaration;
         if (formal != null && formal.type is! OmittedTypeBuilder) {
           DartType formalType = formal.variable!.type;
-          if (!typeEnvironment.isSubtypeOf(formalType, builder.fieldType,
-              SubtypeCheckMode.withNullabilities)) {
+          DartType fieldType =
+              constructorBuilder.substituteFieldType(builder.fieldType);
+          if (!typeEnvironment.isSubtypeOf(
+              formalType, fieldType, SubtypeCheckMode.withNullabilities)) {
             libraryBuilder.addProblem(
                 fasta.templateInitializingFormalTypeMismatch.withArguments(
                     name,
@@ -7914,8 +7918,6 @@ class BodyBuilder extends StackListenerImpl
                 ]);
           }
         }
-        ConstructorDeclaration constructorBuilder =
-            member as ConstructorDeclaration;
         constructorBuilder.registerInitializedField(builder);
         return builder.buildInitializer(assignmentOffset, expression,
             isSynthetic: formal != null);

pkg/front_end/lib/src/fasta/source/constructor_declaration.dart

@@ -54,4 +54,12 @@ abstract class ConstructorDeclaration implements SourceFunctionBuilder {
   /// [registerInitializedField] and passes on the ownership of the collection
   /// to the caller.
   Set<SourceFieldBuilder>? takeInitializedFields();
+
+  /// Substitute [fieldType] from the context of the enclosing class or
+  /// inline class to this constructor.
+  ///
+  /// This is used for generic inline class constructors where the type
+  /// variable referring to the class type variables must be substituted for
+  /// the synthesized constructor type variables.
+  DartType substituteFieldType(DartType fieldType);
 }

pkg/front_end/lib/src/fasta/source/outline_builder.dart

@@ -1966,8 +1966,8 @@ class OutlineBuilder extends StackListenerImpl {
           break;
       }
       bool isStatic = (modifiers & staticMask) != 0;
-      if (constructorName == null &&
-          !isStatic &&
+      bool isConstructor = constructorName != null;
+      if (!isStatic &&
           (libraryBuilder.currentTypeParameterScopeBuilder.kind ==
                   TypeParameterScopeKind.extensionDeclaration ||
               libraryBuilder.currentTypeParameterScopeBuilder.kind ==
@@ -1997,53 +1997,56 @@ class OutlineBuilder extends StackListenerImpl {
             typeVariables = synthesizedTypeVariables;
           }
         }
-        List<FormalParameterBuilder> synthesizedFormals = [];
-        TypeBuilder thisType;
-        if (declaration.kind == TypeParameterScopeKind.extensionDeclaration) {
-          thisType = declaration.extensionThisType;
-        } else {
-          thisType = libraryBuilder.addNamedType(
-              declaration.name,
-              const NullabilityBuilder.omitted(),
-              declaration.typeVariables != null
-                  ? new List<TypeBuilder>.generate(
-                      declaration.typeVariables!.length,
-                      (int index) =>
-                          new NamedTypeBuilder.fromTypeDeclarationBuilder(
-                              typeVariables![index],
-                              const NullabilityBuilder.omitted(),
-                              instanceTypeVariableAccess:
-                                  InstanceTypeVariableAccessState.Allowed))
-                  : null,
+        if (!isConstructor) {
+          List<FormalParameterBuilder> synthesizedFormals = [];
+          TypeBuilder thisType;
+          if (declaration.kind == TypeParameterScopeKind.extensionDeclaration) {
+            thisType = declaration.extensionThisType;
+          } else {
+            thisType = libraryBuilder.addNamedType(
+                declaration.name,
+                const NullabilityBuilder.omitted(),
+                declaration.typeVariables != null
+                    ? new List<TypeBuilder>.generate(
+                        declaration.typeVariables!.length,
+                        (int index) =>
+                            new NamedTypeBuilder.fromTypeDeclarationBuilder(
+                                typeVariables![index],
+                                const NullabilityBuilder.omitted(),
+                                instanceTypeVariableAccess:
+                                    InstanceTypeVariableAccessState.Allowed))
+                    : null,
+                charOffset,
+                instanceTypeVariableAccess:
+                    InstanceTypeVariableAccessState.Allowed);
+          }
+          if (substitution != null) {
+            List<NamedTypeBuilder> unboundTypes = [];
+            List<TypeVariableBuilder> unboundTypeVariables = [];
+            thisType = substitute(thisType, substitution,
+                unboundTypes: unboundTypes,
+                unboundTypeVariables: unboundTypeVariables);
+            for (NamedTypeBuilder unboundType in unboundTypes) {
+              declaration.registerUnresolvedNamedType(unboundType);
+            }
+            libraryBuilder.unboundTypeVariables.addAll(unboundTypeVariables);
+          }
+          synthesizedFormals.add(new FormalParameterBuilder(
+              /* metadata = */
+              null,
+              FormalParameterKind.requiredPositional,
+              finalMask,
+              thisType,
+              syntheticThisName,
+              null,
               charOffset,
-              instanceTypeVariableAccess:
-                  InstanceTypeVariableAccessState.Allowed);
-        }
-        if (substitution != null) {
-          List<NamedTypeBuilder> unboundTypes = [];
-          List<TypeVariableBuilder> unboundTypeVariables = [];
-          thisType = substitute(thisType, substitution,
-              unboundTypes: unboundTypes,
-              unboundTypeVariables: unboundTypeVariables);
-          for (NamedTypeBuilder unboundType in unboundTypes) {
-            declaration.registerUnresolvedNamedType(unboundType);
+              fileUri: uri,
+              isExtensionThis: true));
+          if (formals != null) {
+            synthesizedFormals.addAll(formals);
           }
-          libraryBuilder.unboundTypeVariables.addAll(unboundTypeVariables);
-        }
-        synthesizedFormals.add(new FormalParameterBuilder(
-            /* metadata = */ null,
-            FormalParameterKind.requiredPositional,
-            finalMask,
-            thisType,
-            syntheticThisName,
-            null,
-            charOffset,
-            fileUri: uri,
-            isExtensionThis: true));
-        if (formals != null) {
-          synthesizedFormals.addAll(formals);
+          formals = synthesizedFormals;
         }
-        formals = synthesizedFormals;
       }
 
       declarationBuilder.resolveNamedTypes(typeVariables, libraryBuilder);

pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart

@@ -137,7 +137,8 @@ abstract class AbstractSourceConstructorBuilder
         for (FormalParameterBuilder formal in formals!) {
           if (formal.type is InferableTypeBuilder) {
             if (formal.isInitializingFormal) {
-              formal.finalizeInitializingFormal(declarationBuilder, hierarchy);
+              formal.finalizeInitializingFormal(
+                  declarationBuilder, this, hierarchy);
             }
           }
         }
@@ -903,6 +904,13 @@ class DeclaredSourceConstructorBuilder
       }
     }
   }
+
+  @override
+  DartType substituteFieldType(DartType fieldType) {
+    // Nothing to do. Regular generative constructors don't have their own
+    // type variables.
+    return fieldType;
+  }
 }
 
 class SyntheticSourceConstructorBuilder extends DillConstructorBuilder
@@ -1150,8 +1158,8 @@ class SourceInlineClassConstructorBuilder
 
     InlineClass inlineClass = inlineClassBuilder.inlineClass;
     List<DartType> typeParameterTypes = <DartType>[];
-    for (int i = 0; i < inlineClass.typeParameters.length; i++) {
-      TypeParameter typeParameter = inlineClass.typeParameters[i];
+    for (int i = 0; i < function.typeParameters.length; i++) {
+      TypeParameter typeParameter = function.typeParameters[i];
       typeParameterTypes.add(
           new TypeParameterType.withDefaultNullabilityForLibrary(
               typeParameter, libraryBuilder.library));
@@ -1166,7 +1174,6 @@ class SourceInlineClassConstructorBuilder
       buildFunction();
       _constructor.function.fileOffset = charOpenParenOffset;
       _constructor.function.fileEndOffset = _constructor.fileEndOffset;
-      _constructor.function.typeParameters = const <TypeParameter>[];
       _constructor.isConst = isConst;
       _constructor.isExternal = isExternal;
 
@@ -1224,7 +1231,30 @@ class SourceInlineClassConstructorBuilder
   @override
   bool get isEffectivelyRedirecting => isRedirecting;
 
-// TODO(johnniwinther): Generate initializers and return statement.
+  Substitution? _substitutionCache;
+
+  Substitution get _substitution {
+    if (typeVariables != null) {
+      assert(
+          inlineClassBuilder.typeParameters!.length == typeVariables?.length);
+      _substitutionCache = Substitution.fromPairs(
+          inlineClassBuilder.inlineClass.typeParameters,
+          new List<DartType>.generate(
+              inlineClassBuilder.typeParameters!.length,
+              (int index) =>
+                  new TypeParameterType.withDefaultNullabilityForLibrary(
+                      function.typeParameters[index],
+                      libraryBuilder.origin.library)));
+    } else {
+      _substitutionCache = Substitution.empty;
+    }
+    return _substitutionCache!;
+  }
+
+  @override
+  DartType substituteFieldType(DartType fieldType) {
+    return _substitution.substituteType(fieldType);
+  }
 }
 
 class _InitializerToStatementConverter implements InitializerVisitor<void> {