[cfe] Implement desugaring of ObjectPattern for simple cases

This CL doesn't cover, among other, the following

* Non-class identifiers
* Some erroneous cases

Part of #49749

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

Author: chloestefantsova

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -12084,6 +12084,17 @@ Message _withArgumentsUnspecified(String string) {
       problemMessage: """${string}""", arguments: {'string': string});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeUnspecifiedGetterNameInObjectPattern =
+    messageUnspecifiedGetterNameInObjectPattern;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageUnspecifiedGetterNameInObjectPattern = const MessageCode(
+    "UnspecifiedGetterNameInObjectPattern",
+    analyzerCodes: <String>["MISSING_OBJECT_PATTERN_GETTER_NAME"],
+    problemMessage:
+        r"""The getter name is not specified explicitly, and the pattern is not a variable. Try specifying the getter name explicitly, or using a variable pattern.""");
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeUnsupportedDartExt = messageUnsupportedDartExt;
 

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

@@ -8328,11 +8328,16 @@ class BodyBuilder extends StackListenerImpl
             count)));
     reportIfNotEnabled(
         libraryFeatures.patterns, beginToken.charOffset, beginToken.charCount);
+    List<NamedPattern>? fields;
     for (int i = 0; i < count; i++) {
-      pop();
+      Object? field = pop();
+      if (field is NamedPattern) {
+        (fields ??= <NamedPattern>[]).add(field);
+      } else {
+        // TODO(cstefantsova): Report an error.
+      }
     }
-    // TODO(johnniwinther): Push (named) patterns.
-    push(count != 0 ? <Pattern>[] : NullValue.PatternList);
+    push(fields ?? NullValue.PatternList);
   }
 
   @override
@@ -8347,13 +8352,40 @@ class BodyBuilder extends StackListenerImpl
     reportIfNotEnabled(libraryFeatures.patterns, firstIdentifier.charOffset,
         firstIdentifier.charCount);
 
-    // ignore: unused_local_variable
-    List<Pattern>? fields = pop() as List<Pattern>?;
-    // ignore: unused_local_variable
+    List<NamedPattern>? fields = pop() as List<NamedPattern>?;
     List<TypeBuilder>? typeArguments = pop() as List<TypeBuilder>?;
 
-    // TODO(johnniwinther): Create object pattern.
-    push(new DummyPattern(firstIdentifier.charOffset));
+    // TODO(cstefantsova): Handle the case of secondIdentifier != null
+    handleIdentifier(firstIdentifier, IdentifierContext.typeReference);
+    Object? resolvedIdentifier = pop();
+    if (resolvedIdentifier is TypeUseGenerator) {
+      TypeDeclarationBuilder typeDeclaration = resolvedIdentifier.declaration;
+      if (typeDeclaration is ClassBuilder) {
+        List<DartType>? builtTypeArguments;
+        if (typeArguments != null) {
+          if (typeArguments.length ==
+              typeDeclaration.cls.typeParameters.length) {
+            for (TypeBuilder typeBuilder in typeArguments) {
+              (builtTypeArguments ??= <DartType>[])
+                  .add(typeBuilder.build(libraryBuilder, TypeUse.typeArgument));
+            }
+          } else {
+            // TODO(cstefantsova): Report an error.
+          }
+        }
+        push(new ObjectPattern(
+            typeDeclaration.cls.reference,
+            fields ?? <NamedPattern>[],
+            builtTypeArguments,
+            firstIdentifier.offset));
+      } else {
+        // TODO(cstefantsova): Handle this case.
+        push(new DummyPattern(firstIdentifier.charOffset));
+      }
+    } else {
+      // TODO(cstefantsova): Handle the error.
+      push(new DummyPattern(firstIdentifier.charOffset));
+    }
   }
 
   @override

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

@@ -19,6 +19,7 @@
 /// with the same kind of root node.
 import 'package:kernel/ast.dart';
 import 'package:kernel/clone.dart';
+import 'package:kernel/src/bounds_checks.dart';
 import 'package:kernel/src/printer.dart';
 import 'package:kernel/text/ast_to_text.dart' show Precedence, Printer;
 import 'package:kernel/type_environment.dart';
@@ -3947,8 +3948,14 @@ class OrPattern extends Pattern {
     };
     List<VariableDeclaration> declaredVariables = this.declaredVariables;
     for (VariableDeclaration variable in declaredVariables) {
-      VariableDeclaration leftVariable = leftVariablesByName[variable.name!]!;
-      VariableDeclaration rightVariable = rightVariablesByName[variable.name!]!;
+      VariableDeclaration? leftVariable = leftVariablesByName[variable.name!];
+      VariableDeclaration? rightVariable = rightVariablesByName[variable.name!];
+
+      if (leftVariable == null || rightVariable == null) {
+        // TODO(cstefantsova): Make sure an error is reported.
+        continue;
+      }
+
       variable.initializer = inferenceVisitor.engine.forest
           .createConditionalExpression(
               fileOffset,
@@ -4535,6 +4542,209 @@ class ListPattern extends Pattern {
   }
 }
 
+class ObjectPattern extends Pattern {
+  final Reference classReference;
+  final List<NamedPattern> fields;
+  final List<DartType>? typeArguments;
+  Class get classNode => classReference.asClass;
+
+  ObjectPattern(
+      this.classReference, this.fields, this.typeArguments, int fileOffset)
+      : super(fileOffset) {
+    setParents(fields, this);
+  }
+
+  @override
+  PatternInferenceResult acceptInference(InferenceVisitorImpl visitor,
+      {required SharedMatchContext context}) {
+    return visitor.visitObjectPattern(this, context: context);
+  }
+
+  @override
+  List<VariableDeclaration> get declaredVariables {
+    return [for (NamedPattern field in fields) ...field.declaredVariables];
+  }
+
+  @override
+  void toTextInternal(AstPrinter printer) {
+    printer.write('${classNode.name}');
+    if (typeArguments != null) {
+      printer.write('<');
+      printer.writeTypes(typeArguments!);
+      printer.write('>');
+    }
+    printer.write('(');
+    String comma = '';
+    for (Pattern field in fields) {
+      printer.write(comma);
+      field.toTextInternal(printer);
+      comma = ', ';
+    }
+    printer.write(')');
+  }
+
+  @override
+  String toString() {
+    return "ObjectPattern(${toStringInternal()})";
+  }
+
+  @override
+  PatternTransformationResult transform(
+      Expression matchedExpression,
+      DartType matchedType,
+      Expression variableInitializingContext,
+      InferenceVisitorBase inferenceVisitor) {
+    // targetObjectType: `classNode`<`typeArguments`>
+    DartType targetObjectType;
+    if (typeArguments != null &&
+        typeArguments!.length == classNode.typeParameters.length) {
+      targetObjectType =
+          new InterfaceType(classNode, Nullability.nonNullable, typeArguments);
+    } else {
+      if (typeArguments != null) {
+        // TODO(cstefantsova): Report an error.
+      }
+      targetObjectType = new InterfaceType(
+          classNode,
+          Nullability.nonNullable,
+          calculateBounds(
+              classNode.typeParameters,
+              inferenceVisitor.coreTypes.objectClass,
+              inferenceVisitor.libraryBuilder.library));
+    }
+
+    bool typeCheckForTargetNeeded =
+        !inferenceVisitor.isAssignable(targetObjectType, matchedType) ||
+            matchedType is DynamicType;
+
+    // objectVariable: `matchedType` OVAR = `matchedExpression`
+    VariableDeclaration objectVariable = inferenceVisitor.engine.forest
+        .createVariableDeclarationForValue(matchedExpression,
+            type: matchedType);
+
+    // typeCheck: `objectVariable` is `targetObjectType`
+    //   ==> OVAR is `classNode`<`typeArguments`>
+    Expression? typeCheck;
+    if (typeCheckForTargetNeeded) {
+      typeCheck = inferenceVisitor.engine.forest.createIsExpression(
+          fileOffset,
+          inferenceVisitor.engine.forest
+              .createVariableGet(fileOffset, objectVariable),
+          targetObjectType,
+          forNonNullableByDefault: false);
+    }
+
+    List<VariableDeclaration> elementAccessVariables = [];
+    PatternTransformationResult transformationResult =
+        new PatternTransformationResult([]);
+    for (NamedPattern field in fields) {
+      String? fieldNameString;
+      if (field.name.isNotEmpty) {
+        fieldNameString = field.name;
+      } else {
+        // The name is defined by the nested variable pattern.
+        Pattern nestedPattern = field.pattern;
+        if (nestedPattern is VariablePattern) {
+          fieldNameString = nestedPattern.name;
+        }
+      }
+
+      Expression objectElement;
+      DartType fieldType;
+      if (fieldNameString != null) {
+        Name fieldName = new Name(fieldNameString);
+
+        ObjectAccessTarget fieldAccessTarget = inferenceVisitor
+            .findInterfaceMember(targetObjectType, fieldName, fileOffset,
+                callSiteAccessKind: CallSiteAccessKind.getterInvocation);
+
+        if (fieldAccessTarget.member != null) {
+          fieldType = fieldAccessTarget.getGetterType(inferenceVisitor);
+
+          // objectElement: `objectVariable`.`fieldName`
+          //   ==> OVAR.`fieldName`
+          objectElement = new InstanceGet(
+              InstanceAccessKind.Instance,
+              inferenceVisitor.engine.forest
+                  .createVariableGet(fileOffset, objectVariable)
+                ..promotedType = targetObjectType,
+              fieldName,
+              resultType: fieldType,
+              interfaceTarget: fieldAccessTarget.member!)
+            ..fileOffset = fileOffset;
+        } else {
+          objectElement = inferenceVisitor.helper.buildProblem(
+              templateUndefinedGetter.withArguments(fieldNameString,
+                  targetObjectType, inferenceVisitor.isNonNullableByDefault),
+              fileOffset,
+              noLength);
+          fieldType = const InvalidType();
+        }
+      } else {
+        objectElement = inferenceVisitor.helper.buildProblem(
+            messageUnspecifiedGetterNameInObjectPattern, fileOffset, noLength);
+        fieldType = const InvalidType();
+      }
+
+      // objectElementVariable: `fieldType` EVAR = `objectElement`
+      //   ==> `fieldType` EVAR = OVAR.`fieldName`
+      VariableDeclaration objectElementVariable = inferenceVisitor.engine.forest
+          .createVariableDeclarationForValue(objectElement, type: fieldType);
+
+      PatternTransformationResult subpatternTransformationResult = field.pattern
+          .transform(
+              inferenceVisitor.engine.forest
+                  .createVariableGet(fileOffset, objectElementVariable),
+              fieldType,
+              inferenceVisitor.engine.forest
+                  .createVariableGet(fileOffset, objectElementVariable),
+              inferenceVisitor);
+
+      // If the sub-pattern transformation doesn't declare captured variables
+      // and consists of a single empty element, it means that it simply
+      // doesn't have a place where it could refer to the element expression.
+      // In that case we can avoid creating the intermediary variable for the
+      // element expression.
+      //
+      // An example of such sub-pattern is in the following:
+      //
+      // if (x case A(foo: var _) { /* ... */ }
+      if (field.declaredVariables.isNotEmpty ||
+          !(subpatternTransformationResult.elements.length == 1 &&
+              subpatternTransformationResult.elements.single.isEmpty)) {
+        elementAccessVariables.add(objectElementVariable);
+        transformationResult = transformationResult.combine(
+            subpatternTransformationResult, inferenceVisitor);
+      }
+    }
+
+    transformationResult = transformationResult.prependElement(
+        new PatternTransformationElement(
+            kind: PatternTransformationElementKind.regular,
+            condition: null,
+            variableInitializers: elementAccessVariables),
+        inferenceVisitor);
+
+    if (typeCheck != null) {
+      transformationResult = transformationResult.prependElement(
+          new PatternTransformationElement(
+              kind: PatternTransformationElementKind.regular,
+              condition: typeCheck,
+              variableInitializers: []),
+          inferenceVisitor);
+    }
+
+    transformationResult = transformationResult.prependElement(
+        new PatternTransformationElement(
+            kind: PatternTransformationElementKind.regular,
+            condition: null,
+            variableInitializers: [objectVariable]),
+        inferenceVisitor);
+
+    return transformationResult;
+  }
+}
+
 enum RelationalPatternKind {
   equals,
   notEquals,

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

@@ -9120,6 +9120,17 @@ class InferenceVisitorImpl extends InferenceVisitorBase
     return const PatternInferenceResult();
   }
 
+  PatternInferenceResult visitObjectPattern(ObjectPattern pattern,
+      {required SharedMatchContext context}) {
+    analyzeObjectPattern(context, pattern,
+        fields: <RecordPatternField<Node, Pattern>>[
+          for (NamedPattern field in pattern.fields)
+            new RecordPatternField(
+                node: field, name: field.name, pattern: field.pattern)
+        ]);
+    return const PatternInferenceResult();
+  }
+
   PatternInferenceResult visitRelationalPattern(
     RelationalPattern pattern, {
     required SharedMatchContext context,
@@ -9208,8 +9219,27 @@ class InferenceVisitorImpl extends InferenceVisitorBase
     required DartType matchedType,
     required Pattern pattern,
   }) {
-    // TODO(scheglov): implement downwardInferObjectPatternRequiredType
-    throw new UnimplementedError('TODO(scheglov)');
+    if (pattern is! ObjectPattern) return const InvalidType();
+    if (pattern.classNode.typeParameters.isEmpty) {
+      return new InterfaceType(pattern.classNode, Nullability.nonNullable, []);
+    }
+    if (pattern.typeArguments != null) {
+      return new InterfaceType(
+          pattern.classNode, Nullability.nonNullable, pattern.typeArguments);
+    }
+
+    DartType typeToInfer =
+        pattern.classNode.getThisType(coreTypes, Nullability.nonNullable);
+    List<TypeParameter> typeParametersToInfer =
+        pattern.classNode.typeParameters;
+    TypeConstraintGatherer gatherer =
+        typeSchemaEnvironment.setupGenericTypeInference(typeToInfer,
+            typeParametersToInfer, matchedType, libraryBuilder.library);
+    List<DartType> inferredTypes = typeSchemaEnvironment.partialInfer(
+        gatherer, typeParametersToInfer, null, libraryBuilder.library);
+    Substitution substitution =
+        Substitution.fromPairs(typeParametersToInfer, inferredTypes);
+    return substitution.substituteType(typeToInfer);
   }
 
   @override
@@ -9223,8 +9253,11 @@ class InferenceVisitorImpl extends InferenceVisitorBase
     required DartType receiverType,
     required shared.RecordPatternField<Node, Pattern> field,
   }) {
-    // TODO(scheglov): implement resolveObjectPatternPropertyGet
-    throw new UnimplementedError('TODO(scheglov)');
+    // TODO(cstefantsova): Provide a better fileOffset.
+    ObjectAccessTarget fieldAccessTarget = findInterfaceMember(
+        receiverType, new Name(field.name!), field.pattern.fileOffset,
+        callSiteAccessKind: CallSiteAccessKind.getterInvocation);
+    return fieldAccessTarget.getGetterType(this);
   }
 
   @override

pkg/front_end/messages.yaml

@@ -6025,3 +6025,12 @@ CantUseClassAsMixin:
   script: |
     class A {}
     class B with A {}
+
+UnspecifiedGetterNameInObjectPattern:
+  problemMessage: "The getter name is not specified explicitly, and the pattern is not a variable. Try specifying the getter name explicitly, or using a variable pattern."
+  experiments: patterns
+  analyzerCode: MISSING_OBJECT_PATTERN_GETTER_NAME
+  script: |
+    abstract class A { int get foo;}
+    test(dynamic x) { if (x case A(: 0)) {} }
+