SONARPY-917: Supporting GROUP PATTERN in match statements (#1099)

GitOrigin-RevId: 16520e9871862f13084ca25968708ef92cfdb1bc

Author: joke1196

python-checks/src/test/resources/checks/consistentReturn.py

@@ -152,6 +152,45 @@ def match_irrefutable_in_middle(x):
     case 1:
       pass
 
+def match_group_capture_is_irrefutable(x):
+  match x:
+    case 0:
+      return x
+    case (y):
+      return y
+
+
+def match_group_wildcard_is_irrefutable(x):
+  match x:
+    case 0:
+      return x
+    case (_):
+      return 42
+
+
+def match_nested_group_is_irrefutable(x):
+  match x:
+    case 0:
+      return x
+    case ((y)):
+      return y
+
+
+def match_guarded_group_is_refutable(x): # Noncompliant
+  match x:
+    case 0:
+      return x
+    case (y) if x > 0:
+      return y
+
+
+def match_group_literal_is_refutable(x): # Noncompliant
+  match x:
+    case 0:
+      return x
+    case (42):
+      return 42
+
 # raise / assert
 
 def return_value_or_raise(x):

python-frontend/src/main/java/org/sonar/python/cfg/ControlFlowGraphBuilder.java

@@ -42,6 +42,7 @@
 import org.sonar.plugins.python.api.tree.IfStatement;
 import org.sonar.plugins.python.api.tree.MatchStatement;
 import org.sonar.plugins.python.api.tree.ParameterList;
+import org.sonar.plugins.python.api.tree.GroupPattern;
 import org.sonar.plugins.python.api.tree.Pattern;
 import org.sonar.plugins.python.api.tree.RaiseStatement;
 import org.sonar.plugins.python.api.tree.ReturnStatement;
@@ -251,7 +252,17 @@ private static int findIrrefutableCaseIndex(List<CaseBlock> caseBlocks) {
   }
 
   private static boolean isIrrefutablePattern(CaseBlock caseBlock) {
-    return caseBlock.guard() == null && caseBlock.pattern().is(Tree.Kind.WILDCARD_PATTERN, Tree.Kind.CAPTURE_PATTERN);
+    return caseBlock.guard() == null && isIrrefutablePatternKind(caseBlock.pattern());
+  }
+
+  private static boolean isIrrefutablePatternKind(Pattern pattern) {
+    if (pattern.is(Tree.Kind.WILDCARD_PATTERN, Tree.Kind.CAPTURE_PATTERN)) {
+      return true;
+    }
+    if (pattern.is(Tree.Kind.GROUP_PATTERN)) {
+      return isIrrefutablePatternKind(((GroupPattern) pattern).pattern());
+    }
+    return false;
   }
 
   private PythonCfgBlock buildWithStatement(WithStatement withStatement, PythonCfgBlock successor) {

python-frontend/src/test/java/org/sonar/plugins/python/api/cfg/ControlFlowGraphTest.java

@@ -752,6 +752,99 @@ void match_statement_guarded_wildcard_is_refutable() {
     assertThat(guardedWildcard.falseSuccessor()).isEqualTo(barBlock);
   }
 
+  @Test
+  void match_statement_group_pattern_is_irrefutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case (z): w()",
+      "bar()"
+    );
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    PythonCfgEndBlock end = (PythonCfgEndBlock) cfg.end();
+    assertThat(end.predecessors()).hasSize(1);
+    CfgBlock barBlock = end.predecessors().stream().findFirst().get();
+
+    // case "a" false successor must be the irrefutable block (case (z)), not barBlock
+    PythonCfgSimpleBlock irrefutableBlock = (PythonCfgSimpleBlock) start.falseSuccessor();
+    assertThat(irrefutableBlock.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.NAME, Kind.GROUP_PATTERN);
+
+    CfgBlock irrefutableBody = irrefutableBlock.successors().stream().findFirst().get();
+    assertThat(irrefutableBody.successors()).containsExactly(barBlock);
+  }
+
+  @Test
+  void match_statement_group_wildcard_pattern_is_irrefutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case (_): w()",
+      "bar()"
+    );
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    // case "a" false successor must be a simple block (irrefutable), not a branching block
+    PythonCfgSimpleBlock irrefutableBlock = (PythonCfgSimpleBlock) start.falseSuccessor();
+    assertThat(irrefutableBlock.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.NAME, Kind.GROUP_PATTERN);
+  }
+
+  @Test
+  void match_statement_nested_group_pattern_is_irrefutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case ((z)): w()",
+      "bar()"
+    );
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    // case "a" false successor must be a simple block (irrefutable), not a branching block
+    PythonCfgSimpleBlock irrefutableBlock = (PythonCfgSimpleBlock) start.falseSuccessor();
+    assertThat(irrefutableBlock.elements()).extracting(Tree::getKind)
+      .containsExactly(Kind.NAME, Kind.GROUP_PATTERN);
+  }
+
+  @Test
+  void match_statement_group_literal_pattern_is_refutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case (42): w()",
+      "bar()"
+    );
+
+    // Both cases are refutable — the second case must be a branching block
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    PythonCfgBranchingBlock secondCase = (PythonCfgBranchingBlock) start.falseSuccessor();
+    assertThat(secondCase).isInstanceOf(PythonCfgBranchingBlock.class);
+    // The false path of the second case leads directly to barBlock (no-match path)
+    PythonCfgEndBlock end = (PythonCfgEndBlock) cfg.end();
+    CfgBlock barBlock = end.predecessors().stream().findFirst().get();
+    assertThat(secondCase.falseSuccessor()).isEqualTo(barBlock);
+  }
+
+  @Test
+  void match_statement_guarded_group_pattern_is_refutable() {
+    ControlFlowGraph cfg = cfg("""
+      foo()   """,
+      "match x:",
+      "  case \"a\": y()",
+      "  case (z) if w(): v()",
+      "bar()"
+    );
+
+    // Both cases are refutable — the second case must be a branching block
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    assertThat(start.falseSuccessor()).isInstanceOf(PythonCfgBranchingBlock.class);
+  }
+
   @Test
   void CFGBlock_toString() {
     PythonCfgEndBlock endBlock = new PythonCfgEndBlock();