Add SwitchExpr

javaparser-core-metamodel-generator/src/main/java/com/github/javaparser/generator/metamodel/MetaModelGenerator.java

@@ -107,6 +107,7 @@ public class MetaModelGenerator {
         add(TypeExpr.class);
         add(UnaryExpr.class);
         add(VariableDeclarationExpr.class);
+        add(SwitchExpr.class);
 
         add(ImportDeclaration.class);
 

javaparser-core-testing/src/test/java/com/github/javaparser/ast/expr/SwitchExprTest.java

@@ -0,0 +1,87 @@
+package com.github.javaparser.ast.expr;
+
+import com.github.javaparser.JavaParser;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+class SwitchExprTest {
+    @Disabled("to be implemented")
+    @Test
+    void jep325Example1() {
+        JavaParser.parseStatement("switch (day) {\n" +
+                "    case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);\n" +
+                "    case TUESDAY                -> System.out.println(7);\n" +
+                "    case THURSDAY, SATURDAY     -> System.out.println(8);\n" +
+                "    case WEDNESDAY              -> System.out.println(9);\n" +
+                "}};");
+    }
+
+    @Disabled("to be implemented")
+    @Test
+    void jep325Example2() {
+        JavaParser.parseStatement("int numLetters = switch (day) {\n" +
+                "    case MONDAY, FRIDAY, SUNDAY -> 6;\n" +
+                "    case TUESDAY                -> 7;\n" +
+                "    case THURSDAY, SATURDAY     -> 8;\n" +
+                "    case WEDNESDAY              -> 9;\n" +
+                "};");
+    }
+
+    @Disabled("to be implemented")
+    @Test
+    void jep325Example3() {
+        JavaParser.parseBodyDeclaration("static void howMany(int k) {\n" +
+                "    switch (k) {\n" +
+                "        case 1 -> System.out.println(\"one\");\n" +
+                "        case 2 -> System.out.println(\"two\");\n" +
+                "        case 3 -> System.out.println(\"many\");\n" +
+                "    }\n" +
+                "}");
+    }
+
+    @Disabled("to be implemented")
+    @Test
+    void jep325Example4() {
+        JavaParser.parseStatement("T result = switch (arg) {\n" +
+                "    case L1 -> e1;\n" +
+                "    case L2 -> e2;\n" +
+                "    default -> e3;\n" +
+                "};");
+    }
+
+    @Disabled("to be implemented")
+    @Test
+    void jep325Example5() {
+        JavaParser.parseStatement("int j = switch (day) {\n" +
+                "    case MONDAY  -> 0;\n" +
+                "    case TUESDAY -> 1;\n" +
+                "    default      -> {\n" +
+                "        int k = day.toString().length();\n" +
+                "        int result = f(k);\n" +
+                "        break result;\n" +
+                "    }\n" +
+                "};");
+    }
+
+    @Disabled("to be implemented")
+    @Test
+    void jep325Example6() {
+        JavaParser.parseStatement("int result = switch (s) {\n" +
+                "    case \"Foo\": \n" +
+                "        break 1;\n" +
+                "    case \"Bar\":\n" +
+                "        break 2;\n" +
+                "    default:\n" +
+                "        System.out.println(\"Neither Foo nor Bar, hmmm...\");\n" +
+                "        break 0;\n" +
+                "};");
+    }
+
+    @Test
+    void placeholderTest() {
+        JavaParser.parseStatement("int result = switch (s) {\n" +
+                "    case \"Foo\": \n" +
+                "        break;\n" +
+                "};");
+    }
+}

javaparser-core/src/main/java/com/github/javaparser/ast/expr/Expression.java

@@ -733,4 +733,19 @@ public Optional<UnaryExpr> toUnaryExpr() {
     public Optional<VariableDeclarationExpr> toVariableDeclarationExpr() {
         return Optional.empty();
     }
+
+    public boolean isSwitchExpr() {
+        return false;
+    }
+
+    public SwitchExpr asSwitchExpr() {
+        throw new IllegalStateException(f("%s is not an SwitchExpr", this));
+    }
+
+    public Optional<SwitchExpr> toSwitchExpr() {
+        return Optional.empty();
+    }
+
+    public void ifSwitchExpr(Consumer<SwitchExpr> action) {
+    }
 }

javaparser-core/src/main/java/com/github/javaparser/ast/expr/LambdaExpr.java

@@ -38,10 +38,8 @@
 import com.github.javaparser.metamodel.DerivedProperty;
 import com.github.javaparser.metamodel.JavaParserMetaModel;
 import com.github.javaparser.metamodel.LambdaExprMetaModel;
-
 import java.util.Optional;
 import java.util.function.Consumer;
-
 import static com.github.javaparser.utils.Utils.assertNotNull;
 
 /**
@@ -86,7 +84,6 @@ public LambdaExpr(NodeList<Parameter> parameters, BlockStmt body) {
         this(null, parameters, body, true);
     }
 
-
     /**
      * Creates a single parameter lambda expression.
      */

javaparser-core/src/main/java/com/github/javaparser/ast/expr/SwitchExpr.java

@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) 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.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser 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.
+ */
+package com.github.javaparser.ast.expr;
+
+import com.github.javaparser.TokenRange;
+import com.github.javaparser.ast.AllFieldsConstructor;
+import com.github.javaparser.ast.Generated;
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.nodeTypes.SwitchNode;
+import com.github.javaparser.ast.observer.ObservableProperty;
+import com.github.javaparser.ast.stmt.Statement;
+import com.github.javaparser.ast.stmt.SwitchEntryStmt;
+import com.github.javaparser.ast.visitor.CloneVisitor;
+import com.github.javaparser.ast.visitor.GenericVisitor;
+import com.github.javaparser.ast.visitor.VoidVisitor;
+import com.github.javaparser.metamodel.JavaParserMetaModel;
+import com.github.javaparser.metamodel.SwitchStmtMetaModel;
+import java.util.Optional;
+import java.util.function.Consumer;
+import static com.github.javaparser.utils.Utils.assertNotNull;
+import com.github.javaparser.metamodel.SwitchExprMetaModel;
+
+/**
+ * A switch expression.
+ * <br/>In <code>switch(a) { ... }</code> the selector is "a",
+ * and the contents of the { ... } are the entries.
+ *
+ * @author Julio Vilmar Gesser
+ * @see SwitchEntryStmt
+ * @see com.github.javaparser.ast.stmt.SwitchStmt
+ * @see SwitchNode
+ */
+public final class SwitchExpr extends Expression implements SwitchNode {
+
+    private Expression selector;
+
+    private NodeList<SwitchEntryStmt> entries;
+
+    public SwitchExpr() {
+        this(null, new NameExpr(), new NodeList<>());
+    }
+
+    @AllFieldsConstructor
+    public SwitchExpr(final Expression selector, final NodeList<SwitchEntryStmt> entries) {
+        this(null, selector, entries);
+    }
+
+    /**
+     * This constructor is used by the parser and is considered private.
+     */
+    @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator")
+    public SwitchExpr(TokenRange tokenRange, Expression selector, NodeList<SwitchEntryStmt> entries) {
+        super(tokenRange);
+        setSelector(selector);
+        setEntries(entries);
+        customInitialization();
+    }
+
+    @Override
+    @Generated("com.github.javaparser.generator.core.node.AcceptGenerator")
+    public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    @Generated("com.github.javaparser.generator.core.node.AcceptGenerator")
+    public <A> void accept(final VoidVisitor<A> v, final A arg) {
+        v.visit(this, arg);
+    }
+
+    @Generated("com.github.javaparser.generator.core.node.PropertyGenerator")
+    public NodeList<SwitchEntryStmt> getEntries() {
+        return entries;
+    }
+
+    public SwitchEntryStmt getEntry(int i) {
+        return getEntries().get(i);
+    }
+
+    @Generated("com.github.javaparser.generator.core.node.PropertyGenerator")
+    public Expression getSelector() {
+        return selector;
+    }
+
+    @Generated("com.github.javaparser.generator.core.node.PropertyGenerator")
+    public SwitchExpr setEntries(final NodeList<SwitchEntryStmt> entries) {
+        assertNotNull(entries);
+        if (entries == this.entries) {
+            return (SwitchExpr) this;
+        }
+        notifyPropertyChange(ObservableProperty.ENTRIES, this.entries, entries);
+        if (this.entries != null)
+            this.entries.setParentNode(null);
+        this.entries = entries;
+        setAsParentNodeOf(entries);
+        return this;
+    }
+
+    /**
+     * @deprecated use a method on getEntries instead
+     */
+    @Deprecated
+    public SwitchExpr setEntry(int i, SwitchEntryStmt entry) {
+        getEntries().set(i, entry);
+        return this;
+    }
+
+    /**
+     * @deprecated use a method on getEntries instead
+     */
+    @Deprecated
+    public SwitchExpr addEntry(SwitchEntryStmt entry) {
+        getEntries().add(entry);
+        return this;
+    }
+
+    @Generated("com.github.javaparser.generator.core.node.PropertyGenerator")
+    public SwitchExpr setSelector(final Expression selector) {
+        assertNotNull(selector);
+        if (selector == this.selector) {
+            return (SwitchExpr) this;
+        }
+        notifyPropertyChange(ObservableProperty.SELECTOR, this.selector, selector);
+        if (this.selector != null)
+            this.selector.setParentNode(null);
+        this.selector = selector;
+        setAsParentNodeOf(selector);
+        return this;
+    }
+
+    @Override
+    @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator")
+    public boolean remove(Node node) {
+        if (node == null)
+            return false;
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i) == node) {
+                entries.remove(i);
+                return true;
+            }
+        }
+        return super.remove(node);
+    }
+
+    @Override
+    @Generated("com.github.javaparser.generator.core.node.CloneGenerator")
+    public SwitchExpr clone() {
+        return (SwitchExpr) accept(new CloneVisitor(), null);
+    }
+
+    @Override
+    @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator")
+    public boolean replace(Node node, Node replacementNode) {
+        if (node == null)
+            return false;
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i) == node) {
+                entries.set(i, (SwitchEntryStmt) replacementNode);
+                return true;
+            }
+        }
+        if (node == selector) {
+            setSelector((Expression) replacementNode);
+            return true;
+        }
+        return super.replace(node, replacementNode);
+    }
+
+    @Override
+    public boolean isSwitchExpr() {
+        return true;
+    }
+
+    @Override
+    public SwitchExpr asSwitchExpr() {
+        return this;
+    }
+
+    @Override
+    public Optional<SwitchExpr> toSwitchExpr() {
+        return Optional.of(this);
+    }
+
+    public void ifSwitchExpr(Consumer<SwitchExpr> action) {
+        action.accept(this);
+    }
+
+    @Override
+    public SwitchExprMetaModel getMetaModel() {
+        return JavaParserMetaModel.switchExprMetaModel;
+    }
+}

javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/SwitchNode.java

@@ -0,0 +1,35 @@
+package com.github.javaparser.ast.nodeTypes;
+
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.comments.Comment;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.stmt.SwitchEntryStmt;
+
+import java.util.Optional;
+
+/**
+ * The common interface of {@link com.github.javaparser.ast.expr.SwitchExpr} and {@link com.github.javaparser.ast.stmt.SwitchStmt}
+ */
+public interface SwitchNode {
+    NodeList<SwitchEntryStmt> getEntries();
+
+    SwitchEntryStmt getEntry(int i);
+
+    Expression getSelector();
+
+    SwitchNode setEntries(NodeList<SwitchEntryStmt> entries);
+
+    SwitchNode setSelector(Expression selector);
+
+    boolean remove(Node node);
+
+    SwitchNode clone();
+
+    boolean replace(Node node, Node replacementNode);
+
+    Optional<Comment> getComment();
+
+    // Too bad Node isn't an interface, or this could have easily inherited all of its methods.
+    // Add more when required.
+}