[cfe] Add desugaring of simple cases of pattern variable declaration

The late variables aren't supported in this CL.

Part of #49749

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

Author: chloestefantsova

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

@@ -8552,10 +8552,16 @@ class BodyBuilder extends StackListenerImpl
     ]));
     Expression initializer = popForValue();
     Pattern pattern = toPattern(pop());
+    bool isFinal = keyword.lexeme == 'final';
+    for (VariableDeclaration variable in pattern.declaredVariables) {
+      variable.isFinal = isFinal;
+      declareVariable(variable, scope);
+      typeInferrer.assignedVariables.declare(variable);
+    }
     // TODO(johnniwinther,cstefantsova): Handle metadata.
     pop(NullValue.Metadata) as List<Expression>?;
     push(new PatternVariableDeclaration(pattern, initializer,
-        offset: keyword.charOffset, isFinal: keyword.lexeme == 'final'));
+        offset: keyword.charOffset, isFinal: isFinal));
   }
 }
 

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

@@ -5126,10 +5126,9 @@ class MapPatternEntry extends TreeNode with InternalTreeNode {
 }
 
 class MapPattern extends Pattern {
-  final DartType? keyType;
-  final DartType? valueType;
+  DartType? keyType;
+  DartType? valueType;
   final List<MapPatternEntry> entries;
-  late final InterfaceType type;
 
   @override
   List<VariableDeclaration> get declaredVariables =>
@@ -5173,13 +5172,18 @@ class MapPattern extends Pattern {
       DartType matchedType,
       Expression variableInitializingContext,
       InferenceVisitorBase inferenceVisitor) {
-    DartType valueType = type.typeArguments[1];
+    DartType keyType = this.keyType ?? const DynamicType();
+    DartType valueType = this.valueType ?? const DynamicType();
+    DartType targetMapType = new InterfaceType(
+        inferenceVisitor.coreTypes.mapClass,
+        Nullability.nonNullable,
+        [keyType, valueType]);
 
     ObjectAccessTarget containsKeyTarget = inferenceVisitor.findInterfaceMember(
-        type, containsKeyName, fileOffset,
+        targetMapType, containsKeyName, fileOffset,
         callSiteAccessKind: CallSiteAccessKind.methodInvocation);
     bool typeCheckForTargetMapNeeded =
-        !inferenceVisitor.isAssignable(type, matchedType) ||
+        !inferenceVisitor.isAssignable(targetMapType, matchedType) ||
             matchedType is DynamicType;
 
     // mapVariable: `matchedType` MVAR = `matchedExpression`
@@ -5198,7 +5202,7 @@ class MapPattern extends Pattern {
           InstanceAccessKind.Instance,
           inferenceVisitor.engine.forest
               .createVariableGet(fileOffset, mapVariable)
-            ..promotedType = typeCheckForTargetMapNeeded ? type : null,
+            ..promotedType = typeCheckForTargetMapNeeded ? targetMapType : null,
           containsKeyName,
           inferenceVisitor.engine.forest
               .createArguments(fileOffset, [keyPattern.expression]),
@@ -5224,7 +5228,7 @@ class MapPattern extends Pattern {
           fileOffset,
           inferenceVisitor.engine.forest
               .createVariableGet(fileOffset, mapVariable),
-          type,
+          targetMapType,
           forNonNullableByDefault: inferenceVisitor.isNonNullableByDefault);
     }
 
@@ -5242,7 +5246,7 @@ class MapPattern extends Pattern {
     }
 
     ObjectAccessTarget valueAccess = inferenceVisitor.findInterfaceMember(
-        type, indexGetName, fileOffset,
+        targetMapType, indexGetName, fileOffset,
         callSiteAccessKind: CallSiteAccessKind.operatorInvocation);
     FunctionType valueAccessFunctionType =
         valueAccess.getFunctionType(inferenceVisitor);
@@ -5263,7 +5267,7 @@ class MapPattern extends Pattern {
           InstanceAccessKind.Instance,
           inferenceVisitor.engine.forest
               .createVariableGet(fileOffset, mapVariable)
-            ..promotedType = typeCheckForTargetMapNeeded ? type : null,
+            ..promotedType = typeCheckForTargetMapNeeded ? targetMapType : null,
           indexGetName,
           inferenceVisitor.engine.forest.createArguments(
               fileOffset, [cloner.clone(keyPattern.expression)]),

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

@@ -5,9 +5,10 @@
 import 'package:_fe_analyzer_shared/src/flow_analysis/flow_analysis.dart';
 import 'package:_fe_analyzer_shared/src/type_inference/type_analysis_result.dart';
 import 'package:_fe_analyzer_shared/src/type_inference/type_analyzer.dart'
-    hide NamedType, RecordType;
+    hide NamedType, RecordType, MapPatternEntry;
 import 'package:_fe_analyzer_shared/src/type_inference/type_analyzer.dart'
     as shared;
+import 'package:_fe_analyzer_shared/src/type_inference/type_operations.dart';
 import 'package:_fe_analyzer_shared/src/util/link.dart';
 import 'package:front_end/src/api_prototype/lowering_predicates.dart';
 import 'package:kernel/ast.dart';
@@ -8263,8 +8264,91 @@ class InferenceVisitorImpl extends InferenceVisitorBase
 
   StatementInferenceResult visitPatternVariableDeclaration(
       PatternVariableDeclaration node) {
-    return new StatementInferenceResult.single(
-        new ExpressionStatement(new InvalidExpression('$node')));
+    // TODO(cstefantsova): Support late variables.
+    analyzePatternVariableDeclarationStatement(
+        node, node.pattern, node.initializer,
+        isFinal: node.isFinal, isLate: false);
+    Expression initializer = node.initializer;
+    // Stack: (Expression initializer)
+    Node? rewrite = popRewrite();
+    if (!identical(initializer, rewrite)) {
+      initializer = rewrite as Expression;
+    }
+
+    // TODO(cstefantsova): Do we need a more precise type for the variable?
+    VariableDeclaration matchedExpressionVariable = engine.forest
+        .createVariableDeclarationForValue(initializer,
+            type: const DynamicType());
+
+    // isPatternMatchingFailed: bool VAR = true;
+    VariableDeclaration isPatternMatchingFailed = engine.forest
+        .createVariableDeclarationForValue(
+            engine.forest.createBoolLiteral(node.fileOffset, true),
+            type: coreTypes.boolNonNullableRawType);
+
+    // patternMatchedSet: `isPatternMatchingFailed` = false;
+    //   ==> VAR = true;
+    Statement patternMatchedSet = engine.forest.createExpressionStatement(
+        node.fileOffset,
+        engine.forest.createVariableSet(
+            node.fileOffset,
+            isPatternMatchingFailed,
+            engine.forest.createBoolLiteral(node.fileOffset, false)));
+
+    PatternTransformationResult transformationResult = node.pattern.transform(
+        engine.forest
+            .createVariableGet(node.fileOffset, matchedExpressionVariable),
+        const DynamicType(),
+        engine.forest
+            .createVariableGet(node.fileOffset, matchedExpressionVariable),
+        this);
+
+    List<VariableDeclaration> declaredVariableHelpers = [];
+    List<Statement> replacementStatements = [];
+    for (VariableDeclaration declaredVariable
+        in node.pattern.declaredVariables) {
+      VariableDeclaration declaredVariableHelper = engine.forest
+          .createVariableDeclaration(node.fileOffset, null,
+              type: const DynamicType());
+      replacementStatements.add(engine.forest.createExpressionStatement(
+          node.fileOffset,
+          engine.forest.createVariableSet(node.fileOffset,
+              declaredVariableHelper, declaredVariable.initializer!)));
+      declaredVariable.initializer = engine.forest
+          .createVariableGet(node.fileOffset, declaredVariableHelper)
+        ..promotedType = declaredVariable.type
+        ..parent = declaredVariable;
+      declaredVariableHelpers.add(declaredVariableHelper);
+    }
+    replacementStatements.add(patternMatchedSet);
+
+    replacementStatements = _transformationResultToStatements(
+        node.fileOffset, transformationResult, replacementStatements);
+
+    replacementStatements = [
+      matchedExpressionVariable,
+      isPatternMatchingFailed,
+      ...declaredVariableHelpers,
+      ...replacementStatements,
+      // TODO(cstefantsova): Figure out the right exception to throw.
+      engine.forest.createIfStatement(
+          node.fileOffset,
+          engine.forest
+              .createVariableGet(node.fileOffset, isPatternMatchingFailed),
+          engine.forest.createExpressionStatement(
+              node.fileOffset,
+              new Throw(
+                  new ConstructorInvocation(
+                      coreTypes.reachabilityErrorConstructor,
+                      engine.forest.createArguments(node.fileOffset, []))
+                    ..fileOffset = node.fileOffset)
+                ..fileOffset = node.fileOffset),
+          null),
+      ...node.pattern.declaredVariables
+    ];
+
+    return new StatementInferenceResult.multiple(
+        node.fileOffset, replacementStatements);
   }
 
   @override
@@ -9151,21 +9235,26 @@ class InferenceVisitorImpl extends InferenceVisitorBase
     MapPattern pattern, {
     required SharedMatchContext context,
   }) {
-    // TODO(cstefantsova): Use [analyzeMapPattern] when it's available.
-    // Until then, an ad-hoc inference is used.
-    DartType keyType = const DynamicType();
-    DartType valueType = const DynamicType();
+    analyzeMapPattern(context, pattern,
+        typeArguments: new MapPatternTypeArguments<DartType>(
+            keyType: pattern.keyType ?? const DynamicType(),
+            valueType: pattern.valueType ?? const DynamicType()),
+        elements: pattern.entries);
     DartType matchedType = flow.getMatchedValueType();
+    for (int i = pattern.entries.length - 1; i >= 0; i--) {
+      Node? rewrite = popRewrite();
+      if (!identical(pattern.entries[i], rewrite)) {
+        pattern.entries[i] = (rewrite as MapPatternEntry)..parent = pattern;
+      }
+    }
     if (matchedType is InterfaceType) {
-      List<DartType>? typeArguments = hierarchyBuilder
+      List<DartType>? mapTypeArguments = hierarchyBuilder
           .getTypeArgumentsAsInstanceOf(matchedType, coreTypes.mapClass);
-      if (typeArguments != null) {
-        keyType = typeArguments[0];
-        valueType = typeArguments[1];
+      if (mapTypeArguments != null && mapTypeArguments.length == 2) {
+        pattern.keyType = mapTypeArguments[0];
+        pattern.valueType = mapTypeArguments[1];
       }
     }
-    pattern.type = new InterfaceType(coreTypes.mapClass,
-        Nullability.nonNullable, <DartType>[keyType, valueType]);
     return const PatternInferenceResult();
   }
 
@@ -9185,12 +9274,14 @@ class InferenceVisitorImpl extends InferenceVisitorBase
       for (Pattern fieldPattern in pattern.patterns)
         new RecordPatternField(
             node: fieldPattern,
-            pattern: fieldPattern,
+            pattern: fieldPattern is NamedPattern
+                ? fieldPattern.pattern
+                : fieldPattern,
             name: fieldPattern is NamedPattern ? fieldPattern.name : null)
     ];
-    DartType patternType =
+    DartType recordType =
         analyzeRecordPattern(context, pattern, fields: fields);
-    pattern.type = patternType as RecordType;
+    pattern.type = recordType as RecordType;
     return const PatternInferenceResult();
   }
 
@@ -9328,20 +9419,30 @@ class InferenceVisitorImpl extends InferenceVisitorBase
   @override
   shared.MapPatternEntry<Expression, Pattern>? getMapPatternEntry(
       Node element) {
-    // TODO(scheglov): implement getMapPatternEntry
-    throw new UnimplementedError('TODO(scheglov)');
+    element as MapPatternEntry;
+    return new shared.MapPatternEntry<Expression, Pattern>(
+        key: (element.key as ExpressionPattern).expression,
+        value: element.value);
   }
 
   @override
   void handleMapPatternEntry(Pattern container, Node entryElement) {
-    // TODO(scheglov): implement handleMapPatternEntry
-    throw new UnimplementedError('TODO(scheglov)');
+    entryElement as MapPatternEntry;
+    ExpressionPattern pattern = entryElement.key as ExpressionPattern;
+    Node? key = popRewrite();
+    if (!identical(pattern.expression, key)) {
+      entryElement = new MapPatternEntry(
+          new ExpressionPattern(key as Expression),
+          entryElement.value,
+          entryElement.fileOffset);
+    }
+    pushRewrite(entryElement);
   }
 
   @override
   DartType mapType({required DartType keyType, required DartType valueType}) {
-    // TODO(scheglov): implement mapType
-    throw new UnimplementedError('TODO(scheglov)');
+    return new InterfaceType(coreTypes.mapClass, Nullability.nonNullable,
+        <DartType>[keyType, valueType]);
   }
 
   @override

pkg/front_end/test/spell_checking_list_tests.txt

@@ -467,6 +467,7 @@ offers
 oh
 okay
 ol
+onefour
 onull
 oo
 oobar

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

@@ -26,7 +26,7 @@ static method test(dynamic x) → dynamic {
       #L2:
       case #C1:
         {
-          dynamic n = #t1{dynamic};
+          core::int n = #t1{core::int};
           {
             break #L1;
           }

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

@@ -26,7 +26,7 @@ static method test(dynamic x) → dynamic {
       #L2:
       case #C1:
         {
-          dynamic n = #t1{dynamic};
+          core::int n = #t1{core::int};
           {
             break #L1;
           }

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

@@ -26,7 +26,7 @@ static method test(dynamic x) → dynamic {
       #L2:
       case #C1:
         {
-          dynamic n = #t1{dynamic};
+          core::int n = #t1{core::int};
           {
             break #L1;
           }

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

@@ -26,7 +26,7 @@ static method test(dynamic x) → dynamic {
       #L2:
       case #C1:
         {
-          dynamic n = #t1{dynamic};
+          core::int n = #t1{core::int};
           {
             break #L1;
           }

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

@@ -26,7 +26,7 @@ static method test(dynamic x) → dynamic {
       #L2:
       case #C1:
         {
-          dynamic n = #t1{dynamic};
+          core::int n = #t1{core::int};
           {
             break #L1;
           }

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

@@ -10,10 +10,10 @@ static method test(dynamic x) → dynamic {
     final core::bool #t3 = false;
     if(!#t3) {
       final dynamic #t4 = #t1;
-      if(#t4 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#t4{core::Map<dynamic, dynamic>}.{core::Map::containsKey}("a"){(core::Object?) → core::bool} && #t4{core::Map<dynamic, dynamic>}.{core::Map::containsKey}("b"){(core::Object?) → core::bool})) {
-        final dynamic #t5 = #t4{core::Map<dynamic, dynamic>}.{core::Map::[]}("a"){(core::Object?) → dynamic};
-        final dynamic #t6 = #t4{core::Map<dynamic, dynamic>}.{core::Map::[]}("b"){(core::Object?) → dynamic};
-        if(#t5 =={core::Object::==}{(core::Object) → core::bool} 1 && #t6 =={core::Object::==}{(core::Object) → core::bool} 2) {
+      if(#t4 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#t4{core::Map<core::String, core::int>}.{core::Map::containsKey}("a"){(core::Object?) → core::bool} && #t4{core::Map<core::String, core::int>}.{core::Map::containsKey}("b"){(core::Object?) → core::bool})) {
+        final core::int #t5 = #t4{core::Map<core::String, core::int>}.{core::Map::[]}("a"){(core::Object?) → core::int?};
+        final core::int #t6 = #t4{core::Map<core::String, core::int>}.{core::Map::[]}("b"){(core::Object?) → core::int?};
+        if(#t5 =={core::num::==}{(core::Object) → core::bool} 1 && #t6 =={core::num::==}{(core::Object) → core::bool} 2) {
           #t2 = 0;
           #t3 = true;
         }

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

@@ -10,10 +10,10 @@ static method test(dynamic x) → dynamic {
     final core::bool #t3 = false;
     if(!#t3) {
       final dynamic #t4 = #t1;
-      if(#t4 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#t4{core::Map<dynamic, dynamic>}.{core::Map::containsKey}("a"){(core::Object?) → core::bool} && #t4{core::Map<dynamic, dynamic>}.{core::Map::containsKey}("b"){(core::Object?) → core::bool})) {
-        final dynamic #t5 = #t4{core::Map<dynamic, dynamic>}.{core::Map::[]}("a"){(core::Object?) → dynamic};
-        final dynamic #t6 = #t4{core::Map<dynamic, dynamic>}.{core::Map::[]}("b"){(core::Object?) → dynamic};
-        if(#t5 =={core::Object::==}{(core::Object) → core::bool} 1 && #t6 =={core::Object::==}{(core::Object) → core::bool} 2) {
+      if(#t4 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#t4{core::Map<core::String, core::int>}.{core::Map::containsKey}("a"){(core::Object?) → core::bool} && #t4{core::Map<core::String, core::int>}.{core::Map::containsKey}("b"){(core::Object?) → core::bool})) {
+        final core::int #t5 = #t4{core::Map<core::String, core::int>}.{core::Map::[]}("a"){(core::Object?) → core::int?};
+        final core::int #t6 = #t4{core::Map<core::String, core::int>}.{core::Map::[]}("b"){(core::Object?) → core::int?};
+        if(#t5 =={core::num::==}{(core::Object) → core::bool} 1 && #t6 =={core::num::==}{(core::Object) → core::bool} 2) {
           #t2 = 0;
           #t3 = true;
         }

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

@@ -10,10 +10,10 @@ static method test(dynamic x) → dynamic {
     final core::bool #t3 = false;
     if(!#t3) {
       final dynamic #t4 = #t1;
-      if(#t4 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#t4{core::Map<dynamic, dynamic>}.{core::Map::containsKey}("a"){(core::Object?) → core::bool} && #t4{core::Map<dynamic, dynamic>}.{core::Map::containsKey}("b"){(core::Object?) → core::bool})) {
-        final dynamic #t5 = #t4{core::Map<dynamic, dynamic>}.{core::Map::[]}("a"){(core::Object?) → dynamic};
-        final dynamic #t6 = #t4{core::Map<dynamic, dynamic>}.{core::Map::[]}("b"){(core::Object?) → dynamic};
-        if(#t5 =={core::Object::==}{(core::Object) → core::bool} 1 && #t6 =={core::Object::==}{(core::Object) → core::bool} 2) {
+      if(#t4 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#t4{core::Map<core::String, core::int>}.{core::Map::containsKey}("a"){(core::Object?) → core::bool} && #t4{core::Map<core::String, core::int>}.{core::Map::containsKey}("b"){(core::Object?) → core::bool})) {
+        final core::int #t5 = #t4{core::Map<core::String, core::int>}.{core::Map::[]}("a"){(core::Object?) → core::int?};
+        final core::int #t6 = #t4{core::Map<core::String, core::int>}.{core::Map::[]}("b"){(core::Object?) → core::int?};
+        if(#t5 =={core::num::==}{(core::Object) → core::bool} 1 && #t6 =={core::num::==}{(core::Object) → core::bool} 2) {
           #t2 = 0;
           #t3 = true;
         }

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

@@ -10,10 +10,10 @@ static method test(dynamic x) → dynamic {
     final core::bool #t3 = false;
     if(!#t3) {
       final dynamic #t4 = #t1;
-      if(#t4 is{ForNonNullableByDefault} core::Map<dynamic, dynamic> && (#t4{core::Map<dynamic, dynamic>}.{core::Map::containsKey}("a"){(core::Object?) → core::bool} && #t4{core::Map<dynamic, dynamic>}.{core::Map::containsKey}("b"){(core::Object?) → core::bool})) {
-        final dynamic #t5 = #t4{core::Map<dynamic, dynamic>}.{core::Map::[]}("a"){(core::Object?) → dynamic};
-        final dynamic #t6 = #t4{core::Map<dynamic, dynamic>}.{core::Map::[]}("b"){(core::Object?) → dynamic};
-        if(#t5 =={core::Object::==}{(core::Object) → core::bool} 1 && #t6 =={core::Object::==}{(core::Object) → core::bool} 2) {
+      if(#t4 is{ForNonNullableByDefault} core::Map<core::String, core::int> && (#t4{core::Map<core::String, core::int>}.{core::Map::containsKey}("a"){(core::Object?) → core::bool} && #t4{core::Map<core::String, core::int>}.{core::Map::containsKey}("b"){(core::Object?) → core::bool})) {
+        final core::int #t5 = #t4{core::Map<core::String, core::int>}.{core::Map::[]}("a"){(core::Object?) → core::int?};
+        final core::int #t6 = #t4{core::Map<core::String, core::int>}.{core::Map::[]}("b"){(core::Object?) → core::int?};
+        if(#t5 =={core::num::==}{(core::Object) → core::bool} 1 && #t6 =={core::num::==}{(core::Object) → core::bool} 2) {
           #t2 = 0;
           #t3 = true;
         }