SONARPY-930 Generate CFG for match statement (#995)

Author: guillaume-dequenne

python-checks/src/main/java/org/sonar/python/checks/InvariantReturnCheck.java

@@ -37,6 +37,7 @@
 import org.sonar.plugins.python.api.tree.FunctionDef;
 import org.sonar.plugins.python.api.tree.Name;
 import org.sonar.plugins.python.api.tree.ParenthesizedExpression;
+import org.sonar.plugins.python.api.tree.Pattern;
 import org.sonar.plugins.python.api.tree.ReturnStatement;
 import org.sonar.plugins.python.api.tree.Tree;
 import org.sonar.plugins.python.api.tree.Tree.Kind;
@@ -98,7 +99,7 @@ private static void collectBranchingBlock(List<LatestExecutedBlock> collectedBlo
       if (!TreeUtils.hasDescendant(tryStatement.body(), t -> t.is(Kind.RETURN_STMT))) {
         collectedBlocks.add(new LatestExecutedBlock(branchingBlock));
       }
-    } else if (branchingTree.is(Kind.IF_STMT)) {
+    } else if (branchingTree.is(Kind.IF_STMT) || branchingTree instanceof Pattern) {
       collectedBlocks.add(new LatestExecutedBlock(branchingBlock));
     } else {
       collectBlocksHavingReturnBeforeExceptOrFinallyBlock(collectedBlocks, branchingBlock);

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

@@ -206,3 +206,17 @@ def try_block_without_jump_statements():
         print("except")
     return 42
     print("dead code") # Noncompliant
+
+
+def match_statement_no_fp(value):
+  match value:
+    case "1": return
+    case "2": return
+  print("reachable")
+
+
+def match_statement_fn(value):
+  match value:
+    case "1": return
+    case x: return
+  print("unreachable")  # FN, "case x" will match anything

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

@@ -301,3 +301,19 @@ def assignment_expression_fn():
 def assignment_expression_no_fp():
   a = 3 # No fp: a will be read before it's written into
   dict = {'b' : a, 'c' : (a:=3)} # FN (final assignment expression is unused)
+
+def match_statement_fn(value):
+  a = 42
+  match value:
+    case 1: ...
+    case a: ...  # FN
+
+
+class MyClass:
+  CONST = 99
+
+def match_statement_no_fp(value):
+  a = MyClass()
+  match value:
+    case 1: ...
+    case a.CONST: a = 42  # OK, read before write

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

@@ -50,3 +50,15 @@ def assignment_expression_fn(a): # FN (first dict key computation overwrites "a"
 
 def assignment_expression_no_fp(a):
   dict = {'b' : a, 'c' : (a:=3)} # OK, read before write
+
+def match_statement_fp(value, param): # Noncompliant
+  match value:
+    case param.CONST: param = 42 # FP here: b.CONST should be a reading usage of b
+    case "other": ...
+  value = 42  # OK
+
+def match_statement_fn(value, param):
+  match value:
+    case 1: ...
+    case param: ...  # FN, c is overridden without having been read
+  value = 42  # OK

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

@@ -344,3 +344,16 @@ async def asyn6(i): # Noncompliant
 
 class A:
   def func(*, x, y): ...
+
+
+def match_statement_no_fp(value):
+  match value:
+    case 42:
+      return "hello"
+  return no_fp_with_match(value + 1)
+
+
+def match_statement_fn(value):  # FN, "case x" will always match
+  match value:
+    case x:
+      return match_statement_fn(value + 1)

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

@@ -498,3 +498,25 @@ def unreachable_implicit_return_none(cond):  # Noncompliant
   except Exception:
     return 42
   # Implicit "None" return is unreachable
+
+def basic_match_statement_noncompliant(value):  # Noncompliant
+  match value:
+    case 1:
+      return 42
+  return 42
+
+
+def match_statement_no_fp_with_implicit_return(value):  # OK, implicit "None" return is reachable
+  match value:
+    case 1:
+      return 42
+    case 2:
+      return 42
+
+
+def match_statement_fn_with_capture(value): # FN, implicit "None" return is unreachable
+  match value:
+    case 1:
+      return 42
+    case x:
+      return 42

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

@@ -326,3 +326,15 @@ class Foo:
 
 def single_return():
     return # OK
+
+
+def match_statement(value):
+    match value:
+      case "42":
+        foo()
+        return  # Noncompliant
+
+def match_statement_single_return(value):
+    match value:
+      case "42":
+        return  # OK

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

@@ -179,3 +179,14 @@ def assignment_expression():
 def assignment_expression_fn():
   b = 41
   dict = {k: (k := b + 1)} # FN, key is evaluated first and value second
+
+def match_statement_no_fp(value):
+  match value:
+    case x:
+      ...
+  x = 42
+
+def match_statement_no_fp_reassignment(value):
+  match value:
+    case x:  # OK, though should be raised by S1854 (dead store)
+      x = 42

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

@@ -34,6 +34,7 @@
 import org.sonar.plugins.python.api.cfg.ControlFlowGraph;
 import org.sonar.plugins.python.api.tree.AnyParameter;
 import org.sonar.plugins.python.api.tree.BreakStatement;
+import org.sonar.plugins.python.api.tree.CaseBlock;
 import org.sonar.plugins.python.api.tree.ClassDef;
 import org.sonar.plugins.python.api.tree.ContinueStatement;
 import org.sonar.plugins.python.api.tree.ElseClause;
@@ -42,8 +43,11 @@
 import org.sonar.plugins.python.api.tree.FinallyClause;
 import org.sonar.plugins.python.api.tree.ForStatement;
 import org.sonar.plugins.python.api.tree.FunctionDef;
+import org.sonar.plugins.python.api.tree.Guard;
 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.Pattern;
 import org.sonar.plugins.python.api.tree.RaiseStatement;
 import org.sonar.plugins.python.api.tree.ReturnStatement;
 import org.sonar.plugins.python.api.tree.Statement;
@@ -182,13 +186,37 @@ private PythonCfgBlock build(Statement statement, PythonCfgBlock currentBlock) {
         return tryStatement(((TryStatement) statement), currentBlock);
       case BREAK_STMT:
         return buildBreakStatement((BreakStatement) statement, currentBlock);
+      case MATCH_STMT:
+        return buildMatchStatement((MatchStatement) statement, currentBlock);
       default:
         currentBlock.addElement(statement);
     }
 
     return currentBlock;
   }
 
+  private PythonCfgBlock buildMatchStatement(MatchStatement statement, PythonCfgBlock successor) {
+    List<CaseBlock> caseBlocks = statement.caseBlocks();
+    PythonCfgBlock matchingBlock = null;
+    PythonCfgBlock falseSuccessor = successor;
+    for (int i = caseBlocks.size() - 1; i >= 0; i--) {
+      PythonCfgBlock caseBodyBlock = createSimpleBlock(successor);
+      CaseBlock caseBlock = caseBlocks.get(i);
+      Pattern pattern = caseBlock.pattern();
+      Guard guard = caseBlock.guard();
+      caseBodyBlock = build(caseBlock.body().statements(), caseBodyBlock);
+      matchingBlock = createBranchingBlock(pattern, caseBodyBlock, falseSuccessor);
+      if (guard != null) {
+        matchingBlock.addElement(guard.condition());
+      }
+      matchingBlock.addElement(pattern);
+      matchingBlock.addElement(statement.subjectExpression());
+      blocks.add(matchingBlock);
+      falseSuccessor = matchingBlock;
+    }
+    return matchingBlock;
+  }
+
   private PythonCfgBlock buildWithStatement(WithStatement withStatement, PythonCfgBlock successor) {
     PythonCfgBlock withBodyBlock = build(withStatement.statements().statements(), createSimpleBlock(successor));
     // exceptions may be raised inside with block and be caught by context manager

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

@@ -20,10 +20,13 @@
 package org.sonar.plugins.python.api.cfg;
 
 import java.util.Arrays;
+import java.util.List;
 import java.util.stream.Collectors;
 import org.junit.Test;
 import org.mockito.Mockito;
 import org.sonar.plugins.python.api.PythonFile;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.ExpressionStatement;
 import org.sonar.plugins.python.api.tree.FileInput;
 import org.sonar.plugins.python.api.tree.FunctionDef;
 import org.sonar.plugins.python.api.tree.Parameter;
@@ -596,6 +599,43 @@ public void with_statement() {
     );
   }
 
+  @Test
+  public void match_statement() {
+    ControlFlowGraph cfg = cfg("" +
+      "foo()   ",
+      "match x:",
+      "  case \"1\": y()",
+      "  case a.b if w(): z()",
+      "bar()"
+    );
+
+    assertThat(cfg.blocks()).hasSize(6);
+
+    PythonCfgBranchingBlock start = (PythonCfgBranchingBlock) cfg.start();
+    PythonCfgEndBlock end = (PythonCfgEndBlock) cfg.end();
+    assertThat(end.predecessors()).hasSize(1);
+    CfgBlock barBlock = end.predecessors().stream().findFirst().get();
+
+    assertThat(barBlock.elements()).extracting(Tree::getKind).containsExactly(Kind.EXPRESSION_STMT);
+    ExpressionStatement expressionStatement = (ExpressionStatement) barBlock.elements().get(0);
+    assertThat(expressionStatement.expressions()).extracting(Tree::getKind).containsExactly(Kind.CALL_EXPR);
+
+    assertThat(start.branchingTree().getKind()).isEqualTo(Kind.STRING_LITERAL_PATTERN);
+    assertThat(start.elements()).extracting(Tree::getKind).containsExactly(Kind.EXPRESSION_STMT, Kind.NAME, Kind.STRING_LITERAL_PATTERN);
+
+    PythonCfgSimpleBlock firstCaseBody = (PythonCfgSimpleBlock) start.trueSuccessor();
+    assertThat(firstCaseBody.elements()).extracting(Tree::getKind).containsExactly(Kind.EXPRESSION_STMT);
+    assertThat(firstCaseBody.successors()).containsExactly(barBlock);
+
+    PythonCfgBranchingBlock secondCaseEvaluation = (PythonCfgBranchingBlock) start.falseSuccessor();
+    assertThat(secondCaseEvaluation.elements()).extracting(Tree::getKind).containsExactly(Kind.NAME, Kind.VALUE_PATTERN, Kind.CALL_EXPR);
+
+    PythonCfgSimpleBlock secondCaseTrueSuccessor = (PythonCfgSimpleBlock) secondCaseEvaluation.trueSuccessor();
+    assertThat(secondCaseTrueSuccessor.successors()).containsExactly(barBlock);
+    PythonCfgSimpleBlock secondCaseFalseSuccessor = (PythonCfgSimpleBlock) secondCaseEvaluation.falseSuccessor();
+    assertThat(secondCaseFalseSuccessor).isEqualTo(barBlock);
+  }
+
   @Test
   public void CFGBlock_toString() {
     PythonCfgEndBlock endBlock = new PythonCfgEndBlock();
@@ -609,6 +649,25 @@ public void CFGBlock_toString() {
     assertThat(cfg.start().toString()).isEqualTo("2:2:PASS_STMT;ASSERT_STMT");
   }
 
+  @Test
+  public void CFG_matchStatement() {
+    ControlFlowGraph cfg = cfg("" +
+      "foo()   ",
+      "match x:",
+      "  case \"1\": y()",
+      "  case a.b: z()",
+      "bar()"
+    );
+    assertThat(cfg).hasToString("" +
+      "0[label=\"4:14:EXPRESSION_STMT\"];" +
+      "1[label=\"4:9:EXPRESSION_STMT;NAME;STRING_LITERAL_PATTERN\"];" +
+      "2[label=\"5:14:EXPRESSION_STMT\"];" +
+      "3[label=\"5:9:NAME;VALUE_PATTERN\"];" +
+      "4[label=\"6:2:EXPRESSION_STMT\"];" +
+      "5[label=\"END\"];" +
+      "0->4;1->0;1->3;2->4;3->2;3->4;4->5;");
+  }
+
   @Test
   public void CFG_toString() {
     ControlFlowGraph cfg = cfg("" +