[cfe] Support final joint variables in switch statements

Part of #49749

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

Author: chloestefantsova

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart

@@ -203,8 +203,11 @@ class SwitchStatementMemberInfo<Node extends Object, Statement extends Node,
   /// might become not consistent.
   final Map<String, Variable> variables;
 
-  SwitchStatementMemberInfo(this.heads, this.body, this.variables,
-      {required this.hasLabels});
+  SwitchStatementMemberInfo(
+      {required this.heads,
+      required this.body,
+      required this.variables,
+      required this.hasLabels});
 }
 
 /// Type analysis logic to be shared between the analyzer and front end.  The

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -3669,7 +3669,7 @@ class _MiniAstTypeAnalyzer
           covariant _SwitchStatement node, int caseIndex) {
     _SwitchStatementMember case_ = node.cases[caseIndex];
     return SwitchStatementMemberInfo(
-      [
+      heads: [
         for (var element in case_.elements)
           if (element is _SwitchHeadCase)
             CaseHeadOrDefaultInfo(
@@ -3684,8 +3684,8 @@ class _MiniAstTypeAnalyzer
               guard: null,
             )
       ],
-      case_._body.statements,
-      case_._candidateVariables,
+      body: case_._body.statements,
+      variables: case_._candidateVariables,
       hasLabels: case_.hasLabels,
     );
   }

pkg/analyzer/lib/src/generated/resolver.dart

@@ -1017,9 +1017,9 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
 
     var group = node.memberGroups[index];
     return SwitchStatementMemberInfo(
-      group.members.map(ofMember).toList(),
-      group.statements,
-      group.variables,
+      heads: group.members.map(ofMember).toList(),
+      body: group.statements,
+      variables: group.variables,
       hasLabels: group.hasLabels,
     );
   }

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

@@ -9822,7 +9822,7 @@ class InferenceVisitorImpl extends InferenceVisitorBase
           covariant SwitchStatement node, int caseIndex) {
     SwitchCase case_ = node.cases[caseIndex];
     if (case_ is SwitchCaseImpl) {
-      return new SwitchStatementMemberInfo([
+      return new SwitchStatementMemberInfo(heads: [
         for (Expression expression in case_.expressions)
           new CaseHeadOrDefaultInfo(
             pattern: expression,
@@ -9833,12 +9833,12 @@ class InferenceVisitorImpl extends InferenceVisitorBase
             pattern: null,
             variables: {},
           )
-      ], [
+      ], body: [
         case_.body
-      ], {}, hasLabels: case_.hasLabel);
+      ], variables: {}, hasLabels: case_.hasLabel);
     } else {
       case_ as PatternSwitchCase;
-      return new SwitchStatementMemberInfo([
+      return new SwitchStatementMemberInfo(heads: [
         for (PatternGuard patternGuard in case_.patternGuards)
           new CaseHeadOrDefaultInfo(
             pattern: patternGuard.pattern,
@@ -9854,9 +9854,12 @@ class InferenceVisitorImpl extends InferenceVisitorBase
             pattern: null,
             variables: {},
           )
-      ], [
+      ], body: [
         case_.body
-      ], {}, hasLabels: case_.hasLabel);
+      ], variables: {
+        for (VariableDeclaration jointVariable in case_.jointVariables)
+          jointVariable.name!: jointVariable
+      }, hasLabels: case_.hasLabel);
     }
   }
 

pkg/front_end/testcases/patterns/final_joint_variables.dart

@@ -0,0 +1,29 @@
+// 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.
+
+test(dynamic x) {
+  switch (x) {
+    case [final int a]:
+    case final int a:
+      return a;
+    case [final String a] || final String a:
+      return a;
+    default:
+      return null;
+  }
+}
+
+main() {
+  expectEquals(test(0), 0);
+  expectEquals(test([0]), 0);
+  expectEquals(test("foo"), "foo");
+  expectEquals(test(["foo"]), "foo");
+  expectEquals(test(3.14), null);
+}
+
+expectEquals(x, y) {
+  if (x != y) {
+    throw "Expected '${x}' to be equal to '${x}'.";
+  }
+}

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

@@ -0,0 +1,49 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  #L1:
+  {
+    final core::int a;
+    final core::int a#1;
+    final core::String a#2;
+    final dynamic #0#0 = x;
+    late final core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
+    late final dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t1;
+    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a#1 = #0#0{core::int} in true) && (let final dynamic #t5 = #t1 = a#1 in true)) {
+      final core::int a = #t1{core::int};
+      {
+        return a;
+      }
+    }
+    else
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = a#2 = #0#0{core::String} in true)) {
+        {
+          return a#2;
+        }
+      }
+      else {
+        {
+          return null;
+        }
+      }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(0), 0);
+  self::expectEquals(self::test(<core::int>[0]), 0);
+  self::expectEquals(self::test("foo"), "foo");
+  self::expectEquals(self::test(<core::String>["foo"]), "foo");
+  self::expectEquals(self::test(3.14), 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 '${x}'.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}

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

@@ -0,0 +1,53 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  #L1:
+  {
+    final core::int a;
+    final core::int a#1;
+    final core::String a#2;
+    final dynamic #0#0 = x;
+    function ##0#4#initializer() → core::bool
+      return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
+    late final core::bool #0#4 = ##0#4#initializer(){() → core::bool};
+    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};
+    dynamic #t1;
+    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#6{core::int} in true)) && (let final core::int #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a#1 = #0#0{core::int} in true) && (let final core::int #t5 = #t1 = a#1 in true)) {
+      final core::int a = #t1{core::int};
+      {
+        return a;
+      }
+    }
+    else
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = a#2 = #0#0{core::String} in true)) {
+        {
+          return a#2;
+        }
+      }
+      else {
+        {
+          return null;
+        }
+      }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(0), 0);
+  self::expectEquals(self::test(core::_GrowableList::_literal1<core::int>(0)), 0);
+  self::expectEquals(self::test("foo"), "foo");
+  self::expectEquals(self::test(core::_GrowableList::_literal1<core::String>("foo")), "foo");
+  self::expectEquals(self::test(3.14), 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 '${x}'.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}

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

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

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

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

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

@@ -0,0 +1,49 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  #L1:
+  {
+    final core::int a;
+    final core::int a#1;
+    final core::String a#2;
+    final dynamic #0#0 = x;
+    late final core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
+    late final dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t1;
+    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a#1 = #0#0{core::int} in true) && (let final dynamic #t5 = #t1 = a#1 in true)) {
+      final core::int a = #t1{core::int};
+      {
+        return a;
+      }
+    }
+    else
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = a#2 = #0#0{core::String} in true)) {
+        {
+          return a#2;
+        }
+      }
+      else {
+        {
+          return null;
+        }
+      }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(0), 0);
+  self::expectEquals(self::test(<core::int>[0]), 0);
+  self::expectEquals(self::test("foo"), "foo");
+  self::expectEquals(self::test(<core::String>["foo"]), "foo");
+  self::expectEquals(self::test(3.14), 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 '${x}'.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}

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

@@ -0,0 +1,49 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  #L1:
+  {
+    final core::int a;
+    final core::int a#1;
+    final core::String a#2;
+    final dynamic #0#0 = x;
+    late final core::bool #0#4 = #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
+    late final dynamic #0#6 = #0#0{core::List<dynamic>}.{core::List::[]}(0){(core::int) → dynamic};
+    dynamic #t1;
+    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final dynamic #t2 = a = #0#6{core::int} in true)) && (let final dynamic #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final dynamic #t4 = a#1 = #0#0{core::int} in true) && (let final dynamic #t5 = #t1 = a#1 in true)) {
+      final core::int a = #t1{core::int};
+      {
+        return a;
+      }
+    }
+    else
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final dynamic #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final dynamic #t7 = a#2 = #0#0{core::String} in true)) {
+        {
+          return a#2;
+        }
+      }
+      else {
+        {
+          return null;
+        }
+      }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(0), 0);
+  self::expectEquals(self::test(<core::int>[0]), 0);
+  self::expectEquals(self::test("foo"), "foo");
+  self::expectEquals(self::test(<core::String>["foo"]), "foo");
+  self::expectEquals(self::test(3.14), 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 '${x}'.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}

pkg/front_end/testcases/patterns/final_joint_variables.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/final_joint_variables.dart.weak.transformed.expect

@@ -0,0 +1,53 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+static method test(dynamic x) → dynamic {
+  #L1:
+  {
+    final core::int a;
+    final core::int a#1;
+    final core::String a#2;
+    final dynamic #0#0 = x;
+    function ##0#4#initializer() → core::bool
+      return #0#0{core::List<dynamic>}.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C1;
+    late final core::bool #0#4 = ##0#4#initializer(){() → core::bool};
+    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};
+    dynamic #t1;
+    if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::int && (let final core::int #t2 = a = #0#6{core::int} in true)) && (let final core::int #t3 = #t1 = a in true) || #0#0 is{ForNonNullableByDefault} core::int && (let final core::int #t4 = a#1 = #0#0{core::int} in true) && (let final core::int #t5 = #t1 = a#1 in true)) {
+      final core::int a = #t1{core::int};
+      {
+        return a;
+      }
+    }
+    else
+      if(#0#0 is{ForNonNullableByDefault} core::List<dynamic> && #0#4 && (#0#6 is{ForNonNullableByDefault} core::String && (let final core::String #t6 = a#2 = #0#6{core::String} in true)) || #0#0 is{ForNonNullableByDefault} core::String && (let final core::String #t7 = a#2 = #0#0{core::String} in true)) {
+        {
+          return a#2;
+        }
+      }
+      else {
+        {
+          return null;
+        }
+      }
+  }
+}
+static method main() → dynamic {
+  self::expectEquals(self::test(0), 0);
+  self::expectEquals(self::test(core::_GrowableList::_literal1<core::int>(0)), 0);
+  self::expectEquals(self::test("foo"), "foo");
+  self::expectEquals(self::test(core::_GrowableList::_literal1<core::String>("foo")), "foo");
+  self::expectEquals(self::test(3.14), 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 '${x}'.";
+  }
+}
+
+constants  {
+  #C1 = 1
+}