[cfe] Add basic support for pattern-for statements

Part of #49749

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

Author: chloestefantsova

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

@@ -4010,6 +4010,8 @@ class BodyBuilder extends StackListenerImpl
         variables.addAll(_buildForLoopVariableDeclarations(v)!);
       }
       return variables;
+    } else if (variableOrExpression is PatternVariableDeclaration) {
+      return <VariableDeclaration>[];
     } else if (variableOrExpression == null) {
       return <VariableDeclaration>[];
     }
@@ -4052,6 +4054,42 @@ class BodyBuilder extends StackListenerImpl
     }
   }
 
+  @override
+  void handleForInitializerPatternVariableAssignment(
+      Token keyword, Token equals) {
+    debugEvent("handleForInitializerPatternVariableAssignment");
+    assert(checkState(keyword, [
+      unionOfKinds([
+        ValueKinds.Expression,
+        ValueKinds.Generator,
+        ValueKinds.ProblemBuilder,
+      ]),
+      unionOfKinds([
+        ValueKinds.Expression,
+        ValueKinds.Generator,
+        ValueKinds.ProblemBuilder,
+        ValueKinds.Pattern,
+      ]),
+    ]));
+
+    Object expression = pop() as Object;
+    Object pattern = pop() as Object;
+
+    if (pattern is Pattern) {
+      pop(); // Metadata.
+      for (VariableDeclaration variable in pattern.declaredVariables) {
+        declareVariable(variable, scope);
+        typeInferrer.assignedVariables.declare(variable);
+      }
+      push(new PatternVariableDeclaration(pattern, toValue(expression),
+          fileOffset: offsetForToken(keyword),
+          isFinal: keyword.lexeme == "final"));
+    }
+
+    // This is matched by the call to [deferNode] in [endForStatement].
+    typeInferrer.assignedVariables.beginNode();
+  }
+
   @override
   void handleForLoopParts(Token forKeyword, Token leftParen,
       Token leftSeparator, int updateExpressionCount) {
@@ -4153,6 +4191,7 @@ class BodyBuilder extends StackListenerImpl
     Statement conditionStatement = popStatement();
     // This is matched by the call to [beginNode] in
     // [handleForInitializerEmptyStatement],
+    // [handleForInitializerPatternVariableAssignment],
     // [handleForInitializerExpressionStatement], and
     // [handleForInitializerLocalVariableDeclaration].
     AssignedVariablesNodeInfo assignedVariablesNodeInfo =
@@ -4192,6 +4231,10 @@ class BodyBuilder extends StackListenerImpl
       breakTarget.resolveBreaks(forest, labeledStatement, forStatement);
       result = labeledStatement;
     }
+    if (variableOrExpression is PatternVariableDeclaration) {
+      result = forest.createBlock(result.fileOffset, result.fileOffset,
+          <Statement>[variableOrExpression, result]);
+    }
     if (variableOrExpression is ParserRecovery) {
       problemInLoopOrSwitch ??= buildProblemStatement(
           fasta.messageSyntheticToken, variableOrExpression.charOffset,

pkg/front_end/testcases/patterns/simple_pattern_for_statements.dart

@@ -0,0 +1,31 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+test1(dynamic x) {
+  for (var [int i] = x; true;) {
+    return i;
+  }
+}
+
+main() {
+  expectEquals(test1([0]), 0);
+  expectThrows(() => test1([]));
+}
+
+expectEquals(x, y) {
+  if (x != y) {
+    throw "Expected '${x}' to be equal to '${y}'.";
+  }
+}
+
+expectThrows(void Function() f) {
+  bool hasThrown = true;
+  try {
+    f();
+    hasThrown = false;
+  } catch (e) {}
+  if (!hasThrown) {
+    throw "Expected function to throw.";
+  }
+}

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

@@ -0,0 +1,44 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+static method test1(dynamic x) → dynamic {
+  {
+    core::int i;
+    {
+      final dynamic #0#0 = x;
+      late final dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+      if(!(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = i = #0#6{core::int} in true))))
+        throw new _in::ReachabilityError::•();
+    }
+    for (; true; ) {
+      return i;
+    }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test1(<core::int>[0]), 0);
+  self::expectThrows(() → void => self::test1(<dynamic>[]));
+}
+static method expectEquals(dynamic x, dynamic y) → dynamic {
+  if(!(x =={core::Object::==}{(core::Object) → core::bool} y)) {
+    throw "Expected '${x}' to be equal to '${y}'.";
+  }
+}
+static method expectThrows(() → void f) → dynamic {
+  core::bool hasThrown = true;
+  try {
+    f(){() → void};
+    hasThrown = false;
+  }
+  on core::Object catch(final core::Object e) {
+  }
+  if(!hasThrown) {
+    throw "Expected function to throw.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}

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

@@ -0,0 +1,46 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+static method test1(dynamic x) → dynamic {
+  {
+    core::int i;
+    {
+      final dynamic #0#0 = x;
+      function ##0#6#initializer() → dynamic
+        return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+      late final dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+      if(!(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = i = #0#6{core::int} in true))))
+        throw new _in::ReachabilityError::•();
+    }
+    for (; true; ) {
+      return i;
+    }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test1(core::_GrowableList::_literal1<core::int>(0)), 0);
+  self::expectThrows(() → void => self::test1(core::_GrowableList::•<dynamic>(0)));
+}
+static method expectEquals(dynamic x, dynamic y) → dynamic {
+  if(!(x =={core::Object::==}{(core::Object) → core::bool} y)) {
+    throw "Expected '${x}' to be equal to '${y}'.";
+  }
+}
+static method expectThrows(() → void f) → dynamic {
+  core::bool hasThrown = true;
+  try {
+    f(){() → void};
+    hasThrown = false;
+  }
+  on core::Object catch(final core::Object e) {
+  }
+  if(!hasThrown) {
+    throw "Expected function to throw.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}

pkg/front_end/testcases/patterns/simple_pattern_for_statements.dart.textual_outline.expect

@@ -0,0 +1,4 @@
+test1(dynamic x) {}
+main() {}
+expectEquals(x, y) {}
+expectThrows(void Function() f) {}

pkg/front_end/testcases/patterns/simple_pattern_for_statements.dart.textual_outline_modelled.expect

@@ -0,0 +1,4 @@
+expectEquals(x, y) {}
+expectThrows(void Function() f) {}
+main() {}
+test1(dynamic x) {}

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

@@ -0,0 +1,44 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+static method test1(dynamic x) → dynamic {
+  {
+    core::int i;
+    {
+      final dynamic #0#0 = x;
+      late final dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+      if(!(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = i = #0#6{core::int} in true))))
+        throw new _in::ReachabilityError::•();
+    }
+    for (; true; ) {
+      return i;
+    }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test1(<core::int>[0]), 0);
+  self::expectThrows(() → void => self::test1(<dynamic>[]));
+}
+static method expectEquals(dynamic x, dynamic y) → dynamic {
+  if(!(x =={core::Object::==}{(core::Object) → core::bool} y)) {
+    throw "Expected '${x}' to be equal to '${y}'.";
+  }
+}
+static method expectThrows(() → void f) → dynamic {
+  core::bool hasThrown = true;
+  try {
+    f(){() → void};
+    hasThrown = false;
+  }
+  on core::Object catch(final core::Object e) {
+  }
+  if(!hasThrown) {
+    throw "Expected function to throw.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}

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

@@ -0,0 +1,44 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+static method test1(dynamic x) → dynamic {
+  {
+    core::int i;
+    {
+      final dynamic #0#0 = x;
+      late final dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+      if(!(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t1 = i = #0#6{core::int} in true))))
+        throw new _in::ReachabilityError::•();
+    }
+    for (; true; ) {
+      return i;
+    }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test1(<core::int>[0]), 0);
+  self::expectThrows(() → void => self::test1(<dynamic>[]));
+}
+static method expectEquals(dynamic x, dynamic y) → dynamic {
+  if(!(x =={core::Object::==}{(core::Object) → core::bool} y)) {
+    throw "Expected '${x}' to be equal to '${y}'.";
+  }
+}
+static method expectThrows(() → void f) → dynamic {
+  core::bool hasThrown = true;
+  try {
+    f(){() → void};
+    hasThrown = false;
+  }
+  on core::Object catch(final core::Object e) {
+  }
+  if(!hasThrown) {
+    throw "Expected function to throw.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}

pkg/front_end/testcases/patterns/simple_pattern_for_statements.dart.weak.outline.expect

@@ -0,0 +1,11 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+
+static method test1(dynamic x) → dynamic
+  ;
+static method main() → dynamic
+  ;
+static method expectEquals(dynamic x, dynamic y) → dynamic
+  ;
+static method expectThrows(() → void f) → dynamic
+  ;

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

@@ -0,0 +1,46 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+static method test1(dynamic x) → dynamic {
+  {
+    core::int i;
+    {
+      final dynamic #0#0 = x;
+      function ##0#6#initializer() → dynamic
+        return #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+      late final dynamic #0#6 = ##0#6#initializer(){() → dynamic};
+      if(!(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t1 = i = #0#6{core::int} in true))))
+        throw new _in::ReachabilityError::•();
+    }
+    for (; true; ) {
+      return i;
+    }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test1(core::_GrowableList::_literal1<core::int>(0)), 0);
+  self::expectThrows(() → void => self::test1(core::_GrowableList::•<dynamic>(0)));
+}
+static method expectEquals(dynamic x, dynamic y) → dynamic {
+  if(!(x =={core::Object::==}{(core::Object) → core::bool} y)) {
+    throw "Expected '${x}' to be equal to '${y}'.";
+  }
+}
+static method expectThrows(() → void f) → dynamic {
+  core::bool hasThrown = true;
+  try {
+    f(){() → void};
+    hasThrown = false;
+  }
+  on core::Object catch(final core::Object e) {
+  }
+  if(!hasThrown) {
+    throw "Expected function to throw.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}