Front end: initial implementation of type inference for object patterns.

This code handles simple cases.  Still TBD:
- Object patterns that refer to typedefs
- Object patterns that refer to classes with f-bounded polymorphism
- Inference of `dynamic` when there is no bound

Bug: #51795
Change-Id: I00acae6ba111f7b170650cfeffbfd2aaf7f71e42
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/290347
Reviewed-by: Chloe Stefantsova <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

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

@@ -9170,10 +9170,13 @@ class BodyBuilder extends StackListenerImpl
     push(typeArguments ?? NullValues.TypeArguments);
     handleType(firstIdentifier, null);
     TypeBuilder typeBuilder = pop() as TypeBuilder;
+    TypeDeclarationBuilder? typeDeclaration = typeBuilder.declaration;
     DartType type = buildDartType(typeBuilder, TypeUse.objectPatternType,
         allowPotentiallyConstantType: true);
-    push(forest.createObjectPattern(
-        firstIdentifier.charOffset, type, fields ?? <NamedPattern>[]));
+    push(new ObjectPatternInternal(type, fields ?? <NamedPattern>[],
+        typeDeclaration is TypeAliasBuilder ? typeDeclaration.typedef : null,
+        hasExplicitTypeArguments: typeArguments != null)
+      ..fileOffset = firstIdentifier.charOffset);
   }
 
   @override

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

@@ -1038,11 +1038,6 @@ class Forest {
     return new NullCheckPattern(pattern)..fileOffset = fileOffset;
   }
 
-  ObjectPattern createObjectPattern(
-      int fileOffset, DartType type, List<NamedPattern> fields) {
-    return new ObjectPattern(type, fields)..fileOffset = fileOffset;
-  }
-
   OrPattern createOrPattern(int fileOffset, Pattern left, Pattern right,
       {required List<VariableDeclaration> orPatternJointVariables}) {
     return new OrPattern(left, right,

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

@@ -3682,3 +3682,19 @@ class PatternForMapEntry extends TreeNode
     return "PatternForMapEntry(${toStringInternal()})";
   }
 }
+
+/// Data structure used by the body builder in place of [ObjectPattern], to
+/// allow additional information to be captured that is needed during type
+/// inference.
+class ObjectPatternInternal extends ObjectPattern {
+  /// If the type name in the object pattern refers to a typedef, the typedef in
+  /// question; otherwise `null`.
+  final Typedef? typedef;
+
+  /// Indicates whether the object pattern included explicit type arguments; if
+  /// `true` this means that no further type inference needs to be performed.
+  final bool hasExplicitTypeArguments;
+
+  ObjectPatternInternal(super.requiredType, super.fields, this.typedef,
+      {required this.hasExplicitTypeArguments});
+}

pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart

@@ -10251,6 +10251,8 @@ class InferenceVisitorImpl extends InferenceVisitorBase
           ValueKinds.Pattern, node.fields.length)
     ]));
 
+    node.requiredType = analysisResult.requiredType;
+
     Pattern? replacement;
 
     InvalidExpression? error =
@@ -10873,15 +10875,65 @@ class InferenceVisitorImpl extends InferenceVisitorBase
     return new RecordType(positional, namedFields, Nullability.nonNullable);
   }
 
+  /// Infers type arguments corresponding to [typeParameters] so that, when
+  /// substituted into [declaredType], the resulting type matches [contextType].
+  List<DartType> _inferTypeArguments(
+      {required List<TypeParameter> typeParameters,
+      required DartType declaredType,
+      required DartType contextType}) {
+    TypeConstraintGatherer gatherer = typeSchemaEnvironment
+        .setupGenericTypeInference(declaredType, typeParameters, contextType,
+            isNonNullableByDefault: isNonNullableByDefault);
+    List<DartType> inferredTypes = typeSchemaEnvironment.partialInfer(
+        gatherer, typeParameters, null,
+        isNonNullableByDefault: isNonNullableByDefault);
+    // Type inference may not be able to infer a type for every type parameter;
+    // if it can't fall back on the type parameter's bound.
+    // TODO(paulberry): this doesn't work if the type is F-bounded because in
+    // that case, the bound may refer to other type variables.
+    for (int i = 0; i < inferredTypes.length; i++) {
+      if (inferredTypes[i] is UnknownType) {
+        DartType bound = typeParameters[i].bound;
+        inferredTypes[i] = bound;
+      }
+    }
+    return inferredTypes;
+  }
+
   @override
   DartType downwardInferObjectPatternRequiredType({
     required DartType matchedType,
-    required Pattern pattern,
+    required covariant ObjectPatternInternal pattern,
   }) {
-    if (pattern is! ObjectPattern) return const InvalidType();
-    // TODO(johnniwinther): Update this when language issue #2770 has been
-    // resolved.
-    return pattern.requiredType;
+    DartType requiredType = pattern.requiredType;
+    if (!pattern.hasExplicitTypeArguments) {
+      if (pattern.typedef != null) {
+        // TODO(paulberry): handle typedefs properly.
+      }
+      if (requiredType is InterfaceType &&
+          requiredType.classNode.typeParameters.isNotEmpty) {
+        List<TypeParameter> typeParameters =
+            requiredType.classNode.typeParameters;
+
+        // It's possible that one of the callee type parameters might match a
+        // type that already exists as part of inference.  This might happen,
+        // for instance, in the case where a method in a generic class contains
+        // an object pattern naming the enclosing class.  To avoid creating
+        // invalid inference results, we need to create fresh type parameters.
+        FreshTypeParameters fresh = getFreshTypeParameters(typeParameters);
+        InterfaceType declaredType = new InterfaceType(requiredType.classNode,
+            requiredType.declaredNullability, fresh.freshTypeArguments);
+        typeParameters = fresh.freshTypeParameters;
+
+        List<DartType> inferredTypeArguments = _inferTypeArguments(
+            typeParameters: typeParameters,
+            declaredType: declaredType,
+            contextType: matchedType);
+        requiredType = new InterfaceType(requiredType.classNode,
+            requiredType.declaredNullability, inferredTypeArguments);
+      }
+    }
+    return requiredType;
   }
 
   @override

pkg/front_end/testcases/patterns/non_constant_pattern_in_if.dart.strong.expect

@@ -64,7 +64,7 @@ static method test(dynamic value, core::bool expected) → void {
   }
   {
     final synthesized dynamic #4#0 = value;
-    if(#4#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+    if(#4#0 is{ForNonNullableByDefault} self::Const<core::Object?>) {
       matched = true;
     }
   }

pkg/front_end/testcases/patterns/non_constant_pattern_in_if.dart.strong.transformed.expect

@@ -64,7 +64,7 @@ static method test(dynamic value, core::bool expected) → void {
   }
   {
     final synthesized dynamic #4#0 = value;
-    if(#4#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+    if(#4#0 is{ForNonNullableByDefault} self::Const<core::Object?>) {
       matched = true;
     }
   }

pkg/front_end/testcases/patterns/non_constant_pattern_in_if.dart.weak.expect

@@ -64,7 +64,7 @@ static method test(dynamic value, core::bool expected) → void {
   }
   {
     final synthesized dynamic #4#0 = value;
-    if(#4#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+    if(#4#0 is{ForNonNullableByDefault} self::Const<core::Object?>) {
       matched = true;
     }
   }

pkg/front_end/testcases/patterns/non_constant_pattern_in_if.dart.weak.modular.expect

@@ -64,7 +64,7 @@ static method test(dynamic value, core::bool expected) → void {
   }
   {
     final synthesized dynamic #4#0 = value;
-    if(#4#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+    if(#4#0 is{ForNonNullableByDefault} self::Const<core::Object?>) {
       matched = true;
     }
   }

pkg/front_end/testcases/patterns/non_constant_pattern_in_if.dart.weak.transformed.expect

@@ -64,7 +64,7 @@ static method test(dynamic value, core::bool expected) → void {
   }
   {
     final synthesized dynamic #4#0 = value;
-    if(#4#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+    if(#4#0 is{ForNonNullableByDefault} self::Const<core::Object?>) {
       matched = true;
     }
   }

pkg/front_end/testcases/patterns/non_constant_pattern_in_switch.dart.strong.expect

@@ -82,7 +82,7 @@ static method test(dynamic value, core::bool expected) → void {
       }
     }
     {
-      if(#0#0 is{ForNonNullableByDefault} self::Const<dynamic>) {
+      if(#0#0 is{ForNonNullableByDefault} self::Const<core::Object?>) {
         {
           matched = true;
           break #L1;