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