[cfe] Declare captured variables in patterns in the flow analysis

Part of #49749

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

Author: chloestefantsova

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

@@ -3465,6 +3465,7 @@ class BodyBuilder extends StackListenerImpl
     if (pattern != null) {
       for (VariableDeclaration variable in pattern.declaredVariables) {
         declareVariable(variable, scope);
+        typeInferrer.assignedVariables.declare(variable);
       }
     }
   }

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

@@ -1761,6 +1761,9 @@ class InferenceVisitorImpl extends InferenceVisitorBase
         this);
 
     flowAnalysis.ifStatement_thenBegin(condition, node);
+    for (VariableDeclaration variable in node.pattern.declaredVariables) {
+      flowAnalysis.declare(variable, true);
+    }
     StatementInferenceResult thenResult = inferStatement(node.then);
     Statement then;
     if (thenResult.hasChanged) {

pkg/front_end/testcases/patterns/simple_runtime_test.dart

@@ -0,0 +1,24 @@
+// Copyright (c) 2022, 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.
+
+test(dynamic x) {
+  if (x case [String y]) {
+    return y;
+  } else {
+    return null;
+  }
+}
+
+main() {
+  expectEquals(test(["one", "two", "three"]), "one");
+  expectEquals(test([1, 2, 3]), null);
+  expectEquals(test([true, false]), null);
+  expectEquals(test([]), null);
+}
+
+expectEquals(x, y) {
+  if (x != y) {
+    throw "Expected $x to be equal to $y.";
+  }
+}

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

@@ -0,0 +1,28 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  final dynamic #t1 = x;
+  if(#t1 is core::List<dynamic> && #t1{core::List<dynamic>}.{core::List::length}{core::int}.{core::num::>=}(1){(core::num) → core::bool} && (let final dynamic #t2 = #t1{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in #t2 is core::String)) {
+    final core::List<dynamic> #t3 = #t1 as{ForDynamic} core::List<dynamic>;
+    core::String y = #t3.{core::List::[]}(0){(core::int) → dynamic} as{ForDynamic,ForNonNullableByDefault} core::String;
+    {
+      return y;
+    }
+  }
+  else {
+    return null;
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(<core::String>["one", "two", "three"]), "one");
+  self::expectEquals(self::test(<core::int>[1, 2, 3]), null);
+  self::expectEquals(self::test(<core::bool>[true, false]), null);
+  self::expectEquals(self::test(<dynamic>[]), null);
+}
+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}.";
+  }
+}

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

@@ -0,0 +1,28 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  final dynamic #t1 = x;
+  if(#t1 is core::List<dynamic> && #t1{core::List<dynamic>}.{core::List::length}{core::int}.{core::num::>=}(1){(core::num) → core::bool} && (let final dynamic #t2 = #t1{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in #t2 is core::String)) {
+    final core::List<dynamic> #t3 = #t1 as{ForDynamic} core::List<dynamic>;
+    core::String y = #t3.{core::List::[]}(0){(core::int) → dynamic} as{ForDynamic,ForNonNullableByDefault} core::String;
+    {
+      return y;
+    }
+  }
+  else {
+    return null;
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(core::_GrowableList::_literal3<core::String>("one", "two", "three")), "one");
+  self::expectEquals(self::test(core::_GrowableList::_literal3<core::int>(1, 2, 3)), null);
+  self::expectEquals(self::test(core::_GrowableList::_literal2<core::bool>(true, false)), null);
+  self::expectEquals(self::test(core::_GrowableList::•<dynamic>(0)), null);
+}
+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}.";
+  }
+}

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

@@ -0,0 +1,3 @@
+test(dynamic x) {}
+main() {}
+expectEquals(x, y) {}

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

@@ -0,0 +1,3 @@
+expectEquals(x, y) {}
+main() {}
+test(dynamic x) {}

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

@@ -0,0 +1,28 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  final dynamic #t1 = x;
+  if(#t1 is core::List<dynamic> && #t1{core::List<dynamic>}.{core::List::length}{core::int}.{core::num::>=}(1){(core::num) → core::bool} && (let final dynamic #t2 = #t1{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in #t2 is core::String)) {
+    final core::List<dynamic> #t3 = #t1 as{ForDynamic} core::List<dynamic>;
+    core::String y = #t3.{core::List::[]}(0){(core::int) → dynamic} as{ForDynamic,ForNonNullableByDefault} core::String;
+    {
+      return y;
+    }
+  }
+  else {
+    return null;
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(<core::String>["one", "two", "three"]), "one");
+  self::expectEquals(self::test(<core::int>[1, 2, 3]), null);
+  self::expectEquals(self::test(<core::bool>[true, false]), null);
+  self::expectEquals(self::test(<dynamic>[]), null);
+}
+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}.";
+  }
+}

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

@@ -0,0 +1,28 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  final dynamic #t1 = x;
+  if(#t1 is core::List<dynamic> && #t1{core::List<dynamic>}.{core::List::length}{core::int}.{core::num::>=}(1){(core::num) → core::bool} && (let final dynamic #t2 = #t1{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in #t2 is core::String)) {
+    final core::List<dynamic> #t3 = #t1 as{ForDynamic} core::List<dynamic>;
+    core::String y = #t3.{core::List::[]}(0){(core::int) → dynamic} as{ForDynamic,ForNonNullableByDefault} core::String;
+    {
+      return y;
+    }
+  }
+  else {
+    return null;
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(<core::String>["one", "two", "three"]), "one");
+  self::expectEquals(self::test(<core::int>[1, 2, 3]), null);
+  self::expectEquals(self::test(<core::bool>[true, false]), null);
+  self::expectEquals(self::test(<dynamic>[]), null);
+}
+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}.";
+  }
+}

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

@@ -0,0 +1,9 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+
+static method test(dynamic x) → dynamic
+  ;
+static method main() → dynamic
+  ;
+static method expectEquals(dynamic x, dynamic y) → dynamic
+  ;

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

@@ -0,0 +1,28 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  final dynamic #t1 = x;
+  if(#t1 is core::List<dynamic> && #t1{core::List<dynamic>}.{core::List::length}{core::int}.{core::num::>=}(1){(core::num) → core::bool} && (let final dynamic #t2 = #t1{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic} in #t2 is core::String)) {
+    final core::List<dynamic> #t3 = #t1 as{ForDynamic} core::List<dynamic>;
+    core::String y = #t3.{core::List::[]}(0){(core::int) → dynamic} as{ForDynamic,ForNonNullableByDefault} core::String;
+    {
+      return y;
+    }
+  }
+  else {
+    return null;
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(core::_GrowableList::_literal3<core::String>("one", "two", "three")), "one");
+  self::expectEquals(self::test(core::_GrowableList::_literal3<core::int>(1, 2, 3)), null);
+  self::expectEquals(self::test(core::_GrowableList::_literal2<core::bool>(true, false)), null);
+  self::expectEquals(self::test(core::_GrowableList::•<dynamic>(0)), null);
+}
+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}.";
+  }
+}