SONARPY-929 Match / case statement: support value patterns

Author: guillaume-dequenne

python-frontend/src/main/java/org/sonar/plugins/python/api/tree/BaseTreeVisitor.java

@@ -542,4 +542,8 @@ public void visitKeywordPattern(KeywordPattern keywordPattern) {
     scan(keywordPattern.attributeName());
     scan(keywordPattern.pattern());
   }
+
+  public void visitValuePattern(ValuePattern valuePattern) {
+    scan(valuePattern.qualifiedExpression());
+  }
 }

python-frontend/src/main/java/org/sonar/plugins/python/api/tree/Tree.java

@@ -172,6 +172,7 @@ enum Kind {
     RETURN_TYPE_ANNOTATION(TypeAnnotation.class),
 
     PARAMETER_LIST(ParameterList.class),
+    VALUE_PATTERN(ValuePattern.class),
 
     WHILE_STMT(WhileStatement.class),
 

python-frontend/src/main/java/org/sonar/plugins/python/api/tree/TreeVisitor.java

@@ -198,4 +198,6 @@ public interface TreeVisitor {
   void visitClassPattern(ClassPattern classPattern);
 
   void visitKeywordPattern(KeywordPattern keywordPattern);
+
+  void visitValuePattern(ValuePattern valuePattern);
 }

python-frontend/src/main/java/org/sonar/plugins/python/api/tree/ValuePattern.java

@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2021 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.plugins.python.api.tree;
+
+/**
+ * Value Pattern
+ *
+ * <pre>
+ *   case a.b:
+ *     ...
+ * </pre>
+ *
+ * See https://docs.python.org/3/reference/compound_stmts.html#value-patterns
+ */
+public interface ValuePattern extends Pattern {
+
+  QualifiedExpression qualifiedExpression();
+
+}

python-frontend/src/main/java/org/sonar/python/api/PythonGrammar.java

@@ -173,6 +173,7 @@ public enum PythonGrammar implements GrammarRuleKey {
   PATTERN_ARG,
   KEYWORD_PATTERN,
   NAME_OR_ATTR,
+  VALUE_PATTERN,
 
   SIGNED_NUMBER,
   COMPLEX_NUMBER,
@@ -181,6 +182,7 @@ public enum PythonGrammar implements GrammarRuleKey {
   DECORATORS,
   DECORATOR,
   DOTTED_NAME,
+  ATTR,
   FUNCNAME,
   FUN_RETURN_ANNOTATION,
 
@@ -474,10 +476,11 @@ public static void compoundStatements(LexerfulGrammarBuilder b) {
 
     b.rule(PATTERNS).is(b.firstOf(OPEN_SEQUENCE_PATTERN, PATTERN));
     b.rule(PATTERN).is(b.firstOf(AS_PATTERN, OR_PATTERN));
-    b.rule(CLOSED_PATTERN).is(b.firstOf(CLASS_PATTERN, LITERAL_PATTERN, GROUP_PATTERN, WILDCARD_PATTERN, CAPTURE_PATTERN, SEQUENCE_PATTERN));
+    b.rule(CLOSED_PATTERN).is(b.firstOf(CLASS_PATTERN, LITERAL_PATTERN, GROUP_PATTERN, WILDCARD_PATTERN, VALUE_PATTERN, CAPTURE_PATTERN, SEQUENCE_PATTERN));
     b.rule(AS_PATTERN).is(OR_PATTERN, "as", CAPTURE_PATTERN);
     b.rule(OR_PATTERN).is(CLOSED_PATTERN, b.zeroOrMore("|", CLOSED_PATTERN));
     b.rule(CAPTURE_PATTERN).is(NAME);
+    b.rule(VALUE_PATTERN).is(ATTR);
 
     b.rule(SEQUENCE_PATTERN).is(b.firstOf(
       b.sequence("[", b.optional(MAYBE_SEQUENCE_PATTERN) , "]"),
@@ -523,6 +526,7 @@ public static void compoundStatements(LexerfulGrammarBuilder b) {
     b.rule(DECORATORS).is(b.oneOrMore(DECORATOR));
     b.rule(DECORATOR).is("@", EXPR, NEWLINE);
     b.rule(DOTTED_NAME).is(NAME, b.zeroOrMore(".", NAME));
+    b.rule(ATTR).is(NAME, b.oneOrMore(b.nextNot("(", "["), TRAILER));
 
     b.rule(CLASSDEF).is(b.optional(DECORATORS), "class", CLASSNAME, b.optional("(", b.optional(ARGLIST), ")"), ":", SUITE);
     b.rule(CLASSNAME).is(NAME);

python-frontend/src/main/java/org/sonar/python/tree/PythonTreeMaker.java

@@ -81,6 +81,7 @@
 import org.sonar.plugins.python.api.tree.PassStatement;
 import org.sonar.plugins.python.api.tree.Pattern;
 import org.sonar.plugins.python.api.tree.PrintStatement;
+import org.sonar.plugins.python.api.tree.QualifiedExpression;
 import org.sonar.plugins.python.api.tree.RaiseStatement;
 import org.sonar.plugins.python.api.tree.RegularArgument;
 import org.sonar.plugins.python.api.tree.ReturnStatement;
@@ -872,6 +873,8 @@ public static Pattern closedPattern(AstNode closedPattern) {
       return wildcardPattern(astNode);
     } else if (astNode.is(PythonGrammar.CLASS_PATTERN)) {
       return classPattern(astNode);
+    } else if (astNode.is(PythonGrammar.VALUE_PATTERN)) {
+      return new ValuePatternImpl(nameAttributeAccess(astNode.getFirstChild()));
     }
     throw new IllegalStateException(String.format("Pattern %s not recognized.", astNode.getName()));
   }
@@ -1143,6 +1146,15 @@ private Expression starNamedExpressions(AstNode astNode) {
     return expressions.get(0);
   }
 
+  private static QualifiedExpression nameAttributeAccess(AstNode astNode) {
+    Expression expr = name(astNode.getFirstChild(PythonGrammar.NAME));
+    for (AstNode trailer : astNode.getChildren(PythonGrammar.TRAILER)) {
+      Name name = name(trailer.getFirstChild(PythonGrammar.NAME));
+      expr = new QualifiedExpressionImpl(name, expr, toPyToken(trailer.getFirstChild(PythonPunctuator.DOT).getToken()));
+    }
+    return (QualifiedExpression) expr;
+  }
+
   private Expression assignmentExpression(AstNode astNode) {
     AstNode nameNode = astNode.getFirstChild(PythonGrammar.TEST);
     Expression nameExpression = expression(nameNode);

python-frontend/src/main/java/org/sonar/python/tree/ValuePatternImpl.java

@@ -0,0 +1,56 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2021 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.tree;
+
+import java.util.Collections;
+import java.util.List;
+import org.sonar.plugins.python.api.tree.QualifiedExpression;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.TreeVisitor;
+import org.sonar.plugins.python.api.tree.ValuePattern;
+
+public class ValuePatternImpl extends PyTree implements ValuePattern {
+
+  private final QualifiedExpression qualifiedExpression;
+
+  public ValuePatternImpl(QualifiedExpression qualifiedExpression) {
+    this.qualifiedExpression = qualifiedExpression;
+  }
+
+  @Override
+  public QualifiedExpression qualifiedExpression() {
+    return qualifiedExpression;
+  }
+
+  @Override
+  public void accept(TreeVisitor visitor) {
+    visitor.visitValuePattern(this);
+  }
+
+  @Override
+  public Kind getKind() {
+    return Kind.VALUE_PATTERN;
+  }
+
+  @Override
+  List<Tree> computeChildren() {
+    return Collections.singletonList(qualifiedExpression);
+  }
+}

python-frontend/src/test/java/org/sonar/python/tree/PythonTreeMakerMatchStatementTest.java

@@ -43,6 +43,7 @@
 import org.sonar.plugins.python.api.tree.Tree.Kind;
 import org.sonar.plugins.python.api.tree.Tuple;
 import org.sonar.plugins.python.api.tree.WildcardPattern;
+import org.sonar.plugins.python.api.tree.ValuePattern;
 import org.sonar.python.api.PythonGrammar;
 import org.sonar.python.parser.RuleTest;
 
@@ -195,6 +196,18 @@ public void capture_pattern() {
     assertThat(capturePattern.children()).containsExactly(capturePattern.name());
   }
 
+  @Test
+  public void value_pattern() {
+    ValuePattern valuePattern = pattern("case a.b: ...");
+    QualifiedExpression qualifiedExpression = valuePattern.qualifiedExpression();
+    assertThat(TreeUtils.nameFromQualifiedExpression(qualifiedExpression)).isEqualTo("a.b");
+    assertThat(valuePattern.children()).containsExactly(valuePattern.qualifiedExpression());
+
+    valuePattern = pattern("case a.b.c: ...");
+    qualifiedExpression = valuePattern.qualifiedExpression();
+    assertThat(TreeUtils.nameFromQualifiedExpression(qualifiedExpression)).isEqualTo("a.b.c");
+  }
+
   @Test
   public void sequence_pattern() {
     assertSequenceElements(pattern("case [x, y]: ..."), "x", "y");