jmlparser-core/com.github.javaparser.ast.stmt/SwitchEntry

SwitchEntry

open class SwitchEntry : Node, NodeWithStatements<SwitchEntry> (source)

One case in a switch statement

The main Javadoc is in SwitchStmt

Java 1.0-11


switch (i) {
  case 1:
  case 2:
    System.out.println(444);
    break;
  default:
    System.out.println(0);
}

This contains three SwitchEntrys. All of them are of type STATEMENT_GROUP.

The first one has label 1 and no statements.
The second has label 2 and two statements (the println and the break).
The third, the default, has no label and one statement.

Java 12-


    case 1 -> 15*15;
    case 2 -> { a++; b++; }
    case 3 -> throw new Exception();

These are three new variants.

The first one is of type EXPRESSION and stores its Expression in an ExpressionStmt which is stored as the first and only statement in statements.
The second one is of type BLOCK and stores its BlockStmt as the first and only statement in statements.
The third one is of type THROWS_STATEMENT and stores its ThrowStmt as the first and only statement in statements.


    case MONDAY, FRIDAY, SUNDAY -> 6;

Multiple case labels are now allowed.


    case 16*16, 10+10 -> 6;

Many kinds of expressions are now allowed. Note (https://github.com/javaparser/javaparser/pull/4679): The JavaParser representation for SwitchEntry is (slightly) incorrect. JP Assumes that the body of a SwitchEntry will be a list of statements which was true before switch expressions were added, but is no longer the case for this rule. The workaround for this was to wrap the expression in an ExpressionStmt node which works well, but is not entirely correct according to the JLS since the ExpressionStmt in this specific case can contain any expression, not just those which are legal expression statements according to the JLS, for example below (a lambda is not a valid expression statement, but the below snippet is still legal Java code):


     return switch (o) {
         case String s -> (arg) -> System.out.println(arg + s);
         case null, default -> (arg) -> {};
     };

https://docs.oracle.com/javase/specs/jls/se21/html/jls-15.html#jls-15.28 https://docs.oracle.com/javase/specs/jls/se21/html/jls-14.html#jls-14.8

Author

Julio Vilmar Gesser

Constructors

SwitchEntry

constructor()

constructor(tokenRange: TokenRange, labels: NodeList<Expression>, type: SwitchEntry.Type, statements: NodeList<Statement>)

This constructor exists for backwards compatibility for code that instantiated `SwitchEntries` before the `isDefault` and guard fields were added.

constructor(labels: NodeList<Expression>, type: SwitchEntry.Type, statements: NodeList<Statement>)

This constructor exists for backwards compatibility for code that instantiated `SwitchEntries` before the `isDefault` and guard fields were added.

constructor(labels: NodeList<Expression>, type: SwitchEntry.Type, statements: NodeList<Statement>, isDefault: Boolean, guard: Expression)

constructor(tokenRange: TokenRange, labels: NodeList<Expression>, type: SwitchEntry.Type, statements: NodeList<Statement>, isDefault: Boolean, guard: Expression)

This constructor is used by the parser and is considered private.

constructor(tokenRange: TokenRange, labels: NodeList<Expression>, type: SwitchEntry.Type, statements: NodeList<Statement>, isDefault: Boolean)

This constructor is used by the parser and is considered private.

Types

Type

enum Type

Properties

ABSOLUTE_BEGIN_LINE

val ~~ABSOLUTE_BEGIN_LINE~~: Int = -1

ABSOLUTE_END_LINE

val ~~ABSOLUTE_END_LINE~~: Int = -2

isDefault

open var isDefault: Boolean

labels

open var labels: NodeList<Expression>

LINE_SEPARATOR_KEY

val LINE_SEPARATOR_KEY: DataKey<LineSeparator>

NODE_BY_BEGIN_POSITION

open var NODE_BY_BEGIN_POSITION: Comparator<NodeWithRange<out Any>>

This can be used to sort nodes on position.

parentNode

private open var parentNode: Node

parsed

open var parsed: Node.Parsedness

PRINTER_KEY

val PRINTER_KEY: DataKey<Printer>

range

private open var range: Range

statements

open var statements: NodeList<Statement>

SYMBOL_RESOLVER_KEY

val SYMBOL_RESOLVER_KEY: DataKey<SymbolResolver>

tokenRange

private open var tokenRange: TokenRange

type

open var type: SwitchEntry.Type

Functions

open fun <R, A> accept(v: GenericVisitor<R, A>, arg: A): R

open fun <A> accept(v: VoidVisitor<A>, arg: A)

Accept method for visitor support.

addAndGetStatement

open fun <A : Statement?> addAndGetStatement(statement: A): A

open fun addAndGetStatement(expr: Expression): ExpressionStmt

open fun addAndGetStatement(statement: String): ExpressionStmt

open fun addAndGetStatement(index: Int, statement: Statement): Statement

addOrphanComment

open fun addOrphanComment(comment: Comment)

addStatement

open fun addStatement(expr: Expression): N

open fun addStatement(statement: Statement): N

open fun addStatement(index: Int, expr: Expression): N

open fun addStatement(index: Int, statement: Statement): N

open fun addStatement(statement: String): N

It will use parseStatement inside, so it should end with a semicolon

associatedSpecificationComments

@Nullable

open fun associatedSpecificationComments(): @Nullable NodeList<Comment>

clone

open fun clone(): SwitchEntry

comment

@Nullable

open fun comment(): @Nullable Comment

containsData

open fun containsData(key: DataKey<out Any>): Boolean

containsWithin

open fun ~~containsWithin~~(other: Node): Boolean

containsWithinRange

open fun containsWithinRange(other: Node): Boolean

Checks whether the range of the given Node is contained within the range of this NodeWithRange.

copyStatements

open fun copyStatements(nodeList: NodeList<Statement>): N

open fun copyStatements(other: NodeWithStatements<out Any>): N

equals

open fun equals(obj: Any): Boolean

findAll

open fun <T : Node?> findAll(nodeType: Class<T>): List<T>

Walks the AST with pre-order traversal, returning all nodes of type "nodeType".

open fun <T : Node?> findAll(nodeType: Class<T>, traversal: Node.TreeTraversal): List<T>

Walks the AST with specified traversal order, returning all nodes of type "nodeType".

open fun <T : Node?> findAll(nodeType: Class<T>, predicate: Predicate<T>): List<T>

Walks the AST with pre-order traversal, returning all nodes of type "nodeType" that match the predicate.

findAncestor

open fun <N> findAncestor(types: Array<Class<N>>): Optional<N>

Walks the parents of this node and returns the first node of type type, or empty() if none is found.

open fun <N> ~~findAncestor~~(type: Class<N>, predicate: Predicate<N>): Optional<N>

Walks the parents of this node and returns the first node of type type that matches predicate, or empty() if none is found.

open fun <N> findAncestor(predicate: Predicate<N>, types: Array<Class<N>>): Optional<N>

Walks the parents of this node and returns the first node that matches one of types types, or empty() if none is found.

findByRange

open fun findByRange(range: Range): Optional<Node>

findCompilationUnit

open fun findCompilationUnit(): Optional<CompilationUnit>

findData

open fun <M> findData(key: DataKey<M>): Optional<M>

Gets data for this node using the given key or returns an Optional.empty().

findFirst

open fun <N : Node?> findFirst(nodeType: Class<N>): Optional<N>

Walks the AST with pre-order traversal, returning the first node of type "nodeType" or empty() if none is found.

open fun <T> findFirst(traversal: Node.TreeTraversal, consumer: (Node) -> Optional<T>): Optional<T>

Walks the AST, applying the function for every node, with traversal algorithm "traversal".

open fun <N : Node?> findFirst(nodeType: Class<N>, predicate: Predicate<N>): Optional<N>

Walks the AST with pre-order traversal, returning the first node of type "nodeType" that matches "predicate" or empty() if none is found.

findRootNode

open fun findRootNode(): Node

Finds the root node of this AST by finding the topmost parent.

getAllContainedComments

open fun getAllContainedComments(): List<Comment>

This is the list of Comment which are contained in the Node either because they are properly associated to one of its children or because they are floating around inside the Node

getAssociatedSpecificationComments