1 ///////////////////////////////////////////////////////////////////////////////////////////////
2 // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3 // Copyright (C) 2001-2026 the original author or authors.
4 //
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License, or (at your option) any later version.
9 //
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 ///////////////////////////////////////////////////////////////////////////////////////////////
19
20 package com.puppycrawl.tools.checkstyle.api;
21
22 import com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageLexer;
23
24 /**
25 * Contains the constants for all the tokens contained in the Abstract
26 * Syntax Tree.
27 *
28 * <p>Implementation detail: This class has been introduced to break
29 * the circular dependency between packages.</p>
30 *
31 * @noinspection ClassWithTooManyDependents
32 * @noinspectionreason ClassWithTooManyDependents - this class is a core part of our API
33 */
34 public final class TokenTypes {
35
36 /**
37 * This is the root node for the source file. It's children
38 * are an optional package definition, zero or more import statements,
39 * and zero or more type declarations.
40 *
41 * <p>For example:</p>
42 * <pre>
43 * import java.util.List;
44 *
45 * class MyClass{}
46 * interface MyInterface{}
47 * ;
48 * </pre>
49 *
50 * <p>parses as:</p>
51 *
52 * <pre>
53 * COMPILATION_UNIT -> COMPILATION_UNIT
54 * |--IMPORT -> import
55 * | |--DOT -> .
56 * | | |--DOT -> .
57 * | | | |--IDENT -> java
58 * | | | `--IDENT -> util
59 * | | `--IDENT -> List
60 * | `--SEMI -> ;
61 * |--CLASS_DEF -> CLASS_DEF
62 * | |--MODIFIERS -> MODIFIERS
63 * | |--LITERAL_CLASS -> class
64 * | |--IDENT -> MyClass
65 * | `--OBJBLOCK -> OBJBLOCK
66 * | |--LCURLY -> {
67 * | `--RCURLY -> }
68 * |--INTERFACE_DEF -> INTERFACE_DEF
69 * | |--MODIFIERS -> MODIFIERS
70 * | |--LITERAL_INTERFACE -> interface
71 * | |--IDENT -> MyInterface
72 * | `--OBJBLOCK -> OBJBLOCK
73 * | |--LCURLY -> {
74 * | `--RCURLY -> }
75 * `--SEMI -> ;
76 * </pre>
77 *
78 * @see #PACKAGE_DEF
79 * @see #IMPORT
80 * @see #CLASS_DEF
81 * @see #INTERFACE_DEF
82 * @see #RECORD_DEF
83 * @see #ANNOTATION_DEF
84 * @see #ENUM_DEF
85 **/
86 public static final int COMPILATION_UNIT = JavaLanguageLexer.COMPILATION_UNIT;
87
88 /**
89 * The root of an AST for a JEP 512 (JDK 25) compact source file. This node
90 * replaces {@link #COMPILATION_UNIT} as the root when the source file declares
91 * any top-level method or field. It represents a {@code CompactCompilationUnit},
92 * which is one of the three mutually exclusive compilation-unit
93 * forms ({@code OrdinaryCompilationUnit}, {@code CompactCompilationUnit},
94 * {@code ModularCompilationUnit}). Import declarations and top-level members
95 * appear as direct children of this node. Compact source files cannot declare
96 * a package.
97 *
98 * <p>For example:</p>
99 * <pre>
100 * import java.util.List;
101 *
102 * int counter = 3;
103 * void main() {}
104 * </pre>
105 *
106 * <p>parses as:</p>
107 * <pre>
108 * COMPACT_COMPILATION_UNIT -> COMPACT_COMPILATION_UNIT
109 * |--IMPORT -> import
110 * | |--DOT -> .
111 * | | |--DOT -> .
112 * | | | |--IDENT -> java
113 * | | | `--IDENT -> util
114 * | | `--IDENT -> List
115 * | `--SEMI -> ;
116 * |--VARIABLE_DEF -> VARIABLE_DEF
117 * | |--MODIFIERS -> MODIFIERS
118 * | |--TYPE -> TYPE
119 * | | `--LITERAL_INT -> int
120 * | |--IDENT -> counter
121 * | |--ASSIGN -> =
122 * | | `--EXPR -> EXPR
123 * | | `--NUM_INT -> 3
124 * | `--SEMI -> ;
125 * `--METHOD_DEF -> METHOD_DEF
126 * |--MODIFIERS -> MODIFIERS
127 * |--TYPE -> TYPE
128 * | `--LITERAL_VOID -> void
129 * |--IDENT -> main
130 * |--LPAREN -> (
131 * |--PARAMETERS -> PARAMETERS
132 * |--RPAREN -> )
133 * `--SLIST -> {
134 * `--RCURLY -> }
135 * </pre>
136 *
137 * @see <a href="https://openjdk.org/jeps/512">JEP 512: Compact Source Files
138 * and Instance Main Methods</a>
139 * @see #COMPILATION_UNIT
140 **/
141 public static final int COMPACT_COMPILATION_UNIT =
142 JavaLanguageLexer.COMPACT_COMPILATION_UNIT;
143
144 /**
145 * Modifiers for type, method, and field declarations. The
146 * modifiers element is always present even though it may have no
147 * children.
148 *
149 * <p>For example:</p>
150 * <pre>
151 * public int x;
152 * </pre>
153 *
154 * <p>parses as:</p>
155 * <pre>
156 * VARIABLE_DEF -> VARIABLE_DEF
157 * |--MODIFIERS -> MODIFIERS
158 * | `--LITERAL_PUBLIC -> public
159 * |--TYPE -> TYPE
160 * | `--LITERAL_INT -> int
161 * |--IDENT -> x
162 * `--SEMI -> ;
163 * </pre>
164 *
165 * @see <a
166 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java
167 * Language Specification, §8</a>
168 * @see #LITERAL_PUBLIC
169 * @see #LITERAL_PROTECTED
170 * @see #LITERAL_PRIVATE
171 * @see #ABSTRACT
172 * @see #LITERAL_STATIC
173 * @see #FINAL
174 * @see #LITERAL_TRANSIENT
175 * @see #LITERAL_VOLATILE
176 * @see #LITERAL_SYNCHRONIZED
177 * @see #LITERAL_NATIVE
178 * @see #STRICTFP
179 * @see #ANNOTATION
180 * @see #LITERAL_DEFAULT
181 **/
182 public static final int MODIFIERS = JavaLanguageLexer.MODIFIERS;
183
184 /**
185 * An object block. These are children of class, interface, enum,
186 * annotation and enum constant declarations.
187 * Also, object blocks are children of the new keyword when defining
188 * anonymous inner types.
189 *
190 * <p>For example:</p>
191 * <pre>
192 * class Test {}
193 * </pre>
194 *
195 * <p>parses as:</p>
196 * <pre>
197 * CLASS_DEF -> CLASS_DEF
198 * |--MODIFIERS -> MODIFIERS
199 * |--LITERAL_CLASS -> class
200 * |--IDENT -> Test
201 * `--OBJBLOCK -> OBJBLOCK
202 * |--LCURLY -> {
203 * `--RCURLY -> }
204 * </pre>
205 *
206 * @see #LCURLY
207 * @see #INSTANCE_INIT
208 * @see #STATIC_INIT
209 * @see #CLASS_DEF
210 * @see #CTOR_DEF
211 * @see #METHOD_DEF
212 * @see #VARIABLE_DEF
213 * @see #RCURLY
214 * @see #INTERFACE_DEF
215 * @see #LITERAL_NEW
216 * @see #ENUM_DEF
217 * @see #ENUM_CONSTANT_DEF
218 * @see #ANNOTATION_DEF
219 **/
220 public static final int OBJBLOCK = JavaLanguageLexer.OBJBLOCK;
221 /**
222 * A list of statements.
223 *
224 * <p>For example:</p>
225 * <pre>
226 * if (c == 1) {
227 * c = 0;
228 * }
229 * </pre>
230 *
231 * <p>parses as:</p>
232 * <pre>
233 * LITERAL_IF -> if
234 * |--LPAREN -> (
235 * |--EXPR -> EXPR
236 * | `--EQUAL -> ==
237 * | |--IDENT -> c
238 * | `--NUM_INT -> 1
239 * |--RPAREN -> )
240 * `--SLIST -> {
241 * |--EXPR -> EXPR
242 * | `--ASSIGN -> =
243 * | |--IDENT -> c
244 * | `--NUM_INT -> 0
245 * |--SEMI -> ;
246 * `--RCURLY -> }
247 * </pre>
248 *
249 * @see #RCURLY
250 * @see #EXPR
251 * @see #LABELED_STAT
252 * @see #LITERAL_THROWS
253 * @see #LITERAL_RETURN
254 * @see #SEMI
255 * @see #METHOD_DEF
256 * @see #CTOR_DEF
257 * @see #LITERAL_FOR
258 * @see #LITERAL_WHILE
259 * @see #LITERAL_IF
260 * @see #LITERAL_ELSE
261 * @see #CASE_GROUP
262 **/
263 public static final int SLIST = JavaLanguageLexer.SLIST;
264 /**
265 * A constructor declaration.
266 *
267 * <p>For example:</p>
268 * <pre>
269 * public SpecialEntry(int value, String text)
270 * {
271 * this.value = value;
272 * this.text = text;
273 * }
274 * </pre>
275 *
276 * <p>parses as:</p>
277 * <pre>
278 * CTOR_DEF -> CTOR_DEF
279 * |--MODIFIERS -> MODIFIERS
280 * | `--LITERAL_PUBLIC -> public
281 * |--IDENT -> SpecialEntry
282 * |--LPAREN -> (
283 * |--PARAMETERS -> PARAMETERS
284 * | |--PARAMETER_DEF -> PARAMETER_DEF
285 * | | |--MODIFIERS -> MODIFIERS
286 * | | |--TYPE -> TYPE
287 * | | | `--LITERAL_INT -> int
288 * | | `--IDENT -> value
289 * | |--COMMA -> ,
290 * | `--PARAMETER_DEF -> PARAMETER_DEF
291 * | |--MODIFIERS -> MODIFIERS
292 * | |--TYPE -> TYPE
293 * | | `--IDENT -> String
294 * | `--IDENT -> text
295 * |--RPAREN -> )
296 * `--SLIST -> {
297 * |--EXPR -> EXPR
298 * | `--ASSIGN -> =
299 * | |--DOT -> .
300 * | |--LITERAL_THIS -> this
301 * | | `--IDENT -> value
302 * | `--IDENT -> value
303 * |--SEMI -> ;
304 * |--EXPR -> EXPR
305 * | `--ASSIGN -> =
306 * | |--DOT -> .
307 * | | |--LITERAL_THIS -> this
308 * | | `--IDENT -> text
309 * | `--IDENT -> text
310 * |--SEMI -> ;
311 * `--RCURLY -> }
312 * </pre>
313 *
314 * @see #OBJBLOCK
315 * @see #CLASS_DEF
316 **/
317 public static final int CTOR_DEF = JavaLanguageLexer.CTOR_DEF;
318 /**
319 * A method declaration. The children are modifiers, type parameters,
320 * return type, method name, parameter list, an optional throws list, and
321 * statement list. The statement list is omitted if the method
322 * declaration appears in an interface declaration. Method
323 * declarations may appear inside object blocks of class
324 * declarations, interface declarations, enum declarations,
325 * enum constant declarations or anonymous inner-class declarations.
326 *
327 * <p>For example:</p>
328 *
329 * <pre>
330 * public static int square(int x)
331 * {
332 * return x*x;
333 * }
334 * </pre>
335 *
336 * <p>parses as:</p>
337 *
338 * <pre>
339 * --METHOD_DEF -> METHOD_DEF
340 * |--MODIFIERS -> MODIFIERS
341 * | |--LITERAL_PUBLIC -> public
342 * | `--LITERAL_STATIC -> static
343 * |--TYPE -> TYPE
344 * | `--LITERAL_INT -> int
345 * |--IDENT -> square
346 * |--LPAREN -> (
347 * |--PARAMETERS -> PARAMETERS
348 * | `--PARAMETER_DEF -> PARAMETER_DEF
349 * | |--MODIFIERS -> MODIFIERS
350 * | |--TYPE -> TYPE
351 * | | `--LITERAL_INT -> int
352 * | `--IDENT -> x
353 * |--RPAREN -> )
354 * `--SLIST -> {
355 * |--LITERAL_RETURN -> return
356 * | |--EXPR -> EXPR
357 * | | `--STAR -> *
358 * | | |--IDENT -> x
359 * | | `--IDENT -> x
360 * | `--SEMI -> ;
361 * `--RCURLY -> }
362 * </pre>
363 *
364 * @see #MODIFIERS
365 * @see #TYPE_PARAMETERS
366 * @see #TYPE
367 * @see #IDENT
368 * @see #PARAMETERS
369 * @see #LITERAL_THROWS
370 * @see #SLIST
371 * @see #OBJBLOCK
372 **/
373 public static final int METHOD_DEF = JavaLanguageLexer.METHOD_DEF;
374
375 /**
376 * A field or local variable declaration. The children are
377 * modifiers, type, the identifier name, and an optional
378 * assignment statement.
379 *
380 * <p>For example:</p>
381 * <pre>
382 * final double PI = 3.14;
383 * </pre>
384 *
385 * <p>parses as:</p>
386 * <pre>
387 * VARIABLE_DEF -> VARIABLE_DEF
388 * |--MODIFIERS -> MODIFIERS
389 * | `--FINAL -> final
390 * |--TYPE -> TYPE
391 * | `--LITERAL_DOUBLE -> double
392 * |--IDENT -> PI
393 * |--ASSIGN -> =
394 * | `--EXPR -> EXPR
395 * | `--NUM_FLOAT -> 3.14
396 * `--SEMI -> ;
397 * </pre>
398 *
399 * @see #MODIFIERS
400 * @see #TYPE
401 * @see #IDENT
402 * @see #ASSIGN
403 **/
404 public static final int VARIABLE_DEF =
405 JavaLanguageLexer.VARIABLE_DEF;
406
407 /**
408 * An instance initializer. Zero or more instance initializers
409 * may appear in class and enum definitions. This token will be a child
410 * of the object block of the declaring type.
411 *
412 * <p>For example:</p>
413 * <pre>
414 * public class MyClass {
415 * private int foo;
416 * {foo = 10;}
417 * }
418 * </pre>
419 *
420 * <p>parses as:</p>
421 * <pre>
422 * CLASS_DEF -> CLASS_DEF
423 * |--MODIFIERS -> MODIFIERS
424 * | `--LITERAL_PUBLIC -> public
425 * |--LITERAL_CLASS -> class
426 * |--IDENT -> MyClass
427 * `--OBJBLOCK -> OBJBLOCK
428 * |--LCURLY -> {
429 * |--VARIABLE_DEF -> VARIABLE_DEF
430 * | |--MODIFIERS -> MODIFIERS
431 * | | `--LITERAL_PRIVATE -> private
432 * | |--TYPE -> TYPE
433 * | | `--LITERAL_INT -> int
434 * | |--IDENT -> foo
435 * | `--SEMI -> ;
436 * |--INSTANCE_INIT -> INSTANCE_INIT
437 * | `--SLIST -> {
438 * | |--EXPR -> EXPR
439 * | | `--ASSIGN -> =
440 * | | |--IDENT -> foo
441 * | | `--NUM_INT -> 10
442 * | |--SEMI -> ;
443 * | `--RCURLY -> }
444 * `--RCURLY -> }
445 * </pre>
446 *
447 * @see <a
448 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.6">Java
449 * Language Specification§8.6</a>
450 * @see #SLIST
451 * @see #OBJBLOCK
452 **/
453 public static final int INSTANCE_INIT =
454 JavaLanguageLexer.INSTANCE_INIT;
455
456 /**
457 * A static initialization block. Zero or more static
458 * initializers may be children of the object block of a class
459 * or enum declaration (interfaces cannot have static initializers). The
460 * first and only child is a statement list.
461 *
462 * <p>For Example:</p>
463 * <pre>
464 * static {
465 * num = 10;
466 * }
467 * </pre>
468 *
469 * <p>parses as:</p>
470 * <pre>
471 * STATIC_INIT -> STATIC_INIT
472 * `--SLIST -> {
473 * |--EXPR -> EXPR
474 * | `--ASSIGN -> =
475 * | |--IDENT -> num
476 * | `--NUM_INT -> 10
477 * |--SEMI -> ;
478 * `--RCURLY -> }
479 * </pre>
480 *
481 * @see <a
482 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.7">Java
483 * Language Specification, §8.7</a>
484 * @see #SLIST
485 * @see #OBJBLOCK
486 **/
487 public static final int STATIC_INIT =
488 JavaLanguageLexer.STATIC_INIT;
489
490 /**
491 * A type. This is either a return type of a method or a type of
492 * a variable or field. The first child of this element is the
493 * actual type. This may be a primitive type, an identifier, a
494 * dot which is the root of a fully qualified type, or an array of
495 * any of these. The second child may be type arguments to the type.
496 *
497 * <p>For example:</p>
498 * <pre>boolean var = true;</pre>
499 *
500 * <p>parses as:</p>
501 * <pre>
502 * |--VARIABLE_DEF -> VARIABLE_DEF
503 * | |--MODIFIERS -> MODIFIERS
504 * | |--TYPE -> TYPE
505 * | | `--LITERAL_BOOLEAN -> boolean
506 * | |--IDENT -> var
507 * | `--ASSIGN -> =
508 * | `--EXPR -> EXPR
509 * | `--LITERAL_TRUE -> true
510 * |--SEMI -> ;
511 * </pre>
512 *
513 * @see #VARIABLE_DEF
514 * @see #METHOD_DEF
515 * @see #PARAMETER_DEF
516 * @see #IDENT
517 * @see #DOT
518 * @see #LITERAL_VOID
519 * @see #LITERAL_BOOLEAN
520 * @see #LITERAL_BYTE
521 * @see #LITERAL_CHAR
522 * @see #LITERAL_SHORT
523 * @see #LITERAL_INT
524 * @see #LITERAL_FLOAT
525 * @see #LITERAL_LONG
526 * @see #LITERAL_DOUBLE
527 * @see #ARRAY_DECLARATOR
528 * @see #TYPE_ARGUMENTS
529 **/
530 public static final int TYPE = JavaLanguageLexer.TYPE;
531 /**
532 * A class declaration.
533 *
534 * <p>For example:</p>
535 * <pre>
536 * public class Test {
537 * }
538 * </pre>
539 *
540 * <p>parses as:</p>
541 * <pre>
542 * CLASS_DEF -> CLASS_DEF
543 * |--MODIFIERS -> MODIFIERS
544 * | `--LITERAL_PUBLIC -> public
545 * |--LITERAL_CLASS -> class
546 * |--IDENT -> Test
547 * `--OBJBLOCK -> OBJBLOCK
548 * |--LCURLY -> {
549 * `--RCURLY -> }
550 * </pre>
551 *
552 * @see <a
553 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java
554 * Language Specification, §8</a>
555 * @see #MODIFIERS
556 * @see #IDENT
557 * @see #EXTENDS_CLAUSE
558 * @see #IMPLEMENTS_CLAUSE
559 * @see #OBJBLOCK
560 * @see #LITERAL_NEW
561 **/
562 public static final int CLASS_DEF = JavaLanguageLexer.CLASS_DEF;
563 /**
564 * An interface declaration.
565 *
566 * <p>For example:</p>
567 *
568 * <pre>
569 * public interface MyInterface {
570 *
571 * }
572 * </pre>
573 *
574 * <p>parses as:</p>
575 *
576 * <pre>
577 * INTERFACE_DEF -> INTERFACE_DEF
578 * |--MODIFIERS -> MODIFIERS
579 * | `--LITERAL_PUBLIC -> public
580 * |--LITERAL_INTERFACE -> interface
581 * |--IDENT -> MyInterface
582 * `--OBJBLOCK -> OBJBLOCK
583 * |--LCURLY -> {
584 * `--RCURLY -> }
585 * </pre>
586 *
587 * @see <a
588 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html">Java
589 * Language Specification, §9</a>
590 * @see #MODIFIERS
591 * @see #IDENT
592 * @see #EXTENDS_CLAUSE
593 * @see #OBJBLOCK
594 **/
595 public static final int INTERFACE_DEF =
596 JavaLanguageLexer.INTERFACE_DEF;
597
598 /**
599 * The package declaration. This is optional, but if it is
600 * included, then there is only one package declaration per source
601 * file and it must be the first non-comment in the file. A package
602 * declaration may be annotated in which case the annotations comes
603 * before the rest of the declaration (and are the first children).
604 *
605 * <p>For example:</p>
606 *
607 * <pre>
608 * package com.puppycrawl.tools.checkstyle.api;
609 * </pre>
610 *
611 * <p>parses as:</p>
612 *
613 * <pre>
614 * PACKAGE_DEF -> package
615 * |--ANNOTATIONS -> ANNOTATIONS
616 * |--DOT -> .
617 * | |--DOT -> .
618 * | | |--DOT -> .
619 * | | | |--DOT -> .
620 * | | | | |--IDENT -> com
621 * | | | | `--IDENT -> puppycrawl
622 * | | | `--IDENT -> tools
623 * | | `--IDENT -> checkstyle
624 * | `--IDENT -> api
625 * `--SEMI -> ;
626 * </pre>
627 *
628 * @see <a
629 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.4">Java
630 * Language Specification §7.4</a>
631 * @see #DOT
632 * @see #IDENT
633 * @see #SEMI
634 * @see #ANNOTATIONS
635 * @see FullIdent
636 **/
637 public static final int PACKAGE_DEF = JavaLanguageLexer.PACKAGE_DEF;
638 /**
639 * An array declaration.
640 *
641 * <p>If the array declaration represents a type, then the type of
642 * the array elements is the first child. Multidimensional arrays
643 * may be regarded as arrays of arrays. In other words, the first
644 * child of the array declaration is another array
645 * declaration.</p>
646 *
647 * <p>For example:</p>
648 * <pre>
649 * int[] x;
650 * </pre>
651 *
652 * <p>parses as:</p>
653 * <pre>
654 * VARIABLE_DEF -> VARIABLE_DEF
655 * |--MODIFIERS -> MODIFIERS
656 * |--TYPE -> TYPE
657 * | |--LITERAL_INT -> int
658 * | `--ARRAY_DECLARATOR -> [
659 * | `--RBRACK -> ]
660 * |--IDENT -> x
661 * `--SEMI -> ;
662 * </pre>
663 *
664 * <p>The array declaration may also represent an inline array
665 * definition. In this case, the first child will be either an
666 * expression specifying the length of the array or an array
667 * initialization block.</p>
668 *
669 * @see <a
670 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-10.html">Java
671 * Language Specification §10</a>
672 * @see #TYPE
673 * @see #ARRAY_INIT
674 **/
675 public static final int ARRAY_DECLARATOR =
676 JavaLanguageLexer.ARRAY_DECLARATOR;
677
678 /**
679 * An extends clause. This appears as part of class and interface
680 * definitions. This element appears even if the
681 * {@code extends} keyword is not explicitly used. The child
682 * is an optional identifier.
683 *
684 * <p>For example:</p>
685 * <pre>
686 * public class Test extends ArrayList {
687 * }
688 * </pre>
689 *
690 * <p>parses as:</p>
691 * <pre>
692 * CLASS_DEF -> CLASS_DEF
693 * |--MODIFIERS -> MODIFIERS
694 * | `--LITERAL_PUBLIC -> public
695 * |--LITERAL_CLASS -> class
696 * |--IDENT -> Test
697 * |--EXTENDS_CLAUSE -> extends
698 * | `--IDENT -> ArrayList
699 * `--OBJBLOCK -> OBJBLOCK
700 * |--LCURLY -> {
701 * `--RCURLY -> }
702 * </pre>
703 *
704 * @see #IDENT
705 * @see #DOT
706 * @see #CLASS_DEF
707 * @see #INTERFACE_DEF
708 * @see FullIdent
709 **/
710 public static final int EXTENDS_CLAUSE =
711 JavaLanguageLexer.EXTENDS_CLAUSE;
712
713 /**
714 * An implements clause. This always appears in a class or enum
715 * declaration, even if there are no implemented interfaces. The
716 * children are a comma separated list of zero or more
717 * identifiers.
718 *
719 * <p>For example:</p>
720 * <pre>
721 * public class MyClass implements Collection {
722 *
723 * }
724 * </pre>
725 *
726 * <p>parses as:</p>
727 * <pre>
728 * CLASS_DEF -> CLASS_DEF
729 * |--MODIFIERS -> MODIFIERS
730 * | `--LITERAL_PUBLIC -> public
731 * |--LITERAL_CLASS -> class
732 * |--IDENT -> MyClass
733 * |--IMPLEMENTS_CLAUSE -> implements
734 * | `--IDENT -> Collection
735 * `--OBJBLOCK -> OBJBLOCK
736 * |--LCURLY -> {
737 * `--RCURLY -> }
738 * </pre>
739 *
740 * @see #IDENT
741 * @see #DOT
742 * @see #COMMA
743 * @see #CLASS_DEF
744 * @see #ENUM_DEF
745 **/
746 public static final int IMPLEMENTS_CLAUSE =
747 JavaLanguageLexer.IMPLEMENTS_CLAUSE;
748
749 /**
750 * A list of parameters to a method or constructor. The children
751 * are zero or more parameter declarations separated by commas.
752 *
753 * <p>For example</p>
754 * <pre>
755 * int start, int end
756 * </pre>
757 *
758 * <p>parses as:</p>
759 * <pre>
760 * PARAMETERS -> PARAMETERS
761 * |--PARAMETER_DEF -> PARAMETER_DEF
762 * | |--MODIFIERS -> MODIFIERS
763 * | |--TYPE -> TYPE
764 * | | `--LITERAL_INT -> int
765 * | `--IDENT -> start
766 * |--COMMA -> ,
767 * `--PARAMETER_DEF -> PARAMETER_DEF
768 * |--MODIFIERS -> MODIFIERS
769 * |--TYPE -> TYPE
770 * | `--LITERAL_INT -> int
771 * `--IDENT -> end
772 * </pre>
773 *
774 * @see #PARAMETER_DEF
775 * @see #COMMA
776 * @see #METHOD_DEF
777 * @see #CTOR_DEF
778 **/
779 public static final int PARAMETERS = JavaLanguageLexer.PARAMETERS;
780 /**
781 * A parameter declaration. The last parameter in a list of parameters may
782 * be variable length (indicated by the ELLIPSIS child node immediately
783 * after the TYPE child).
784 *
785 * <p>For example</p>
786 * <pre>
787 * void foo(SomeType SomeType.this, int firstParameter, int... secondParameter) {}
788 * </pre>
789 *
790 * <p>parses as:</p>
791 * <pre>
792 * METHOD_DEF -> METHOD_DEF
793 * |--MODIFIERS -> MODIFIERS
794 * |--TYPE -> TYPE
795 * | `--LITERAL_VOID -> void
796 * |--IDENT -> foo
797 * |--LPAREN -> (
798 * |--PARAMETERS -> PARAMETERS
799 * | |--PARAMETER_DEF -> PARAMETER_DEF
800 * | | |--MODIFIERS -> MODIFIERS
801 * | | |--TYPE -> TYPE
802 * | | | `--IDENT -> SomeType
803 * | | `--DOT -> .
804 * | | |--IDENT -> SomeType
805 * | | `--LITERAL_THIS -> this
806 * | |--COMMA -> ,
807 * | |--PARAMETER_DEF -> PARAMETER_DEF
808 * | | |--MODIFIERS -> MODIFIERS
809 * | | |--TYPE -> TYPE
810 * | | | `--LITERAL_INT -> int
811 * | | `--IDENT -> firstParameter
812 * | |--COMMA -> ,
813 * | `--PARAMETER_DEF -> PARAMETER_DEF
814 * | |--MODIFIERS -> MODIFIERS
815 * | |--TYPE -> TYPE
816 * | | `--LITERAL_INT -> int
817 * | |--ELLIPSIS -> ...
818 * | `--IDENT -> secondParameter
819 * |--RPAREN -> )
820 * `--SLIST -> {
821 * `--RCURLY -> }
822 *
823 * </pre>
824 *
825 * @see #MODIFIERS
826 * @see #TYPE
827 * @see #IDENT
828 * @see #PARAMETERS
829 * @see #ELLIPSIS
830 **/
831 public static final int PARAMETER_DEF =
832 JavaLanguageLexer.PARAMETER_DEF;
833
834 /**
835 * A labeled statement.
836 *
837 * <p>For example:</p>
838 * <pre>
839 * outer:
840 * while (i < 10) {
841 * if (i == 5)
842 * continue outer;
843 * i++;
844 * }
845 * </pre>
846 *
847 * <p>parses as:</p>
848 * <pre>
849 * LABELED_STAT -> :
850 * |--IDENT -> outer
851 * `--LITERAL_WHILE -> while
852 * |--LPAREN -> (
853 * |--EXPR -> EXPR
854 * | `--LT -> <
855 * | |--IDENT -> i
856 * | `--NUM_INT -> 10
857 * |--RPAREN -> )
858 * `--SLIST -> {
859 * |--LITERAL_IF -> if
860 * | |--LPAREN -> (
861 * | |--EXPR -> EXPR
862 * | | `--EQUAL -> ==
863 * | | |--IDENT -> i
864 * | | `--NUM_INT -> 5
865 * | |--RPAREN -> )
866 * | `--LITERAL_CONTINUE -> continue
867 * | |--IDENT -> outer
868 * | `--SEMI -> ;
869 * |--EXPR -> EXPR
870 * | `--POST_INC -> ++
871 * | `--IDENT -> i
872 * |--SEMI -> ;
873 * `--RCURLY -> }
874 * </pre>
875 *
876 * @see <a
877 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.7">Java
878 * Language Specification, §14.7</a>
879 * @see #SLIST
880 **/
881 public static final int LABELED_STAT =
882 JavaLanguageLexer.LABELED_STAT;
883
884 /**
885 * A type-cast.
886 *
887 * <p>For example:</p>
888 * <pre>
889 * (String)it.next()
890 * </pre>
891 *
892 * <p>parses as:</p>
893 * <pre>
894 * `--TYPECAST -> (
895 * |--TYPE -> TYPE
896 * | `--IDENT -> String
897 * |--RPAREN -> )
898 * `--METHOD_CALL -> (
899 * |--DOT -> .
900 * | |--IDENT -> it
901 * | `--IDENT -> next
902 * |--ELIST -> ELIST
903 * `--RPAREN -> )
904 * </pre>
905 *
906 * @see <a
907 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">Java
908 * Language Specification, §15.16</a>
909 * @see #EXPR
910 * @see #TYPE
911 * @see #TYPE_ARGUMENTS
912 * @see #RPAREN
913 **/
914 public static final int TYPECAST = JavaLanguageLexer.TYPECAST;
915 /**
916 * The array index operator.
917 *
918 * <p>For example:</p>
919 * <pre>
920 * arr[0] = 10;
921 * </pre>
922 *
923 * <p>parses as:</p>
924 * <pre>
925 * |--EXPR -> EXPR
926 * | `--ASSIGN -> =
927 * | |--INDEX_OP -> [
928 * | | |--IDENT -> arr
929 * | | |--EXPR -> EXPR
930 * | | | `--NUM_INT -> 0
931 * | | `--RBRACK -> ]
932 * | `--NUM_INT -> 10
933 * |--SEMI -> ;
934 * </pre>
935 *
936 * @see #EXPR
937 **/
938 public static final int INDEX_OP = JavaLanguageLexer.INDEX_OP;
939 /**
940 * The {@code ++} (postfix increment) operator.
941 *
942 * <p>For example:</p>
943 * <pre>
944 * a++;
945 * </pre>
946 *
947 * <p>parses as:</p>
948 * <pre>
949 * |--EXPR -> EXPR
950 * | `--POST_INC -> ++
951 * | `--IDENT -> a
952 * |--SEMI -> ;
953 * </pre>
954 *
955 * @see <a
956 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.1">Java
957 * Language Specification, §15.14.1</a>
958 * @see #EXPR
959 * @see #INC
960 **/
961 public static final int POST_INC = JavaLanguageLexer.POST_INC;
962 /**
963 * The {@code --} (postfix decrement) operator.
964 *
965 * <p>For example:</p>
966 * <pre>
967 * a--;
968 * </pre>
969 *
970 * <p>parses as:</p>
971 * <pre>
972 * |--EXPR -> EXPR
973 * | `--POST_DEC -> --
974 * | `--IDENT -> a
975 * |--SEMI -> ;
976 * </pre>
977 *
978 * @see <a
979 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.2">Java
980 * Language Specification, §15.14.2</a>
981 * @see #EXPR
982 * @see #DEC
983 **/
984 public static final int POST_DEC = JavaLanguageLexer.POST_DEC;
985 /**
986 * A method call. A method call may have type arguments however these
987 * are attached to the appropriate node in the qualified method name.
988 *
989 * <p>For example:</p>
990 * <pre>
991 * Integer.parseInt("123");
992 * </pre>
993 *
994 * <p>parses as:</p>
995 * <pre>
996 * |--EXPR -> EXPR
997 * | `--METHOD_CALL -> (
998 * | |--DOT -> .
999 * | | |--IDENT -> Integer
1000 * | | `--IDENT -> parseInt
1001 * | |--ELIST -> ELIST
1002 * | | `--EXPR -> EXPR
1003 * | | `--STRING_LITERAL -> "123"
1004 * | `--RPAREN -> )
1005 * |--SEMI -> ;
1006 * </pre>
1007 *
1008 *
1009 * @see #IDENT
1010 * @see #TYPE_ARGUMENTS
1011 * @see #DOT
1012 * @see #ELIST
1013 * @see #RPAREN
1014 * @see FullIdent
1015 **/
1016 public static final int METHOD_CALL = JavaLanguageLexer.METHOD_CALL;
1017
1018 /**
1019 * A reference to a method or constructor without arguments. Part of Java 8 syntax.
1020 * The token should be used for subscribing for double colon literal.
1021 * {@link #DOUBLE_COLON} token does not appear in the tree.
1022 *
1023 * <p>For example:</p>
1024 * <pre>
1025 * Comparator<String> compare = String::compareToIgnoreCase;
1026 * </pre>
1027 *
1028 * <p>parses as:
1029 * <pre>
1030 * |--VARIABLE_DEF -> VARIABLE_DEF
1031 * | |--MODIFIERS -> MODIFIERS
1032 * | |--TYPE -> TYPE
1033 * | | |--IDENT -> Comparator
1034 * | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
1035 * | | |--GENERIC_START -> <
1036 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
1037 * | | | `--IDENT -> String
1038 * | | `--GENERIC_END -> >
1039 * | |--IDENT -> compare
1040 * | `--ASSIGN -> =
1041 * | `--EXPR -> EXPR
1042 * | `--METHOD_REF -> ::
1043 * | |--IDENT -> String
1044 * | `--IDENT -> compareToIgnoreCase
1045 * |--SEMI -> ;
1046 * </pre>
1047 *
1048 * @see #IDENT
1049 * @see #DOUBLE_COLON
1050 */
1051 public static final int METHOD_REF = JavaLanguageLexer.METHOD_REF;
1052 /**
1053 * An expression. Operators with lower precedence appear at a
1054 * higher level in the tree than operators with higher precedence.
1055 * Parentheses are siblings to the operator they enclose.
1056 *
1057 * <p>For example:</p>
1058 * <pre>
1059 * int x = 4 + 2 * (5 % 3) + (1 << 3) - 4 * 5;
1060 * </pre>
1061 *
1062 * <p>parses as:</p>
1063 * <pre>
1064 * |--VARIABLE_DEF -> VARIABLE_DEF
1065 * | |--MODIFIERS -> MODIFIERS
1066 * | |--TYPE -> TYPE
1067 * | | `--LITERAL_INT -> int
1068 * | |--IDENT -> x
1069 * | `--ASSIGN -> =
1070 * | `--EXPR -> EXPR
1071 * | `--MINUS -> -
1072 * | |--PLUS -> +
1073 * | | |--PLUS -> +
1074 * | | | |--NUM_INT -> 4
1075 * | | | `--STAR -> *
1076 * | | | |--NUM_INT -> 2
1077 * | | | |--LPAREN -> (
1078 * | | | |--MOD -> %
1079 * | | | | |--NUM_INT -> 5
1080 * | | | | `--NUM_INT -> 3
1081 * | | | `--RPAREN -> )
1082 * | | |--LPAREN -> (
1083 * | | |--SL -> <<
1084 * | | | |--NUM_INT -> 1
1085 * | | | `--NUM_INT -> 3
1086 * | | `--RPAREN -> )
1087 * | `--STAR -> *
1088 * | |--NUM_INT -> 4
1089 * | `--NUM_INT -> 5
1090 * |--SEMI -> ;
1091 * </pre>
1092 *
1093 * @see #ELIST
1094 * @see #ASSIGN
1095 * @see #LPAREN
1096 * @see #RPAREN
1097 **/
1098 public static final int EXPR = JavaLanguageLexer.EXPR;
1099 /**
1100 * An array initialization. This may occur as part of an array
1101 * declaration or inline with {@code new}.
1102 *
1103 * <p>For example:</p>
1104 * <pre>
1105 * int[] y =
1106 * {
1107 * 1,
1108 * 2,
1109 * };
1110 * </pre>
1111 *
1112 * <p>parses as:</p>
1113 * <pre>
1114 * VARIABLE_DEF -> VARIABLE_DEF
1115 * |--MODIFIERS -> MODIFIERS
1116 * |--TYPE -> TYPE
1117 * | |--LITERAL_INT -> int
1118 * | `--ARRAY_DECLARATOR -> [
1119 * | `--RBRACK -> ]
1120 * |--IDENT -> y
1121 * |--ASSIGN -> =
1122 * | `--ARRAY_INIT -> {
1123 * | |--EXPR -> EXPR
1124 * | | `--NUM_INT -> 1
1125 * | |--COMMA -> ,
1126 * | |--EXPR -> EXPR
1127 * | | `--NUM_INT -> 2
1128 * | |--COMMA -> ,
1129 * | `--RCURLY -> }
1130 * `--SEMI -> ;
1131 * </pre>
1132 *
1133 * <p>Also consider:</p>
1134 * <pre>
1135 * int[] z = new int[]
1136 * {
1137 * 1,
1138 * 2,
1139 * };
1140 * </pre>
1141 *
1142 * <p>which parses as:</p>
1143 * <pre>
1144 * VARIABLE_DEF -> VARIABLE_DEF
1145 * |--MODIFIERS -> MODIFIERS
1146 * |--TYPE -> TYPE [2:4]
1147 * | |--LITERAL_INT -> int
1148 * | `--ARRAY_DECLARATOR -> [
1149 * | `--RBRACK -> ]
1150 * |--IDENT -> z
1151 * |--ASSIGN -> =
1152 * | `--EXPR -> EXPR
1153 * | `--LITERAL_NEW -> new
1154 * | |--LITERAL_INT -> int
1155 * | |--ARRAY_DECLARATOR -> [
1156 * | | `--RBRACK -> ]
1157 * | `--ARRAY_INIT -> {
1158 * | |--EXPR -> EXPR
1159 * | | `--NUM_INT -> 1
1160 * | |--COMMA -> ,
1161 * | |--EXPR -> EXPR
1162 * | | `--NUM_INT -> 2
1163 * | |--COMMA -> ,
1164 * | `--RCURLY -> }
1165 * `--SEMI -> ;
1166 * </pre>
1167 *
1168 * @see #ARRAY_DECLARATOR
1169 * @see #TYPE
1170 * @see #LITERAL_NEW
1171 * @see #COMMA
1172 **/
1173 public static final int ARRAY_INIT = JavaLanguageLexer.ARRAY_INIT;
1174 /**
1175 * An import declaration. Import declarations are option, but
1176 * must appear after the package declaration and before the first type
1177 * declaration.
1178 *
1179 * <p>For example:</p>
1180 *
1181 * <pre>
1182 * import java.io.IOException;
1183 * </pre>
1184 *
1185 * <p>parses as:</p>
1186 *
1187 * <pre>
1188 * IMPORT -> import
1189 * |--DOT -> .
1190 * | |--DOT -> .
1191 * | | |--IDENT -> java
1192 * | | `--IDENT -> io
1193 * | `--IDENT -> IOException
1194 * `--SEMI -> ;
1195 * </pre>
1196 *
1197 * @see <a
1198 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5">Java
1199 * Language Specification §7.5</a>
1200 * @see #DOT
1201 * @see #IDENT
1202 * @see #STAR
1203 * @see #SEMI
1204 * @see FullIdent
1205 **/
1206 public static final int IMPORT = JavaLanguageLexer.IMPORT;
1207 /**
1208 * The {@code -} (unary minus) operator.
1209 *
1210 * <p>For example:</p>
1211 * <pre>
1212 * a = -b;
1213 * </pre>
1214 *
1215 * <p>parses as:</p>
1216 * <pre>
1217 * |--EXPR -> EXPR
1218 * | `--ASSIGN -> =
1219 * | |--IDENT -> a
1220 * | `--UNARY_MINUS -> -
1221 * | `--IDENT -> b
1222 * |--SEMI -> ;
1223 * </pre>
1224 *
1225 * @see <a
1226 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.4">Java
1227 * Language Specification, §15.15.4</a>
1228 * @see #EXPR
1229 **/
1230 public static final int UNARY_MINUS = JavaLanguageLexer.UNARY_MINUS;
1231 /**
1232 * The {@code +} (unary plus) operator.
1233 *
1234 * <p>For example:</p>
1235 * <pre>
1236 * a = + b;
1237 * </pre>
1238 *
1239 * <p>parses as:</p>
1240 * <pre>
1241 * |--EXPR -> EXPR
1242 * | `--ASSIGN -> =
1243 * | |--IDENT -> a
1244 * | `--UNARY_PLUS -> +
1245 * | `--IDENT -> b
1246 * |--SEMI -> ;
1247 * </pre>
1248 *
1249 * @see <a
1250 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.3">Java
1251 * Language Specification, §15.15.3</a>
1252 * @see #EXPR
1253 **/
1254 public static final int UNARY_PLUS = JavaLanguageLexer.UNARY_PLUS;
1255 /**
1256 * A group of case clauses. Case clauses with no associated
1257 * statements are grouped together into a case group. The last
1258 * child is a statement list containing the statements to execute
1259 * upon a match.
1260 *
1261 * <p>For example:</p>
1262 * <pre>
1263 * case 0:
1264 * case 1:
1265 * case 2:
1266 * x = 3;
1267 * break;
1268 * </pre>
1269 *
1270 * <p>parses as:</p>
1271 * <pre>
1272 * CASE_GROUP -> CASE_GROUP
1273 * |--LITERAL_CASE -> case
1274 * | |--EXPR -> EXPR
1275 * | | `--NUM_INT -> 0
1276 * | `--COLON -> :
1277 * |--LITERAL_CASE -> case
1278 * | |--EXPR -> EXPR
1279 * | | `--NUM_INT -> 1
1280 * | `--COLON -> :
1281 * |--LITERAL_CASE -> case
1282 * | |--EXPR -> EXPR
1283 * | | `--NUM_INT -> 2
1284 * | `--COLON -> :
1285 * `--SLIST -> SLIST
1286 * |--EXPR -> EXPR
1287 * | `--ASSIGN -> =
1288 * | |--IDENT -> x
1289 * | `--NUM_INT -> 3
1290 * |--SEMI -> ;
1291 * `--LITERAL_BREAK -> break
1292 * `--SEMI -> ;
1293 * </pre>
1294 *
1295 * @see #LITERAL_CASE
1296 * @see #LITERAL_DEFAULT
1297 * @see #LITERAL_SWITCH
1298 * @see #LITERAL_YIELD
1299 **/
1300 public static final int CASE_GROUP = JavaLanguageLexer.CASE_GROUP;
1301 /**
1302 * An expression list. The children are a comma separated list of
1303 * expressions.
1304 *
1305 * <p>For example:</p>
1306 * <pre>
1307 * new ArrayList(50);
1308 * </pre>
1309 *
1310 * <p>parses as:</p>
1311 * <pre>
1312 * |--EXPR -> EXPR
1313 * | `--LITERAL_NEW -> new
1314 * | |--IDENT -> ArrayList
1315 * | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
1316 * | | |--GENERIC_START -> <
1317 * | | `--GENERIC_END -> >
1318 * | |--LPAREN -> (
1319 * | |--ELIST -> ELIST
1320 * | | `--EXPR -> EXPR
1321 * | | `--NUM_INT -> 50
1322 * | `--RPAREN -> )
1323 * |--SEMI -> ;
1324 * </pre>
1325 *
1326 * @see #LITERAL_NEW
1327 * @see #FOR_INIT
1328 * @see #FOR_ITERATOR
1329 * @see #EXPR
1330 * @see #METHOD_CALL
1331 * @see #CTOR_CALL
1332 * @see #SUPER_CTOR_CALL
1333 **/
1334 public static final int ELIST = JavaLanguageLexer.ELIST;
1335 /**
1336 * A for loop initializer. This is a child of
1337 * {@code LITERAL_FOR}. The children of this element may be
1338 * a comma separated list of variable declarations, an expression
1339 * list, or empty.
1340 *
1341 * <p>For example:</p>
1342 * <pre>
1343 * for (int i = 0; i < arr.length; i++) {}
1344 * </pre>
1345 *
1346 * <p>parses as:</p>
1347 * <pre>
1348 * LITERAL_FOR -> for
1349 * |--LPAREN -> (
1350 * |--FOR_INIT -> FOR_INIT
1351 * | `--VARIABLE_DEF -> VARIABLE_DEF
1352 * | |--MODIFIERS -> MODIFIERS
1353 * | |--TYPE -> TYPE
1354 * | | `--LITERAL_INT -> int
1355 * | |--IDENT -> i
1356 * | `--ASSIGN -> =
1357 * | `--EXPR -> EXPR
1358 * | `--NUM_INT -> 0
1359 * |--SEMI -> ;
1360 * |--FOR_CONDITION -> FOR_CONDITION
1361 * | `--EXPR -> EXPR
1362 * | `--LT -> <
1363 * | |--IDENT -> i
1364 * | `--DOT -> .
1365 * | |--IDENT -> arr
1366 * | `--IDENT -> length
1367 * |--SEMI -> ;
1368 * |--FOR_ITERATOR -> FOR_ITERATOR
1369 * | `--ELIST -> ELIST
1370 * | `--EXPR -> EXPR
1371 * | `--POST_INC -> ++
1372 * | `--IDENT -> i
1373 * |--RPAREN -> )
1374 * `--SLIST -> {
1375 * `--RCURLY -> }
1376 * </pre>
1377 *
1378 * @see #VARIABLE_DEF
1379 * @see #ELIST
1380 * @see #LITERAL_FOR
1381 **/
1382 public static final int FOR_INIT = JavaLanguageLexer.FOR_INIT;
1383 /**
1384 * A for loop condition. This is a child of
1385 * {@code LITERAL_FOR}. The child of this element is an
1386 * optional expression.
1387 *
1388 * <p>For example:</p>
1389 * <pre>
1390 * for (int i = 0; i < arr.length; i++) {}
1391 * </pre>
1392 *
1393 * <p>parses as:</p>
1394 * <pre>
1395 * LITERAL_FOR -> for
1396 * |--LPAREN -> (
1397 * |--FOR_INIT -> FOR_INIT
1398 * | `--VARIABLE_DEF -> VARIABLE_DEF
1399 * | |--MODIFIERS -> MODIFIERS
1400 * | |--TYPE -> TYPE
1401 * | | `--LITERAL_INT -> int
1402 * | |--IDENT -> i
1403 * | `--ASSIGN -> =
1404 * | `--EXPR -> EXPR
1405 * | `--NUM_INT -> 0
1406 * |--SEMI -> ;
1407 * |--FOR_CONDITION -> FOR_CONDITION
1408 * | `--EXPR -> EXPR
1409 * | `--LT -> <
1410 * | |--IDENT -> i
1411 * | `--DOT -> .
1412 * | |--IDENT -> arr
1413 * | `--IDENT -> length
1414 * |--SEMI -> ;
1415 * |--FOR_ITERATOR -> FOR_ITERATOR
1416 * | `--ELIST -> ELIST
1417 * | `--EXPR -> EXPR
1418 * | `--POST_INC -> ++
1419 * | `--IDENT -> i
1420 * |--RPAREN -> )
1421 * `--SLIST -> {
1422 * `--RCURLY -> }
1423 * </pre>
1424 *
1425 * @see #EXPR
1426 * @see #LITERAL_FOR
1427 **/
1428 public static final int FOR_CONDITION =
1429 JavaLanguageLexer.FOR_CONDITION;
1430
1431 /**
1432 * A for loop iterator. This is a child of
1433 * {@code LITERAL_FOR}. The child of this element is an
1434 * optional expression list.
1435 *
1436 * <p>For example:</p>
1437 * <pre>
1438 * for (int i = 0; i < arr.length; i++) {}
1439 * </pre>
1440 *
1441 * <p>parses as:</p>
1442 * <pre>
1443 * LITERAL_FOR -> for
1444 * |--LPAREN -> (
1445 * |--FOR_INIT -> FOR_INIT
1446 * | `--VARIABLE_DEF -> VARIABLE_DEF
1447 * | |--MODIFIERS -> MODIFIERS
1448 * | |--TYPE -> TYPE
1449 * | | `--LITERAL_INT -> int
1450 * | |--IDENT -> i
1451 * | `--ASSIGN -> =
1452 * | `--EXPR -> EXPR
1453 * | `--NUM_INT -> 0
1454 * |--SEMI -> ;
1455 * |--FOR_CONDITION -> FOR_CONDITION
1456 * | `--EXPR -> EXPR
1457 * | `--LT -> <
1458 * | |--IDENT -> i
1459 * | `--DOT -> .
1460 * | |--IDENT -> arr
1461 * | `--IDENT -> length
1462 * |--SEMI -> ;
1463 * |--FOR_ITERATOR -> FOR_ITERATOR
1464 * | `--ELIST -> ELIST
1465 * | `--EXPR -> EXPR
1466 * | `--POST_INC -> ++
1467 * | `--IDENT -> i
1468 * |--RPAREN -> )
1469 * `--SLIST -> {
1470 * `--RCURLY -> }
1471 * </pre>
1472 *
1473 * @see #ELIST
1474 * @see #LITERAL_FOR
1475 **/
1476 public static final int FOR_ITERATOR =
1477 JavaLanguageLexer.FOR_ITERATOR;
1478
1479 /**
1480 * The empty statement. This goes in place of an
1481 * {@code SLIST} for a {@code for} or {@code while}
1482 * loop body.
1483 *
1484 * <p>For example:</p>
1485 * <pre>
1486 * while(true);
1487 * </pre>
1488 *
1489 * <p>parses as:</p>
1490 * <pre>
1491 * LITERAL_WHILE -> while
1492 * |--LPAREN -> (
1493 * |--EXPR -> EXPR
1494 * | `--LITERAL_TRUE -> true
1495 * |--RPAREN -> )
1496 * `--EMPTY_STAT -> ;
1497 * </pre>
1498 *
1499 * @see <a
1500 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.6">Java
1501 * Language Specification, §14.6</a>
1502 * @see #LITERAL_FOR
1503 * @see #LITERAL_WHILE
1504 **/
1505 public static final int EMPTY_STAT = JavaLanguageLexer.EMPTY_STAT;
1506 /**
1507 * The {@code final} keyword.
1508 *
1509 * <p>For example:</p>
1510 * <pre>
1511 * public final int x = 0;
1512 * </pre>
1513 *
1514 * <p>parses as:</p>
1515 * <pre>
1516 * VARIABLE_DEF -> VARIABLE_DEF
1517 * |--MODIFIERS -> MODIFIERS
1518 * | |--LITERAL_PUBLIC -> public
1519 * | `--FINAL -> final
1520 * |--TYPE -> TYPE
1521 * | `--LITERAL_INT -> int
1522 * |--IDENT -> x
1523 * |--ASSIGN -> =
1524 * | `--EXPR -> EXPR
1525 * | `--NUM_INT -> 0
1526 * `--SEMI -> ;
1527 * </pre>
1528 *
1529 * @see #MODIFIERS
1530 **/
1531 public static final int FINAL = JavaLanguageLexer.FINAL;
1532 /**
1533 * The {@code abstract} keyword.
1534 *
1535 * <p>For example:</p>
1536 * <pre>
1537 * public abstract class MyClass
1538 * {
1539 * }
1540 * </pre>
1541 *
1542 * <p>parses as:</p>
1543 * <pre>
1544 * --CLASS_DEF
1545 * |--MODIFIERS
1546 * | |--LITERAL_PUBLIC (public)
1547 * | `--ABSTRACT (abstract)
1548 * |--LITERAL_CLASS (class)
1549 * |--IDENT (MyClass)
1550 * `--OBJBLOCK
1551 * |--LCURLY ({)
1552 * `--RCURLY (})
1553 * </pre>
1554 *
1555 * @see #MODIFIERS
1556 **/
1557 public static final int ABSTRACT = JavaLanguageLexer.ABSTRACT;
1558 /**
1559 * The {@code strictfp} keyword.
1560 *
1561 * <p>For example:</p>
1562 * <pre>public strictfp class Test {}</pre>
1563 *
1564 * <p>parses as:</p>
1565 * <pre>
1566 * CLASS_DEF -> CLASS_DEF
1567 * |--MODIFIERS -> MODIFIERS
1568 * | |--LITERAL_PUBLIC -> public
1569 * | `--STRICTFP -> strictfp
1570 * |--LITERAL_CLASS -> class
1571 * |--IDENT -> Test
1572 * `--OBJBLOCK -> OBJBLOCK
1573 * |--LCURLY -> {
1574 * `--RCURLY -> }
1575 * </pre>
1576 *
1577 * @see #MODIFIERS
1578 **/
1579 public static final int STRICTFP = JavaLanguageLexer.STRICTFP;
1580 /**
1581 * A super constructor call.
1582 *
1583 * <p>For example:</p>
1584 * <pre>
1585 * super(1);
1586 * </pre>
1587 *
1588 * <p>parses as:</p>
1589 * <pre>
1590 * SUPER_CTOR_CALL -> super
1591 * |--LPAREN -> (
1592 * |--ELIST -> ELIST
1593 * | `--EXPR -> EXPR
1594 * | `--NUM_INT -> 1
1595 * |--RPAREN -> )
1596 * `--SEMI -> ;
1597 * </pre>
1598 *
1599 * @see #ELIST
1600 * @see #RPAREN
1601 * @see #SEMI
1602 * @see #CTOR_CALL
1603 **/
1604 public static final int SUPER_CTOR_CALL =
1605 JavaLanguageLexer.SUPER_CTOR_CALL;
1606
1607 /**
1608 * A constructor call.
1609 *
1610 * <p>For example:</p>
1611 * <pre>
1612 * this(1);
1613 * </pre>
1614 *
1615 * <p>parses as:</p>
1616 * <pre>
1617 * CTOR_CALL -> this
1618 * |--LPAREN -> (
1619 * |--ELIST -> ELIST
1620 * | `--EXPR -> EXPR
1621 * | `--NUM_INT -> 1
1622 * |--RPAREN -> )
1623 * `--SEMI -> ;
1624 * </pre>
1625 *
1626 * @see #ELIST
1627 * @see #RPAREN
1628 * @see #SEMI
1629 * @see #SUPER_CTOR_CALL
1630 **/
1631 public static final int CTOR_CALL = JavaLanguageLexer.CTOR_CALL;
1632
1633 /**
1634 * The statement terminator ({@code ;}). Depending on the
1635 * context, this make occur as a sibling, a child, or not at all.
1636 *
1637 * <p>For example:</p>
1638 * <pre>
1639 * for(;;);
1640 * </pre>
1641 *
1642 * <p>parses as:</p>
1643 * <pre>
1644 * LITERAL_FOR -> for
1645 * |--LPAREN -> (
1646 * |--FOR_INIT -> FOR_INIT
1647 * |--SEMI -> ;
1648 * |--FOR_CONDITION -> FOR_CONDITION
1649 * |--SEMI -> ;
1650 * |--FOR_ITERATOR -> FOR_ITERATOR
1651 * |--RPAREN -> )
1652 * `--EMPTY_STAT -> ;
1653 * </pre>
1654 *
1655 * @see #PACKAGE_DEF
1656 * @see #IMPORT
1657 * @see #SLIST
1658 * @see #ARRAY_INIT
1659 * @see #LITERAL_FOR
1660 **/
1661 public static final int SEMI = JavaLanguageLexer.SEMI;
1662
1663 /**
1664 * The {@code ]} symbol.
1665 *
1666 * <p>For example:</p>
1667 * <pre>
1668 * int a[];
1669 * </pre>
1670 *
1671 * <p>parses as:</p>
1672 * <pre>
1673 * VARIABLE_DEF -> VARIABLE_DEF
1674 * |--MODIFIERS -> MODIFIERS
1675 * |--TYPE -> TYPE
1676 * | |--LITERAL_INT -> int
1677 * | `--ARRAY_DECLARATOR -> [
1678 * | `--RBRACK -> ]
1679 * |--IDENT -> a
1680 * `--SEMI -> ;
1681 * </pre>
1682 *
1683 * @see #INDEX_OP
1684 * @see #ARRAY_DECLARATOR
1685 **/
1686 public static final int RBRACK = JavaLanguageLexer.RBRACK;
1687 /**
1688 * The {@code void} keyword.
1689 *
1690 * <p>For example:</p>
1691 * <pre>
1692 * {@code void LITERAL_VOID(){}}
1693 * </pre>
1694 *
1695 * <p>'void' parses as:</p>
1696 * <pre>
1697 * METHOD_DEF -> METHOD_DEF
1698 * |--MODIFIERS -> MODIFIERS
1699 * |--TYPE -> TYPE
1700 * | `--LITERAL_VOID -> void
1701 * |--IDENT -> LITERAL_VOID
1702 * </pre>
1703 *
1704 * @see #TYPE
1705 **/
1706 public static final int LITERAL_VOID =
1707 JavaLanguageLexer.LITERAL_VOID;
1708
1709 /**
1710 * The {@code boolean} keyword.
1711 *
1712 * <p>For example:</p>
1713 * <pre>
1714 * public boolean flag;
1715 * </pre>
1716 *
1717 * <p>parses as:</p>
1718 * <pre>
1719 * VARIABLE_DEF -> VARIABLE_DEF
1720 * |--MODIFIERS -> MODIFIERS
1721 * | `--LITERAL_PUBLIC -> public
1722 * |--TYPE -> TYPE
1723 * | `--LITERAL_BOOLEAN -> boolean
1724 * |--IDENT -> flag
1725 * `--SEMI -> ;
1726 * </pre>
1727 *
1728 * @see #TYPE
1729 **/
1730 public static final int LITERAL_BOOLEAN =
1731 JavaLanguageLexer.LITERAL_BOOLEAN;
1732
1733 /**
1734 * The {@code byte} keyword.
1735 *
1736 * <p>For example:</p>
1737 * <pre>
1738 * public byte x;
1739 * </pre>
1740 *
1741 * <p>parses as:</p>
1742 * <pre>
1743 * VARIABLE_DEF -> VARIABLE_DEF
1744 * |--MODIFIERS -> MODIFIERS
1745 * | `--LITERAL_PUBLIC -> public
1746 * |--TYPE -> TYPE
1747 * | `--LITERAL_BYTE -> byte
1748 * |--IDENT -> x
1749 * `--SEMI -> ;
1750 * </pre>
1751 *
1752 * @see #TYPE
1753 **/
1754 public static final int LITERAL_BYTE =
1755 JavaLanguageLexer.LITERAL_BYTE;
1756
1757 /**
1758 * The {@code char} keyword.
1759 *
1760 * <p>For example:</p>
1761 * <pre>
1762 * char a = 'A';
1763 * </pre>
1764 *
1765 * <p>parses as:</p>
1766 * <pre>
1767 * VARIABLE_DEF -> VARIABLE_DEF
1768 * |--MODIFIERS -> MODIFIERS
1769 * |--TYPE -> TYPE
1770 * | `--LITERAL_CHAR -> char
1771 * |--IDENT -> a
1772 * |--ASSIGN -> =
1773 * | `--EXPR -> EXPR
1774 * | `--CHAR_LITERAL -> 'A'
1775 * `--SEMI -> ;
1776 * </pre>
1777 *
1778 * @see #TYPE
1779 **/
1780 public static final int LITERAL_CHAR =
1781 JavaLanguageLexer.LITERAL_CHAR;
1782
1783 /**
1784 * The {@code short} keyword.
1785 *
1786 * <p>For example:</p>
1787 * <pre>
1788 * public short x;
1789 * </pre>
1790 *
1791 * <p>parses as:</p>
1792 * <pre>
1793 * VARIABLE_DEF -> VARIABLE_DEF
1794 * |--MODIFIERS -> MODIFIERS
1795 * | `--LITERAL_PUBLIC -> public
1796 * |--TYPE -> TYPE
1797 * | `--LITERAL_SHORT -> short
1798 * |--IDENT -> x
1799 * `--SEMI -> ;
1800 * </pre>
1801 *
1802 * @see #TYPE
1803 **/
1804 public static final int LITERAL_SHORT =
1805 JavaLanguageLexer.LITERAL_SHORT;
1806
1807 /**
1808 * The {@code int} keyword.
1809 *
1810 * <p>For example:</p>
1811 * <pre>
1812 * public int x;
1813 * </pre>
1814 *
1815 * <p>parses as:</p>
1816 * <pre>
1817 * VARIABLE_DEF -> VARIABLE_DEF
1818 * |--MODIFIERS -> MODIFIERS
1819 * | `--LITERAL_PUBLIC -> public
1820 * |--TYPE -> TYPE
1821 * | `--LITERAL_INT -> int
1822 * |--IDENT -> x
1823 * `--SEMI -> ;
1824 * </pre>
1825 *
1826 * @see #TYPE
1827 **/
1828 public static final int LITERAL_INT = JavaLanguageLexer.LITERAL_INT;
1829 /**
1830 * The {@code float} keyword.
1831 *
1832 * <p>For example:</p>
1833 * <pre>
1834 * public float x;
1835 * </pre>
1836 *
1837 * <p>parses as:</p>
1838 * <pre>
1839 * VARIABLE_DEF -> VARIABLE_DEF
1840 * |--MODIFIERS -> MODIFIERS
1841 * | `--LITERAL_PUBLIC -> public
1842 * |--TYPE -> TYPE
1843 * | `--LITERAL_FLOAT -> float
1844 * |--IDENT -> x
1845 * `--SEMI -> ;
1846 * </pre>
1847 *
1848 * @see #TYPE
1849 **/
1850 public static final int LITERAL_FLOAT =
1851 JavaLanguageLexer.LITERAL_FLOAT;
1852
1853 /**
1854 * The {@code long} keyword.
1855 *
1856 * <p>For example:</p>
1857 * <pre>
1858 * public long x;
1859 * </pre>
1860 *
1861 * <p>parses as:</p>
1862 * <pre>
1863 * VARIABLE_DEF -> VARIABLE_DEF
1864 * |--MODIFIERS -> MODIFIERS
1865 * | `--LITERAL_PUBLIC -> public
1866 * |--TYPE -> TYPE
1867 * | `--LITERAL_LONG -> long
1868 * |--IDENT -> x
1869 * `--SEMI -> ;
1870 * </pre>
1871 *
1872 * @see #TYPE
1873 **/
1874 public static final int LITERAL_LONG =
1875 JavaLanguageLexer.LITERAL_LONG;
1876
1877 /**
1878 * The {@code double} keyword.
1879 *
1880 * <p>For example:</p>
1881 * <pre>
1882 * public double x;
1883 * </pre>
1884 *
1885 * <p>parses as:</p>
1886 * <pre>
1887 * VARIABLE_DEF -> VARIABLE_DEF
1888 * |--MODIFIERS -> MODIFIERS
1889 * | `--LITERAL_PUBLIC -> public
1890 * |--TYPE -> TYPE
1891 * | `--LITERAL_DOUBLE -> double
1892 * |--IDENT -> x
1893 * `--SEMI -> ;
1894 * </pre>
1895 *
1896 * @see #TYPE
1897 **/
1898 public static final int LITERAL_DOUBLE =
1899 JavaLanguageLexer.LITERAL_DOUBLE;
1900
1901 /**
1902 * An identifier. These can be names of types, subpackages,
1903 * fields, methods, parameters, and local variables.
1904 *
1905 * <p>For example:</p>
1906 * <pre>
1907 * int a = 10;
1908 * </pre>
1909 *
1910 * <p>parses as:</p>
1911 * <pre>
1912 * VARIABLE_DEF -> VARIABLE_DEF
1913 * |--MODIFIERS -> MODIFIERS
1914 * |--TYPE -> TYPE
1915 * | `--LITERAL_INT -> int
1916 * |--IDENT -> a
1917 * | `--ASSIGN -> =
1918 * | `--EXPR -> EXPR
1919 * | `--NUM_INT -> 10
1920 * `--SEMI -> ;
1921 * </pre>
1922 *
1923 **/
1924 public static final int IDENT = JavaLanguageLexer.IDENT;
1925 /**
1926 * The {@code .} (dot) operator.
1927 *
1928 * <p>For example:</p>
1929 * <pre>
1930 * return person.name;
1931 * </pre>
1932 *
1933 * <p>parses as:</p>
1934 * <pre>
1935 * --LITERAL_RETURN -> return
1936 * |--EXPR -> EXPR
1937 * | `--DOT -> .
1938 * | |--IDENT -> person
1939 * | `--IDENT -> name
1940 * `--SEMI -> ;
1941 * </pre>
1942 *
1943 * @see FullIdent
1944 **/
1945 public static final int DOT = JavaLanguageLexer.DOT;
1946 /**
1947 * The {@code *} (multiplication or wildcard) operator.
1948 *
1949 * <p>For example:</p>
1950 * <pre>
1951 * f = m * a;
1952 * </pre>
1953 *
1954 * <p>parses as:</p>
1955 * <pre>
1956 * |--EXPR -> EXPR
1957 * | `--ASSIGN -> =
1958 * | |--IDENT -> f
1959 * | `--STAR -> *
1960 * | |--IDENT -> m
1961 * | `--IDENT -> a
1962 * |--SEMI -> ;
1963 * </pre>
1964 *
1965 * @see <a
1966 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5.2">Java
1967 * Language Specification, §7.5.2</a>
1968 * @see <a
1969 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.1">Java
1970 * Language Specification, §15.17.1</a>
1971 * @see #EXPR
1972 * @see #IMPORT
1973 **/
1974 public static final int STAR = JavaLanguageLexer.STAR;
1975 /**
1976 * The {@code private} keyword.
1977 *
1978 * <p>For example:</p>
1979 * <pre>
1980 * private int x;
1981 * </pre>
1982 *
1983 * <p>parses as:</p>
1984 * <pre>
1985 * VARIABLE_DEF -> VARIABLE_DEF
1986 * |--MODIFIERS -> MODIFIERS
1987 * | `--LITERAL_PRIVATE -> private
1988 * |--TYPE -> TYPE
1989 * | `--LITERAL_INT -> int
1990 * |--IDENT -> x
1991 * `--SEMI -> ;
1992 * </pre>
1993 *
1994 * @see #MODIFIERS
1995 **/
1996 public static final int LITERAL_PRIVATE =
1997 JavaLanguageLexer.LITERAL_PRIVATE;
1998
1999 /**
2000 * The {@code public} keyword.
2001 *
2002 * <p>For example:</p>
2003 * <pre>
2004 * public int x;
2005 * </pre>
2006 *
2007 * <p>parses as:</p>
2008 * <pre>
2009 * VARIABLE_DEF -> VARIABLE_DEF
2010 * |--MODIFIERS -> MODIFIERS
2011 * | `--LITERAL_PUBLIC -> public
2012 * |--TYPE -> TYPE
2013 * | `--LITERAL_INT -> int
2014 * |--IDENT -> x
2015 * `--SEMI -> ;
2016 * </pre>
2017 *
2018 * @see #MODIFIERS
2019 **/
2020 public static final int LITERAL_PUBLIC =
2021 JavaLanguageLexer.LITERAL_PUBLIC;
2022
2023 /**
2024 * The {@code protected} keyword.
2025 *
2026 * <p>For example:</p>
2027 * <pre>
2028 * protected int x;
2029 * </pre>
2030 *
2031 * <p>parses as:</p>
2032 * <pre>
2033 * VARIABLE_DEF -> VARIABLE_DEF
2034 * |--MODIFIERS -> MODIFIERS
2035 * | `--LITERAL_PROTECTED -> protected
2036 * |--TYPE -> TYPE
2037 * | `--LITERAL_INT -> int
2038 * |--IDENT -> x
2039 * `--SEMI -> ;
2040 * </pre>
2041 *
2042 * @see #MODIFIERS
2043 **/
2044 public static final int LITERAL_PROTECTED =
2045 JavaLanguageLexer.LITERAL_PROTECTED;
2046
2047 /**
2048 * The {@code static} keyword.
2049 *
2050 * <p>For example:</p>
2051 * <pre>
2052 * public static int x;
2053 * </pre>
2054 *
2055 * <p>parses as:</p>
2056 * <pre>
2057 * VARIABLE_DEF -> VARIABLE_DEF
2058 * |--MODIFIERS -> MODIFIERS
2059 * | |--LITERAL_PUBLIC -> public
2060 * | `--LITERAL_STATIC -> static
2061 * |--TYPE -> TYPE
2062 * | `--LITERAL_INT -> int
2063 * |--IDENT -> x
2064 * `--SEMI -> ;
2065 * </pre>
2066 *
2067 * @see #MODIFIERS
2068 **/
2069 public static final int LITERAL_STATIC =
2070 JavaLanguageLexer.LITERAL_STATIC;
2071
2072 /**
2073 * The {@code transient} keyword.
2074 *
2075 * <p>For example:</p>
2076 * <pre>
2077 * transient int a;
2078 * </pre>
2079 *
2080 * <p>parses as:</p>
2081 * <pre>
2082 * VARIABLE_DEF -> VARIABLE_DEF
2083 * |--MODIFIERS -> MODIFIERS
2084 * | `--LITERAL_TRANSIENT -> transient
2085 * |--TYPE -> TYPE
2086 * | `--LITERAL_INT -> int
2087 * |--IDENT -> a
2088 * `--SEMI -> ;
2089 * </pre>
2090 *
2091 * @see #MODIFIERS
2092 **/
2093 public static final int LITERAL_TRANSIENT =
2094 JavaLanguageLexer.LITERAL_TRANSIENT;
2095
2096 /**
2097 * The {@code native} keyword.
2098 *
2099 * <p>For example:</p>
2100 * <pre>
2101 * native void foo(){}
2102 * </pre>
2103 *
2104 * <p>parses as:</p>
2105 * <pre>
2106 * METHOD_DEF -> METHOD_DEF
2107 * |--MODIFIERS -> MODIFIERS
2108 * | `--LITERAL_NATIVE -> native
2109 * |--TYPE -> TYPE
2110 * | `--LITERAL_VOID -> void
2111 * |--IDENT -> foo
2112 * |--LPAREN -> (
2113 * |--PARAMETERS -> PARAMETERS
2114 * |--RPAREN -> )
2115 * `--SLIST -> {
2116 * `--RCURLY -> }
2117 * </pre>
2118 *
2119 * @see #MODIFIERS
2120 **/
2121 public static final int LITERAL_NATIVE =
2122 JavaLanguageLexer.LITERAL_NATIVE;
2123
2124 /**
2125 * The {@code synchronized} keyword. This may be used as a
2126 * modifier of a method or in the definition of a synchronized
2127 * block.
2128 *
2129 * <p>For example:</p>
2130 *
2131 * <pre>
2132 * synchronized(this)
2133 * {
2134 * x++;
2135 * }
2136 * </pre>
2137 *
2138 * <p>parses as:</p>
2139 *
2140 * <pre>
2141 * |--LITERAL_SYNCHRONIZED -> synchronized
2142 * | |--LPAREN -> (
2143 * | |--EXPR -> EXPR
2144 * | | `--LITERAL_THIS -> this
2145 * | |--RPAREN -> )
2146 * | `--SLIST -> {
2147 * | |--EXPR -> EXPR
2148 * | | `--POST_INC -> ++
2149 * | | `--IDENT -> x
2150 * | |--SEMI -> ;
2151 * | `--RCURLY -> }
2152 * `--RCURLY -> }
2153 * </pre>
2154 *
2155 * @see #MODIFIERS
2156 * @see #LPAREN
2157 * @see #EXPR
2158 * @see #RPAREN
2159 * @see #SLIST
2160 * @see #RCURLY
2161 **/
2162 public static final int LITERAL_SYNCHRONIZED =
2163 JavaLanguageLexer.LITERAL_SYNCHRONIZED;
2164
2165 /**
2166 * The {@code volatile} keyword. This may be used as a
2167 * modifier of a field.
2168 *
2169 * <p>For example:</p>
2170 * <pre>
2171 * private volatile int x;
2172 * </pre>
2173 *
2174 * <p>parses as:</p>
2175 * <pre>
2176 * VARIABLE_DEF -> VARIABLE_DEF
2177 * |--MODIFIERS -> MODIFIERS
2178 * | |--LITERAL_PRIVATE -> private
2179 * | `--LITERAL_VOLATILE -> volatile
2180 * |--TYPE -> TYPE
2181 * | `--LITERAL_INT -> int
2182 * |--IDENT -> x
2183 * `--SEMI -> ;
2184 * </pre>
2185 *
2186 * @see #MODIFIERS
2187 **/
2188 public static final int LITERAL_VOLATILE =
2189 JavaLanguageLexer.LITERAL_VOLATILE;
2190
2191 /**
2192 * The {@code class} keyword. This element appears both
2193 * as part of a class declaration, and inline to reference a
2194 * class object.
2195 *
2196 * <p>For example:</p>
2197 * <pre>
2198 * class Test {
2199 * }
2200 * </pre>
2201 *
2202 * <p>parses as:</p>
2203 * <pre>
2204 * CLASS_DEF -> CLASS_DEF
2205 * |--MODIFIERS -> MODIFIERS
2206 * |--LITERAL_CLASS -> class
2207 * |--IDENT -> Test
2208 * `--OBJBLOCK -> OBJBLOCK
2209 * |--LCURLY -> {
2210 * `--RCURLY -> }
2211 * </pre>
2212 *
2213 * <p>For example:</p>
2214 * <pre> int.class
2215 * </pre>
2216 *
2217 * <p>parses as:</p>
2218 * <pre>
2219 * EXPR -> EXPR
2220 * `--DOT -> .
2221 * |--LITERAL_INT -> int
2222 * `--LITERAL_CLASS -> class
2223 * </pre>
2224 *
2225 * @see #DOT
2226 * @see #IDENT
2227 * @see #CLASS_DEF
2228 * @see FullIdent
2229 **/
2230 public static final int LITERAL_CLASS =
2231 JavaLanguageLexer.LITERAL_CLASS;
2232
2233 /**
2234 * The {@code interface} keyword. This token appears in
2235 * interface definition.
2236 *
2237 * <p>For example:</p>
2238 *
2239 * <pre>
2240 * public interface MyInterface {
2241 *
2242 * }
2243 * </pre>
2244 *
2245 * <p>parses as:</p>
2246 *
2247 * <pre>
2248 * INTERFACE_DEF -> INTERFACE_DEF
2249 * |--MODIFIERS -> MODIFIERS
2250 * | `--LITERAL_PUBLIC -> public
2251 * |--LITERAL_INTERFACE -> interface
2252 * |--IDENT -> MyInterface
2253 * `--OBJBLOCK -> OBJBLOCK
2254 * |--LCURLY -> {
2255 * `--RCURLY -> }
2256 * </pre>
2257 *
2258 * @see #INTERFACE_DEF
2259 **/
2260 public static final int LITERAL_INTERFACE =
2261 JavaLanguageLexer.LITERAL_INTERFACE;
2262
2263 /**
2264 * A left curly brace (<code>{</code>).
2265 *
2266 * <p>For example:</p>
2267 *
2268 * <pre>
2269 * class App {
2270 * int num;
2271 * }
2272 * </pre>
2273 *
2274 * <p>parses as:</p>
2275 * <pre>
2276 * CLASS_DEF -> CLASS_DEF
2277 * |--MODIFIERS -> MODIFIERS
2278 * |--LITERAL_CLASS -> class
2279 * |--IDENT -> App
2280 * `--OBJBLOCK -> OBJBLOCK
2281 * |--LCURLY -> {
2282 * |--VARIABLE_DEF -> VARIABLE_DEF
2283 * | |--MODIFIERS -> MODIFIERS
2284 * | |--TYPE -> TYPE
2285 * | | `--LITERAL_INT -> int
2286 * | |--IDENT -> num
2287 * | `--SEMI -> ;
2288 * `--RCURLY -> }
2289 * </pre>
2290 *
2291 * @see #OBJBLOCK
2292 * @see #ARRAY_INIT
2293 * @see #SLIST
2294 **/
2295 public static final int LCURLY = JavaLanguageLexer.LCURLY;
2296 /**
2297 * A right curly brace (<code>}</code>).
2298 *
2299 * <p>For example:</p>
2300 * <pre>
2301 * {@code
2302 * void foo(){}
2303 * }
2304 * </pre>
2305 *
2306 * <p>parses as:</p>
2307 * <pre>
2308 * METHOD_DEF -> METHOD_DEF
2309 * |--MODIFIERS -> MODIFIERS
2310 * |--TYPE -> TYPE
2311 * | `--LITERAL_VOID -> void
2312 * |--IDENT -> foo
2313 * |--LPAREN -> (
2314 * |--PARAMETERS -> PARAMETERS
2315 * |--RPAREN -> )
2316 * `--SLIST -> {
2317 * `--RCURLY -> }
2318 * </pre>
2319 *
2320 * @see #OBJBLOCK
2321 * @see #ARRAY_INIT
2322 * @see #SLIST
2323 **/
2324 public static final int RCURLY = JavaLanguageLexer.RCURLY;
2325
2326 /**
2327 * The {@code ,} (comma) operator.
2328 *
2329 * <p>For example:</p>
2330 * <pre>
2331 * int a, b;
2332 * </pre>
2333 *
2334 * <p>parses as:</p>
2335 * <pre>
2336 * |--VARIABLE_DEF -> VARIABLE_DEF
2337 * | |--MODIFIERS -> MODIFIERS
2338 * | |--TYPE -> TYPE
2339 * | | `--LITERAL_INT -> int
2340 * | `--IDENT -> a
2341 * |--COMMA -> ,
2342 * |--VARIABLE_DEF -> VARIABLE_DEF
2343 * | |--MODIFIERS -> MODIFIERS
2344 * | |--TYPE -> TYPE
2345 * | | `--LITERAL_INT -> int
2346 * | `--IDENT -> b
2347 * |--SEMI -> ;
2348 * </pre>
2349 *
2350 * @see #ARRAY_INIT
2351 * @see #FOR_INIT
2352 * @see #FOR_ITERATOR
2353 * @see #LITERAL_THROWS
2354 * @see #IMPLEMENTS_CLAUSE
2355 **/
2356 public static final int COMMA = JavaLanguageLexer.COMMA;
2357
2358 /**
2359 * A left parenthesis ({@code (}).
2360 *
2361 * <p>For example:</p>
2362 * <pre>
2363 * Integer val = new Integer();
2364 * while (false) {
2365 * val += (-3);
2366 * }
2367 * </pre>
2368 *
2369 * <p>parses as:</p>
2370 * <pre>
2371 * |--VARIABLE_DEF -> VARIABLE_DEF
2372 * | |--MODIFIERS -> MODIFIERS
2373 * | |--TYPE -> TYPE
2374 * | | `--IDENT -> Integer
2375 * | |--IDENT -> val
2376 * | `--ASSIGN -> =
2377 * | `--EXPR -> EXPR
2378 * | `--LITERAL_NEW -> new
2379 * | |--IDENT -> Integer
2380 * | |--LPAREN -> (
2381 * | |--ELIST -> ELIST
2382 * | `--RPAREN -> )
2383 * |--SEMI -> ;
2384 * |--LITERAL_WHILE -> while
2385 * | |--LPAREN -> (
2386 * | |--EXPR -> EXPR
2387 * | | `--LITERAL_FALSE -> false
2388 * | |--RPAREN -> )
2389 * | `--SLIST -> {
2390 * | |--EXPR -> EXPR
2391 * | | `--PLUS_ASSIGN -> +=
2392 * | | |--IDENT -> val
2393 * | | |--LPAREN -> (
2394 * | | |--UNARY_MINUS -> -
2395 * | | | `--NUM_INT -> 3
2396 * | | `--RPAREN -> )
2397 * | |--SEMI -> ;
2398 * | `--RCURLY -> }
2399 * </pre>
2400 *
2401 * @see #LITERAL_FOR
2402 * @see #LITERAL_NEW
2403 * @see #EXPR
2404 * @see #LITERAL_SWITCH
2405 * @see #LITERAL_CATCH
2406 **/
2407 public static final int LPAREN = JavaLanguageLexer.LPAREN;
2408 /**
2409 * A right parenthesis ({@code )}).
2410 *
2411 * <p>For example:</p>
2412 * <pre>
2413 * void check() {
2414 * }
2415 * </pre>
2416 *
2417 * <p>parses as:</p>
2418 * <pre>
2419 * METHOD_DEF -> METHOD_DEF
2420 * |--MODIFIERS -> MODIFIERS
2421 * |--TYPE -> TYPE
2422 * | `--LITERAL_VOID -> void
2423 * |--IDENT -> check
2424 * |--LPAREN -> (
2425 * |--PARAMETERS -> PARAMETERS
2426 * |--RPAREN -> )
2427 * `--SLIST -> {
2428 * `--RCURLY -> }
2429 * </pre>
2430 *
2431 * @see #LITERAL_FOR
2432 * @see #LITERAL_NEW
2433 * @see #METHOD_CALL
2434 * @see #TYPECAST
2435 * @see #EXPR
2436 * @see #LITERAL_SWITCH
2437 * @see #LITERAL_CATCH
2438 **/
2439 public static final int RPAREN = JavaLanguageLexer.RPAREN;
2440 /**
2441 * The {@code this} keyword use to refer the current object.
2442 * This can also be used to call the constructor.
2443 *
2444 * <p>For example:</p>
2445 * <pre>
2446 * this.name = name;
2447 * </pre>
2448 *
2449 * <p>parses as:</p>
2450 * <pre>
2451 * EXPR -> EXPR
2452 * `--ASSIGN -> =
2453 * |--DOT -> .
2454 * | |--LITERAL_THIS -> this
2455 * | `--IDENT -> name
2456 * `--IDENT -> name
2457 * SEMI -> ;
2458 * </pre>
2459 *
2460 * <p>Also consider:</p>
2461 * <pre>
2462 * this(1, "NULL");
2463 * </pre>
2464 *
2465 * <p>parses as:</p>
2466 * <pre>
2467 * CTOR_CALL -> this
2468 * |--LPAREN -> (
2469 * |--ELIST -> ELIST
2470 * | |--EXPR -> EXPR
2471 * | | `--NUM_INT -> 1
2472 * | |--COMMA -> ,
2473 * | `--EXPR -> EXPR
2474 * | `--STRING_LITERAL -> "NULL"
2475 * |--RPAREN -> )
2476 * `--SEMI -> ;
2477 * </pre>
2478 *
2479 * @see #EXPR
2480 * @see #CTOR_CALL
2481 **/
2482 public static final int LITERAL_THIS =
2483 JavaLanguageLexer.LITERAL_THIS;
2484
2485 /**
2486 * The {@code super} keyword.
2487 *
2488 * <p>For example:</p>
2489 * <pre>
2490 * super.toString()；
2491 * </pre>
2492 *
2493 * <p>parses as:</p>
2494 * <pre>
2495 * |--EXPR -> EXPR
2496 * | `--METHOD_CALL -> (
2497 * | |--DOT -> .
2498 * | | |--LITERAL_SUPER -> super
2499 * | | `--IDENT -> toString
2500 * | |--ELIST -> ELIST
2501 * | `--RPAREN -> )
2502 * |--SEMI -> ;
2503 * </pre>
2504 *
2505 * @see #EXPR
2506 * @see #SUPER_CTOR_CALL
2507 **/
2508 public static final int LITERAL_SUPER =
2509 JavaLanguageLexer.LITERAL_SUPER;
2510
2511 /**
2512 * The {@code =} (assignment) operator.
2513 *
2514 * <p>For example:</p>
2515 * <pre>
2516 * a = b;
2517 * </pre>
2518 *
2519 * <p>parses as:</p>
2520 * <pre>
2521 * |--EXPR -> EXPR
2522 * | `--ASSIGN -> =
2523 * | |--IDENT -> a
2524 * | `--IDENT -> b
2525 * |--SEMI -> ;
2526 * </pre>
2527 *
2528 * @see <a
2529 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.1">Java
2530 * Language Specification, §15.26.1</a>
2531 * @see #EXPR
2532 **/
2533 public static final int ASSIGN = JavaLanguageLexer.ASSIGN;
2534 /**
2535 * The {@code throws} keyword. The children are a number of
2536 * one or more identifiers separated by commas.
2537 *
2538 * <p>For example:</p>
2539 * <pre>
2540 * void test() throws FileNotFoundException, EOFException {
2541 * }
2542 * </pre>
2543 *
2544 * <p>parses as:</p>
2545 * <pre>
2546 * METHOD_DEF -> METHOD_DEF
2547 * |--MODIFIERS -> MODIFIERS
2548 * |--TYPE -> TYPE
2549 * | `--LITERAL_VOID -> void
2550 * |--IDENT -> test
2551 * |--LPAREN -> (
2552 * |--PARAMETERS -> PARAMETERS
2553 * |--RPAREN -> )
2554 * |--LITERAL_THROWS -> throws
2555 * | |--IDENT -> FileNotFoundException
2556 * | |--COMMA -> ,
2557 * | `--IDENT -> EOFException
2558 * `--SLIST -> {
2559 * `--RCURLY -> }
2560 * </pre>
2561 *
2562 * @see <a
2563 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.4">Java
2564 * Language Specification, §8.4.4</a>
2565 * @see #IDENT
2566 * @see #DOT
2567 * @see #COMMA
2568 * @see #METHOD_DEF
2569 * @see #CTOR_DEF
2570 * @see FullIdent
2571 **/
2572 public static final int LITERAL_THROWS =
2573 JavaLanguageLexer.LITERAL_THROWS;
2574
2575 /**
2576 * The {@code :} (colon) operator. This will appear as part
2577 * of the conditional operator ({@code ? :}).
2578 *
2579 * <p>For example:</p>
2580 * <pre>
2581 * num = isValid ? 1 : 0;
2582 * </pre>
2583 *
2584 * <p>parses as:</p>
2585 * <pre>
2586 * |--EXPR -> EXPR
2587 * | `--ASSIGN -> =
2588 * | |--IDENT -> num
2589 * | `--QUESTION -> ?
2590 * | |--IDENT -> isValid
2591 * | |--NUM_INT -> 1
2592 * | |--COLON -> :
2593 * | `--NUM_INT -> 0
2594 * |--SEMI -> ;
2595 * </pre>
2596 *
2597 * @see #QUESTION
2598 * @see #LABELED_STAT
2599 * @see #CASE_GROUP
2600 **/
2601 public static final int COLON = JavaLanguageLexer.COLON;
2602
2603 /**
2604 * The {@code ::} (double colon) separator.
2605 * It is part of Java 8 syntax that is used for method reference.
2606 * The token does not appear in tree, {@link #METHOD_REF} should be used instead.
2607 *
2608 * <p>For example:</p>
2609 * <pre>
2610 * Function<Double, Double> square = MyClass::square;
2611 * </pre>
2612 *
2613 * <p>parses as:</p>
2614 * <pre>
2615 * VARIABLE_DEF -> VARIABLE_DEF
2616 * |--MODIFIERS -> MODIFIERS
2617 * |--TYPE -> TYPE
2618 * | |--IDENT -> Function
2619 * | | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
2620 * | | |--GENERIC_START -> <
2621 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
2622 * | | | `--IDENT -> Double
2623 * | | |--COMMA -> ,
2624 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
2625 * | | | `--IDENT -> Double
2626 * | | `--GENERIC_END -> >
2627 * | |--IDENT -> square
2628 * | |--ASSIGN -> =
2629 * | | `--EXPR -> EXPR
2630 * | | `--METHOD_REF -> ::
2631 * | | |--IDENT -> MyClass
2632 * | | `--IDENT -> square
2633 * | `--SEMI -> ;
2634 * </pre>
2635 *
2636 * @see #METHOD_REF
2637 */
2638 public static final int DOUBLE_COLON = JavaLanguageLexer.DOUBLE_COLON;
2639 /**
2640 * The {@code if} keyword.
2641 *
2642 * <p>For example:</p>
2643 * <pre>
2644 * if (optimistic)
2645 * {
2646 * message = "half full";
2647 * }
2648 * else
2649 * {
2650 * message = "half empty";
2651 * }
2652 * </pre>
2653 *
2654 * <p>parses as:</p>
2655 * <pre>
2656 * LITERAL_IF -> if
2657 * |--LPAREN -> (
2658 * |--EXPR -> EXPR
2659 * | `--IDENT -> optimistic
2660 * |--RPAREN -> )
2661 * |--SLIST -> {
2662 * | |--EXPR -> EXPR
2663 * | | `--ASSIGN -> =
2664 * | | |--IDENT -> message
2665 * | | `--STRING_LITERAL -> "half full"
2666 * | |--SEMI -> ;
2667 * | `--RCURLY -> }
2668 * `--LITERAL_ELSE -> else
2669 * `--SLIST -> {
2670 * |--EXPR -> EXPR
2671 * | `--ASSIGN -> =
2672 * | |--IDENT -> message
2673 * | `--STRING_LITERAL -> "half empty"
2674 * |--SEMI -> ;
2675 * `--RCURLY -> }
2676 * </pre>
2677 *
2678 * @see #LPAREN
2679 * @see #EXPR
2680 * @see #RPAREN
2681 * @see #SLIST
2682 * @see #EMPTY_STAT
2683 * @see #LITERAL_ELSE
2684 **/
2685 public static final int LITERAL_IF = JavaLanguageLexer.LITERAL_IF;
2686 /**
2687 * The {@code for} keyword. The children are {@code (},
2688 * an initializer, a condition, an iterator, a {@code )} and
2689 * either a statement list, a single expression, or an empty
2690 * statement.
2691 *
2692 * <p>For example:</p>
2693 * <pre>
2694 * for (int i = 0; i < arr.length; i++) {}
2695 * </pre>
2696 *
2697 * <p>parses as:</p>
2698 * <pre>
2699 * LITERAL_FOR -> for
2700 * |--LPAREN -> (
2701 * |--FOR_INIT -> FOR_INIT
2702 * | `--VARIABLE_DEF -> VARIABLE_DEF
2703 * | |--MODIFIERS -> MODIFIERS
2704 * | |--TYPE -> TYPE
2705 * | | `--LITERAL_INT -> int
2706 * | |--IDENT -> i
2707 * | `--ASSIGN -> =
2708 * | `--EXPR -> EXPR
2709 * | `--NUM_INT -> 0
2710 * |--SEMI -> ;
2711 * |--FOR_CONDITION -> FOR_CONDITION
2712 * | `--EXPR -> EXPR
2713 * | `--LT -> <
2714 * | |--IDENT -> i
2715 * | `--DOT -> .
2716 * | |--IDENT -> arr
2717 * | `--IDENT -> length
2718 * |--SEMI -> ;
2719 * |--FOR_ITERATOR -> FOR_ITERATOR
2720 * | `--ELIST -> ELIST
2721 * | `--EXPR -> EXPR
2722 * | `--POST_INC -> ++
2723 * | `--IDENT -> i
2724 * |--RPAREN -> )
2725 * `--SLIST -> {
2726 * `--RCURLY -> }
2727 * </pre>
2728 *
2729 * @see #LPAREN
2730 * @see #FOR_INIT
2731 * @see #SEMI
2732 * @see #FOR_CONDITION
2733 * @see #FOR_ITERATOR
2734 * @see #RPAREN
2735 * @see #SLIST
2736 * @see #EMPTY_STAT
2737 * @see #EXPR
2738 **/
2739 public static final int LITERAL_FOR = JavaLanguageLexer.LITERAL_FOR;
2740 /**
2741 * The {@code while} keyword.
2742 *
2743 * <p>For example:</p>
2744 * <pre>
2745 * while (i < 5) {
2746 * i++;
2747 * }
2748 * </pre>
2749 *
2750 * <p>parses as:</p>
2751 * <pre>
2752 * LITERAL_WHILE -> while
2753 * |--LPAREN -> (
2754 * |--EXPR -> EXPR
2755 * | `--LT -> <
2756 * | |--IDENT -> i
2757 * | `--NUM_INT -> 5
2758 * |--RPAREN -> )
2759 * `--SLIST -> {
2760 * |--EXPR -> EXPR
2761 * | `--POST_INC -> ++
2762 * | `--IDENT -> i
2763 * |--SEMI -> ;
2764 * `--RCURLY -> }
2765 * </pre>
2766 **/
2767 public static final int LITERAL_WHILE =
2768 JavaLanguageLexer.LITERAL_WHILE;
2769
2770 /**
2771 * The {@code do} keyword. Note that the while token does not
2772 * appear as part of the do-while construct.
2773 *
2774 * <p>For example:</p>
2775 * <pre>
2776 * do {
2777 * x = rand.nextInt();
2778 * } while (x < 5);
2779 * </pre>
2780 *
2781 * <p>parses as:</p>
2782 * <pre>
2783 * LITERAL_DO -> do
2784 * |--SLIST -> {
2785 * | |--EXPR -> EXPR
2786 * | | `--ASSIGN -> =
2787 * | | |--IDENT -> x
2788 * | | `--METHOD_CALL -> (
2789 * | | |--DOT -> .
2790 * | | | |--IDENT -> rand
2791 * | | | `--IDENT -> nextInt
2792 * | | |--ELIST -> ELIST
2793 * | | `--RPAREN -> )
2794 * | |--SEMI -> ;
2795 * | `--RCURLY -> }
2796 * |--DO_WHILE -> while
2797 * |--LPAREN -> (
2798 * |--EXPR -> EXPR
2799 * | `--LT -> <
2800 * | |--IDENT -> x
2801 * | `--NUM_INT -> 5
2802 * |--RPAREN -> )
2803 * `--SEMI -> ;
2804 * </pre>
2805 *
2806 * @see #SLIST
2807 * @see #EXPR
2808 * @see #EMPTY_STAT
2809 * @see #LPAREN
2810 * @see #RPAREN
2811 * @see #SEMI
2812 **/
2813 public static final int LITERAL_DO = JavaLanguageLexer.LITERAL_DO;
2814 /**
2815 * Literal {@code while} in do-while loop.
2816 *
2817 * <p>For example:</p>
2818 * <pre>
2819 * do {
2820 *
2821 * } while (a > 0);
2822 * </pre>
2823 *
2824 * <p>parses as:</p>
2825 * <pre>
2826 * --LITERAL_DO -> do
2827 * |--SLIST -> {
2828 * | `--RCURLY -> }
2829 * |--DO_WHILE -> while
2830 * |--LPAREN -> (
2831 * |--EXPR -> EXPR
2832 * | `--GT -> >
2833 * | |--IDENT -> a
2834 * | `--NUM_INT -> 0
2835 * |--RPAREN -> )
2836 * `--SEMI -> ;
2837 * </pre>
2838 *
2839 * @see #LITERAL_DO
2840 */
2841 public static final int DO_WHILE = JavaLanguageLexer.DO_WHILE;
2842 /**
2843 * The {@code break} keyword. The first child is an optional
2844 * identifier and the last child is a semicolon.
2845 *
2846 * <p>For example:</p>
2847 * <pre>
2848 * for (;;) {
2849 * break;
2850 * }
2851 * </pre>
2852 *
2853 * <p>parses as:</p>
2854 * <pre>
2855 * LITERAL_FOR -> for
2856 * |--LPAREN -> (
2857 * |--FOR_INIT -> FOR_INIT
2858 * |--SEMI -> ;
2859 * |--FOR_CONDITION -> FOR_CONDITION
2860 * |--SEMI -> ;
2861 * |--FOR_ITERATOR -> FOR_ITERATOR
2862 * |--RPAREN -> )
2863 * `--SLIST -> {
2864 * |--LITERAL_BREAK -> break
2865 * | `--SEMI -> ;
2866 * `--RCURLY -> }
2867 * </pre>
2868 *
2869 * @see #IDENT
2870 * @see #SEMI
2871 * @see #SLIST
2872 **/
2873 public static final int LITERAL_BREAK =
2874 JavaLanguageLexer.LITERAL_BREAK;
2875
2876 /**
2877 * The {@code continue} keyword. The first child is an
2878 * optional identifier and the last child is a semicolon.
2879 *
2880 * <p>For example:</p>
2881 * <pre>
2882 * for (;;) {
2883 * continue;
2884 * }
2885 * </pre>
2886 *
2887 * <p>parses as:</p>
2888 * <pre>
2889 * LITERAL_FOR -> for
2890 * |--LPAREN -> (
2891 * |--FOR_INIT -> FOR_INIT
2892 * |--SEMI -> ;
2893 * |--FOR_CONDITION -> FOR_CONDITION
2894 * |--SEMI -> ;
2895 * |--FOR_ITERATOR -> FOR_ITERATOR
2896 * |--RPAREN -> )
2897 * `--SLIST -> {
2898 * |--LITERAL_CONTINUE -> continue
2899 * | `--SEMI -> ;
2900 * `--RCURLY -> }
2901 * </pre>
2902 *
2903 * @see #IDENT
2904 * @see #SEMI
2905 * @see #SLIST
2906 **/
2907 public static final int LITERAL_CONTINUE =
2908 JavaLanguageLexer.LITERAL_CONTINUE;
2909
2910 /**
2911 * The {@code return} keyword. The first child is an
2912 * optional expression for the return value. The last child is a
2913 * semicolon.
2914 *
2915 * <p>For example:</p>
2916 * <pre>
2917 * public int foo(int i) {
2918 * return i+1;
2919 * }
2920 * </pre>
2921 *
2922 * <p>parses as:</p>
2923 * <pre>
2924 * METHOD_DEF -> METHOD_DEF
2925 * |--MODIFIERS -> MODIFIERS
2926 * | `--LITERAL_PUBLIC -> public
2927 * |--TYPE -> TYPE
2928 * | `--LITERAL_INT -> int
2929 * |--IDENT -> foo
2930 * |--LPAREN -> (
2931 * |--PARAMETERS -> PARAMETERS
2932 * | `--PARAMETER_DEF -> PARAMETER_DEF
2933 * | |--MODIFIERS -> MODIFIERS
2934 * | |--TYPE -> TYPE
2935 * | | `--LITERAL_INT -> int
2936 * | `--IDENT -> i
2937 * |--RPAREN -> )
2938 * `--SLIST -> {
2939 * |--LITERAL_RETURN -> return
2940 * | |--EXPR -> EXPR
2941 * | | `--PLUS -> +
2942 * | | |--IDENT -> i
2943 * | | `--NUM_INT -> 1
2944 * | `--SEMI -> ;
2945 * `--RCURLY -> }
2946 * </pre>
2947 *
2948 * @see #EXPR
2949 * @see #SEMI
2950 * @see #SLIST
2951 **/
2952 public static final int LITERAL_RETURN =
2953 JavaLanguageLexer.LITERAL_RETURN;
2954
2955 /**
2956 * The {@code switch} keyword.
2957 *
2958 * <p>For example:</p>
2959 * <pre>
2960 * switch (type) {
2961 * case 0:
2962 * background = Color.red;
2963 * break;
2964 * case 1:
2965 * background = Color.blue;
2966 * break;
2967 * default:
2968 * background = Color.green;
2969 * }
2970 * </pre>
2971 *
2972 * <p>parses as:</p>
2973 * <pre>
2974 * LITERAL_SWITCH -> switch
2975 * |--LPAREN -> (
2976 * |--EXPR -> EXPR
2977 * | `--IDENT -> type
2978 * |--RPAREN -> )
2979 * |--LCURLY -> {
2980 * |--CASE_GROUP -> CASE_GROUP
2981 * | |--LITERAL_CASE -> case
2982 * | | |--EXPR -> EXPR
2983 * | | | `--NUM_INT -> 0
2984 * | | `--COLON -> :
2985 * | `--SLIST -> SLIST
2986 * | |--EXPR -> EXPR
2987 * | | `--ASSIGN -> =
2988 * | | |--IDENT -> background
2989 * | | `--DOT -> .
2990 * | | |--IDENT -> Color
2991 * | | `--IDENT -> red
2992 * | |--SEMI -> ;
2993 * | `--LITERAL_BREAK -> break
2994 * | `--SEMI -> ;
2995 * |--CASE_GROUP -> CASE_GROUP
2996 * | |--LITERAL_CASE -> case
2997 * | | |--EXPR -> EXPR
2998 * | | | `--NUM_INT -> 1
2999 * | | `--COLON -> :
3000 * | `--SLIST -> SLIST
3001 * | |--EXPR -> EXPR
3002 * | | `--ASSIGN -> =
3003 * | | |--IDENT -> background
3004 * | | `--DOT -> .
3005 * | | |--IDENT -> Color
3006 * | | `--IDENT -> blue
3007 * | |--SEMI -> ;
3008 * | `--LITERAL_BREAK -> break
3009 * | `--SEMI -> ;
3010 * |--CASE_GROUP -> CASE_GROUP
3011 * | |--LITERAL_DEFAULT -> default
3012 * | | `--COLON -> :
3013 * | `--SLIST -> SLIST
3014 * | |--EXPR -> EXPR
3015 * | | `--ASSIGN -> =
3016 * | | |--IDENT -> background
3017 * | | `--DOT -> .
3018 * | | |--IDENT -> Color
3019 * | | `--IDENT -> green
3020 * | `--SEMI -> ;
3021 * `--RCURLY -> }
3022 * </pre>
3023 *
3024 * @see <a
3025 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.10">Java
3026 * Language Specification, §14.10</a>
3027 * @see #LPAREN
3028 * @see #EXPR
3029 * @see #RPAREN
3030 * @see #LCURLY
3031 * @see #CASE_GROUP
3032 * @see #RCURLY
3033 * @see #SLIST
3034 * @see #SWITCH_RULE
3035 **/
3036 public static final int LITERAL_SWITCH =
3037 JavaLanguageLexer.LITERAL_SWITCH;
3038
3039 /**
3040 * The {@code throw} keyword. The first child is an
3041 * expression that evaluates to a {@code Throwable} instance.
3042 *
3043 * <p>For example:</p>
3044 * <pre>
3045 * throw new ArithmeticException("An exception occurred.");
3046 * </pre>
3047 *
3048 * <p>parses as:</p>
3049 * <pre>
3050 * LITERAL_THROW -> throw
3051 * |--EXPR -> EXPR
3052 * | `--LITERAL_NEW -> new
3053 * | |--IDENT -> ArithmeticException
3054 * | |--LPAREN -> (
3055 * | |--ELIST -> ELIST
3056 * | | `--EXPR -> EXPR
3057 * | | `--STRING_LITERAL -> "An exception occurred."
3058 * | `--RPAREN -> )
3059 * `--SEMI -> ;
3060 * </pre>
3061 *
3062 * @see <a
3063 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.17">Java
3064 * Language Specification, §14.17</a>
3065 * @see #SLIST
3066 * @see #EXPR
3067 **/
3068 public static final int LITERAL_THROW =
3069 JavaLanguageLexer.LITERAL_THROW;
3070
3071 /**
3072 * The {@code else} keyword. This appears as a child of an
3073 * {@code if} statement.
3074 *
3075 * <p>For example:</p>
3076 * <pre>
3077 * if (flag) {
3078 *
3079 * } else {
3080 *
3081 * }
3082 * </pre>
3083 *
3084 * <p>parses as:</p>
3085 * <pre>
3086 * LITERAL_IF -> if
3087 * |--LPAREN -> (
3088 * |--EXPR -> EXPR
3089 * | `--IDENT -> flag
3090 * |--RPAREN -> )
3091 * |--SLIST -> {
3092 * | `--RCURLY -> }
3093 * `--LITERAL_ELSE -> else
3094 * `--SLIST -> {
3095 * `--RCURLY -> }
3096 * </pre>
3097 *
3098 * @see #SLIST
3099 * @see #EXPR
3100 * @see #EMPTY_STAT
3101 * @see #LITERAL_IF
3102 **/
3103 public static final int LITERAL_ELSE =
3104 JavaLanguageLexer.LITERAL_ELSE;
3105
3106 /**
3107 * The {@code case} keyword. The first child is a constant
3108 * expression that evaluates to an integer.
3109 *
3110 * <p>For example:</p>
3111 * <pre>
3112 * switch(num){
3113 * case 0:
3114 * num = 1;
3115 * }
3116 * </pre>
3117 *
3118 * <p>parses as:</p>
3119 * <pre>
3120 *
3121 * CASE_GROUP -> CASE_GROUP
3122 * |--LITERAL_CASE -> cas
3123 * | |--EXPR -> EXPR
3124 * | | `--NUM_INT -> 0
3125 * | `--COLON -> :
3126 * `--SLIST -> SLIST
3127 * |--EXPR -> EXPR
3128 * | `--ASSIGN -> =
3129 * | |--IDENT -> num
3130 * | `--NUM_INT -> 1
3131 * `--SEMI -> ;
3132 * </pre>
3133 *
3134 * <p>For example:</p>
3135 * <pre>
3136 * switch(num){
3137 * case 1 -> num = -1
3138 * }
3139 * </pre>
3140 *
3141 * <p>parses as:</p>
3142 * <pre>
3143 * SWITCH_RULE -> SWITCH_RULE
3144 * |--LITERAL_CASE -> case
3145 * | `--EXPR -> EXPR
3146 * | `--NUM_INT -> 1
3147 * |--LAMBDA -> ->
3148 * |--EXPR -> EXPR
3149 * | `--ASSIGN -> =
3150 * | |--IDENT -> num
3151 * | `--UNARY_MINUS -> -
3152 * | `--NUM_INT -> 1
3153 * `--SEMI -> ;
3154 * </pre>
3155 *
3156 * @see #CASE_GROUP
3157 * @see #EXPR
3158 **/
3159 public static final int LITERAL_CASE =
3160 JavaLanguageLexer.LITERAL_CASE;
3161
3162 /**
3163 * The {@code default} keyword. This element has no
3164 * children.
3165 *
3166 * <p>For example:</p>
3167 * <pre>
3168 * switch (type) {
3169 * case 1:
3170 * x = 1;
3171 * break;
3172 * default:
3173 * x = 3;
3174 * }
3175 * </pre>
3176 *
3177 * <p>parses as:</p>
3178 * <pre>
3179 * LITERAL_SWITCH -> switch
3180 * |--LPAREN -> (
3181 * |--EXPR -> EXPR
3182 * | `--IDENT -> type
3183 * |--RPAREN -> )
3184 * |--LCURLY -> {
3185 * |--CASE_GROUP -> CASE_GROUP
3186 * | |--LITERAL_CASE -> case
3187 * | | |--EXPR -> EXPR
3188 * | | | `--NUM_INT -> 1
3189 * | | `--COLON -> :
3190 * | `--SLIST -> SLIST
3191 * | |--EXPR -> EXPR
3192 * | | `--ASSIGN -> =
3193 * | | |--IDENT -> x
3194 * | | `--NUM_INT -> 1
3195 * | | | |--SEMI -> ;
3196 * | `--LITERAL_BREAK -> break
3197 * | `--SEMI -> ;
3198 * |--CASE_GROUP -> CASE_GROUP
3199 * | |--LITERAL_DEFAULT -> default
3200 * | | `--COLON -> :
3201 * | `--SLIST -> SLIST
3202 * | |--EXPR -> EXPR
3203 * | | `--ASSIGN -> =
3204 * | | |--IDENT -> x
3205 * | | `--NUM_INT -> 3
3206 * | `--SEMI -> ;
3207 * `--RCURLY -> }
3208 * </pre>
3209 *
3210 * @see #CASE_GROUP
3211 * @see #MODIFIERS
3212 * @see #SWITCH_RULE
3213 **/
3214 public static final int LITERAL_DEFAULT =
3215 JavaLanguageLexer.LITERAL_DEFAULT;
3216
3217 /**
3218 * The {@code try} keyword. The children are a statement
3219 * list, zero or more catch blocks and then an optional finally
3220 * block.
3221 *
3222 * <p>For example:</p>
3223 * <pre>
3224 * try { } finally {}
3225 * </pre>
3226 *
3227 * <p>parses as:</p>
3228 * <pre>
3229 * LITERAL_TRY -> try
3230 * |--SLIST -> {
3231 * | `--RCURLY -> }
3232 * `--LITERAL_FINALLY -> finally
3233 * `--SLIST -> {
3234 * `--RCURLY -> }
3235 * </pre>
3236 *
3237 * @see <a
3238 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19">Java
3239 * Language Specification, §14.19</a>
3240 * @see #SLIST
3241 * @see #LITERAL_CATCH
3242 * @see #LITERAL_FINALLY
3243 **/
3244 public static final int LITERAL_TRY = JavaLanguageLexer.LITERAL_TRY;
3245
3246 /**
3247 * The Java 7 try-with-resources construct.
3248 *
3249 * <p>For example:</p>
3250 * <pre>
3251 * try (Foo foo = new Foo(); Bar bar = new Bar()) {
3252 * }
3253 * </pre>
3254 *
3255 * <p>parses as:</p>
3256 * <pre>
3257 * LITERAL_TRY -> try
3258 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION
3259 * | |--LPAREN -> (
3260 * | |--RESOURCES -> RESOURCES
3261 * | | |--RESOURCE -> RESOURCE
3262 * | | | |--MODIFIERS -> MODIFIERS
3263 * | | | |--TYPE -> TYPE
3264 * | | | | `--IDENT -> Foo
3265 * | | | |--IDENT -> foo
3266 * | | | `--ASSIGN -> =
3267 * | | | `--EXPR -> EXPR
3268 * | | | `--LITERAL_NEW -> new
3269 * | | | |--IDENT -> Foo
3270 * | | | |--LPAREN -> (
3271 * | | | |--ELIST -> ELIST
3272 * | | | `--RPAREN -> )
3273 * | | |--SEMI -> ;
3274 * | | `--RESOURCE -> RESOURCE
3275 * | | |--MODIFIERS -> MODIFIERS
3276 * | | |--TYPE -> TYPE
3277 * | | | `--IDENT -> Bar
3278 * | | |--IDENT -> bar
3279 * | | `--ASSIGN -> =
3280 * | | `--EXPR -> EXPR
3281 * | | `--LITERAL_NEW -> new
3282 * | | |--IDENT -> Bar
3283 * | | |--LPAREN -> (
3284 * | | |--ELIST -> ELIST
3285 * | | `--RPAREN -> )
3286 * | `--RPAREN -> )
3287 * `--SLIST -> {
3288 * `--RCURLY -> }
3289 * </pre>
3290 *
3291 * <p>Also consider:</p>
3292 * <pre>
3293 * try (BufferedReader br = new BufferedReader(new FileReader(path))) {
3294 * }
3295 * </pre>
3296 *
3297 * <p>which parses as:</p>
3298 * <pre>
3299 * LITERAL_TRY -> try
3300 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION
3301 * | |--LPAREN -> (
3302 * | |--RESOURCES -> RESOURCES
3303 * | | `--RESOURCE -> RESOURCE
3304 * | | |--MODIFIERS -> MODIFIERS
3305 * | | |--TYPE -> TYPE
3306 * | | | `--IDENT -> BufferedReader
3307 * | | |--IDENT -> br
3308 * | | `--ASSIGN -> =
3309 * | | `--EXPR -> EXPR
3310 * | | `--LITERAL_NEW -> new
3311 * | | |--IDENT -> BufferedReader
3312 * | | |--LPAREN -> (
3313 * | | |--ELIST -> ELIST
3314 * | | | `--EXPR -> EXPR
3315 * | | | `--LITERAL_NEW -> new
3316 * | | | |--IDENT -> FileReader
3317 * | | | |--LPAREN -> (
3318 * | | | |--ELIST -> ELIST
3319 * | | | | `--EXPR -> EXPR
3320 * | | | | `--IDENT -> path
3321 * | | | `--RPAREN -> )
3322 * | | `--RPAREN -> )
3323 * | `--RPAREN -> )
3324 * `--SLIST -> {
3325 * `--RCURLY -> }
3326 * </pre>
3327 *
3328 * @see #LPAREN
3329 * @see #RESOURCES
3330 * @see #RESOURCE
3331 * @see #SEMI
3332 * @see #RPAREN
3333 * @see #LITERAL_TRY
3334 **/
3335 public static final int RESOURCE_SPECIFICATION =
3336 JavaLanguageLexer.RESOURCE_SPECIFICATION;
3337
3338 /**
3339 * A list of resources in the Java 7 try-with-resources construct.
3340 * This is a child of RESOURCE_SPECIFICATION.
3341 *
3342 * <p>For example:</p>
3343 * <pre>
3344 * try (FileReader fr = new FileReader("config.xml")) {
3345 * } finally {}
3346 * </pre>
3347 *
3348 * <p>parses as:</p>
3349 * <pre>
3350 * LITERAL_TRY -> try
3351 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION
3352 * | |--LPAREN -> (
3353 * | |--RESOURCES -> RESOURCES
3354 * | | `--RESOURCE -> RESOURCE
3355 * | | |--MODIFIERS -> MODIFIERS
3356 * | | |--TYPE -> TYPE
3357 * | | | `--IDENT -> FileReader
3358 * | | |--IDENT -> fr
3359 * | | `--ASSIGN -> =
3360 * | | `--EXPR -> EXPR
3361 * | | `--LITERAL_NEW -> new
3362 * | | |--IDENT -> FileReader
3363 * | | |--LPAREN -> (
3364 * | | |--ELIST -> ELIST
3365 * | | | `--EXPR -> EXPR
3366 * | | | `--STRING_LITERAL -> "config.xml"
3367 * | | `--RPAREN -> )
3368 * | `--RPAREN -> )
3369 * |--SLIST -> {
3370 * | `--RCURLY -> }
3371 * `--LITERAL_FINALLY -> finally
3372 * `--SLIST -> {
3373 * `--RCURLY -> }
3374 * </pre>
3375 *
3376 * @see #RESOURCE_SPECIFICATION
3377 **/
3378 public static final int RESOURCES =
3379 JavaLanguageLexer.RESOURCES;
3380
3381 /**
3382 * A resource in the Java 7 try-with-resources construct.
3383 * This is a child of RESOURCES.
3384 *
3385 * <p>For example:</p>
3386 * <pre>
3387 * try (Foo foo = new Foo(); Bar bar = new Bar()) { }
3388 * </pre>
3389 *
3390 * <p>parses as:</p>
3391 * <pre>
3392 * LITERAL_TRY -> try
3393 * |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION
3394 * | |--LPAREN -> (
3395 * | |--RESOURCES -> RESOURCES
3396 * | | |--RESOURCE -> RESOURCE
3397 * | | | |--MODIFIERS -> MODIFIERS
3398 * | | | |--TYPE -> TYPE
3399 * | | | | `--IDENT -> Foo
3400 * | | | |--IDENT -> foo
3401 * | | | `--ASSIGN -> =
3402 * | | | `--EXPR -> EXPR
3403 * | | | `--LITERAL_NEW -> new
3404 * | | | |--IDENT -> Foo
3405 * | | | |--LPAREN -> (
3406 * | | | |--ELIST -> ELIST
3407 * | | | `--RPAREN -> )
3408 * | | |--SEMI -> ;
3409 * | | `--RESOURCE -> RESOURCE
3410 * | | |--MODIFIERS -> MODIFIERS
3411 * | | |--TYPE -> TYPE
3412 * | | | `--IDENT -> Bar
3413 * | | |--IDENT -> bar
3414 * | | `--ASSIGN -> =
3415 * | | `--EXPR -> EXPR
3416 * | | `--LITERAL_NEW -> new
3417 * | | |--IDENT -> Bar
3418 * | | |--LPAREN -> (
3419 * | | |--ELIST -> ELIST
3420 * | | `--RPAREN -> )
3421 * | `--RPAREN -> )
3422 * `--SLIST -> {
3423 * `--RCURLY -> }
3424 * </pre>
3425 *
3426 * @see #RESOURCES
3427 * @see #RESOURCE_SPECIFICATION
3428 **/
3429 public static final int RESOURCE =
3430 JavaLanguageLexer.RESOURCE;
3431
3432 /**
3433 * The {@code catch} keyword.
3434 *
3435 * <p>For example:</p>
3436 * <pre>
3437 * try {
3438 * FileReader fr = new FileReader("Test.txt");
3439 * } catch (FileNotFoundException e) {
3440 *
3441 * }
3442 * </pre>
3443 *
3444 * <p>parses as:</p>
3445 * <pre>
3446 * LITERAL_TRY -> try
3447 * |--SLIST -> {
3448 * | |--VARIABLE_DEF -> VARIABLE_DEF
3449 * | | |--MODIFIERS -> MODIFIERS
3450 * | | |--TYPE -> TYPE
3451 * | | | `--IDENT -> FileReader
3452 * | | |--IDENT -> fr
3453 * | | `--ASSIGN -> =
3454 * | | `--EXPR -> EXPR
3455 * | | `--LITERAL_NEW -> new
3456 * | | |--IDENT -> FileReader
3457 * | | |--LPAREN -> (
3458 * | | |--ELIST -> ELIST
3459 * | | | `--EXPR -> EXPR
3460 * | | | `--STRING_LITERAL -> "Test.txt"
3461 * | | `--RPAREN -> )
3462 * | |--SEMI -> ;
3463 * | `--RCURLY -> }
3464 * `--LITERAL_CATCH -> catch
3465 * |--LPAREN -> (
3466 * |--PARAMETER_DEF -> PARAMETER_DEF
3467 * | |--MODIFIERS -> MODIFIERS
3468 * | |--TYPE -> TYPE
3469 * | | `--IDENT -> FileNotFoundException
3470 * | `--IDENT -> e
3471 * |--RPAREN -> )
3472 * `--SLIST -> {
3473 * `--RCURLY -> }
3474 * </pre>
3475 *
3476 * @see #LPAREN
3477 * @see #PARAMETER_DEF
3478 * @see #RPAREN
3479 * @see #SLIST
3480 * @see #LITERAL_TRY
3481 **/
3482 public static final int LITERAL_CATCH =
3483 JavaLanguageLexer.LITERAL_CATCH;
3484
3485 /**
3486 * The {@code finally} keyword.
3487 *
3488 * <p>For example:</p>
3489 * <pre>
3490 * try {} finally {}
3491 * </pre>
3492 *
3493 * <p>parses as:</p>
3494 * <pre>
3495 * LITERAL_TRY -> try
3496 * |--SLIST -> {
3497 * | `--RCURLY -> }
3498 * `--LITERAL_FINALLY -> finally
3499 * `--SLIST -> {
3500 * `--RCURLY -> }
3501 * </pre>
3502 *
3503 * @see #SLIST
3504 * @see #LITERAL_TRY
3505 **/
3506 public static final int LITERAL_FINALLY =
3507 JavaLanguageLexer.LITERAL_FINALLY;
3508
3509 /**
3510 * The {@code +=} (addition assignment) operator.
3511 *
3512 * <p>For example:</p>
3513 * <pre>
3514 * a += b;
3515 * </pre>
3516 *
3517 * <p>parses as:</p>
3518 * <pre>
3519 * |--EXPR -> EXPR
3520 * | `--PLUS_ASSIGN -> +=
3521 * | |--IDENT -> a
3522 * | `--IDENT -> b
3523 * |--SEMI -> ;
3524 * </pre>
3525 *
3526 * @see <a
3527 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3528 * Language Specification, §15.26.2</a>
3529 * @see #EXPR
3530 **/
3531 public static final int PLUS_ASSIGN = JavaLanguageLexer.PLUS_ASSIGN;
3532 /**
3533 * The {@code -=} (subtraction assignment) operator.
3534 *
3535 * <p>For example:</p>
3536 * <pre>
3537 * a -= b;
3538 * </pre>
3539 *
3540 * <p>parses as:</p>
3541 * <pre>
3542 * |--EXPR -> EXPR
3543 * | `--MINUS_ASSIGN -> -=
3544 * | |--IDENT -> a
3545 * | `--IDENT -> b
3546 * |--SEMI -> ;
3547 * </pre>
3548 *
3549 * @see <a
3550 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3551 * Language Specification, §15.26.2</a>
3552 * @see #EXPR
3553 **/
3554 public static final int MINUS_ASSIGN =
3555 JavaLanguageLexer.MINUS_ASSIGN;
3556
3557 /**
3558 * The {@code *=} (multiplication assignment) operator.
3559 *
3560 * <p>For example:</p>
3561 * <pre>
3562 * a *= b;
3563 * </pre>
3564 *
3565 * <p>parses as:</p>
3566 * <pre>
3567 * |--EXPR -> EXPR
3568 * | `--STAR_ASSIGN -> *=
3569 * | |--IDENT -> a
3570 * | `--IDENT -> b
3571 * |--SEMI -> ;
3572 * </pre>
3573 *
3574 * @see <a
3575 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3576 * Language Specification, §15.26.2</a>
3577 * @see #EXPR
3578 **/
3579 public static final int STAR_ASSIGN = JavaLanguageLexer.STAR_ASSIGN;
3580 /**
3581 * The {@code /=} (division assignment) operator.
3582 *
3583 * <p>For example:</p>
3584 * <pre>
3585 * a /= b;
3586 * </pre>
3587 *
3588 * <p>parses as:</p>
3589 * <pre>
3590 * |--EXPR -> EXPR
3591 * | `--DIV_ASSIGN -> /=
3592 * | |--IDENT -> a
3593 * | `--IDENT -> b
3594 * |--SEMI -> ;
3595 * </pre>
3596 *
3597 * @see <a
3598 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3599 * Language Specification, §15.26.2</a>
3600 * @see #EXPR
3601 **/
3602 public static final int DIV_ASSIGN = JavaLanguageLexer.DIV_ASSIGN;
3603 /**
3604 * The {@code %=} (remainder assignment) operator.
3605 *
3606 * <p>For example:</p>
3607 * <pre>a %= 2;</pre>
3608 *
3609 * <p>parses as:</p>
3610 * <pre>
3611 * |--EXPR -> EXPR
3612 * | `--MOD_ASSIGN -> %=
3613 * | |--IDENT -> a
3614 * | `--NUM_INT -> 2
3615 * |--SEMI -> ;
3616 * </pre>
3617 *
3618 * @see <a
3619 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3620 * Language Specification, §15.26.2</a>
3621 * @see #EXPR
3622 **/
3623 public static final int MOD_ASSIGN = JavaLanguageLexer.MOD_ASSIGN;
3624 /**
3625 * The {@code >>=} (signed right shift assignment)
3626 * operator.
3627 *
3628 * <p>For example:</p>
3629 * <pre>
3630 * a >>= b;
3631 * </pre>
3632 *
3633 * <p>parses as:</p>
3634 * <pre>
3635 * |--EXPR -> EXPR
3636 * | `--SR_ASSIGN -> >>=
3637 * | |--IDENT -> a
3638 * | `--IDENT -> b
3639 * |--SEMI -> ;
3640 * </pre>
3641 *
3642 * @see <a
3643 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3644 * Language Specification, §15.26.2</a>
3645 * @see #EXPR
3646 **/
3647 public static final int SR_ASSIGN = JavaLanguageLexer.SR_ASSIGN;
3648 /**
3649 * The {@code >>>=} (unsigned right shift assignment)
3650 * operator.
3651 *
3652 * <p>For example:</p>
3653 * <pre>
3654 * a >>>= b;
3655 * </pre>
3656 *
3657 * <p>parses as:</p>
3658 * <pre>
3659 * |--EXPR -> EXPR
3660 * | `--BSR_ASSIGN -> >>>=
3661 * | |--IDENT -> a
3662 * | `--IDENT -> b
3663 * |--SEMI -> ;
3664 * </pre>
3665 *
3666 * @see <a
3667 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3668 * Language Specification, §15.26.2</a>
3669 * @see #EXPR
3670 **/
3671 public static final int BSR_ASSIGN = JavaLanguageLexer.BSR_ASSIGN;
3672 /**
3673 * The {@code <<=} (left shift assignment) operator.
3674 *
3675 * @see <a
3676 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3677 * Language Specification, §15.26.2</a>
3678 * @see #EXPR
3679 **/
3680 public static final int SL_ASSIGN = JavaLanguageLexer.SL_ASSIGN;
3681 /**
3682 * The {@code &=} (bitwise AND assignment) operator.
3683 *
3684 * <p>For example:</p>
3685 * <pre>
3686 * a &= b;
3687 * </pre>
3688 *
3689 * <p>parses as:</p>
3690 * <pre>
3691 * |--EXPR -> EXPR
3692 * | `--BAND_ASSIGN -> &=
3693 * | |--IDENT -> a
3694 * | `--IDENT -> b
3695 * |--SEMI -> ;
3696 * </pre>
3697 *
3698 * @see <a
3699 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3700 * Language Specification, §15.26.2</a>
3701 * @see #EXPR
3702 **/
3703 public static final int BAND_ASSIGN = JavaLanguageLexer.BAND_ASSIGN;
3704 /**
3705 * The {@code ^=} (bitwise exclusive OR assignment) operator.
3706 *
3707 * @see <a
3708 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3709 * Language Specification, §15.26.2</a>
3710 * @see #EXPR
3711 **/
3712 public static final int BXOR_ASSIGN = JavaLanguageLexer.BXOR_ASSIGN;
3713 /**
3714 * The {@code |=} (bitwise OR assignment) operator.
3715 *
3716 * <p>For example:</p>
3717 * <pre>
3718 * a |= b;
3719 * </pre>
3720 *
3721 * <p>parses as:</p>
3722 * <pre>
3723 * |--EXPR -> EXPR
3724 * | `--BOR_ASSIGN -> |=
3725 * | |--IDENT -> a
3726 * | `--IDENT -> b
3727 * |--SEMI -> ;
3728 * </pre>
3729 *
3730 * @see <a
3731 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
3732 * Language Specification, §15.26.2</a>
3733 * @see #EXPR
3734 **/
3735 public static final int BOR_ASSIGN = JavaLanguageLexer.BOR_ASSIGN;
3736 /**
3737 * The {@code ?} (conditional) operator. Technically,
3738 * the colon is also part of this operator, but it appears as a
3739 * separate token.
3740 *
3741 * <p>For example:</p>
3742 * <pre>
3743 * String variable=(quantity==1)?"true":"false";
3744 * </pre>
3745 *
3746 * <p>parses as:</p>
3747 * <pre>
3748 * |--VARIABLE_DEF -> VARIABLE_DEF
3749 * | |--MODIFIERS -> MODIFIERS
3750 * | |--TYPE -> TYPE
3751 * | | `--IDENT -> String
3752 * | |--IDENT -> variable
3753 * | `--ASSIGN -> =
3754 * | `--EXPR -> EXPR
3755 * | `--QUESTION -> ?
3756 * | |--LPAREN -> (
3757 * | |--EQUAL -> ==
3758 * | | |--IDENT -> quantity
3759 * | | `--NUM_INT -> 1
3760 * | |--RPAREN -> )
3761 * | |--STRING_LITERAL -> "true"
3762 * | |--COLON -> :
3763 * | `--STRING_LITERAL -> "false"
3764 * |--SEMI -> ;
3765 * </pre>
3766 *
3767 * @see <a
3768 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.25">Java
3769 * Language Specification, §15.25</a>
3770 * @see #EXPR
3771 * @see #COLON
3772 **/
3773 public static final int QUESTION = JavaLanguageLexer.QUESTION;
3774 /**
3775 * The {@code ||} (conditional OR) operator.
3776 *
3777 * <p>For example:</p>
3778 * <pre>
3779 * if (a || b) {
3780 * }
3781 * </pre>
3782 *
3783 * <p>
3784 * parses as:
3785 * </p>
3786 * <pre>
3787 * LITERAL_IF -> if
3788 * |--LPAREN -> (
3789 * |--EXPR -> EXPR
3790 * | `--LOR -> ||
3791 * | |--IDENT -> a
3792 * | `--IDENT -> b
3793 * |--RPAREN -> )
3794 * |--SLIST -> {
3795 * | |--RCURLY -> }
3796 * </pre>
3797 *
3798 * @see <a
3799 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.24">Java
3800 * Language Specification, §15.24</a>
3801 * @see #EXPR
3802 **/
3803 public static final int LOR = JavaLanguageLexer.LOR;
3804 /**
3805 * The {@code &&} (conditional AND) operator.
3806 *
3807 * <p>For example:</p>
3808 * <pre>
3809 * if (a && b) {
3810 * }
3811 * </pre>
3812 *
3813 * <p>parses as:</p>
3814 * <pre>
3815 * LITERAL_IF -> if
3816 * |--LPAREN -> (
3817 * |--EXPR -> EXPR
3818 * | `--LAND -> &&
3819 * | |--IDENT -> a
3820 * | `--IDENT -> b
3821 * |--RPAREN -> )
3822 * |--SLIST -> {
3823 * | |--RCURLY -> }
3824 * </pre>
3825 *
3826 * @see <a
3827 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.23">Java
3828 * Language Specification, §15.23</a>
3829 * @see #EXPR
3830 **/
3831 public static final int LAND = JavaLanguageLexer.LAND;
3832 /**
3833 * The {@code |} (bitwise OR) operator.
3834 *
3835 * <p>For example:</p>
3836 * <pre>
3837 * a = a | b;
3838 * </pre>
3839 *
3840 * <p>parses as:</p>
3841 * <pre>
3842 * |--EXPR -> EXPR
3843 * | `--ASSIGN -> =
3844 * | |--IDENT -> a
3845 * | `--BOR -> |
3846 * | |--IDENT -> a
3847 * | `--IDENT -> b
3848 * |--SEMI -> ;
3849 * </pre>
3850 *
3851 * @see <a
3852 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java
3853 * Language Specification, §15.22.1</a>
3854 * @see #EXPR
3855 **/
3856 public static final int BOR = JavaLanguageLexer.BOR;
3857 /**
3858 * The {@code ^} (bitwise exclusive OR) operator.
3859 *
3860 * @see <a
3861 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java
3862 * Language Specification, §15.22.1</a>
3863 * @see #EXPR
3864 **/
3865 public static final int BXOR = JavaLanguageLexer.BXOR;
3866 /**
3867 * The {@code &} (bitwise AND) operator.
3868 *
3869 * <p>For example:</p>
3870 * <pre>
3871 * c = a & b;
3872 * </pre>
3873 *
3874 * <p>parses as:</p>
3875 * <pre>
3876 * |--EXPR -> EXPR
3877 * | `--ASSIGN -> =
3878 * | |--IDENT -> c
3879 * | `--BAND -> &
3880 * | |--IDENT -> a
3881 * | `--IDENT -> b
3882 * |--SEMI -> ;
3883 * </pre>
3884 *
3885 * @see <a
3886 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java
3887 * Language Specification, §15.22.1</a>
3888 * @see #EXPR
3889 **/
3890 public static final int BAND = JavaLanguageLexer.BAND;
3891 /**
3892 * The {@code !=} (not equal) operator.
3893 *
3894 * <p>For example:</p>
3895 * <pre>
3896 * a != b;
3897 * </pre>
3898 *
3899 * <p>parses as:</p>
3900 * <pre>
3901 * |--EXPR -> EXPR
3902 * | `--NOT_EQUAL -> !=
3903 * | |--IDENT -> a
3904 * | `--IDENT -> b
3905 * `--SEMI -> ;
3906 * </pre>
3907 *
3908 * @see #EXPR
3909 **/
3910 public static final int NOT_EQUAL = JavaLanguageLexer.NOT_EQUAL;
3911 /**
3912 * The {@code ==} (equal) operator.
3913 *
3914 * <p>For example:</p>
3915 * <pre>
3916 * return a == b;
3917 * </pre>
3918 *
3919 * <p>parses as:</p>
3920 * <pre>
3921 * |--EXPR -> EXPR
3922 * | `--EQUAL -> ==
3923 * | |--IDENT -> a
3924 * | `--IDENT -> b
3925 * `--SEMI -> ;
3926 * </pre>
3927 *
3928 * @see #EXPR
3929 **/
3930 public static final int EQUAL = JavaLanguageLexer.EQUAL;
3931 /**
3932 * The {@code <} (less than) operator.
3933 *
3934 * <p>For example:</p>
3935 * <pre>
3936 * c = a < b;
3937 * </pre>
3938 *
3939 * <p>parses as:</p>
3940 * <pre>
3941 * |--EXPR -> EXPR
3942 * | `--ASSIGN -> =
3943 * | |--IDENT -> c
3944 * | `--LT -> <
3945 * | |--IDENT -> a
3946 * | `--IDENT -> b
3947 * |--SEMI -> ;
3948 * </pre>
3949 *
3950 * @see #EXPR
3951 **/
3952 public static final int LT = JavaLanguageLexer.LT;
3953 /**
3954 * The {@code >} (greater than) operator.
3955 *
3956 * <p>For example:</p>
3957 * <pre>
3958 * c = a > b;
3959 * </pre>
3960 *
3961 * <p>parses as:</p>
3962 * <pre>
3963 * |--EXPR -> EXPR
3964 * | `--ASSIGN -> =
3965 * | |--IDENT -> c
3966 * | `--BAND -> >
3967 * | |--IDENT -> a
3968 * | `--IDENT -> b
3969 * |--SEMI -> ;
3970 * </pre>
3971 *
3972 * @see #EXPR
3973 **/
3974 public static final int GT = JavaLanguageLexer.GT;
3975 /**
3976 * The {@code <=} (less than or equal) operator.
3977 *
3978 * <p>For example:</p>
3979 * <pre>
3980 * c = a <= b;
3981 * </pre>
3982 *
3983 * <p>parses as:</p>
3984 * <pre>
3985 * |--EXPR -> EXPR
3986 * | `--ASSIGN -> =
3987 * | |--IDENT -> c
3988 * | `--LE -> <=
3989 * | |--IDENT -> a
3990 * | `--IDENT -> b
3991 * |--SEMI -> ;
3992 * </pre>
3993 *
3994 * @see #EXPR
3995 **/
3996 public static final int LE = JavaLanguageLexer.LE;
3997 /**
3998 * The {@code >=} (greater than or equal) operator.
3999 *
4000 * <p>For example:</p>
4001 * <pre>
4002 * boolean b = a >= 3;
4003 * </pre>
4004 *
4005 * <p>parses as:</p>
4006 * <pre>
4007 * VARIABLE_DEF -> VARIABLE_DEF
4008 * |--MODIFIERS -> MODIFIERS
4009 * |--TYPE -> TYPE
4010 * | `--LITERAL_BOOLEAN -> boolean
4011 * |--IDENT -> b
4012 * `--ASSIGN -> =
4013 * `--EXPR -> EXPR
4014 * `--GE -> >=
4015 * |--IDENT -> a
4016 * `--NUM_INT -> 3
4017 * </pre>
4018 *
4019 * @see #EXPR
4020 **/
4021 public static final int GE = JavaLanguageLexer.GE;
4022 /**
4023 * The {@code instanceof} operator. The first child is an
4024 * object reference or something that evaluates to an object
4025 * reference. The second child is a reference type or pattern.
4026 *
4027 * <p>For example:</p>
4028 * <pre>
4029 * boolean isBuilderReferenceType = text instanceof StringBuilder; // reference type
4030 * boolean isBuilderPatternWithPattern =
4031 * text instanceof StringBuilder s; // type pattern, no `PATTERN_DEF`
4032 * </pre>
4033 *
4034 * <p>parses as:</p>
4035 * <pre>
4036 * |--VARIABLE_DEF -> VARIABLE_DEF
4037 * | |--MODIFIERS -> MODIFIERS
4038 * | |--TYPE -> TYPE
4039 * | | `--LITERAL_BOOLEAN -> boolean
4040 * | |--IDENT -> isBuilderReferenceType
4041 * | `--ASSIGN -> =
4042 * | `--EXPR -> EXPR
4043 * | `--LITERAL_INSTANCEOF -> instanceof
4044 * | |--IDENT -> text
4045 * | `--TYPE -> TYPE
4046 * | `--IDENT -> StringBuilder
4047 * |--SEMI -> ;
4048 * |--VARIABLE_DEF -> VARIABLE_DEF
4049 * | |--MODIFIERS -> MODIFIERS
4050 * | |--TYPE -> TYPE
4051 * | | `--LITERAL_BOOLEAN -> boolean
4052 * | |--IDENT -> isBuilderPatternWithPattern
4053 * | `--ASSIGN -> =
4054 * | `--EXPR -> EXPR
4055 * | `--LITERAL_INSTANCEOF -> instanceof
4056 * | |--IDENT -> text
4057 * | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
4058 * | |--MODIFIERS -> MODIFIERS
4059 * | |--TYPE -> TYPE
4060 * | | `--IDENT -> StringBuilder
4061 * | `--IDENT -> s
4062 * |--SEMI -> ;
4063 * </pre>
4064 *
4065 * @see <a
4066 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java
4067 * Language Specification, §15.20.2</a>
4068 * @see #EXPR
4069 * @see #METHOD_CALL
4070 * @see #IDENT
4071 * @see #DOT
4072 * @see #TYPE
4073 * @see #PATTERN_VARIABLE_DEF
4074 * @see FullIdent
4075 **/
4076 public static final int LITERAL_INSTANCEOF =
4077 JavaLanguageLexer.LITERAL_INSTANCEOF;
4078
4079 /**
4080 * The {@code <<} (shift left) operator.
4081 *
4082 * <p>For example:</p>
4083 * <pre>
4084 * a = a << b;
4085 * </pre>
4086 *
4087 * <p>parses as:</p>
4088 * <pre>
4089 * |--EXPR -> EXPR
4090 * | `--ASSIGN -> =
4091 * | |--IDENT -> a
4092 * | `--SR -> <<
4093 * | |--IDENT -> a
4094 * | `--IDENT -> b
4095 * |--SEMI -> ;
4096 * </pre>
4097 *
4098 * @see <a
4099 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java
4100 * Language Specification, §15.19</a>
4101 * @see #EXPR
4102 **/
4103 public static final int SL = JavaLanguageLexer.SL;
4104 /**
4105 * The {@code >>} (signed shift right) operator.
4106 *
4107 * <p>For example:</p>
4108 * <pre>
4109 * a = a >> b;
4110 * </pre>
4111 *
4112 * <p>parses as:</p>
4113 * <pre>
4114 * |--EXPR -> EXPR
4115 * | `--ASSIGN -> =
4116 * | |--IDENT -> a
4117 * | `--SR -> >>
4118 * | |--IDENT -> a
4119 * | `--IDENT -> b
4120 * |--SEMI -> ;
4121 * </pre>
4122 *
4123 * @see <a
4124 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java
4125 * Language Specification, §15.19</a>
4126 * @see #EXPR
4127 **/
4128 public static final int SR = JavaLanguageLexer.SR;
4129 /**
4130 * The {@code >>>} (unsigned shift right) operator.
4131 *
4132 * <p>For example:</p>
4133 * <pre>
4134 * a >>> b;
4135 * </pre>
4136 *
4137 * <p>parses as:</p>
4138 * <pre>
4139 * |--EXPR -> EXPR
4140 * | `--BSR -> >>>
4141 * | |--IDENT -> a
4142 * | `--IDENT -> b
4143 * |--SEMI -> ;
4144 * </pre>
4145 *
4146 * @see <a
4147 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java
4148 * Language Specification, §15.19</a>
4149 * @see #EXPR
4150 **/
4151 public static final int BSR = JavaLanguageLexer.BSR;
4152 /**
4153 * The {@code +} (addition) operator.
4154 *
4155 * <p>For example:</p>
4156 * <pre>
4157 * c = a + b;
4158 * </pre>
4159 *
4160 * <p>parses as:</p>
4161 * <pre>
4162 * |--EXPR -> EXPR
4163 * | `--ASSIGN -> =
4164 * | |--IDENT -> c
4165 * | `--PLUS -> +
4166 * | |--IDENT -> a
4167 * | `--IDENT -> b
4168 * |--SEMI -> ;
4169 * </pre>
4170 *
4171 * @see <a
4172 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java
4173 * Language Specification, §15.18</a>
4174 * @see #EXPR
4175 **/
4176 public static final int PLUS = JavaLanguageLexer.PLUS;
4177 /**
4178 * The {@code -} (subtraction) operator.
4179 *
4180 * <p>For example:</p>
4181 * <pre>
4182 * c = a - b;
4183 * </pre>
4184 *
4185 * <p>parses as:</p>
4186 * <pre>
4187 * |--EXPR -> EXPR
4188 * | `--ASSIGN -> =
4189 * | |--IDENT -> c
4190 * | `--MINUS -> -
4191 * | |--IDENT -> a
4192 * | `--IDENT -> b
4193 * |--SEMI -> ;
4194 * </pre>
4195 *
4196 * @see <a
4197 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java
4198 * Language Specification, §15.18</a>
4199 * @see #EXPR
4200 **/
4201 public static final int MINUS = JavaLanguageLexer.MINUS;
4202 /**
4203 * The {@code /} (division) operator.
4204 *
4205 * <p>For example:</p>
4206 * <pre>
4207 * a = 4 / 2;
4208 * </pre>
4209 *
4210 * <p>parses as:</p>
4211 * <pre>
4212 * |--EXPR -> EXPR
4213 * | `--ASSIGN -> =
4214 * | |--IDENT -> a
4215 * | `--DIV -> /
4216 * | |--NUM_INT -> 4
4217 * | `--NUM_INT -> 2
4218 * |--SEMI -> ;
4219 * </pre>
4220 *
4221 * @see <a
4222 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java
4223 * Language Specification, §15.17.2</a>
4224 * @see #EXPR
4225 **/
4226 public static final int DIV = JavaLanguageLexer.DIV;
4227 /**
4228 * The {@code %} (remainder) operator.
4229 *
4230 * <p>For example:</p>
4231 * <pre>
4232 * c = a % b;
4233 * </pre>
4234 *
4235 * <p>parses as:</p>
4236 * <pre>
4237 * EXPR -> EXPR
4238 * `--ASSIGN -> =
4239 * |--IDENT -> c
4240 * `--MOD -> %
4241 * |--IDENT -> a
4242 * `--IDENT -> b
4243 * SEMI -> ;
4244 * </pre>
4245 *
4246 * @see <a
4247 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java
4248 * Language Specification, §15.17.3</a>
4249 * @see #EXPR
4250 **/
4251 public static final int MOD = JavaLanguageLexer.MOD;
4252 /**
4253 * The {@code ++} (prefix increment) operator.
4254 *
4255 * <p>For example:</p>
4256 * <pre>
4257 * ++a;
4258 * </pre>
4259 *
4260 * <p>parses as:</p>
4261 * <pre>
4262 * |--EXPR -> EXPR
4263 * | `--INC -> ++
4264 * | `--IDENT -> a
4265 * |--SEMI -> ;
4266 * </pre>
4267 *
4268 * @see <a
4269 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java
4270 * Language Specification, §15.15.1</a>
4271 * @see #EXPR
4272 * @see #POST_INC
4273 **/
4274 public static final int INC = JavaLanguageLexer.INC;
4275 /**
4276 * The {@code --} (prefix decrement) operator.
4277 *
4278 * <p>For example:</p>
4279 * <pre>
4280 * --a;
4281 * </pre>
4282 *
4283 * <p>parses as:</p>
4284 * <pre>
4285 * |--EXPR -> EXPR
4286 * | `--DEC -> --
4287 * | `--IDENT -> a
4288 * |--SEMI -> ;
4289 * </pre>
4290 *
4291 * @see <a
4292 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java
4293 * Language Specification, §15.15.2</a>
4294 * @see #EXPR
4295 * @see #POST_DEC
4296 **/
4297 public static final int DEC = JavaLanguageLexer.DEC;
4298 /**
4299 * The {@code ~} (bitwise complement) operator.
4300 *
4301 * <p>For example:</p>
4302 * <pre>
4303 * a = ~ a;
4304 * </pre>
4305 *
4306 * <p>parses as:</p>
4307 * <pre>
4308 * |--EXPR -> EXPR
4309 * | `--ASSIGN -> =
4310 * | |--IDENT -> a
4311 * | `--BNOT -> ~
4312 * | `--IDENT -> a
4313 * |--SEMI -> ;
4314 * </pre>
4315 *
4316 * @see <a
4317 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java
4318 * Language Specification, §15.15.5</a>
4319 * @see #EXPR
4320 **/
4321 public static final int BNOT = JavaLanguageLexer.BNOT;
4322 /**
4323 * The {@code !} (logical complement) operator.
4324 *
4325 * <p>For example:</p>
4326 * <pre>
4327 * c = ! a;
4328 * </pre>
4329 *
4330 * <p>parses as:</p>
4331 * <pre>
4332 * |--EXPR -> EXPR
4333 * | `--ASSIGN -> =
4334 * | |--IDENT -> c
4335 * | `--LNOT -> !
4336 * | `--IDENT -> a
4337 * |--SEMI -> ;
4338 * </pre>
4339 *
4340 * @see <a
4341 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java
4342 * Language Specification, §15.15.6</a>
4343 * @see #EXPR
4344 **/
4345 public static final int LNOT = JavaLanguageLexer.LNOT;
4346 /**
4347 * The {@code true} keyword.
4348 *
4349 * <p>For example:</p>
4350 * <pre>
4351 * boolean a = true;
4352 * </pre>
4353 *
4354 * <p>parses as:</p>
4355 * <pre>
4356 * |--VARIABLE_DEF -> VARIABLE_DEF
4357 * | |--MODIFIERS -> MODIFIERS
4358 * | |--TYPE -> TYPE
4359 * | | `--LITERAL_BOOLEAN -> boolean
4360 * | |--IDENT -> a
4361 * | `--ASSIGN -> =
4362 * | `--EXPR -> EXPR
4363 * | `--LITERAL_TRUE -> true
4364 * |--SEMI -> ;
4365 * </pre>
4366 *
4367 * @see <a
4368 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java
4369 * Language Specification, §3.10.3</a>
4370 * @see #EXPR
4371 * @see #LITERAL_FALSE
4372 **/
4373 public static final int LITERAL_TRUE =
4374 JavaLanguageLexer.LITERAL_TRUE;
4375
4376 /**
4377 * The {@code false} keyword.
4378 *
4379 * <p>For example:</p>
4380 * <pre>
4381 * boolean a = false;
4382 * </pre>
4383 *
4384 * <p>parses as:</p>
4385 * <pre>
4386 * VARIABLE_DEF -> VARIABLE_DEF
4387 * |--MODIFIERS -> MODIFIERS
4388 * |--TYPE -> TYPE
4389 * | `--LITERAL_BOOLEAN -> boolean
4390 * |--IDENT -> a
4391 * |--ASSIGN -> =
4392 * | `--EXPR -> EXPR
4393 * | `--LITERAL_FALSE -> false
4394 * `--SEMI -> ;
4395 * </pre>
4396 *
4397 * @see <a
4398 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java
4399 * Language Specification, §3.10.3</a>
4400 * @see #EXPR
4401 * @see #LITERAL_TRUE
4402 **/
4403 public static final int LITERAL_FALSE =
4404 JavaLanguageLexer.LITERAL_FALSE;
4405
4406 /**
4407 * The {@code null} keyword.
4408 *
4409 * <p>For example:</p>
4410 * <pre>
4411 * String s = null;
4412 * </pre>
4413 *
4414 * <p>parses as:</p>
4415 * <pre>
4416 * VARIABLE_DEF -> VARIABLE_DEF
4417 * |--MODIFIERS -> MODIFIERS
4418 * |--TYPE -> TYPE
4419 * | `--IDENT -> String
4420 * |--IDENT -> s
4421 * |--ASSIGN -> =
4422 * | `--EXPR -> EXPR
4423 * | `--LITERAL_NULL -> null
4424 * `--SEMI -> ;
4425 * </pre>
4426 *
4427 * @see <a
4428 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java
4429 * Language Specification, §3.10.7</a>
4430 * @see #EXPR
4431 **/
4432 public static final int LITERAL_NULL =
4433 JavaLanguageLexer.LITERAL_NULL;
4434
4435 /**
4436 * The {@code new} keyword. This element is used to define
4437 * new instances of objects, new arrays, and new anonymous inner
4438 * classes.
4439 *
4440 * <p>For example:</p>
4441 *
4442 * <pre>
4443 * List<String> l = new ArrayList<String>();
4444 * </pre>
4445 *
4446 * <p>parses as:</p>
4447 * <pre>
4448 * VARIABLE_DEF -> VARIABLE_DEF
4449 * |--MODIFIERS -> MODIFIERS
4450 * |--TYPE -> TYPE
4451 * | |--IDENT -> List
4452 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
4453 * | |--GENERIC_START -> <
4454 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
4455 * | | `--IDENT -> String
4456 * | `--GENERIC_END -> >
4457 * |--IDENT -> l
4458 * |--ASSIGN -> =
4459 * | `--EXPR -> EXPR
4460 * | `--LITERAL_NEW -> new
4461 * | |--IDENT -> ArrayList
4462 * | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
4463 * | | |--GENERIC_START -> <
4464 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
4465 * | | | `--IDENT -> String
4466 * | | `--GENERIC_END -> >
4467 * | |--LPAREN -> (
4468 * | |--ELIST -> ELIST
4469 * | `--RPAREN -> )
4470 * `--SEMI -> ;
4471 * </pre>
4472 *
4473 * <p>For example:</p>
4474 * <pre>
4475 * String[] strings = new String[3];
4476 * </pre>
4477 *
4478 * <p>parses as:</p>
4479 * <pre>
4480 * VARIABLE_DEF -> VARIABLE_DEF
4481 * |--MODIFIERS -> MODIFIERS
4482 * |--TYPE -> TYPE
4483 * | |--IDENT -> String
4484 * | `--ARRAY_DECLARATOR -> [
4485 * | `--RBRACK -> ]
4486 * |--IDENT -> strings
4487 * |--ASSIGN -> =
4488 * | `--EXPR -> EXPR
4489 * | `--LITERAL_NEW -> new
4490 * | |--IDENT -> String
4491 * | `--ARRAY_DECLARATOR -> [
4492 * | |--EXPR -> EXPR
4493 * | | `--NUM_INT -> 3
4494 * | `--RBRACK -> ]
4495 * `--SEMI -> ;
4496 * </pre>
4497 *
4498 * <p>For example:</p>
4499 * <pre>
4500 * Supplier<Integer> s = new Supplier<>() {
4501 * @Override
4502 * public Integer get() {
4503 * return 42;
4504 * }
4505 * };
4506 * </pre>
4507 *
4508 * <p>parses as:</p>
4509 * <pre>
4510 * VARIABLE_DEF -> VARIABLE_DEF
4511 * |--MODIFIERS -> MODIFIERS
4512 * |--TYPE -> TYPE
4513 * | |--IDENT -> Supplier
4514 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
4515 * | |--GENERIC_START -> <
4516 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
4517 * | | `--IDENT -> Integer
4518 * | `--GENERIC_END -> >
4519 * |--IDENT -> s
4520 * |--ASSIGN -> =
4521 * | `--EXPR -> EXPR
4522 * | `--LITERAL_NEW -> new
4523 * | |--IDENT -> Supplier
4524 * | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
4525 * | | |--GENERIC_START -> <
4526 * | | `--GENERIC_END -> >
4527 * | |--LPAREN -> (
4528 * | |--ELIST -> ELIST
4529 * | |--RPAREN -> )
4530 * | `--OBJBLOCK -> OBJBLOCK
4531 * | |--LCURLY -> {
4532 * | |--METHOD_DEF -> METHOD_DEF
4533 * | | |--MODIFIERS -> MODIFIERS
4534 * | | | |--ANNOTATION -> ANNOTATION
4535 * | | | | |--AT -> @
4536 * | | | | `--IDENT -> Override
4537 * | | | `--LITERAL_PUBLIC -> public
4538 * | | |--TYPE -> TYPE
4539 * | | | `--IDENT -> Integer
4540 * | | |--IDENT -> get
4541 * | | |--LPAREN -> (
4542 * | | |--PARAMETERS -> PARAMETERS
4543 * | | |--RPAREN -> )
4544 * | | `--SLIST -> {
4545 * | | |--LITERAL_RETURN -> return
4546 * | | | |--EXPR -> EXPR
4547 * | | | | `--NUM_INT -> 42
4548 * | | | `--SEMI -> ;
4549 * | | `--RCURLY -> }
4550 * | `--RCURLY -> }
4551 * `--SEMI -> ;
4552 * </pre>
4553 *
4554 * @see #IDENT
4555 * @see #DOT
4556 * @see #LPAREN
4557 * @see #ELIST
4558 * @see #RPAREN
4559 * @see #OBJBLOCK
4560 * @see #ARRAY_INIT
4561 * @see FullIdent
4562 **/
4563 public static final int LITERAL_NEW = JavaLanguageLexer.LITERAL_NEW;
4564 /**
4565 * An integer literal. These may be specified in decimal,
4566 * hexadecimal, or octal form.
4567 *
4568 * <p>For example:</p>
4569 * <pre>
4570 * a = 3;
4571 * </pre>
4572 *
4573 * <p>parses as:</p>
4574 * <pre>
4575 * |--EXPR -> EXPR
4576 * | `--ASSIGN -> =
4577 * | |--IDENT -> a
4578 * | `--NUM_INT -> 3
4579 * |--SEMI -> ;
4580 * </pre>
4581 *
4582 * @see <a
4583 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java
4584 * Language Specification, §3.10.1</a>
4585 * @see #EXPR
4586 * @see #NUM_LONG
4587 **/
4588 public static final int NUM_INT = JavaLanguageLexer.NUM_INT;
4589 /**
4590 * A character literal. This is a (possibly escaped) character
4591 * enclosed in single quotes.
4592 *
4593 * <p>For example:</p>
4594 * <pre>
4595 * return 'a';
4596 * </pre>
4597 *
4598 * <p>parses as:</p>
4599 * <pre>
4600 * --LITERAL_RETURN -> return
4601 * |--EXPR -> EXPR
4602 * | `--CHAR_LITERAL -> 'a'
4603 * `--SEMI -> ;
4604 * </pre>
4605 *
4606 * @see <a
4607 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.4">Java
4608 * Language Specification, §3.10.4</a>
4609 * @see #EXPR
4610 **/
4611 public static final int CHAR_LITERAL =
4612 JavaLanguageLexer.CHAR_LITERAL;
4613
4614 /**
4615 * A string literal. This is a sequence of (possibly escaped)
4616 * characters enclosed in double quotes.
4617 *
4618 * <p>For example:</p>
4619 * <pre>String str = "StringLiteral";</pre>
4620 *
4621 * <p>parses as:</p>
4622 * <pre>
4623 * |--VARIABLE_DEF -> VARIABLE_DEF
4624 * | |--MODIFIERS -> MODIFIERS
4625 * | |--TYPE -> TYPE
4626 * | | `--IDENT -> String
4627 * | |--IDENT -> str
4628 * | `--ASSIGN -> =
4629 * | `--EXPR -> EXPR
4630 * | `--STRING_LITERAL -> "StringLiteral"
4631 * |--SEMI -> ;
4632 * </pre>
4633 *
4634 * @see <a
4635 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java
4636 * Language Specification, §3.10.5</a>
4637 * @see #EXPR
4638 **/
4639 public static final int STRING_LITERAL =
4640 JavaLanguageLexer.STRING_LITERAL;
4641
4642 /**
4643 * A single precision floating point literal. This is a floating
4644 * point number with an {@code F} or {@code f} suffix.
4645 *
4646 * <p>For example:</p>
4647 * <pre>
4648 * a = 3.14f;
4649 * </pre>
4650 *
4651 * <p>parses as:</p>
4652 * <pre>
4653 * |--EXPR -> EXPR
4654 * | `--ASSIGN -> =
4655 * | |--IDENT -> a
4656 * | `--NUM_FLOAT -> 3.14f
4657 * |--SEMI -> ;
4658 * </pre>
4659 *
4660 * @see <a
4661 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java
4662 * Language Specification, §3.10.2</a>
4663 * @see #EXPR
4664 * @see #NUM_DOUBLE
4665 **/
4666 public static final int NUM_FLOAT = JavaLanguageLexer.NUM_FLOAT;
4667 /**
4668 * A long integer literal. These are almost the same as integer
4669 * literals, but they have an {@code L} or {@code l}
4670 * (ell) suffix.
4671 *
4672 * <p>For example:</p>
4673 * <pre>
4674 * a = 3l;
4675 * </pre>
4676 *
4677 * <p>parses as:</p>
4678 * <pre>
4679 * |--EXPR -> EXPR
4680 * | `--ASSIGN -> =
4681 * | |--IDENT -> a
4682 * | `--NUM_LONG -> 3l
4683 * |--SEMI -> ;
4684 * </pre>
4685 *
4686 * @see <a
4687 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java
4688 * Language Specification, §3.10.1</a>
4689 * @see #EXPR
4690 * @see #NUM_INT
4691 **/
4692 public static final int NUM_LONG = JavaLanguageLexer.NUM_LONG;
4693 /**
4694 * A double precision floating point literal. This is a floating
4695 * point number with an optional {@code D} or {@code d}
4696 * suffix.
4697 *
4698 * <p>For example:</p>
4699 * <pre>
4700 * a = 3.14d;
4701 * </pre>
4702 *
4703 * <p>parses as:</p>
4704 * <pre>
4705 * |--EXPR -> EXPR
4706 * | `--ASSIGN -> =
4707 * | |--IDENT -> a
4708 * | `--NUM_DOUBLE -> 3.14d
4709 * |--SEMI -> ;
4710 * </pre>
4711 *
4712 * @see <a
4713 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java
4714 * Language Specification, §3.10.2</a>
4715 * @see #EXPR
4716 * @see #NUM_FLOAT
4717 **/
4718 public static final int NUM_DOUBLE = JavaLanguageLexer.NUM_DOUBLE;
4719
4720 /**
4721 * The {@code assert} keyword. This is only for Java 1.4 and
4722 * later.
4723 *
4724 * <p>For example:</p>
4725 * <pre>
4726 * assert(x==4);
4727 * </pre>
4728 *
4729 * <p>parses as:</p>
4730 * <pre>
4731 * LITERAL_ASSERT -> assert
4732 * |--EXPR -> EXPR
4733 * | |--LPAREN -> (
4734 * | |--EQUAL -> ==
4735 * | | |--IDENT -> x
4736 * | | `--NUM_INT -> 4
4737 * | `--RPAREN -> )
4738 * `--SEMI -> ;
4739 * </pre>
4740 **/
4741 public static final int LITERAL_ASSERT = JavaLanguageLexer.ASSERT;
4742
4743 /**
4744 * A static import declaration. Static import declarations are optional,
4745 * but must appear after the package declaration and before the type
4746 * declaration.
4747 *
4748 * <p>For example:</p>
4749 * <pre>
4750 * import static java.io.IOException;
4751 * </pre>
4752 *
4753 * <p>parses as:</p>
4754 * <pre>
4755 * STATIC_IMPORT -> import
4756 * |--LITERAL_STATIC -> static
4757 * |--DOT -> .
4758 * | |--DOT -> .
4759 * | | |--IDENT -> java
4760 * | | `--IDENT -> io
4761 * | `--IDENT -> IOException
4762 * `--SEMI -> ;
4763 * </pre>
4764 *
4765 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
4766 * JSR201</a>
4767 * @see #LITERAL_STATIC
4768 * @see #DOT
4769 * @see #IDENT
4770 * @see #STAR
4771 * @see #SEMI
4772 * @see FullIdent
4773 **/
4774 public static final int STATIC_IMPORT =
4775 JavaLanguageLexer.STATIC_IMPORT;
4776
4777 /**
4778 * An enum declaration. Its notable children are
4779 * enum constant declarations followed by
4780 * any construct that may be expected in a class body.
4781 *
4782 * <p>For example:</p>
4783 * <pre>
4784 * public enum MyEnum
4785 * implements Serializable
4786 * {
4787 * FIRST_CONSTANT,
4788 * SECOND_CONSTANT;
4789 *
4790 * public void someMethod()
4791 * {
4792 * }
4793 * }
4794 * </pre>
4795 *
4796 * <p>parses as:</p>
4797 * <pre>
4798 * ENUM_DEF -> ENUM_DEF
4799 * |--MODIFIERS -> MODIFIERS
4800 * | `--LITERAL_PUBLIC -> public
4801 * |--ENUM -> enum
4802 * |--IDENT -> MyEnum
4803 * |--IMPLEMENTS_CLAUSE -> implements
4804 * | `--IDENT -> Serializable
4805 * `--OBJBLOCK -> OBJBLOCK
4806 * |--LCURLY -> {
4807 * |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF
4808 * | |--ANNOTATIONS -> ANNOTATIONS
4809 * | `--IDENT -> FIRST_CONSTANT
4810 * |--COMMA -> ,
4811 * |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF
4812 * | |--ANNOTATIONS -> ANNOTATIONS
4813 * | `--IDENT -> SECOND_CONSTANT
4814 * |--SEMI -> ;
4815 * |--METHOD_DEF -> METHOD_DEF
4816 * | |--MODIFIERS -> MODIFIERS
4817 * | | `--LITERAL_PUBLIC -> public
4818 * | |--TYPE -> TYPE
4819 * | | `--LITERAL_VOID -> void
4820 * | |--IDENT -> someMethod
4821 * | |--LPAREN -> (
4822 * | |--PARAMETERS -> PARAMETERS
4823 * | |--RPAREN -> )
4824 * | `--SLIST -> {
4825 * | `--RCURLY -> }
4826 * `--RCURLY -> }
4827 * </pre>
4828 *
4829 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
4830 * JSR201</a>
4831 * @see #MODIFIERS
4832 * @see #ENUM
4833 * @see #IDENT
4834 * @see #EXTENDS_CLAUSE
4835 * @see #IMPLEMENTS_CLAUSE
4836 * @see #OBJBLOCK
4837 * @see #LITERAL_NEW
4838 * @see #ENUM_CONSTANT_DEF
4839 **/
4840 public static final int ENUM_DEF =
4841 JavaLanguageLexer.ENUM_DEF;
4842
4843 /**
4844 * The {@code enum} keyword. This element appears
4845 * as part of an enum declaration.
4846 *
4847 * <p>For example:</p>
4848 * <pre>
4849 * public enum Count {}
4850 * </pre>
4851 *
4852 * <p>parses as:</p>
4853 * <pre>
4854 * ENUM_DEF -> ENUM_DEF
4855 * |--MODIFIERS -> MODIFIERS
4856 * | `--LITERAL_PUBLIC -> public
4857 * |--ENUM -> enum
4858 * |--IDENT -> Count
4859 * `--OBJBLOCK -> OBJBLOCK
4860 * |--LCURLY -> {
4861 * `--RCURLY -> }
4862 * </pre>
4863 *
4864 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">JSR201</a>
4865 * @see #MODIFIERS
4866 * @see #ENUM_DEF
4867 * @see #IDENT
4868 * @see #OBJBLOCK
4869 **/
4870 public static final int ENUM =
4871 JavaLanguageLexer.ENUM;
4872
4873 /**
4874 * An enum constant declaration. Its notable children are annotations,
4875 * arguments and object block akin to an anonymous
4876 * inner class' body.
4877 *
4878 * <p>For example:</p>
4879 * <pre>
4880 * SOME_CONSTANT(1)
4881 * {
4882 * public void someMethodOverriddenFromMainBody()
4883 * {
4884 * }
4885 * }
4886 * </pre>
4887 *
4888 * <p>parses as:</p>
4889 * <pre>
4890 * ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF
4891 * | |--ANNOTATIONS -> ANNOTATIONS
4892 * | |--IDENT -> SOME_CONSTANT
4893 * | |--LPAREN -> (
4894 * | |--ELIST -> ELIST
4895 * | | `--EXPR -> EXPR
4896 * | | `--NUM_INT -> 1
4897 * | |--RPAREN -> )
4898 * | `--OBJBLOCK -> OBJBLOCK
4899 * | |--LCURLY -> {
4900 * | |--METHOD_DEF -> METHOD_DEF
4901 * | | |--MODIFIERS -> MODIFIERS
4902 * | | | `--LITERAL_PUBLIC -> public
4903 * | | |--TYPE -> TYPE
4904 * | | | `--LITERAL_VOID -> void
4905 * | | |--IDENT -> someMethodOverriddenFromMainBody
4906 * | | |--LPAREN -> (
4907 * | | |--PARAMETERS -> PARAMETERS
4908 * | | |--RPAREN -> )
4909 * | | `--SLIST -> {
4910 * | | `--RCURLY -> }
4911 * | `--RCURLY -> }
4912 * </pre>
4913 *
4914 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
4915 * JSR201</a>
4916 * @see #ANNOTATIONS
4917 * @see #MODIFIERS
4918 * @see #IDENT
4919 * @see #ELIST
4920 * @see #OBJBLOCK
4921 **/
4922 public static final int ENUM_CONSTANT_DEF =
4923 JavaLanguageLexer.ENUM_CONSTANT_DEF;
4924
4925 /**
4926 * A for-each clause. This is a child of
4927 * {@code LITERAL_FOR}. The children of this element may be
4928 * a parameter definition, the colon literal and an expression.
4929 *
4930 * <p>For example:</p>
4931 * <pre>
4932 * for (int value : values) {
4933 * doSomething();
4934 * }
4935 * </pre>
4936 *
4937 * <p>parses as:</p>
4938 * <pre>
4939 * LITERAL_FOR -> for
4940 * |--LPAREN -> (
4941 * |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE
4942 * | |--VARIABLE_DEF -> VARIABLE_DEF
4943 * | | |--MODIFIERS -> MODIFIERS
4944 * | | |--TYPE -> TYPE
4945 * | | | `--LITERAL_INT -> int
4946 * | | `--IDENT -> value
4947 * | |--COLON -> :
4948 * | `--EXPR -> EXPR
4949 * | `--IDENT -> values
4950 * |--RPAREN -> )
4951 * `--SLIST -> {
4952 * |--EXPR -> EXPR
4953 * | `--METHOD_CALL -> (
4954 * | |--IDENT -> doSomething
4955 * | |--ELIST -> ELIST
4956 * | `--RPAREN -> )
4957 * |--SEMI -> ;
4958 * `--RCURLY -> }
4959 * </pre>
4960 *
4961 * @see #VARIABLE_DEF
4962 * @see #ELIST
4963 * @see #LITERAL_FOR
4964 **/
4965 public static final int FOR_EACH_CLAUSE =
4966 JavaLanguageLexer.FOR_EACH_CLAUSE;
4967
4968 /**
4969 * An annotation declaration. The notable children are the name of the
4970 * annotation type, annotation field declarations and (constant) fields.
4971 *
4972 * <p>For example:</p>
4973 * <pre>
4974 * public @interface MyAnnotation
4975 * {
4976 * int someValue();
4977 * }
4978 * </pre>
4979 *
4980 * <p>parses as:</p>
4981 * <pre>
4982 * ANNOTATION_DEF -> ANNOTATION_DEF
4983 * |--MODIFIERS -> MODIFIERS
4984 * | `--LITERAL_PUBLIC -> public
4985 * |--AT -> @
4986 * |--LITERAL_INTERFACE -> interface
4987 * |--IDENT -> MyAnnotation
4988 * `--OBJBLOCK -> OBJBLOCK
4989 * |--LCURLY -> {
4990 * |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF
4991 * | |--MODIFIERS -> MODIFIERS
4992 * | |--TYPE -> TYPE
4993 * | | `--LITERAL_INT -> int
4994 * | |--IDENT -> someValue
4995 * | |--LPAREN -> (
4996 * | |--RPAREN -> )
4997 * | `--SEMI -> ;
4998 * `--RCURLY -> }
4999 * </pre>
5000 *
5001 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5002 * JSR201</a>
5003 * @see #MODIFIERS
5004 * @see #LITERAL_INTERFACE
5005 * @see #IDENT
5006 * @see #OBJBLOCK
5007 * @see #ANNOTATION_FIELD_DEF
5008 **/
5009 public static final int ANNOTATION_DEF =
5010 JavaLanguageLexer.ANNOTATION_DEF;
5011
5012 /**
5013 * An annotation field declaration. The notable children are modifiers,
5014 * field type, field name and an optional default value (a conditional
5015 * compile-time constant expression). Default values may also be
5016 * annotations.
5017 *
5018 * <p>For example:</p>
5019 *
5020 * <pre>
5021 * String someField() default "Hello world";
5022 * </pre>
5023 *
5024 * <p>parses as:</p>
5025 *
5026 * <pre>
5027 * ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF
5028 * |--MODIFIERS -> MODIFIERS
5029 * |--TYPE -> TYPE
5030 * | `--IDENT -> String
5031 * |--IDENT -> someField
5032 * |--LPAREN -> (
5033 * |--RPAREN -> )
5034 * |--LITERAL_DEFAULT -> default
5035 * | `--EXPR -> EXPR
5036 * | `--STRING_LITERAL -> "Hello world"
5037 * `--SEMI -> ;
5038 * </pre>
5039 *
5040 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5041 * JSR201</a>
5042 * @see #MODIFIERS
5043 * @see #TYPE
5044 * @see #LITERAL_DEFAULT
5045 */
5046 public static final int ANNOTATION_FIELD_DEF =
5047 JavaLanguageLexer.ANNOTATION_FIELD_DEF;
5048
5049 // note: @ is the html escape for '@',
5050 // used here to avoid confusing the javadoc tool
5051 /**
5052 * A collection of annotations on a package or enum constant.
5053 * A collections of annotations will only occur on these nodes
5054 * as all other nodes that may be qualified with an annotation can
5055 * be qualified with any other modifier and hence these annotations
5056 * would be contained in a {@link #MODIFIERS} node.
5057 *
5058 * <p>For example:</p>
5059 *
5060 * <pre>
5061 * @MyAnnotation package blah;
5062 * </pre>
5063 *
5064 * <p>parses as:</p>
5065 *
5066 * <pre>
5067 * PACKAGE_DEF -> package
5068 * |--ANNOTATIONS -> ANNOTATIONS
5069 * | `--ANNOTATION -> ANNOTATION
5070 * | |--AT -> @
5071 * | `--IDENT -> MyAnnotation
5072 * |--IDENT -> blah
5073 * `--SEMI -> ;
5074 * </pre>
5075 *
5076 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5077 * JSR201</a>
5078 * @see #ANNOTATION
5079 * @see #AT
5080 * @see #IDENT
5081 */
5082 public static final int ANNOTATIONS =
5083 JavaLanguageLexer.ANNOTATIONS;
5084
5085 // note: @ is the html escape for '@',
5086 // used here to avoid confusing the javadoc tool
5087 /**
5088 * An annotation of a package, type, field, parameter or variable.
5089 * An annotation may occur anywhere modifiers occur (it is a
5090 * type of modifier) and may also occur prior to a package definition.
5091 * The notable children are: The annotation name and either a single
5092 * default annotation value or a sequence of name value pairs.
5093 * Annotation values may also be annotations themselves.
5094 *
5095 * <p>For example:</p>
5096 * <pre>
5097 * @MyAnnotation(someField1 = "Hello",
5098 * someField2 = @SomeOtherAnnotation)
5099 * </pre>
5100 *
5101 * <p>parses as:</p>
5102 * <pre>
5103 * ANNOTATION -> ANNOTATION
5104 * |--AT -> @
5105 * |--IDENT -> MyAnnotation
5106 * |--LPAREN -> (
5107 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR
5108 * | |--IDENT -> someField1
5109 * | |--ASSIGN -> =
5110 * | `--EXPR -> EXPR
5111 * | `--STRING_LITERAL -> "Hello"
5112 * |--COMMA -> ,
5113 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR
5114 * | |--IDENT -> someField2
5115 * | |--ASSIGN -> =
5116 * | `--ANNOTATION -> ANNOTATION
5117 * | |--AT -> @
5118 * | `--IDENT -> SomeOtherAnnotation
5119 * `--RPAREN -> )
5120 * </pre>
5121 *
5122 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5123 * JSR201</a>
5124 * @see #MODIFIERS
5125 * @see #IDENT
5126 * @see #ANNOTATION_MEMBER_VALUE_PAIR
5127 */
5128 public static final int ANNOTATION =
5129 JavaLanguageLexer.ANNOTATION;
5130
5131 /**
5132 * An initialization of an annotation member with a value.
5133 * Its children are the name of the member, the assignment literal
5134 * and the (compile-time constant conditional expression) value.
5135 *
5136 * <p>For example:</p>
5137 * <pre>
5138 * @Annotation(
5139 * value="123"
5140 * )
5141 * </pre>
5142 *
5143 * <p>parses as:</p>
5144 * <pre>
5145 * ANNOTATION -> ANNOTATION
5146 * |--AT -> @
5147 * |--IDENT -> Annotation
5148 * |--LPAREN -> (
5149 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR
5150 * | |--IDENT -> value
5151 * | |--ASSIGN -> =
5152 * | `--EXPR -> EXPR
5153 * | `--STRING_LITERAL -> "123"
5154 * `--RPAREN -> )
5155 * </pre>
5156 *
5157 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5158 * JSR201</a>
5159 * @see #ANNOTATION
5160 * @see #IDENT
5161 */
5162 public static final int ANNOTATION_MEMBER_VALUE_PAIR =
5163 JavaLanguageLexer.ANNOTATION_MEMBER_VALUE_PAIR;
5164
5165 /**
5166 * An annotation array member initialization.
5167 * Initializers can not be nested.
5168 * An initializer may be present as a default to an annotation
5169 * member, as the single default value to an annotation
5170 * (e.g. @Annotation({1,2})) or as the value of an annotation
5171 * member value pair.
5172 *
5173 * <p>For example:</p>
5174 * <pre>
5175 * @Annotation({1, 2})
5176 * </pre>
5177 *
5178 * <p>parses as:</p>
5179 * <pre>
5180 * ANNOTATION -> ANNOTATION
5181 * |--AT -> @
5182 * |--IDENT -> Annotation
5183 * |--LPAREN -> (
5184 * |--ANNOTATION_ARRAY_INIT -> {
5185 * | |--EXPR -> EXPR
5186 * | | `--NUM_INT -> 1
5187 * | |--COMMA -> ,
5188 * | |--EXPR -> EXPR
5189 * | | `--NUM_INT -> 2
5190 * | `--RCURLY -> }
5191 * `--RPAREN -> )
5192 * </pre>
5193 *
5194 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5195 * JSR201</a>
5196 * @see #ANNOTATION
5197 * @see #IDENT
5198 * @see #ANNOTATION_MEMBER_VALUE_PAIR
5199 */
5200 public static final int ANNOTATION_ARRAY_INIT =
5201 JavaLanguageLexer.ANNOTATION_ARRAY_INIT;
5202
5203 /**
5204 * A list of type parameters to a class, interface or
5205 * method definition. Children are LT, at least one
5206 * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single
5207 * TYPE_PARAMETER and a final GT.
5208 *
5209 * <p>For example:</p>
5210 *
5211 * <pre>
5212 * public class MyClass<A, B> {
5213 *
5214 * }
5215 * </pre>
5216 *
5217 * <p>parses as:</p>
5218 *
5219 * <pre>
5220 * CLASS_DEF -> CLASS_DEF
5221 * |--MODIFIERS -> MODIFIERS
5222 * | `--LITERAL_PUBLIC -> public
5223 * |--LITERAL_CLASS -> class
5224 * |--IDENT -> MyClass
5225 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5226 * | |--GENERIC_START -> <
5227 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5228 * | | `--IDENT -> A
5229 * | |--COMMA -> ,
5230 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5231 * | | `--IDENT -> B
5232 * | `--GENERIC_END -> >
5233 * `--OBJBLOCK -> OBJBLOCK
5234 * |--LCURLY -> {
5235 * `--RCURLY -> }
5236 * </pre>
5237 *
5238 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5239 * Generic Classes and Type Parameters</a>
5240 * @see #GENERIC_START
5241 * @see #GENERIC_END
5242 * @see #TYPE_PARAMETER
5243 * @see #COMMA
5244 */
5245 public static final int TYPE_PARAMETERS =
5246 JavaLanguageLexer.TYPE_PARAMETERS;
5247
5248 /**
5249 * A type parameter to a class, interface or method definition.
5250 * Children are the type name and an optional TYPE_UPPER_BOUNDS.
5251 *
5252 * <p>For example:</p>
5253 *
5254 * <pre>
5255 * public class MyClass <A extends Collection> {
5256 *
5257 * }
5258 * </pre>
5259 *
5260 * <p>parses as:</p>
5261 *
5262 * <pre>
5263 * CLASS_DEF -> CLASS_DEF
5264 * |--MODIFIERS -> MODIFIERS
5265 * | `--LITERAL_PUBLIC -> public
5266 * |--LITERAL_CLASS -> class
5267 * |--IDENT -> MyClass
5268 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5269 * | |--GENERIC_START -> <
5270 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5271 * | | |--IDENT -> A
5272 * | | `--TYPE_UPPER_BOUNDS -> extends
5273 * | | `--IDENT -> Collection
5274 * | `--GENERIC_END -> >
5275 * `--OBJBLOCK -> OBJBLOCK
5276 * |--LCURLY -> {
5277 * `--RCURLY -> }
5278 * </pre>
5279 *
5280 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5281 * Generic Classes and Type Parameters</a>
5282 * @see #IDENT
5283 * @see #WILDCARD_TYPE
5284 * @see #TYPE_UPPER_BOUNDS
5285 */
5286 public static final int TYPE_PARAMETER =
5287 JavaLanguageLexer.TYPE_PARAMETER;
5288
5289 /**
5290 * A list of type arguments to a type reference or
5291 * a method/ctor invocation. Children are GENERIC_START, at least one
5292 * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single
5293 * TYPE_ARGUMENT, and a final GENERIC_END.
5294 *
5295 * <p>For example:</p>
5296 *
5297 * <pre>
5298 * public Collection<?> a;
5299 * </pre>
5300 *
5301 * <p>parses as:</p>
5302 *
5303 * <pre>
5304 * VARIABLE_DEF -> VARIABLE_DEF
5305 * |--MODIFIERS -> MODIFIERS
5306 * | `--LITERAL_PUBLIC -> public
5307 * |--TYPE -> TYPE
5308 * | |--IDENT -> Collection
5309 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5310 * | |--GENERIC_START -> <
5311 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5312 * | | `--WILDCARD_TYPE -> ?
5313 * | `--GENERIC_END -> >
5314 * |--IDENT -> a
5315 * `--SEMI -> ;
5316 * </pre>
5317 *
5318 * @see #GENERIC_START
5319 * @see #GENERIC_END
5320 * @see #TYPE_ARGUMENT
5321 * @see #COMMA
5322 */
5323 public static final int TYPE_ARGUMENTS =
5324 JavaLanguageLexer.TYPE_ARGUMENTS;
5325
5326 /**
5327 * A type arguments to a type reference or a method/ctor invocation.
5328 * Children are either: type name or wildcard type with possible type
5329 * upper or lower bounds.
5330 *
5331 * <p>For example:</p>
5332 * <pre>List<? super List> list;</pre>
5333 *
5334 * <p>parses as:</p>
5335 * <pre>
5336 * VARIABLE_DEF -> VARIABLE_DEF
5337 * |--MODIFIERS -> MODIFIERS
5338 * |--TYPE -> TYPE
5339 * | |--IDENT -> List
5340 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5341 * | |--GENERIC_START -> <
5342 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5343 * | | |--WILDCARD_TYPE -> ?
5344 * | | `--TYPE_LOWER_BOUNDS -> super
5345 * | | `--IDENT -> List
5346 * | `--GENERIC_END -> >
5347 * |--IDENT -> list
5348 * `--SEMI -> ;
5349 * </pre>
5350 *
5351 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5352 * Generic Classes and Type Parameters</a>
5353 * @see #WILDCARD_TYPE
5354 * @see #TYPE_UPPER_BOUNDS
5355 * @see #TYPE_LOWER_BOUNDS
5356 */
5357 public static final int TYPE_ARGUMENT =
5358 JavaLanguageLexer.TYPE_ARGUMENT;
5359
5360 /**
5361 * The type that refers to all types. This node has no children.
5362 *
5363 * <p>For example: </p>
5364 * <pre>
5365 *
5366 * List<?> list;
5367 * </pre>
5368 *
5369 * <p>parses as:</p>
5370 * <pre>
5371 * |--VARIABLE_DEF -> VARIABLE_DEF
5372 * | |--MODIFIERS -> MODIFIERS
5373 * | |--TYPE -> TYPE
5374 * | | |--IDENT -> List
5375 * | | |`--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5376 * | | |--GENERIC_START -> <
5377 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5378 * | | | `--WILDCARD_TYPE -> ?
5379 * | | `--GENERIC_END -> >
5380 * | `--IDENT -> list
5381 * |--SEMI -> ;
5382 * </pre>
5383 *
5384 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5385 * Generic Classes and Type Parameters</a>
5386 * @see #TYPE_ARGUMENT
5387 * @see #TYPE_UPPER_BOUNDS
5388 * @see #TYPE_LOWER_BOUNDS
5389 */
5390 public static final int WILDCARD_TYPE =
5391 JavaLanguageLexer.WILDCARD_TYPE;
5392
5393 /**
5394 * An upper bounds on a wildcard type argument or type parameter.
5395 * This node has one child - the type that is being used for
5396 * the bounding.
5397 *
5398 * <p>For example:</p>
5399 * <pre>List<? extends Number> list;</pre>
5400 *
5401 * <p>parses as:</p>
5402 * <pre>
5403 * --VARIABLE_DEF -> VARIABLE_DEF
5404 * |--MODIFIERS -> MODIFIERS
5405 * |--TYPE -> TYPE
5406 * | |--IDENT -> List
5407 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5408 * | |--GENERIC_START -> <
5409 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5410 * | | |--WILDCARD_TYPE -> ?
5411 * | | `--TYPE_UPPER_BOUNDS -> extends
5412 * | | `--IDENT -> Number
5413 * | `--GENERIC_END -> >
5414 * |--IDENT -> list
5415 * `--SEMI -> ;
5416 * </pre>
5417 *
5418 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5419 * Generic Classes and Type Parameters</a>
5420 * @see #TYPE_PARAMETER
5421 * @see #TYPE_ARGUMENT
5422 * @see #WILDCARD_TYPE
5423 */
5424 public static final int TYPE_UPPER_BOUNDS =
5425 JavaLanguageLexer.TYPE_UPPER_BOUNDS;
5426
5427 /**
5428 * A lower bounds on a wildcard type argument. This node has one child
5429 * - the type that is being used for the bounding.
5430 *
5431 * <p>For example:</p>
5432 * <pre>List<? super Integer> list;</pre>
5433 *
5434 * <p>parses as:</p>
5435 * <pre>
5436 * --VARIABLE_DEF -> VARIABLE_DEF
5437 * |--MODIFIERS -> MODIFIERS
5438 * |--TYPE -> TYPE
5439 * | |--IDENT -> List
5440 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5441 * | |--GENERIC_START -> <
5442 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5443 * | | |--WILDCARD_TYPE -> ?
5444 * | | `--TYPE_LOWER_BOUNDS -> super
5445 * | | `--IDENT -> Integer
5446 * | `--GENERIC_END -> >
5447 * |--IDENT -> list
5448 * `--SEMI -> ;
5449 * </pre>
5450 *
5451 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5452 * Generic Classes and Type Parameters</a>
5453 * @see #TYPE_ARGUMENT
5454 * @see #WILDCARD_TYPE
5455 */
5456 public static final int TYPE_LOWER_BOUNDS =
5457 JavaLanguageLexer.TYPE_LOWER_BOUNDS;
5458
5459 /**
5460 * An {@code @} symbol - signifying an annotation instance or the prefix
5461 * to the interface literal signifying the definition of an annotation
5462 * declaration.
5463 *
5464 * <p>For example:</p>
5465 * <pre>
5466 * @Deprecated
5467 * private int value;
5468 * </pre>
5469 *
5470 * <p>parses as:</p>
5471 * <pre>
5472 * VARIABLE_DEF -> VARIABLE_DEF
5473 * |--MODIFIERS -> MODIFIERS
5474 * | |--ANNOTATION -> ANNOTATION
5475 * | | |--AT -> @
5476 * | | `--IDENT -> Deprecated
5477 * | `--LITERAL_PRIVATE -> private
5478 * |--TYPE -> TYPE
5479 * | `--LITERAL_INT -> int
5480 * |--IDENT -> value
5481 * `--SEMI -> ;
5482 * </pre>
5483 *
5484 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5485 * JSR201</a>
5486 */
5487 public static final int AT = JavaLanguageLexer.AT;
5488
5489 /**
5490 * A triple dot for variable-length parameters. This token only ever occurs
5491 * in a parameter declaration immediately after the type of the parameter.
5492 *
5493 * <p>For example:</p>
5494 * <pre>
5495 * public void myShape(int... dimension) {
5496 *
5497 * }
5498 * </pre>
5499 *
5500 * <p>parses as:</p>
5501 * <pre>
5502 * METHOD_DEF -> METHOD_DEF
5503 * |--MODIFIERS -> MODIFIERS
5504 * | `--LITERAL_PUBLIC -> public
5505 * |--TYPE -> TYPE
5506 * | `--LITERAL_VOID -> void
5507 * |--IDENT -> myShape
5508 * |--LPAREN -> (
5509 * |--PARAMETERS -> PARAMETERS
5510 * | `--PARAMETER_DEF -> PARAMETER_DEF
5511 * | |--MODIFIERS -> MODIFIERS
5512 * | |--TYPE -> TYPE
5513 * | | `--LITERAL_INT -> int
5514 * | |--ELLIPSIS -> ...
5515 * | `--IDENT -> dimension
5516 * |--RPAREN -> )
5517 * `--SLIST -> {
5518 * `--RCURLY -> }
5519 * </pre>
5520 *
5521 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5522 * JSR201</a>
5523 */
5524 public static final int ELLIPSIS = JavaLanguageLexer.ELLIPSIS;
5525
5526 /**
5527 * The {@code &} symbol when used to extend a generic upper or lower bounds constrain
5528 * or a type cast expression with an additional interface.
5529 *
5530 * <p>Generic type bounds extension:
5531 * {@code class Comparable<T extends Serializable & CharSequence>}</p>
5532 * <pre>
5533 * CLASS_DEF -> CLASS_DEF
5534 * |--MODIFIERS -> MODIFIERS
5535 * |--LITERAL_CLASS -> class
5536 * |--IDENT -> Comparable
5537 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5538 * |--GENERIC_START -> <
5539 * |--TYPE_PARAMETER -> TYPE_PARAMETER
5540 * | |--IDENT -> T
5541 * | `--TYPE_UPPER_BOUNDS -> extends
5542 * | |--IDENT -> Serializable
5543 * | |--TYPE_EXTENSION_AND -> &
5544 * | `--IDENT -> CharSequence
5545 * `--GENERIC_END -> >
5546 * </pre>
5547 *
5548 * <p>Type cast extension:
5549 * {@code return (Serializable & CharSequence) null;}</p>
5550 * <pre>
5551 * --LITERAL_RETURN -> return
5552 * |--EXPR -> EXPR
5553 * | `--TYPECAST -> (
5554 * | |--TYPE -> TYPE
5555 * | | `--IDENT -> Serializable
5556 * | |--TYPE_EXTENSION_AND -> &
5557 * | |--TYPE -> TYPE
5558 * | | `--IDENT -> CharSequence
5559 * | |--RPAREN -> )
5560 * | `--LITERAL_NULL -> null
5561 * `--SEMI -> ;
5562 * </pre>
5563 *
5564 * @see #EXTENDS_CLAUSE
5565 * @see #TYPECAST
5566 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4">
5567 * Java Language Specification, §4.4</a>
5568 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">
5569 * Java Language Specification, §15.16</a>
5570 */
5571 public static final int TYPE_EXTENSION_AND =
5572 JavaLanguageLexer.TYPE_EXTENSION_AND;
5573
5574 /**
5575 * A {@code <} symbol signifying the start of type arguments or type parameters.
5576 *
5577 * <p>For example:</p>
5578 * <pre>
5579 * class Test<T> {}
5580 * </pre>
5581 *
5582 * <p>parses as:</p>
5583 * <pre>
5584 * CLASS_DEF -> CLASS_DEF
5585 * |--MODIFIERS -> MODIFIERS
5586 * |--LITERAL_CLASS -> class
5587 * |--IDENT -> Test
5588 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5589 * | |--GENERIC_START -> <
5590 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5591 * | | `--IDENT -> T
5592 * | `--GENERIC_END -> >
5593 * `--OBJBLOCK -> OBJBLOCK
5594 * |--LCURLY -> {
5595 * `--RCURLY -> }
5596 * </pre>
5597 *
5598 * @see #MODIFIERS
5599 * @see #IDENT
5600 * @see #OBJBLOCK
5601 * @see #TYPE_PARAMETERS
5602 * @see #GENERIC_END
5603 */
5604 public static final int GENERIC_START =
5605 JavaLanguageLexer.GENERIC_START;
5606
5607 /**
5608 * A {@code >} symbol signifying the end of type arguments or type parameters.
5609 *
5610 * <p>For example:</p>
5611 * <pre>
5612 * class Test<T> {}
5613 * </pre>
5614 *
5615 * <p>parses as:</p>
5616 * <pre>
5617 * CLASS_DEF -> CLASS_DEF
5618 * |--MODIFIERS -> MODIFIERS
5619 * |--LITERAL_CLASS -> class
5620 * |--IDENT -> Test
5621 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5622 * | |--GENERIC_START -> <
5623 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5624 * | | `--IDENT -> T
5625 * | `--GENERIC_END -> >
5626 * `--OBJBLOCK -> OBJBLOCK
5627 * |--LCURLY -> {
5628 * `--RCURLY -> }
5629 * </pre>
5630 *
5631 * @see #MODIFIERS
5632 * @see #IDENT
5633 * @see #OBJBLOCK
5634 * @see #TYPE_PARAMETERS
5635 * @see #GENERIC_START
5636 */
5637 public static final int GENERIC_END = JavaLanguageLexer.GENERIC_END;
5638
5639 /**
5640 * Special lambda symbol {@code ->}.
5641 *
5642 * <p>For example:</p>
5643 * <pre>
5644 * numbers.forEach((n) -> System.out.println(n));
5645 * </pre>
5646 *
5647 * <p>parses as:</p>
5648 * <pre>
5649 * METHOD_CALL -> (
5650 * |--DOT -> .
5651 * | |--IDENT -> numbers
5652 * | `--IDENT -> forEach
5653 * |--ELIST -> ELIST
5654 * | `--LAMBDA -> ->
5655 * | |--LPAREN -> (
5656 * | |--PARAMETERS -> PARAMETERS
5657 * | | `--PARAMETER_DEF -> PARAMETER_DEF
5658 * | | |--MODIFIERS -> MODIFIERS
5659 * | | |--TYPE -> TYPE
5660 * | | `--IDENT -> n
5661 * | |--RPAREN -> )
5662 * | `--EXPR -> EXPR
5663 * | `--METHOD_CALL -> (
5664 * | |--DOT -> .
5665 * | | |--DOT -> .
5666 * | | | |--IDENT -> System
5667 * | | | `--IDENT -> out
5668 * | | `--IDENT -> println
5669 * | |--ELIST -> ELIST
5670 * | | `--EXPR -> EXPR
5671 * | | `--IDENT -> n
5672 * | `--RPAREN -> )
5673 * `--RPAREN -> )
5674 * </pre>
5675 *
5676 */
5677 public static final int LAMBDA = JavaLanguageLexer.LAMBDA;
5678
5679 /**
5680 * Beginning of single-line comment: '//'.
5681 *
5682 * <pre>
5683 * SINGLE_LINE_COMMENT -> //
5684 * `--COMMENT_CONTENT -> \r\n
5685 * </pre>
5686 *
5687 * <p>For example:</p>
5688 * <pre>
5689 * // Comment content
5690 * </pre>
5691 *
5692 * <p>parses as:</p>
5693 * <pre>
5694 * SINGLE_LINE_COMMENT -> //
5695 * `--COMMENT_CONTENT -> Comment Content\n
5696 * </pre>
5697 */
5698 public static final int SINGLE_LINE_COMMENT =
5699 JavaLanguageLexer.SINGLE_LINE_COMMENT;
5700
5701 /**
5702 * Beginning of block comment: '/*'.
5703 *
5704 * <p>For example:</p>
5705 * <pre>
5706 * /* Comment content
5707 * */
5708 * </pre>
5709 *
5710 * <p>parses as:</p>
5711 * <pre>
5712 * --BLOCK_COMMENT_BEGIN -> /*
5713 * |--COMMENT_CONTENT -> Comment content\r\n
5714 * `--BLOCK_COMMENT_END -> */
5715 * </pre>
5716 */
5717 public static final int BLOCK_COMMENT_BEGIN =
5718 JavaLanguageLexer.BLOCK_COMMENT_BEGIN;
5719
5720 /**
5721 * End of block comment: '*/'.
5722 *
5723 * <p>For example:</p>
5724 * <pre>
5725 * /*comment*/
5726 * </pre>
5727 *
5728 * <p>parses as:</p>
5729 * <pre>
5730 * BLOCK_COMMENT_BEGIN -> /*
5731 * |--COMMENT_CONTENT -> comment
5732 * `--BLOCK_COMMENT_END -> */
5733 * </pre>
5734 *
5735 */
5736 public static final int BLOCK_COMMENT_END =
5737 JavaLanguageLexer.BLOCK_COMMENT_END;
5738
5739 /**
5740 * Text of single-line or block comment.
5741 *
5742 * <p>For example:</p>
5743 * <pre>
5744 * //this is single-line comment
5745 *
5746 * /*
5747 * this is multiline comment
5748 * */
5749 * </pre>
5750 *
5751 * <p>parses as:</p>
5752 * <pre>
5753 * |--SINGLE_LINE_COMMENT -> //
5754 * | `--COMMENT_CONTENT -> this is single-line comment\n
5755 * |--BLOCK_COMMENT_BEGIN -> /*
5756 * | |--COMMENT_CONTENT -> \n\t\t\tthis is multiline comment\n\t\t
5757 * | `--BLOCK_COMMENT_END -> */
5758 * </pre>
5759 *
5760 */
5761 public static final int COMMENT_CONTENT =
5762 JavaLanguageLexer.COMMENT_CONTENT;
5763
5764 /**
5765 * A pattern variable definition; when conditionally matched,
5766 * this variable is assigned with the defined type.
5767 *
5768 * <p>For example:</p>
5769 * <pre>
5770 * if (obj instanceof String str) { }
5771 * </pre>
5772 *
5773 * <p>parses as:</p>
5774 * <pre>
5775 * LITERAL_IF -> if
5776 * |--LPAREN -> (
5777 * |--EXPR -> EXPR
5778 * | `--LITERAL_INSTANCEOF -> instanceof
5779 * | |--IDENT -> obj
5780 * | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
5781 * | |--TYPE -> TYPE
5782 * | | `--IDENT -> String
5783 * | `--IDENT -> str
5784 * |--RPAREN -> )
5785 * `--SLIST -> {
5786 * `--RCURLY -> }
5787 * </pre>
5788 *
5789 * @see #LITERAL_INSTANCEOF
5790 * @since 8.35
5791 */
5792 public static final int PATTERN_VARIABLE_DEF =
5793 JavaLanguageLexer.PATTERN_VARIABLE_DEF;
5794
5795 /**
5796 * The {@code record} keyword. This element appears
5797 * as part of a record declaration.
5798 *
5799 * <p>For example:</p>
5800 * <pre>
5801 * public record MyRecord () {
5802 *
5803 * }
5804 * </pre>
5805 *
5806 * <p>parses as:</p>
5807 * <pre>
5808 * RECORD_DEF -> RECORD_DEF
5809 * |--MODIFIERS -> MODIFIERS
5810 * | `--LITERAL_PUBLIC -> public
5811 * |--LITERAL_RECORD -> record
5812 * |--IDENT -> MyRecord
5813 * |--LPAREN -> (
5814 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS
5815 * |--RPAREN -> )
5816 * `--OBJBLOCK -> OBJBLOCK
5817 * |--LCURLY -> {
5818 * `--RCURLY -> }
5819 * </pre>
5820 *
5821 * @since 8.35
5822 **/
5823 public static final int LITERAL_RECORD =
5824 JavaLanguageLexer.LITERAL_RECORD;
5825
5826 /**
5827 * A declaration of a record specifies a name, a header, and a body.
5828 * The header lists the components of the record, which are the variables
5829 * that make up its state.
5830 *
5831 * <p>For example:</p>
5832 * <pre>
5833 * public record MyRecord () {
5834 *
5835 * }
5836 * </pre>
5837 *
5838 * <p>parses as:</p>
5839 * <pre>
5840 * RECORD_DEF -> RECORD_DEF
5841 * |--MODIFIERS -> MODIFIERS
5842 * | `--LITERAL_PUBLIC -> public
5843 * |--LITERAL_RECORD -> record
5844 * |--IDENT -> MyRecord
5845 * |--LPAREN -> (
5846 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS
5847 * |--RPAREN -> )
5848 * `--OBJBLOCK -> OBJBLOCK
5849 * |--LCURLY -> {
5850 * `--RCURLY -> }
5851 * </pre>
5852 *
5853 * @since 8.35
5854 */
5855 public static final int RECORD_DEF =
5856 JavaLanguageLexer.RECORD_DEF;
5857
5858 /**
5859 * Record components are a (possibly empty) list containing the components of a record, which
5860 * are the variables that make up its state.
5861 *
5862 * <p>For example:</p>
5863 * <pre>
5864 * public record myRecord (Comp x, Comp y) { }
5865 * </pre>
5866 *
5867 * <p>parses as:</p>
5868 * <pre>
5869 * RECORD_DEF -> RECORD_DEF
5870 * |--MODIFIERS -> MODIFIERS
5871 * | `--LITERAL_PUBLIC -> public
5872 * |--LITERAL_RECORD -> record
5873 * |--IDENT -> myRecord
5874 * |--LPAREN -> (
5875 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS
5876 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
5877 * | | |--ANNOTATIONS -> ANNOTATIONS
5878 * | | |--TYPE -> TYPE
5879 * | | | `--IDENT -> Comp
5880 * | | `--IDENT -> x
5881 * | |--COMMA -> ,
5882 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
5883 * | |--ANNOTATIONS -> ANNOTATIONS
5884 * | |--TYPE -> TYPE
5885 * | | `--IDENT -> Comp
5886 * | `--IDENT -> y
5887 * |--RPAREN -> )
5888 * `--OBJBLOCK -> OBJBLOCK
5889 * |--LCURLY -> {
5890 * `--RCURLY -> }
5891 * </pre>
5892 *
5893 * @since 8.36
5894 */
5895 public static final int RECORD_COMPONENTS =
5896 JavaLanguageLexer.RECORD_COMPONENTS;
5897
5898 /**
5899 * A record component is a variable that comprises the state of a record. Record components
5900 * have annotations (possibly), a type definition, and an identifier. They can also be of
5901 * variable arity ('...').
5902 *
5903 * <p>For example:</p>
5904 * <pre>
5905 * public record MyRecord(Comp x, Comp... comps) {
5906 *
5907 * }
5908 * </pre>
5909 *
5910 * <p>parses as:</p>
5911 * <pre>
5912 * RECORD_DEF -> RECORD_DEF
5913 * |--MODIFIERS -> MODIFIERS
5914 * | `--LITERAL_PUBLIC -> public
5915 * |--LITERAL_RECORD -> record
5916 * |--IDENT -> MyRecord
5917 * |--LPAREN -> (
5918 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS
5919 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
5920 * | | |--ANNOTATIONS -> ANNOTATIONS
5921 * | | |--TYPE -> TYPE
5922 * | | | `--IDENT -> Comp
5923 * | | `--IDENT -> x
5924 * | |--COMMA -> ,
5925 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
5926 * | |--ANNOTATIONS -> ANNOTATIONS
5927 * | |--TYPE -> TYPE
5928 * | | `--IDENT -> Comp
5929 * | |--ELLIPSIS -> ...
5930 * | `--IDENT -> comps
5931 * |--RPAREN -> )
5932 * `--OBJBLOCK -> OBJBLOCK
5933 * |--LCURLY -> {
5934 * `--RCURLY -> }
5935 * </pre>
5936 *
5937 * @since 8.36
5938 */
5939 public static final int RECORD_COMPONENT_DEF =
5940 JavaLanguageLexer.RECORD_COMPONENT_DEF;
5941
5942 /**
5943 * A compact canonical constructor eliminates the list of formal parameters; they are
5944 * declared implicitly.
5945 *
5946 * <p>For example:</p>
5947 * <pre>
5948 * public record myRecord () {
5949 * public myRecord{}
5950 * }
5951 * </pre>
5952 *
5953 * <p>parses as:</p>
5954 * <pre>
5955 * RECORD_DEF
5956 * |--MODIFIERS
5957 * | `--LITERAL_PUBLIC (public)
5958 * |--LITERAL_RECORD (record)
5959 * |--IDENT (myRecord)
5960 * |--LPAREN (()
5961 * |--RECORD_COMPONENTS
5962 * |--RPAREN ())
5963 * `--OBJBLOCK
5964 * |--LCURLY ({)
5965 * |--COMPACT_CTOR_DEF
5966 * | |--MODIFIERS
5967 * | | `--LITERAL_PUBLIC (public)
5968 * | |--IDENT (myRecord)
5969 * | `--SLIST ({)
5970 * | `--RCURLY (})
5971 * `--RCURLY (})
5972 * </pre>
5973 *
5974 * @since 8.36
5975 */
5976 public static final int COMPACT_CTOR_DEF =
5977 JavaLanguageLexer.COMPACT_CTOR_DEF;
5978
5979 /**
5980 * Text blocks are a new feature added to to Java SE 15 and later
5981 * that will make writing multi-line strings much easier and cleaner.
5982 * Beginning of a Java 15 Text Block literal,
5983 * delimited by three double quotes.
5984 *
5985 * <p>For example:</p>
5986 * <pre>
5987 * String hello = """
5988 * Hello, world!
5989 * """;
5990 * </pre>
5991 *
5992 * <p>parses as:</p>
5993 * <pre>
5994 * |--VARIABLE_DEF -> VARIABLE_DEF
5995 * | |--MODIFIERS -> MODIFIERS
5996 * | |--TYPE -> TYPE
5997 * | | `--IDENT -> String
5998 * | |--IDENT -> hello
5999 * | `--ASSIGN -> =
6000 * | `--EXPR -> EXPR
6001 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """
6002 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n
6003 * | `--TEXT_BLOCK_LITERAL_END -> """
6004 * `--SEMI -> ;
6005 * </pre>
6006 *
6007 * @since 8.36
6008 */
6009 public static final int TEXT_BLOCK_LITERAL_BEGIN =
6010 JavaLanguageLexer.TEXT_BLOCK_LITERAL_BEGIN;
6011
6012 /**
6013 * Content of a Java 15 text block. This is a
6014 * sequence of characters, possibly escaped with '\'. Actual line terminators
6015 * are represented by '\n'.
6016 *
6017 * <p>For example:</p>
6018 * <pre>
6019 * String hello = """
6020 * Hello, world!
6021 * """;
6022 * </pre>
6023 *
6024 * <p>parses as:</p>
6025 * <pre>
6026 * |--VARIABLE_DEF -> VARIABLE_DEF
6027 * | |--MODIFIERS -> MODIFIERS
6028 * | |--TYPE -> TYPE
6029 * | | `--IDENT -> String
6030 * | |--IDENT -> hello
6031 * | `--ASSIGN -> =
6032 * | `--EXPR -> EXPR
6033 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """
6034 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n
6035 * | `--TEXT_BLOCK_LITERAL_END -> """
6036 * `--SEMI -> ;
6037 * </pre>
6038 *
6039 * @since 8.36
6040 */
6041 public static final int TEXT_BLOCK_CONTENT =
6042 JavaLanguageLexer.TEXT_BLOCK_CONTENT;
6043
6044 /**
6045 * End of a Java 15 text block literal, delimited by three
6046 * double quotes.
6047 *
6048 * <p>For example:</p>
6049 * <pre>
6050 * String hello = """
6051 * Hello, world!
6052 * """;
6053 * </pre>
6054 *
6055 * <p>parses as:</p>
6056 * <pre>
6057 * |--VARIABLE_DEF -> VARIABLE_DEF
6058 * | |--MODIFIERS -> MODIFIERS
6059 * | |--TYPE -> TYPE
6060 * | | `--IDENT -> String
6061 * | |--IDENT -> hello
6062 * | `--ASSIGN -> =
6063 * | `--EXPR -> EXPR
6064 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """
6065 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n
6066 * | `--TEXT_BLOCK_LITERAL_END -> """
6067 * `--SEMI -> ;
6068 * </pre>
6069 *
6070 * @since 8.36
6071 */
6072 public static final int TEXT_BLOCK_LITERAL_END =
6073 JavaLanguageLexer.TEXT_BLOCK_LITERAL_END;
6074
6075 /**
6076 * The {@code yield} keyword. This element appears
6077 * as part of a yield statement.
6078 *
6079 * <p>For example:</p>
6080 * <pre>
6081 * int yield = 0; // not a keyword here
6082 * return switch (mode) {
6083 * case "a", "b":
6084 * yield 1;
6085 * default:
6086 * yield - 1;
6087 * };
6088 * </pre>
6089 *
6090 * <p>parses as:</p>
6091 * <pre>
6092 * |--VARIABLE_DEF -> VARIABLE_DEF
6093 * | |--MODIFIERS -> MODIFIERS
6094 * | |--TYPE -> TYPE
6095 * | | `--LITERAL_INT -> int
6096 * | |--IDENT -> yield
6097 * | `--ASSIGN -> =
6098 * | `--EXPR -> EXPR
6099 * | `--NUM_INT -> 0
6100 * |--SEMI -> ;
6101 * |--LITERAL_RETURN -> return
6102 * | |--EXPR -> EXPR
6103 * | | `--LITERAL_SWITCH -> switch
6104 * | | |--LPAREN -> (
6105 * | | |--EXPR -> EXPR
6106 * | | | `--IDENT -> mode
6107 * | | |--RPAREN -> )
6108 * | | |--LCURLY -> {
6109 * | | |--CASE_GROUP -> CASE_GROUP
6110 * | | | |--LITERAL_CASE -> case
6111 * | | | | |--EXPR -> EXPR
6112 * | | | | | `--STRING_LITERAL -> "a"
6113 * | | | | |--COMMA -> ,
6114 * | | | | |--EXPR -> EXPR
6115 * | | | | | `--STRING_LITERAL -> "b"
6116 * | | | | `--COLON -> :
6117 * | | | `--SLIST -> SLIST
6118 * | | | `--LITERAL_YIELD -> yield
6119 * | | | |--EXPR -> EXPR
6120 * | | | | `--NUM_INT -> 1
6121 * | | | `--SEMI -> ;
6122 * | | |--CASE_GROUP -> CASE_GROUP
6123 * | | | |--LITERAL_DEFAULT -> default
6124 * | | | | `--COLON -> :
6125 * | | | `--SLIST -> SLIST
6126 * | | | `--LITERAL_YIELD -> yield
6127 * | | | |--EXPR -> EXPR
6128 * | | | | `--UNARY_MINUS -> -
6129 * | | | | `--NUM_INT -> 1
6130 * | | | `--SEMI -> ;
6131 * | | `--RCURLY -> }
6132 * | `--SEMI -> ;
6133 * </pre>
6134 *
6135 *
6136 * @see #LITERAL_SWITCH
6137 * @see #CASE_GROUP
6138 * @see #SLIST
6139 * @see #SWITCH_RULE
6140 *
6141 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html">
6142 * Java Language Specification, §14.21</a>
6143 *
6144 * @since 8.36
6145 */
6146 public static final int LITERAL_YIELD =
6147 JavaLanguageLexer.LITERAL_YIELD;
6148
6149 /**
6150 * Switch Expressions.
6151 *
6152 * <p>For example:</p>
6153 * <pre>
6154 * return switch (day) {
6155 * case SAT, SUN -> "Weekend";
6156 * default -> "Working day";
6157 * };
6158 * </pre>
6159 *
6160 * <p>parses as:</p>
6161 * <pre>
6162 * LITERAL_RETURN -> return
6163 * |--EXPR -> EXPR
6164 * | `--LITERAL_SWITCH -> switch
6165 * | |--LPAREN -> (
6166 * | |--EXPR -> EXPR
6167 * | | `--IDENT -> day
6168 * | |--RPAREN -> )
6169 * | |--LCURLY -> {
6170 * | |--SWITCH_RULE -> SWITCH_RULE
6171 * | | |--LITERAL_CASE -> case
6172 * | | | |--EXPR -> EXPR
6173 * | | | | `--IDENT -> SAT
6174 * | | | |--COMMA -> ,
6175 * | | | `--EXPR -> EXPR
6176 * | | | `--IDENT -> SUN
6177 * | | |--LAMBDA -> ->
6178 * | | |--EXPR -> EXPR
6179 * | | | `--STRING_LITERAL -> "Weekend"
6180 * | | `--SEMI -> ;
6181 * | |--SWITCH_RULE -> SWITCH_RULE
6182 * | | |--LITERAL_DEFAULT -> default
6183 * | | |--LAMBDA -> ->
6184 * | | |--EXPR -> EXPR
6185 * | | | `--STRING_LITERAL -> "Working day"
6186 * | | `--SEMI -> ;
6187 * | `--RCURLY -> }
6188 * `--SEMI -> ;
6189 * </pre>
6190 *
6191 * @see #LITERAL_CASE
6192 * @see #LITERAL_DEFAULT
6193 * @see #LITERAL_SWITCH
6194 * @see #LITERAL_YIELD
6195 *
6196 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html">
6197 * Java Language Specification, §14.21</a>
6198 *
6199 * @since 8.36
6200 */
6201 public static final int SWITCH_RULE =
6202 JavaLanguageLexer.SWITCH_RULE;
6203
6204 /**
6205 * The {@code non-sealed} keyword. This element appears
6206 * as part of a class or interface declaration.
6207 *
6208 * <p>For example:</p>
6209 * <pre>
6210 * non-sealed class Square extends Rectangle { }
6211 * </pre>
6212 *
6213 * <p>parses as:</p>
6214 * <pre>
6215 * CLASS_DEF -> CLASS_DEF
6216 * |--MODIFIERS -> MODIFIERS
6217 * | `--LITERAL_NON_SEALED -> non-sealed
6218 * |--LITERAL_CLASS -> class
6219 * |--IDENT -> Square
6220 * |--EXTENDS_CLAUSE -> extends
6221 * | `--IDENT -> Rectangle
6222 * `--OBJBLOCK -> OBJBLOCK
6223 * |--LCURLY -> {
6224 * `--RCURLY -> }
6225 * </pre>
6226 *
6227 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html">
6228 * Java Language Specification, §8.1.1.2</a>
6229 * @see #MODIFIERS
6230 *
6231 * @since 8.42
6232 */
6233 public static final int LITERAL_NON_SEALED =
6234 JavaLanguageLexer.LITERAL_NON_SEALED;
6235
6236 /**
6237 * The {@code sealed} restricted identifier. This element appears
6238 * as part of a class or interface declaration.
6239 *
6240 * <p>For example:</p>
6241 * <pre>
6242 * public sealed class Shape permits Circle, Square, Rectangle { }
6243 * </pre>
6244 *
6245 * <p>parses as:</p>
6246 * <pre>
6247 * CLASS_DEF -> CLASS_DEF
6248 * |--MODIFIERS -> MODIFIERS
6249 * | |--LITERAL_PUBLIC -> public
6250 * | `--LITERAL_SEALED -> sealed
6251 * |--LITERAL_CLASS -> class
6252 * |--IDENT -> Shape
6253 * |--PERMITS_CLAUSE -> permits
6254 * | |--IDENT -> Circle
6255 * | |--COMMA -> ,
6256 * | |--IDENT -> Square
6257 * | |--COMMA -> ,
6258 * | `--IDENT -> Rectangle
6259 * `--OBJBLOCK -> OBJBLOCK
6260 * |--LCURLY -> {
6261 * `--RCURLY -> }
6262 * </pre>
6263 *
6264 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html">
6265 * Java Language Specification, §8.1.1.2</a>
6266 * @see #MODIFIERS
6267 *
6268 * @since 8.42
6269 */
6270 public static final int LITERAL_SEALED =
6271 JavaLanguageLexer.LITERAL_SEALED;
6272
6273 /**
6274 * The {@code permits} restricted identifier. This element appears
6275 * as part of a class or interface declaration.
6276 *
6277 * <p>For example:</p>
6278 * <pre>
6279 * public sealed class Shape permits Circle, Square, Rectangle { }
6280 * </pre>
6281 *
6282 * <p>parses as:</p>
6283 * <pre>
6284 * CLASS_DEF -> CLASS_DEF
6285 * |--MODIFIERS -> MODIFIERS
6286 * | |--LITERAL_PUBLIC -> public
6287 * | `--LITERAL_SEALED -> sealed
6288 * |--LITERAL_CLASS -> class
6289 * |--IDENT -> Shape
6290 * |--PERMITS_CLAUSE -> permits
6291 * | |--IDENT -> Circle
6292 * | |--COMMA -> ,
6293 * | |--IDENT -> Square
6294 * | |--COMMA -> ,
6295 * | `--IDENT -> Rectangle
6296 * `--OBJBLOCK -> OBJBLOCK
6297 * |--LCURLY -> {
6298 * `--RCURLY -> }
6299 * </pre>
6300 *
6301 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html">
6302 * Java Language Specification, §9.1.4</a>
6303 * @see #MODIFIERS
6304 *
6305 * @since 8.42
6306 */
6307 public static final int LITERAL_PERMITS =
6308 JavaLanguageLexer.LITERAL_PERMITS;
6309
6310 /**
6311 * A permits clause. A permits clause's children are a comma separated list of one or
6312 * more identifiers.
6313 *
6314 * <p>For example:</p>
6315 * <pre>
6316 * public sealed class Shape permits Circle, Square, Rectangle { }
6317 * </pre>
6318 *
6319 * <p>parses as:</p>
6320 * <pre>
6321 * CLASS_DEF -> CLASS_DEF
6322 * |--MODIFIERS -> MODIFIERS
6323 * | |--LITERAL_PUBLIC -> public
6324 * | `--LITERAL_SEALED -> sealed
6325 * |--LITERAL_CLASS -> class
6326 * |--IDENT -> Shape
6327 * |--PERMITS_CLAUSE -> permits
6328 * | |--IDENT -> Circle
6329 * | |--COMMA -> ,
6330 * | |--IDENT -> Square
6331 * | |--COMMA -> ,
6332 * | `--IDENT -> Rectangle
6333 * `--OBJBLOCK -> OBJBLOCK
6334 * |--LCURLY -> {
6335 * `--RCURLY -> }
6336 * </pre>
6337 *
6338 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html">
6339 * Java Language Specification, §9.1.4</a>
6340 * @see #MODIFIERS
6341 * @see #CLASS_DEF
6342 * @see #INTERFACE_DEF
6343 * @see #COMMA
6344 * @see #IDENT
6345 *
6346 * @since 8.42
6347 */
6348 public static final int PERMITS_CLAUSE =
6349 JavaLanguageLexer.PERMITS_CLAUSE;
6350
6351 /**
6352 * A pattern definition, excluding simple type pattern (pattern variable)
6353 * definition such as {@code if (o instanceof Integer i){}}. Pattern definitions
6354 * appear as operands of statements and expressions.
6355 *
6356 * <p>For example:</p>
6357 * <pre>
6358 * switch(o) {
6359 * case String s when s.length() > 4: // guarded pattern, `PATTERN_DEF`
6360 * break;
6361 * case String s: // type pattern, no `PATTERN_DEF`
6362 * break;
6363 * }
6364 * </pre>
6365 *
6366 * <p>parses as:</p>
6367 * <pre>
6368 * LITERAL_SWITCH -> switch
6369 * | |--LPAREN -> (
6370 * | |--EXPR -> EXPR
6371 * | | `--IDENT -> o
6372 * | |--RPAREN -> )
6373 * | |--LCURLY -> {
6374 * | |--CASE_GROUP -> CASE_GROUP
6375 * | | |--LITERAL_CASE -> case
6376 * | | | |--PATTERN_DEF -> PATTERN_DEF
6377 * | | | | `--LITERAL_WHEN -> when
6378 * | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6379 * | | | | | |--MODIFIERS -> MODIFIERS
6380 * | | | | | |--TYPE -> TYPE
6381 * | | | | | | `--IDENT -> String
6382 * | | | | | `--IDENT -> s
6383 * | | | | `--GT -> >
6384 * | | | | |--METHOD_CALL -> (
6385 * | | | | | |--DOT -> .
6386 * | | | | | | |--IDENT -> s
6387 * | | | | | | `--IDENT -> length
6388 * | | | | | |--ELIST -> ELIST
6389 * | | | | | `--RPAREN -> )
6390 * | | | | `--NUM_INT -> 4
6391 * | | | `--COLON -> :
6392 * | | `--SLIST -> SLIST
6393 * | | `--LITERAL_BREAK -> break
6394 * | | `--SEMI -> ;
6395 * | |--CASE_GROUP -> CASE_GROUP
6396 * | | |--LITERAL_CASE -> case
6397 * | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6398 * | | | | |--MODIFIERS -> MODIFIERS
6399 * | | | | |--TYPE -> TYPE
6400 * | | | | | `--IDENT -> String
6401 * | | | | `--IDENT -> s
6402 * | | | `--COLON -> :
6403 * | | `--SLIST -> SLIST
6404 * | | `--LITERAL_BREAK -> break
6405 * | | `--SEMI -> ;
6406 * | `--RCURLY -> }
6407 * `--RCURLY -> }
6408 * </pre>
6409 *
6410 * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.30">
6411 * Java Language Specification, §14.30</a>
6412 * @see #LITERAL_SWITCH
6413 * @see #PATTERN_VARIABLE_DEF
6414 * @see #LITERAL_INSTANCEOF
6415 *
6416 * @since 9.3
6417 */
6418 public static final int PATTERN_DEF =
6419 JavaLanguageLexer.PATTERN_DEF;
6420
6421 /**
6422 * A {@code when} clause. Appears as part of a switch label in a guarded pattern definition.
6423 *
6424 * <p>For example:</p>
6425 * <pre>
6426 * return switch (o) {
6427 * case Integer i when i >= 0 -> i;
6428 * default -> 2;
6429 * };
6430 * </pre>
6431 *
6432 * <p>parses as:</p>
6433 * <pre>
6434 * LITERAL_RETURN -> return
6435 * `--EXPR -> EXPR
6436 * `--LITERAL_SWITCH -> switch
6437 * |--LPAREN -> (
6438 * |--EXPR -> EXPR
6439 * | `--IDENT -> o
6440 * |--RPAREN -> )
6441 * |--LCURLY -> {
6442 * |--SWITCH_RULE -> SWITCH_RULE
6443 * | |--LITERAL_CASE -> case
6444 * | | `--PATTERN_DEF -> PATTERN_DEF
6445 * | | `--LITERAL_WHEN -> when
6446 * | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6447 * | | | |--MODIFIERS -> MODIFIERS
6448 * | | | |--TYPE -> TYPE
6449 * | | | | `--IDENT -> Integer
6450 * | | | `--IDENT -> i
6451 * | | `--GE -> >=
6452 * | | |--IDENT -> i
6453 * | | `--NUM_INT -> 0
6454 * | |--LAMBDA -> ->
6455 * | |--EXPR -> EXPR
6456 * | | `--IDENT -> i
6457 * | `--SEMI -> ;
6458 * |--SWITCH_RULE -> SWITCH_RULE
6459 * | |--LITERAL_DEFAULT -> default
6460 * | |--LAMBDA -> ->
6461 * | |--EXPR -> EXPR
6462 * | | `--NUM_INT -> 2
6463 * | `--SEMI -> ;
6464 * `--RCURLY -> }
6465 * </pre>
6466 *
6467 * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.30">
6468 * Java Language Specification, §14.30</a>
6469 * @see #LITERAL_SWITCH
6470 * @see #PATTERN_VARIABLE_DEF
6471 * @see #LITERAL_INSTANCEOF
6472 * @see #SWITCH_RULE
6473 *
6474 * @since 10.7.0
6475 */
6476 public static final int LITERAL_WHEN =
6477 JavaLanguageLexer.LITERAL_WHEN;
6478
6479 /**
6480 * A {@code record} pattern definition. A record pattern consists of a type,
6481 * a (possibly empty) record component pattern list which is used to match against
6482 * the corresponding record components, and an optional identifier. Appears as part of
6483 * an {@code instanceof} expression or a {@code case} label in a switch.
6484 *
6485 * <p>For example:</p>
6486 * <pre>
6487 * record R(Object o){}
6488 * if (o instanceof R(String s) myRecord) {}
6489 * switch (o) {
6490 * case R(String s) myRecord -> {}
6491 * }
6492 * </pre>
6493 *
6494 * <p>parses as:</p>
6495 * <pre>
6496 * |--RECORD_DEF -> RECORD_DEF
6497 * | |--MODIFIERS -> MODIFIERS
6498 * | |--LITERAL_RECORD -> record
6499 * | |--IDENT -> R
6500 * | |--LPAREN -> (
6501 * | |--RECORD_COMPONENTS -> RECORD_COMPONENTS
6502 * | | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
6503 * | | |--ANNOTATIONS -> ANNOTATIONS
6504 * | | |--TYPE -> TYPE
6505 * | | | `--IDENT -> Object
6506 * | | `--IDENT -> o
6507 * | |--RPAREN -> )
6508 * | `--OBJBLOCK -> OBJBLOCK
6509 * | |--LCURLY -> {
6510 * | `--RCURLY -> }
6511 * |--LITERAL_IF -> if
6512 * | |--LPAREN -> (
6513 * | |--EXPR -> EXPR
6514 * | | `--LITERAL_INSTANCEOF -> instanceof
6515 * | | |--IDENT -> o
6516 * | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6517 * | | |--MODIFIERS -> MODIFIERS
6518 * | | |--TYPE -> TYPE
6519 * | | | `--IDENT -> R
6520 * | | |--LPAREN -> (
6521 * | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6522 * | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6523 * | | | |--MODIFIERS -> MODIFIERS
6524 * | | | |--TYPE -> TYPE
6525 * | | | | `--IDENT -> String
6526 * | | | `--IDENT -> s
6527 * | | |--RPAREN -> )
6528 * | | `--IDENT -> myRecord
6529 * | |--RPAREN -> )
6530 * | `--SLIST -> {
6531 * | `--RCURLY -> }
6532 * |--LITERAL_SWITCH -> switch
6533 * | |--LPAREN -> (
6534 * | |--EXPR -> EXPR
6535 * | | `--IDENT -> o
6536 * | |--RPAREN -> )
6537 * | |--LCURLY -> {
6538 * | |--SWITCH_RULE -> SWITCH_RULE
6539 * | | |--LITERAL_CASE -> case
6540 * | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6541 * | | | |--MODIFIERS -> MODIFIERS
6542 * | | | |--TYPE -> TYPE
6543 * | | | | `--IDENT -> R
6544 * | | | |--LPAREN -> (
6545 * | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6546 * | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6547 * | | | | |--MODIFIERS -> MODIFIERS
6548 * | | | | |--TYPE -> TYPE
6549 * | | | | | `--IDENT -> String
6550 * | | | | `--IDENT -> s
6551 * | | | |--RPAREN -> )
6552 * | | | `--IDENT -> myRecord
6553 * | | |--LAMBDA -> ->
6554 * | | `--SLIST -> {
6555 * | | `--RCURLY -> }
6556 * | `--RCURLY -> }
6557 * `--RCURLY -> }
6558 * </pre>
6559 *
6560 * @see <a href="https://openjdk.org/jeps/405">JEP 405: Record Patterns</a>
6561 * @see #LITERAL_WHEN
6562 * @see #PATTERN_VARIABLE_DEF
6563 * @see #LITERAL_INSTANCEOF
6564 * @see #SWITCH_RULE
6565 *
6566 * @since 10.12.0
6567 */
6568 public static final int RECORD_PATTERN_DEF =
6569 JavaLanguageLexer.RECORD_PATTERN_DEF;
6570
6571 /**
6572 * A (possibly empty) record component pattern list which is used to match against
6573 * the corresponding record components. Appears as part of a record pattern definition.
6574 *
6575 * <p>For example:</p>
6576 * <pre>
6577 * record R(Object o){}
6578 * if (o instanceof R(String myComponent)) {}
6579 * switch (o) {
6580 * case R(String myComponent) when "component".equalsIgnoreCase(myComponent) -> {}
6581 * }
6582 * </pre>
6583 *
6584 * <p>parses as:</p>
6585 * <pre>
6586 * |--RECORD_DEF -> RECORD_DEF
6587 * | |--MODIFIERS -> MODIFIERS
6588 * | |--LITERAL_RECORD -> record
6589 * | |--IDENT -> R
6590 * | |--LPAREN -> (
6591 * | |--RECORD_COMPONENTS -> RECORD_COMPONENTS
6592 * | | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
6593 * | | |--ANNOTATIONS -> ANNOTATIONS
6594 * | | |--TYPE -> TYPE
6595 * | | | `--IDENT -> Object
6596 * | | `--IDENT -> o
6597 * | |--RPAREN -> )
6598 * | `--OBJBLOCK -> OBJBLOCK
6599 * | |--LCURLY -> {
6600 * | `--RCURLY -> }
6601 * |--LITERAL_IF -> if
6602 * | |--LPAREN -> (
6603 * | |--EXPR -> EXPR
6604 * | | `--LITERAL_INSTANCEOF -> instanceof
6605 * | | |--IDENT -> o
6606 * | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6607 * | | |--MODIFIERS -> MODIFIERS
6608 * | | |--TYPE -> TYPE
6609 * | | | `--IDENT -> R
6610 * | | |--LPAREN -> (
6611 * | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6612 * | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6613 * | | | |--MODIFIERS -> MODIFIERS
6614 * | | | |--TYPE -> TYPE
6615 * | | | | `--IDENT -> String
6616 * | | | `--IDENT -> myComponent
6617 * | | `--RPAREN -> )
6618 * | |--RPAREN -> )
6619 * | `--SLIST -> {
6620 * | `--RCURLY -> }
6621 * |--LITERAL_SWITCH -> switch
6622 * | |--LPAREN -> (
6623 * | |--EXPR -> EXPR
6624 * | | `--IDENT -> o
6625 * | |--RPAREN -> )
6626 * | |--LCURLY -> {
6627 * | |--SWITCH_RULE -> SWITCH_RULE
6628 * | | |--LITERAL_CASE -> case
6629 * | | | `--PATTERN_DEF -> PATTERN_DEF
6630 * | | | `--LITERAL_WHEN -> when
6631 * | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6632 * | | | | |--MODIFIERS -> MODIFIERS
6633 * | | | | |--TYPE -> TYPE
6634 * | | | | | `--IDENT -> R
6635 * | | | | |--LPAREN -> (
6636 * | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6637 * | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6638 * | | | | | |--MODIFIERS -> MODIFIERS
6639 * | | | | | |--TYPE -> TYPE
6640 * | | | | | | `--IDENT -> String
6641 * | | | | | `--IDENT -> myComponent
6642 * | | | | `--RPAREN -> )
6643 * | | | `--METHOD_CALL -> (
6644 * | | | |--DOT -> .
6645 * | | | | |--STRING_LITERAL -> "component"
6646 * | | | | `--IDENT -> equalsIgnoreCase
6647 * | | | |--ELIST -> ELIST
6648 * | | | | `--EXPR -> EXPR
6649 * | | | | `--IDENT -> myComponent
6650 * | | | `--RPAREN -> )
6651 * | | |--LAMBDA -> ->
6652 * | | `--SLIST -> {
6653 * | | `--RCURLY -> }
6654 * | `--RCURLY -> }
6655 * `--RCURLY -> }
6656 * </pre>
6657 *
6658 * @see <a href="https://openjdk.org/jeps/405">JEP 405: Record Patterns</a>
6659 * @see #LITERAL_WHEN
6660 * @see #PATTERN_VARIABLE_DEF
6661 * @see #LITERAL_INSTANCEOF
6662 * @see #SWITCH_RULE
6663 *
6664 * @since 10.12.0
6665 */
6666 public static final int RECORD_PATTERN_COMPONENTS =
6667 JavaLanguageLexer.RECORD_PATTERN_COMPONENTS;
6668
6669 /**
6670 * An unnamed pattern variable definition. Appears as part of a pattern definition.
6671 *
6672 * <p>For example:</p>
6673 * <pre>
6674 * if (r instanceof R(_)) {}
6675 * </pre>
6676 *
6677 * <p>parses as:</p>
6678 * <pre>
6679 * LITERAL_IF -> if
6680 * |--LPAREN -> (
6681 * |--EXPR -> EXPR
6682 * | `--LITERAL_INSTANCEOF -> instanceof
6683 * | |--IDENT -> r
6684 * | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6685 * | |--MODIFIERS -> MODIFIERS
6686 * | |--TYPE -> TYPE
6687 * | | `--IDENT -> R
6688 * | |--LPAREN -> (
6689 * | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6690 * | | `--UNNAMED_PATTERN_DEF -> _
6691 * | `--RPAREN -> )
6692 * |--RPAREN -> )
6693 * `--SLIST -> {
6694 * `--RCURLY -> }
6695 * </pre>
6696 *
6697 * @see #RECORD_PATTERN_COMPONENTS
6698 * @see #RECORD_PATTERN_DEF
6699 * @see #LITERAL_SWITCH
6700 * @see #LITERAL_INSTANCEOF
6701 * @see #SWITCH_RULE
6702 * @see #LITERAL_WHEN
6703 * @see #PATTERN_VARIABLE_DEF
6704 * @see #PATTERN_DEF
6705 *
6706 * @since 10.14.0
6707 */
6708 public static final int UNNAMED_PATTERN_DEF =
6709 JavaLanguageLexer.UNNAMED_PATTERN_DEF;
6710
6711 /**
6712 * A {@code module} keyword.
6713 *
6714 * <p>For example:</p>
6715 * <pre>
6716 * import module java.base;
6717 * </pre>
6718 *
6719 * <p>parses as:</p>
6720 * <pre>
6721 * MODULE_IMPORT -> import
6722 * |--LITERAL_MODULE -> module
6723 * |--DOT -> .
6724 * | |--IDENT -> java
6725 * | `--IDENT -> base
6726 * `--SEMI -> ;
6727 * </pre>
6728 *
6729 * @see <a href="https://docs.oracle.com/javase/specs/jls/se25/html/jls-7.html#jls-7.5.5">
6730 * Java Language Specification, §7.5.5</a>
6731 * @see <a href="https://docs.oracle.com/javase/specs/jls/se25/html/jls-7.html#jls-7.7">
6732 * Java Language Specification, §7.7</a>
6733 * @see #IMPORT
6734 * @see #MODULE_IMPORT
6735 *
6736 * @since 12.2.0
6737 */
6738 public static final int LITERAL_MODULE = JavaLanguageLexer.LITERAL_MODULE;
6739
6740 /**
6741 * A module import declaration - {@code import module}.
6742 *
6743 * <p>For example:</p>
6744 * <pre>
6745 * import module java.base;
6746 * </pre>
6747 *
6748 * <p>parses as:</p>
6749 * <pre>
6750 * MODULE_IMPORT -> import
6751 * |--LITERAL_MODULE -> module
6752 * |--DOT -> .
6753 * | |--IDENT -> java
6754 * | `--IDENT -> base
6755 * `--SEMI -> ;
6756 * </pre>
6757 *
6758 * @see <a href="https://docs.oracle.com/javase/specs/jls/se25/html/jls-7.html#jls-7.5.5">
6759 * Java Language Specification, §7.5.5</a>
6760 * @see #IMPORT
6761 * @see #LITERAL_MODULE
6762 *
6763 * @since 12.2.0
6764 */
6765 public static final int MODULE_IMPORT = JavaLanguageLexer.MODULE_IMPORT;
6766
6767 /** Prevent instantiation. */
6768 private TokenTypes() {
6769 }
6770
6771 }