Simplify LiteralPattern interface (#993)

Author: andrea-guarino-sonarsource

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

@@ -39,12 +39,4 @@ public interface LiteralPattern extends Pattern {
 
   String valueAsString();
 
-  LiteralKind literalKind();
-
-  enum LiteralKind {
-    STRING,
-    NUMBER,
-    BOOLEAN,
-    NONE
-  }
 }

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

@@ -56,6 +56,8 @@ enum Kind {
 
     BREAK_STMT(BreakStatement.class),
 
+    BOOLEAN_LITERAL_PATTERN(LiteralPattern.class),
+
     CALL_EXPR(CallExpression.class),
 
     CAPTURE_PATTERN(CapturePattern.class),
@@ -122,8 +124,6 @@ enum Kind {
 
     LIST_LITERAL(ListLiteral.class),
 
-    LITERAL_PATTERN(LiteralPattern.class),
-
     MATCH_STMT(MatchStatement.class),
 
     MAPPING_PATTERN(MappingPattern.class),
@@ -134,8 +134,12 @@ enum Kind {
 
     NONE(NoneExpression.class),
 
+    NONE_LITERAL_PATTERN(LiteralPattern.class),
+
     NUMERIC_LITERAL(NumericLiteral.class),
 
+    NUMERIC_LITERAL_PATTERN(LiteralPattern.class),
+
     OR_PATTERN(OrPattern.class),
 
     PASS_STMT(PassStatement.class),
@@ -160,6 +164,8 @@ enum Kind {
 
     STRING_LITERAL(StringLiteral.class),
 
+    STRING_LITERAL_PATTERN(LiteralPattern.class),
+
     STRING_ELEMENT(StringElement.class),
 
     FORMATTED_EXPRESSION(FormattedExpression.class),

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

@@ -31,32 +31,27 @@
 // TODO: should we consider None as NoneExpression?
 public class LiteralPatternImpl extends PyTree implements LiteralPattern {
 
-  private final LiteralKind literalKind;
+  private final Kind kind;
   private final List<Token> tokens;
 
-  public LiteralPatternImpl(List<Token> tokens, LiteralKind literalKind) {
-    this.literalKind = literalKind;
+  public LiteralPatternImpl(List<Token> tokens, Kind kind) {
     this.tokens = tokens;
+    this.kind = kind;
   }
 
   @Override
   public String valueAsString() {
     return tokens.stream().map(Token::value).collect(Collectors.joining());
   }
 
-  @Override
-  public LiteralKind literalKind() {
-    return literalKind;
-  }
-
   @Override
   public void accept(TreeVisitor visitor) {
     visitor.visitLiteralPattern(this);
   }
 
   @Override
   public Kind getKind() {
-    return Kind.LITERAL_PATTERN;
+    return kind;
   }
 
   @Override

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

@@ -1048,15 +1048,15 @@ private static MappingPattern mappingPattern(AstNode astNode) {
   }
 
   private static LiteralPattern literalPattern(AstNode literalPattern) {
-    LiteralPattern.LiteralKind literalKind;
+    Tree.Kind literalKind;
     if (literalPattern.hasDirectChildren(PythonGrammar.COMPLEX_NUMBER, PythonGrammar.SIGNED_NUMBER)) {
-      literalKind = LiteralPattern.LiteralKind.NUMBER;
+      literalKind = Tree.Kind.NUMERIC_LITERAL_PATTERN;
     } else if (literalPattern.hasDirectChildren(PythonTokenType.STRING)) {
-      literalKind = LiteralPattern.LiteralKind.STRING;
+      literalKind = Tree.Kind.STRING_LITERAL_PATTERN;
     } else if (literalPattern.hasDirectChildren(PythonKeyword.NONE)) {
-      literalKind = LiteralPattern.LiteralKind.NONE;
+      literalKind = Tree.Kind.NONE_LITERAL_PATTERN;
     } else {
-      literalKind = LiteralPattern.LiteralKind.BOOLEAN;
+      literalKind = Tree.Kind.BOOLEAN_LITERAL_PATTERN;
     }
     List<Token> tokens = literalPattern.getTokens().stream().map(PythonTreeMaker::toPyToken).collect(Collectors.toList());
     return new LiteralPatternImpl(tokens, literalKind);

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

@@ -74,12 +74,11 @@ public void match_statement() {
     assertThat(caseBlock.guard()).isNull();
     assertThat(caseBlock.body().statements()).extracting(Tree::getKind).containsExactly(Kind.EXPRESSION_STMT);
     assertThat(caseBlock.children()).extracting(Tree::getKind)
-      .containsExactly(Kind.TOKEN, Kind.LITERAL_PATTERN, Kind.TOKEN, Kind.STATEMENT_LIST);
+      .containsExactly(Kind.TOKEN, Kind.NUMERIC_LITERAL_PATTERN, Kind.TOKEN, Kind.STATEMENT_LIST);
 
     Pattern pattern = caseBlock.pattern();
-    assertThat(pattern.getKind()).isEqualTo(Kind.LITERAL_PATTERN);
+    assertThat(pattern.getKind()).isEqualTo(Kind.NUMERIC_LITERAL_PATTERN);
     LiteralPattern literalPattern = (LiteralPattern) pattern;
-    assertThat(literalPattern.literalKind()).isEqualTo(LiteralPattern.LiteralKind.NUMBER);
     assertThat(literalPattern.children()).extracting(Tree::getKind)
       .containsExactly(Kind.TOKEN);
   }
@@ -130,41 +129,13 @@ public void case_block_with_guard() {
 
   @Test
   public void literal_patterns() {
-    setRootRule(PythonGrammar.CASE_BLOCK);
-    CaseBlock caseBlock = parse("case \"foo\": ...", treeMaker::caseBlock);
-    LiteralPattern literalPattern = (LiteralPattern) caseBlock.pattern();
-    assertThat(literalPattern.literalKind()).isEqualTo(LiteralPattern.LiteralKind.STRING);
-    assertThat(literalPattern.valueAsString()).isEqualTo("\"foo\"");
-
-    caseBlock = parse("case \"foo\" \"bar\": ...", treeMaker::caseBlock);
-    literalPattern = (LiteralPattern) caseBlock.pattern();
-    assertThat(literalPattern.literalKind()).isEqualTo(LiteralPattern.LiteralKind.STRING);
-    assertThat(literalPattern.valueAsString()).isEqualTo("\"foo\"\"bar\"");
-
-    caseBlock = parse("case -42: ...", treeMaker::caseBlock);
-    literalPattern = (LiteralPattern) caseBlock.pattern();
-    assertThat(literalPattern.literalKind()).isEqualTo(LiteralPattern.LiteralKind.NUMBER);
-    assertThat(literalPattern.valueAsString()).isEqualTo("-42");
-
-    caseBlock = parse("case 3 + 5j: ...", treeMaker::caseBlock);
-    literalPattern = (LiteralPattern) caseBlock.pattern();
-    assertThat(literalPattern.literalKind()).isEqualTo(LiteralPattern.LiteralKind.NUMBER);
-    assertThat(literalPattern.valueAsString()).isEqualTo("3+5j");
-
-    caseBlock = parse("case None: ...", treeMaker::caseBlock);
-    literalPattern = (LiteralPattern) caseBlock.pattern();
-    assertThat(literalPattern.literalKind()).isEqualTo(LiteralPattern.LiteralKind.NONE);
-    assertThat(literalPattern.valueAsString()).isEqualTo("None");
-
-    caseBlock = parse("case True: ...", treeMaker::caseBlock);
-    literalPattern = (LiteralPattern) caseBlock.pattern();
-    assertThat(literalPattern.literalKind()).isEqualTo(LiteralPattern.LiteralKind.BOOLEAN);
-    assertThat(literalPattern.valueAsString()).isEqualTo("True");
-
-    caseBlock = parse("case False: ...", treeMaker::caseBlock);
-    literalPattern = (LiteralPattern) caseBlock.pattern();
-    assertThat(literalPattern.literalKind()).isEqualTo(LiteralPattern.LiteralKind.BOOLEAN);
-    assertThat(literalPattern.valueAsString()).isEqualTo("False");
+    assertLiteralPattern(pattern("case \"foo\": ..."), Kind.STRING_LITERAL_PATTERN, "\"foo\"");
+    assertLiteralPattern(pattern("case \"foo\" \"bar\": ..."), Kind.STRING_LITERAL_PATTERN, "\"foo\"\"bar\"");
+    assertLiteralPattern(pattern("case -42: ..."), Kind.NUMERIC_LITERAL_PATTERN, "-42");
+    assertLiteralPattern(pattern("case 3 + 5j: ..."), Kind.NUMERIC_LITERAL_PATTERN, "3+5j");
+    assertLiteralPattern(pattern("case None: ..."), Kind.NONE_LITERAL_PATTERN, "None");
+    assertLiteralPattern(pattern("case True: ..."), Kind.BOOLEAN_LITERAL_PATTERN, "True");
+    assertLiteralPattern(pattern("case False: ..."), Kind.BOOLEAN_LITERAL_PATTERN, "False");
   }
 
   @Test
@@ -184,7 +155,7 @@ public void as_pattern() {
     AsPattern asPattern = (AsPattern) caseBlock.pattern();
     assertThat(asPattern.pattern()).isInstanceOf(LiteralPattern.class);
     assertThat(asPattern.alias().name()).isEqualTo("x");
-    assertThat(asPattern.children()).extracting(Tree::getKind).containsExactly(Tree.Kind.LITERAL_PATTERN, Tree.Kind.TOKEN, Tree.Kind.NAME);
+    assertThat(asPattern.children()).extracting(Tree::getKind).containsExactly(Kind.STRING_LITERAL_PATTERN, Tree.Kind.TOKEN, Tree.Kind.NAME);
 
     caseBlock = parse("case value as x: ...", treeMaker::caseBlock);
     asPattern = (AsPattern) caseBlock.pattern();
@@ -353,6 +324,11 @@ private void assertSequenceElements(SequencePattern sequencePattern, Kind... ele
     assertThat(sequencePattern.elements()).extracting(Tree::getKind).containsExactly(elements);
   }
 
+  private void assertLiteralPattern(LiteralPattern literalPattern, Kind literalKind, String valueAsString) {
+    assertThat(literalPattern.getKind()).isEqualTo(literalKind);
+    assertThat(literalPattern.valueAsString()).isEqualTo(valueAsString);
+  }
+
   @SuppressWarnings("unchecked")
   private <T extends Pattern> T pattern(String code) {
     setRootRule(PythonGrammar.CASE_BLOCK);