1 ///////////////////////////////////////////////////////////////////////////////////////////////
2 // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3 // Copyright (C) 2001-2025 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 * boolean isBuilderEmpty = text instanceof
3985 * (StringBuilder sb && sb.isEmpty()); // guarded pattern, `PATTERN_DEF`
3986 * </pre>
3987 *
3988 * <p>parses as:</p>
3989 * <pre>
3990 * |--VARIABLE_DEF -> VARIABLE_DEF
3991 * | |--MODIFIERS -> MODIFIERS
3992 * | |--TYPE -> TYPE
3993 * | | `--LITERAL_BOOLEAN -> boolean
3994 * | |--IDENT -> isBuilderReferenceType
3995 * | `--ASSIGN -> =
3996 * | `--EXPR -> EXPR
3997 * | `--LITERAL_INSTANCEOF -> instanceof
3998 * | |--IDENT -> text
3999 * | `--TYPE -> TYPE
4000 * | `--IDENT -> StringBuilder
4001 * |--SEMI -> ;
4002 * |--VARIABLE_DEF -> VARIABLE_DEF
4003 * | |--MODIFIERS -> MODIFIERS
4004 * | |--TYPE -> TYPE
4005 * | | `--LITERAL_BOOLEAN -> boolean
4006 * | |--IDENT -> isBuilderPatternWithPattern
4007 * | `--ASSIGN -> =
4008 * | `--EXPR -> EXPR
4009 * | `--LITERAL_INSTANCEOF -> instanceof
4010 * | |--IDENT -> text
4011 * | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
4012 * | |--MODIFIERS -> MODIFIERS
4013 * | |--TYPE -> TYPE
4014 * | | `--IDENT -> StringBuilder
4015 * | `--IDENT -> s
4016 * |--SEMI -> ;
4017 * |--VARIABLE_DEF -> VARIABLE_DEF
4018 * | |--MODIFIERS -> MODIFIERS
4019 * | |--TYPE -> TYPE
4020 * | | `--LITERAL_BOOLEAN -> boolean
4021 * | |--IDENT -> isBuilderEmpty
4022 * | `--ASSIGN -> =
4023 * | `--EXPR -> EXPR
4024 * | `--LITERAL_INSTANCEOF -> instanceof
4025 * | |--IDENT -> text
4026 * | `--PATTERN_DEF -> PATTERN_DEF
4027 * | `--LPAREN -> (
4028 * | |--LAND -> &&
4029 * | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
4030 * | | | |--MODIFIERS -> MODIFIERS
4031 * | | | |--TYPE -> TYPE
4032 * | | | | `--IDENT -> StringBuilder
4033 * | | | `--IDENT -> sb
4034 * | | `--METHOD_CALL -> (
4035 * | | |--DOT -> .
4036 * | | | |--IDENT -> sb
4037 * | | | `--IDENT -> isEmpty
4038 * | | |--ELIST -> ELIST
4039 * | | `--RPAREN -> )
4040 * | `--RPAREN -> )
4041 * `--SEMI -> ;
4042 * </pre>
4043 *
4044 * @see <a
4045 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java
4046 * Language Specification, §15.20.2</a>
4047 * @see #EXPR
4048 * @see #METHOD_CALL
4049 * @see #IDENT
4050 * @see #DOT
4051 * @see #TYPE
4052 * @see #PATTERN_VARIABLE_DEF
4053 * @see #PATTERN_DEF
4054 * @see FullIdent
4055 **/
4056 public static final int LITERAL_INSTANCEOF =
4057 JavaLanguageLexer.LITERAL_INSTANCEOF;
4058
4059 /**
4060 * The {@code <<} (shift left) operator.
4061 *
4062 * <p>For example:</p>
4063 * <pre>
4064 * a = a << b;
4065 * </pre>
4066 *
4067 * <p>parses as:</p>
4068 * <pre>
4069 * |--EXPR -> EXPR
4070 * | `--ASSIGN -> =
4071 * | |--IDENT -> a
4072 * | `--SR -> <<
4073 * | |--IDENT -> a
4074 * | `--IDENT -> b
4075 * |--SEMI -> ;
4076 * </pre>
4077 *
4078 * @see <a
4079 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java
4080 * Language Specification, §15.19</a>
4081 * @see #EXPR
4082 **/
4083 public static final int SL = JavaLanguageLexer.SL;
4084 /**
4085 * The {@code >>} (signed shift right) operator.
4086 *
4087 * <p>For example:</p>
4088 * <pre>
4089 * a = a >> b;
4090 * </pre>
4091 *
4092 * <p>parses as:</p>
4093 * <pre>
4094 * |--EXPR -> EXPR
4095 * | `--ASSIGN -> =
4096 * | |--IDENT -> a
4097 * | `--SR -> >>
4098 * | |--IDENT -> a
4099 * | `--IDENT -> b
4100 * |--SEMI -> ;
4101 * </pre>
4102 *
4103 * @see <a
4104 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java
4105 * Language Specification, §15.19</a>
4106 * @see #EXPR
4107 **/
4108 public static final int SR = JavaLanguageLexer.SR;
4109 /**
4110 * The {@code >>>} (unsigned shift right) operator.
4111 *
4112 * <p>For example:</p>
4113 * <pre>
4114 * a >>> b;
4115 * </pre>
4116 *
4117 * <p>parses as:</p>
4118 * <pre>
4119 * |--EXPR -> EXPR
4120 * | `--BSR -> >>>
4121 * | |--IDENT -> a
4122 * | `--IDENT -> b
4123 * |--SEMI -> ;
4124 * </pre>
4125 *
4126 * @see <a
4127 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java
4128 * Language Specification, §15.19</a>
4129 * @see #EXPR
4130 **/
4131 public static final int BSR = JavaLanguageLexer.BSR;
4132 /**
4133 * The {@code +} (addition) operator.
4134 *
4135 * <p>For example:</p>
4136 * <pre>
4137 * c = a + b;
4138 * </pre>
4139 *
4140 * <p>parses as:</p>
4141 * <pre>
4142 * |--EXPR -> EXPR
4143 * | `--ASSIGN -> =
4144 * | |--IDENT -> c
4145 * | `--PLUS -> +
4146 * | |--IDENT -> a
4147 * | `--IDENT -> b
4148 * |--SEMI -> ;
4149 * </pre>
4150 *
4151 * @see <a
4152 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java
4153 * Language Specification, §15.18</a>
4154 * @see #EXPR
4155 **/
4156 public static final int PLUS = JavaLanguageLexer.PLUS;
4157 /**
4158 * The {@code -} (subtraction) operator.
4159 *
4160 * <p>For example:</p>
4161 * <pre>
4162 * c = a - b;
4163 * </pre>
4164 *
4165 * <p>parses as:</p>
4166 * <pre>
4167 * |--EXPR -> EXPR
4168 * | `--ASSIGN -> =
4169 * | |--IDENT -> c
4170 * | `--MINUS -> -
4171 * | |--IDENT -> a
4172 * | `--IDENT -> b
4173 * |--SEMI -> ;
4174 * </pre>
4175 *
4176 * @see <a
4177 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java
4178 * Language Specification, §15.18</a>
4179 * @see #EXPR
4180 **/
4181 public static final int MINUS = JavaLanguageLexer.MINUS;
4182 /**
4183 * The {@code /} (division) operator.
4184 *
4185 * <p>For example:</p>
4186 * <pre>
4187 * a = 4 / 2;
4188 * </pre>
4189 *
4190 * <p>parses as:</p>
4191 * <pre>
4192 * |--EXPR -> EXPR
4193 * | `--ASSIGN -> =
4194 * | |--IDENT -> a
4195 * | `--DIV -> /
4196 * | |--NUM_INT -> 4
4197 * | `--NUM_INT -> 2
4198 * |--SEMI -> ;
4199 * </pre>
4200 *
4201 * @see <a
4202 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java
4203 * Language Specification, §15.17.2</a>
4204 * @see #EXPR
4205 **/
4206 public static final int DIV = JavaLanguageLexer.DIV;
4207 /**
4208 * The {@code %} (remainder) operator.
4209 *
4210 * <p>For example:</p>
4211 * <pre>
4212 * c = a % b;
4213 * </pre>
4214 *
4215 * <p>parses as:</p>
4216 * <pre>
4217 * EXPR -> EXPR
4218 * `--ASSIGN -> =
4219 * |--IDENT -> c
4220 * `--MOD -> %
4221 * |--IDENT -> a
4222 * `--IDENT -> b
4223 * SEMI -> ;
4224 * </pre>
4225 *
4226 * @see <a
4227 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java
4228 * Language Specification, §15.17.3</a>
4229 * @see #EXPR
4230 **/
4231 public static final int MOD = JavaLanguageLexer.MOD;
4232 /**
4233 * The {@code ++} (prefix increment) operator.
4234 *
4235 * <p>For example:</p>
4236 * <pre>
4237 * ++a;
4238 * </pre>
4239 *
4240 * <p>parses as:</p>
4241 * <pre>
4242 * |--EXPR -> EXPR
4243 * | `--INC -> ++
4244 * | `--IDENT -> a
4245 * |--SEMI -> ;
4246 * </pre>
4247 *
4248 * @see <a
4249 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java
4250 * Language Specification, §15.15.1</a>
4251 * @see #EXPR
4252 * @see #POST_INC
4253 **/
4254 public static final int INC = JavaLanguageLexer.INC;
4255 /**
4256 * The {@code --} (prefix decrement) operator.
4257 *
4258 * <p>For example:</p>
4259 * <pre>
4260 * --a;
4261 * </pre>
4262 *
4263 * <p>parses as:</p>
4264 * <pre>
4265 * |--EXPR -> EXPR
4266 * | `--DEC -> --
4267 * | `--IDENT -> a
4268 * |--SEMI -> ;
4269 * </pre>
4270 *
4271 * @see <a
4272 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java
4273 * Language Specification, §15.15.2</a>
4274 * @see #EXPR
4275 * @see #POST_DEC
4276 **/
4277 public static final int DEC = JavaLanguageLexer.DEC;
4278 /**
4279 * The {@code ~} (bitwise complement) operator.
4280 *
4281 * <p>For example:</p>
4282 * <pre>
4283 * a = ~ a;
4284 * </pre>
4285 *
4286 * <p>parses as:</p>
4287 * <pre>
4288 * |--EXPR -> EXPR
4289 * | `--ASSIGN -> =
4290 * | |--IDENT -> a
4291 * | `--BNOT -> ~
4292 * | `--IDENT -> a
4293 * |--SEMI -> ;
4294 * </pre>
4295 *
4296 * @see <a
4297 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java
4298 * Language Specification, §15.15.5</a>
4299 * @see #EXPR
4300 **/
4301 public static final int BNOT = JavaLanguageLexer.BNOT;
4302 /**
4303 * The <code>!</code> (logical complement) operator.
4304 *
4305 * <p>For example:</p>
4306 * <pre>
4307 * c = ! a;
4308 * </pre>
4309 *
4310 * <p>parses as:</p>
4311 * <pre>
4312 * |--EXPR -> EXPR
4313 * | `--ASSIGN -> =
4314 * | |--IDENT -> c
4315 * | `--LNOT -> !
4316 * | `--IDENT -> a
4317 * |--SEMI -> ;
4318 * </pre>
4319 *
4320 * @see <a
4321 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java
4322 * Language Specification, §15.15.6</a>
4323 * @see #EXPR
4324 * @noinspection HtmlTagCanBeJavadocTag
4325 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded
4326 * when replaced with Javadoc tag
4327 **/
4328 public static final int LNOT = JavaLanguageLexer.LNOT;
4329 /**
4330 * The {@code true} keyword.
4331 *
4332 * <p>For example:</p>
4333 * <pre>
4334 * boolean a = true;
4335 * </pre>
4336 *
4337 * <p>parses as:</p>
4338 * <pre>
4339 * |--VARIABLE_DEF -> VARIABLE_DEF
4340 * | |--MODIFIERS -> MODIFIERS
4341 * | |--TYPE -> TYPE
4342 * | | `--LITERAL_BOOLEAN -> boolean
4343 * | |--IDENT -> a
4344 * | `--ASSIGN -> =
4345 * | `--EXPR -> EXPR
4346 * | `--LITERAL_TRUE -> true
4347 * |--SEMI -> ;
4348 * </pre>
4349 *
4350 * @see <a
4351 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java
4352 * Language Specification, §3.10.3</a>
4353 * @see #EXPR
4354 * @see #LITERAL_FALSE
4355 **/
4356 public static final int LITERAL_TRUE =
4357 JavaLanguageLexer.LITERAL_TRUE;
4358
4359 /**
4360 * The {@code false} keyword.
4361 *
4362 * <p>For example:</p>
4363 * <pre>
4364 * boolean a = false;
4365 * </pre>
4366 *
4367 * <p>parses as:</p>
4368 * <pre>
4369 * VARIABLE_DEF -> VARIABLE_DEF
4370 * |--MODIFIERS -> MODIFIERS
4371 * |--TYPE -> TYPE
4372 * | `--LITERAL_BOOLEAN -> boolean
4373 * |--IDENT -> a
4374 * |--ASSIGN -> =
4375 * | `--EXPR -> EXPR
4376 * | `--LITERAL_FALSE -> false
4377 * `--SEMI -> ;
4378 * </pre>
4379 *
4380 * @see <a
4381 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java
4382 * Language Specification, §3.10.3</a>
4383 * @see #EXPR
4384 * @see #LITERAL_TRUE
4385 **/
4386 public static final int LITERAL_FALSE =
4387 JavaLanguageLexer.LITERAL_FALSE;
4388
4389 /**
4390 * The {@code null} keyword.
4391 *
4392 * <p>For example:</p>
4393 * <pre>
4394 * String s = null;
4395 * </pre>
4396 *
4397 * <p>parses as:</p>
4398 * <pre>
4399 * VARIABLE_DEF -> VARIABLE_DEF
4400 * |--MODIFIERS -> MODIFIERS
4401 * |--TYPE -> TYPE
4402 * | `--IDENT -> String
4403 * |--IDENT -> s
4404 * |--ASSIGN -> =
4405 * | `--EXPR -> EXPR
4406 * | `--LITERAL_NULL -> null
4407 * `--SEMI -> ;
4408 * </pre>
4409 *
4410 * @see <a
4411 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java
4412 * Language Specification, §3.10.7</a>
4413 * @see #EXPR
4414 **/
4415 public static final int LITERAL_NULL =
4416 JavaLanguageLexer.LITERAL_NULL;
4417
4418 /**
4419 * The {@code new} keyword. This element is used to define
4420 * new instances of objects, new arrays, and new anonymous inner
4421 * classes.
4422 *
4423 * <p>For example:</p>
4424 *
4425 * <pre>
4426 * List<String> l = new ArrayList<String>();
4427 * </pre>
4428 *
4429 * <p>parses as:</p>
4430 * <pre>
4431 * VARIABLE_DEF -> VARIABLE_DEF
4432 * |--MODIFIERS -> MODIFIERS
4433 * |--TYPE -> TYPE
4434 * | |--IDENT -> List
4435 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
4436 * | |--GENERIC_START -> <
4437 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
4438 * | | `--IDENT -> String
4439 * | `--GENERIC_END -> >
4440 * |--IDENT -> l
4441 * |--ASSIGN -> =
4442 * | `--EXPR -> EXPR
4443 * | `--LITERAL_NEW -> new
4444 * | |--IDENT -> ArrayList
4445 * | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
4446 * | | |--GENERIC_START -> <
4447 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
4448 * | | | `--IDENT -> String
4449 * | | `--GENERIC_END -> >
4450 * | |--LPAREN -> (
4451 * | |--ELIST -> ELIST
4452 * | `--RPAREN -> )
4453 * `--SEMI -> ;
4454 * </pre>
4455 *
4456 * <p>For example:</p>
4457 * <pre>
4458 * String[] strings = new String[3];
4459 * </pre>
4460 *
4461 * <p>parses as:</p>
4462 * <pre>
4463 * VARIABLE_DEF -> VARIABLE_DEF
4464 * |--MODIFIERS -> MODIFIERS
4465 * |--TYPE -> TYPE
4466 * | |--IDENT -> String
4467 * | `--ARRAY_DECLARATOR -> [
4468 * | `--RBRACK -> ]
4469 * |--IDENT -> strings
4470 * |--ASSIGN -> =
4471 * | `--EXPR -> EXPR
4472 * | `--LITERAL_NEW -> new
4473 * | |--IDENT -> String
4474 * | `--ARRAY_DECLARATOR -> [
4475 * | |--EXPR -> EXPR
4476 * | | `--NUM_INT -> 3
4477 * | `--RBRACK -> ]
4478 * `--SEMI -> ;
4479 * </pre>
4480 *
4481 * <p>For example:</p>
4482 * <pre>
4483 * Supplier<Integer> s = new Supplier<>() {
4484 * @Override
4485 * public Integer get() {
4486 * return 42;
4487 * }
4488 * };
4489 * </pre>
4490 *
4491 * <p>parses as:</p>
4492 * <pre>
4493 * VARIABLE_DEF -> VARIABLE_DEF
4494 * |--MODIFIERS -> MODIFIERS
4495 * |--TYPE -> TYPE
4496 * | |--IDENT -> Supplier
4497 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
4498 * | |--GENERIC_START -> <
4499 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
4500 * | | `--IDENT -> Integer
4501 * | `--GENERIC_END -> >
4502 * |--IDENT -> s
4503 * |--ASSIGN -> =
4504 * | `--EXPR -> EXPR
4505 * | `--LITERAL_NEW -> new
4506 * | |--IDENT -> Supplier
4507 * | |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
4508 * | | |--GENERIC_START -> <
4509 * | | `--GENERIC_END -> >
4510 * | |--LPAREN -> (
4511 * | |--ELIST -> ELIST
4512 * | |--RPAREN -> )
4513 * | `--OBJBLOCK -> OBJBLOCK
4514 * | |--LCURLY -> {
4515 * | |--METHOD_DEF -> METHOD_DEF
4516 * | | |--MODIFIERS -> MODIFIERS
4517 * | | | |--ANNOTATION -> ANNOTATION
4518 * | | | | |--AT -> @
4519 * | | | | `--IDENT -> Override
4520 * | | | `--LITERAL_PUBLIC -> public
4521 * | | |--TYPE -> TYPE
4522 * | | | `--IDENT -> Integer
4523 * | | |--IDENT -> get
4524 * | | |--LPAREN -> (
4525 * | | |--PARAMETERS -> PARAMETERS
4526 * | | |--RPAREN -> )
4527 * | | `--SLIST -> {
4528 * | | |--LITERAL_RETURN -> return
4529 * | | | |--EXPR -> EXPR
4530 * | | | | `--NUM_INT -> 42
4531 * | | | `--SEMI -> ;
4532 * | | `--RCURLY -> }
4533 * | `--RCURLY -> }
4534 * `--SEMI -> ;
4535 * </pre>
4536 *
4537 * @see #IDENT
4538 * @see #DOT
4539 * @see #LPAREN
4540 * @see #ELIST
4541 * @see #RPAREN
4542 * @see #OBJBLOCK
4543 * @see #ARRAY_INIT
4544 * @see FullIdent
4545 **/
4546 public static final int LITERAL_NEW = JavaLanguageLexer.LITERAL_NEW;
4547 /**
4548 * An integer literal. These may be specified in decimal,
4549 * hexadecimal, or octal form.
4550 *
4551 * <p>For example:</p>
4552 * <pre>
4553 * a = 3;
4554 * </pre>
4555 *
4556 * <p>parses as:</p>
4557 * <pre>
4558 * |--EXPR -> EXPR
4559 * | `--ASSIGN -> =
4560 * | |--IDENT -> a
4561 * | `--NUM_INT -> 3
4562 * |--SEMI -> ;
4563 * </pre>
4564 *
4565 * @see <a
4566 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java
4567 * Language Specification, §3.10.1</a>
4568 * @see #EXPR
4569 * @see #NUM_LONG
4570 **/
4571 public static final int NUM_INT = JavaLanguageLexer.NUM_INT;
4572 /**
4573 * A character literal. This is a (possibly escaped) character
4574 * enclosed in single quotes.
4575 *
4576 * <p>For example:</p>
4577 * <pre>
4578 * return 'a';
4579 * </pre>
4580 *
4581 * <p>parses as:</p>
4582 * <pre>
4583 * --LITERAL_RETURN -> return
4584 * |--EXPR -> EXPR
4585 * | `--CHAR_LITERAL -> 'a'
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.4">Java
4591 * Language Specification, §3.10.4</a>
4592 * @see #EXPR
4593 **/
4594 public static final int CHAR_LITERAL =
4595 JavaLanguageLexer.CHAR_LITERAL;
4596
4597 /**
4598 * A string literal. This is a sequence of (possibly escaped)
4599 * characters enclosed in double quotes.
4600 *
4601 * <p>For example:</p>
4602 * <pre>String str = "StringLiteral";</pre>
4603 *
4604 * <p>parses as:</p>
4605 * <pre>
4606 * |--VARIABLE_DEF -> VARIABLE_DEF
4607 * | |--MODIFIERS -> MODIFIERS
4608 * | |--TYPE -> TYPE
4609 * | | `--IDENT -> String
4610 * | |--IDENT -> str
4611 * | `--ASSIGN -> =
4612 * | `--EXPR -> EXPR
4613 * | `--STRING_LITERAL -> "StringLiteral"
4614 * |--SEMI -> ;
4615 * </pre>
4616 *
4617 * @see <a
4618 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java
4619 * Language Specification, §3.10.5</a>
4620 * @see #EXPR
4621 **/
4622 public static final int STRING_LITERAL =
4623 JavaLanguageLexer.STRING_LITERAL;
4624
4625 /**
4626 * A single precision floating point literal. This is a floating
4627 * point number with an {@code F} or {@code f} suffix.
4628 *
4629 * <p>For example:</p>
4630 * <pre>
4631 * a = 3.14f;
4632 * </pre>
4633 *
4634 * <p>parses as:</p>
4635 * <pre>
4636 * |--EXPR -> EXPR
4637 * | `--ASSIGN -> =
4638 * | |--IDENT -> a
4639 * | `--NUM_FLOAT -> 3.14f
4640 * |--SEMI -> ;
4641 * </pre>
4642 *
4643 * @see <a
4644 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java
4645 * Language Specification, §3.10.2</a>
4646 * @see #EXPR
4647 * @see #NUM_DOUBLE
4648 **/
4649 public static final int NUM_FLOAT = JavaLanguageLexer.NUM_FLOAT;
4650 /**
4651 * A long integer literal. These are almost the same as integer
4652 * literals, but they have an {@code L} or {@code l}
4653 * (ell) suffix.
4654 *
4655 * <p>For example:</p>
4656 * <pre>
4657 * a = 3l;
4658 * </pre>
4659 *
4660 * <p>parses as:</p>
4661 * <pre>
4662 * |--EXPR -> EXPR
4663 * | `--ASSIGN -> =
4664 * | |--IDENT -> a
4665 * | `--NUM_LONG -> 3l
4666 * |--SEMI -> ;
4667 * </pre>
4668 *
4669 * @see <a
4670 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java
4671 * Language Specification, §3.10.1</a>
4672 * @see #EXPR
4673 * @see #NUM_INT
4674 **/
4675 public static final int NUM_LONG = JavaLanguageLexer.NUM_LONG;
4676 /**
4677 * A double precision floating point literal. This is a floating
4678 * point number with an optional {@code D} or {@code d}
4679 * suffix.
4680 *
4681 * <p>For example:</p>
4682 * <pre>
4683 * a = 3.14d;
4684 * </pre>
4685 *
4686 * <p>parses as:</p>
4687 * <pre>
4688 * |--EXPR -> EXPR
4689 * | `--ASSIGN -> =
4690 * | |--IDENT -> a
4691 * | `--NUM_DOUBLE -> 3.14d
4692 * |--SEMI -> ;
4693 * </pre>
4694 *
4695 * @see <a
4696 * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java
4697 * Language Specification, §3.10.2</a>
4698 * @see #EXPR
4699 * @see #NUM_FLOAT
4700 **/
4701 public static final int NUM_DOUBLE = JavaLanguageLexer.NUM_DOUBLE;
4702
4703 /**
4704 * The {@code assert} keyword. This is only for Java 1.4 and
4705 * later.
4706 *
4707 * <p>For example:</p>
4708 * <pre>
4709 * assert(x==4);
4710 * </pre>
4711 *
4712 * <p>parses as:</p>
4713 * <pre>
4714 * LITERAL_ASSERT -> assert
4715 * |--EXPR -> EXPR
4716 * | |--LPAREN -> (
4717 * | |--EQUAL -> ==
4718 * | | |--IDENT -> x
4719 * | | `--NUM_INT -> 4
4720 * | `--RPAREN -> )
4721 * `--SEMI -> ;
4722 * </pre>
4723 **/
4724 public static final int LITERAL_ASSERT = JavaLanguageLexer.ASSERT;
4725
4726 /**
4727 * A static import declaration. Static import declarations are optional,
4728 * but must appear after the package declaration and before the type
4729 * declaration.
4730 *
4731 * <p>For example:</p>
4732 * <pre>
4733 * import static java.io.IOException;
4734 * </pre>
4735 *
4736 * <p>parses as:</p>
4737 * <pre>
4738 * STATIC_IMPORT -> import
4739 * |--LITERAL_STATIC -> static
4740 * |--DOT -> .
4741 * | |--DOT -> .
4742 * | | |--IDENT -> java
4743 * | | `--IDENT -> io
4744 * | `--IDENT -> IOException
4745 * `--SEMI -> ;
4746 * </pre>
4747 *
4748 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
4749 * JSR201</a>
4750 * @see #LITERAL_STATIC
4751 * @see #DOT
4752 * @see #IDENT
4753 * @see #STAR
4754 * @see #SEMI
4755 * @see FullIdent
4756 **/
4757 public static final int STATIC_IMPORT =
4758 JavaLanguageLexer.STATIC_IMPORT;
4759
4760 /**
4761 * An enum declaration. Its notable children are
4762 * enum constant declarations followed by
4763 * any construct that may be expected in a class body.
4764 *
4765 * <p>For example:</p>
4766 * <pre>
4767 * public enum MyEnum
4768 * implements Serializable
4769 * {
4770 * FIRST_CONSTANT,
4771 * SECOND_CONSTANT;
4772 *
4773 * public void someMethod()
4774 * {
4775 * }
4776 * }
4777 * </pre>
4778 *
4779 * <p>parses as:</p>
4780 * <pre>
4781 * ENUM_DEF -> ENUM_DEF
4782 * |--MODIFIERS -> MODIFIERS
4783 * | `--LITERAL_PUBLIC -> public
4784 * |--ENUM -> enum
4785 * |--IDENT -> MyEnum
4786 * |--IMPLEMENTS_CLAUSE -> implements
4787 * | `--IDENT -> Serializable
4788 * `--OBJBLOCK -> OBJBLOCK
4789 * |--LCURLY -> {
4790 * |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF
4791 * | |--ANNOTATIONS -> ANNOTATIONS
4792 * | `--IDENT -> FIRST_CONSTANT
4793 * |--COMMA -> ,
4794 * |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF
4795 * | |--ANNOTATIONS -> ANNOTATIONS
4796 * | `--IDENT -> SECOND_CONSTANT
4797 * |--SEMI -> ;
4798 * |--METHOD_DEF -> METHOD_DEF
4799 * | |--MODIFIERS -> MODIFIERS
4800 * | | `--LITERAL_PUBLIC -> public
4801 * | |--TYPE -> TYPE
4802 * | | `--LITERAL_VOID -> void
4803 * | |--IDENT -> someMethod
4804 * | |--LPAREN -> (
4805 * | |--PARAMETERS -> PARAMETERS
4806 * | |--RPAREN -> )
4807 * | `--SLIST -> {
4808 * | `--RCURLY -> }
4809 * `--RCURLY -> }
4810 * </pre>
4811 *
4812 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
4813 * JSR201</a>
4814 * @see #MODIFIERS
4815 * @see #ENUM
4816 * @see #IDENT
4817 * @see #EXTENDS_CLAUSE
4818 * @see #IMPLEMENTS_CLAUSE
4819 * @see #OBJBLOCK
4820 * @see #LITERAL_NEW
4821 * @see #ENUM_CONSTANT_DEF
4822 **/
4823 public static final int ENUM_DEF =
4824 JavaLanguageLexer.ENUM_DEF;
4825
4826 /**
4827 * The {@code enum} keyword. This element appears
4828 * as part of an enum declaration.
4829 *
4830 * <p>For example:</p>
4831 * <pre>
4832 * public enum Count {}
4833 * </pre>
4834 *
4835 * <p>parses as:</p>
4836 * <pre>
4837 * ENUM_DEF -> ENUM_DEF
4838 * |--MODIFIERS -> MODIFIERS
4839 * | `--LITERAL_PUBLIC -> public
4840 * |--ENUM -> enum
4841 * |--IDENT -> Count
4842 * `--OBJBLOCK -> OBJBLOCK
4843 * |--LCURLY -> {
4844 * `--RCURLY -> }
4845 * </pre>
4846 *
4847 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">JSR201</a>
4848 * @see #MODIFIERS
4849 * @see #ENUM_DEF
4850 * @see #IDENT
4851 * @see #OBJBLOCK
4852 **/
4853 public static final int ENUM =
4854 JavaLanguageLexer.ENUM;
4855
4856 /**
4857 * An enum constant declaration. Its notable children are annotations,
4858 * arguments and object block akin to an anonymous
4859 * inner class' body.
4860 *
4861 * <p>For example:</p>
4862 * <pre>
4863 * SOME_CONSTANT(1)
4864 * {
4865 * public void someMethodOverriddenFromMainBody()
4866 * {
4867 * }
4868 * }
4869 * </pre>
4870 *
4871 * <p>parses as:</p>
4872 * <pre>
4873 * ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF
4874 * | |--ANNOTATIONS -> ANNOTATIONS
4875 * | |--IDENT -> SOME_CONSTANT
4876 * | |--LPAREN -> (
4877 * | |--ELIST -> ELIST
4878 * | | `--EXPR -> EXPR
4879 * | | `--NUM_INT -> 1
4880 * | |--RPAREN -> )
4881 * | `--OBJBLOCK -> OBJBLOCK
4882 * | |--LCURLY -> {
4883 * | |--METHOD_DEF -> METHOD_DEF
4884 * | | |--MODIFIERS -> MODIFIERS
4885 * | | | `--LITERAL_PUBLIC -> public
4886 * | | |--TYPE -> TYPE
4887 * | | | `--LITERAL_VOID -> void
4888 * | | |--IDENT -> someMethodOverriddenFromMainBody
4889 * | | |--LPAREN -> (
4890 * | | |--PARAMETERS -> PARAMETERS
4891 * | | |--RPAREN -> )
4892 * | | `--SLIST -> {
4893 * | | `--RCURLY -> }
4894 * | `--RCURLY -> }
4895 * </pre>
4896 *
4897 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
4898 * JSR201</a>
4899 * @see #ANNOTATIONS
4900 * @see #MODIFIERS
4901 * @see #IDENT
4902 * @see #ELIST
4903 * @see #OBJBLOCK
4904 **/
4905 public static final int ENUM_CONSTANT_DEF =
4906 JavaLanguageLexer.ENUM_CONSTANT_DEF;
4907
4908 /**
4909 * A for-each clause. This is a child of
4910 * {@code LITERAL_FOR}. The children of this element may be
4911 * a parameter definition, the colon literal and an expression.
4912 *
4913 * <p>For example:</p>
4914 * <pre>
4915 * for (int value : values) {
4916 * doSmth();
4917 * }
4918 * </pre>
4919 *
4920 * <p>parses as:</p>
4921 * <pre>
4922 * LITERAL_FOR -> for
4923 * |--LPAREN -> (
4924 * |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE
4925 * | |--VARIABLE_DEF -> VARIABLE_DEF
4926 * | | |--MODIFIERS -> MODIFIERS
4927 * | | |--TYPE -> TYPE
4928 * | | | `--LITERAL_INT -> int
4929 * | | `--IDENT -> value
4930 * | |--COLON -> :
4931 * | `--EXPR -> EXPR
4932 * | `--IDENT -> values
4933 * |--RPAREN -> )
4934 * `--SLIST -> {
4935 * |--EXPR -> EXPR
4936 * | `--METHOD_CALL -> (
4937 * | |--IDENT -> doSmth
4938 * | |--ELIST -> ELIST
4939 * | `--RPAREN -> )
4940 * |--SEMI -> ;
4941 * `--RCURLY -> }
4942 * </pre>
4943 *
4944 * @see #VARIABLE_DEF
4945 * @see #ELIST
4946 * @see #LITERAL_FOR
4947 **/
4948 public static final int FOR_EACH_CLAUSE =
4949 JavaLanguageLexer.FOR_EACH_CLAUSE;
4950
4951 /**
4952 * An annotation declaration. The notable children are the name of the
4953 * annotation type, annotation field declarations and (constant) fields.
4954 *
4955 * <p>For example:</p>
4956 * <pre>
4957 * public @interface MyAnnotation
4958 * {
4959 * int someValue();
4960 * }
4961 * </pre>
4962 *
4963 * <p>parses as:</p>
4964 * <pre>
4965 * ANNOTATION_DEF -> ANNOTATION_DEF
4966 * |--MODIFIERS -> MODIFIERS
4967 * | `--LITERAL_PUBLIC -> public
4968 * |--AT -> @
4969 * |--LITERAL_INTERFACE -> interface
4970 * |--IDENT -> MyAnnotation
4971 * `--OBJBLOCK -> OBJBLOCK
4972 * |--LCURLY -> {
4973 * |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF
4974 * | |--MODIFIERS -> MODIFIERS
4975 * | |--TYPE -> TYPE
4976 * | | `--LITERAL_INT -> int
4977 * | |--IDENT -> someValue
4978 * | |--LPAREN -> (
4979 * | |--RPAREN -> )
4980 * | `--SEMI -> ;
4981 * `--RCURLY -> }
4982 * </pre>
4983 *
4984 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
4985 * JSR201</a>
4986 * @see #MODIFIERS
4987 * @see #LITERAL_INTERFACE
4988 * @see #IDENT
4989 * @see #OBJBLOCK
4990 * @see #ANNOTATION_FIELD_DEF
4991 **/
4992 public static final int ANNOTATION_DEF =
4993 JavaLanguageLexer.ANNOTATION_DEF;
4994
4995 /**
4996 * An annotation field declaration. The notable children are modifiers,
4997 * field type, field name and an optional default value (a conditional
4998 * compile-time constant expression). Default values may also be
4999 * annotations.
5000 *
5001 * <p>For example:</p>
5002 *
5003 * <pre>
5004 * String someField() default "Hello world";
5005 * </pre>
5006 *
5007 * <p>parses as:</p>
5008 *
5009 * <pre>
5010 * ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF
5011 * |--MODIFIERS -> MODIFIERS
5012 * |--TYPE -> TYPE
5013 * | `--IDENT -> String
5014 * |--IDENT -> someField
5015 * |--LPAREN -> (
5016 * |--RPAREN -> )
5017 * |--LITERAL_DEFAULT -> default
5018 * | `--EXPR -> EXPR
5019 * | `--STRING_LITERAL -> "Hello world"
5020 * `--SEMI -> ;
5021 * </pre>
5022 *
5023 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5024 * JSR201</a>
5025 * @see #MODIFIERS
5026 * @see #TYPE
5027 * @see #LITERAL_DEFAULT
5028 */
5029 public static final int ANNOTATION_FIELD_DEF =
5030 JavaLanguageLexer.ANNOTATION_FIELD_DEF;
5031
5032 // note: @ is the html escape for '@',
5033 // used here to avoid confusing the javadoc tool
5034 /**
5035 * A collection of annotations on a package or enum constant.
5036 * A collections of annotations will only occur on these nodes
5037 * as all other nodes that may be qualified with an annotation can
5038 * be qualified with any other modifier and hence these annotations
5039 * would be contained in a {@link #MODIFIERS} node.
5040 *
5041 * <p>For example:</p>
5042 *
5043 * <pre>
5044 * @MyAnnotation package blah;
5045 * </pre>
5046 *
5047 * <p>parses as:</p>
5048 *
5049 * <pre>
5050 * PACKAGE_DEF -> package
5051 * |--ANNOTATIONS -> ANNOTATIONS
5052 * | `--ANNOTATION -> ANNOTATION
5053 * | |--AT -> @
5054 * | `--IDENT -> MyAnnotation
5055 * |--IDENT -> blah
5056 * `--SEMI -> ;
5057 * </pre>
5058 *
5059 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5060 * JSR201</a>
5061 * @see #ANNOTATION
5062 * @see #AT
5063 * @see #IDENT
5064 */
5065 public static final int ANNOTATIONS =
5066 JavaLanguageLexer.ANNOTATIONS;
5067
5068 // note: @ is the html escape for '@',
5069 // used here to avoid confusing the javadoc tool
5070 /**
5071 * An annotation of a package, type, field, parameter or variable.
5072 * An annotation may occur anywhere modifiers occur (it is a
5073 * type of modifier) and may also occur prior to a package definition.
5074 * The notable children are: The annotation name and either a single
5075 * default annotation value or a sequence of name value pairs.
5076 * Annotation values may also be annotations themselves.
5077 *
5078 * <p>For example:</p>
5079 * <pre>
5080 * @MyAnnotation(someField1 = "Hello",
5081 * someField2 = @SomeOtherAnnotation)
5082 * </pre>
5083 *
5084 * <p>parses as:</p>
5085 * <pre>
5086 * ANNOTATION -> ANNOTATION
5087 * |--AT -> @
5088 * |--IDENT -> MyAnnotation
5089 * |--LPAREN -> (
5090 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR
5091 * | |--IDENT -> someField1
5092 * | |--ASSIGN -> =
5093 * | `--EXPR -> EXPR
5094 * | `--STRING_LITERAL -> "Hello"
5095 * |--COMMA -> ,
5096 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR
5097 * | |--IDENT -> someField2
5098 * | |--ASSIGN -> =
5099 * | `--ANNOTATION -> ANNOTATION
5100 * | |--AT -> @
5101 * | `--IDENT -> SomeOtherAnnotation
5102 * `--RPAREN -> )
5103 * </pre>
5104 *
5105 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5106 * JSR201</a>
5107 * @see #MODIFIERS
5108 * @see #IDENT
5109 * @see #ANNOTATION_MEMBER_VALUE_PAIR
5110 */
5111 public static final int ANNOTATION =
5112 JavaLanguageLexer.ANNOTATION;
5113
5114 /**
5115 * An initialization of an annotation member with a value.
5116 * Its children are the name of the member, the assignment literal
5117 * and the (compile-time constant conditional expression) value.
5118 *
5119 * <p>For example:</p>
5120 * <pre>
5121 * @Annotation(
5122 * value="123"
5123 * )
5124 * </pre>
5125 *
5126 * <p>parses as:</p>
5127 * <pre>
5128 * ANNOTATION -> ANNOTATION
5129 * |--AT -> @
5130 * |--IDENT -> Annotation
5131 * |--LPAREN -> (
5132 * |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR
5133 * | |--IDENT -> value
5134 * | |--ASSIGN -> =
5135 * | `--EXPR -> EXPR
5136 * | `--STRING_LITERAL -> "123"
5137 * `--RPAREN -> )
5138 * </pre>
5139 *
5140 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5141 * JSR201</a>
5142 * @see #ANNOTATION
5143 * @see #IDENT
5144 */
5145 public static final int ANNOTATION_MEMBER_VALUE_PAIR =
5146 JavaLanguageLexer.ANNOTATION_MEMBER_VALUE_PAIR;
5147
5148 /**
5149 * An annotation array member initialization.
5150 * Initializers can not be nested.
5151 * An initializer may be present as a default to an annotation
5152 * member, as the single default value to an annotation
5153 * (e.g. @Annotation({1,2})) or as the value of an annotation
5154 * member value pair.
5155 *
5156 * <p>For example:</p>
5157 * <pre>
5158 * @Annotation({1, 2})
5159 * </pre>
5160 *
5161 * <p>parses as:</p>
5162 * <pre>
5163 * ANNOTATION -> ANNOTATION
5164 * |--AT -> @
5165 * |--IDENT -> Annotation
5166 * |--LPAREN -> (
5167 * |--ANNOTATION_ARRAY_INIT -> {
5168 * | |--EXPR -> EXPR
5169 * | | `--NUM_INT -> 1
5170 * | |--COMMA -> ,
5171 * | |--EXPR -> EXPR
5172 * | | `--NUM_INT -> 2
5173 * | `--RCURLY -> }
5174 * `--RPAREN -> )
5175 * </pre>
5176 *
5177 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5178 * JSR201</a>
5179 * @see #ANNOTATION
5180 * @see #IDENT
5181 * @see #ANNOTATION_MEMBER_VALUE_PAIR
5182 */
5183 public static final int ANNOTATION_ARRAY_INIT =
5184 JavaLanguageLexer.ANNOTATION_ARRAY_INIT;
5185
5186 /**
5187 * A list of type parameters to a class, interface or
5188 * method definition. Children are LT, at least one
5189 * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single
5190 * TYPE_PARAMETER and a final GT.
5191 *
5192 * <p>For example:</p>
5193 *
5194 * <pre>
5195 * public class MyClass<A, B> {
5196 *
5197 * }
5198 * </pre>
5199 *
5200 * <p>parses as:</p>
5201 *
5202 * <pre>
5203 * CLASS_DEF -> CLASS_DEF
5204 * |--MODIFIERS -> MODIFIERS
5205 * | `--LITERAL_PUBLIC -> public
5206 * |--LITERAL_CLASS -> class
5207 * |--IDENT -> MyClass
5208 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5209 * | |--GENERIC_START -> <
5210 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5211 * | | `--IDENT -> A
5212 * | |--COMMA -> ,
5213 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5214 * | | `--IDENT -> B
5215 * | `--GENERIC_END -> >
5216 * `--OBJBLOCK -> OBJBLOCK
5217 * |--LCURLY -> {
5218 * `--RCURLY -> }
5219 * </pre>
5220 *
5221 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5222 * Generic Classes and Type Parameters</a>
5223 * @see #GENERIC_START
5224 * @see #GENERIC_END
5225 * @see #TYPE_PARAMETER
5226 * @see #COMMA
5227 */
5228 public static final int TYPE_PARAMETERS =
5229 JavaLanguageLexer.TYPE_PARAMETERS;
5230
5231 /**
5232 * A type parameter to a class, interface or method definition.
5233 * Children are the type name and an optional TYPE_UPPER_BOUNDS.
5234 *
5235 * <p>For example:</p>
5236 *
5237 * <pre>
5238 * public class MyClass <A extends Collection> {
5239 *
5240 * }
5241 * </pre>
5242 *
5243 * <p>parses as:</p>
5244 *
5245 * <pre>
5246 * CLASS_DEF -> CLASS_DEF
5247 * |--MODIFIERS -> MODIFIERS
5248 * | `--LITERAL_PUBLIC -> public
5249 * |--LITERAL_CLASS -> class
5250 * |--IDENT -> MyClass
5251 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5252 * | |--GENERIC_START -> <
5253 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5254 * | | |--IDENT -> A
5255 * | | `--TYPE_UPPER_BOUNDS -> extends
5256 * | | `--IDENT -> Collection
5257 * | `--GENERIC_END -> >
5258 * `--OBJBLOCK -> OBJBLOCK
5259 * |--LCURLY -> {
5260 * `--RCURLY -> }
5261 * </pre>
5262 *
5263 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5264 * Generic Classes and Type Parameters</a>
5265 * @see #IDENT
5266 * @see #WILDCARD_TYPE
5267 * @see #TYPE_UPPER_BOUNDS
5268 */
5269 public static final int TYPE_PARAMETER =
5270 JavaLanguageLexer.TYPE_PARAMETER;
5271
5272 /**
5273 * A list of type arguments to a type reference or
5274 * a method/ctor invocation. Children are GENERIC_START, at least one
5275 * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single
5276 * TYPE_ARGUMENT, and a final GENERIC_END.
5277 *
5278 * <p>For example:</p>
5279 *
5280 * <pre>
5281 * public Collection<?> a;
5282 * </pre>
5283 *
5284 * <p>parses as:</p>
5285 *
5286 * <pre>
5287 * VARIABLE_DEF -> VARIABLE_DEF
5288 * |--MODIFIERS -> MODIFIERS
5289 * | `--LITERAL_PUBLIC -> public
5290 * |--TYPE -> TYPE
5291 * | |--IDENT -> Collection
5292 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5293 * | |--GENERIC_START -> <
5294 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5295 * | | `--WILDCARD_TYPE -> ?
5296 * | `--GENERIC_END -> >
5297 * |--IDENT -> a
5298 * `--SEMI -> ;
5299 * </pre>
5300 *
5301 * @see #GENERIC_START
5302 * @see #GENERIC_END
5303 * @see #TYPE_ARGUMENT
5304 * @see #COMMA
5305 */
5306 public static final int TYPE_ARGUMENTS =
5307 JavaLanguageLexer.TYPE_ARGUMENTS;
5308
5309 /**
5310 * A type arguments to a type reference or a method/ctor invocation.
5311 * Children are either: type name or wildcard type with possible type
5312 * upper or lower bounds.
5313 *
5314 * <p>For example:</p>
5315 * <pre>List<? super List> list;</pre>
5316 *
5317 * <p>parses as:</p>
5318 * <pre>
5319 * VARIABLE_DEF -> VARIABLE_DEF
5320 * |--MODIFIERS -> MODIFIERS
5321 * |--TYPE -> TYPE
5322 * | |--IDENT -> List
5323 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5324 * | |--GENERIC_START -> <
5325 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5326 * | | |--WILDCARD_TYPE -> ?
5327 * | | `--TYPE_LOWER_BOUNDS -> super
5328 * | | `--IDENT -> List
5329 * | `--GENERIC_END -> >
5330 * |--IDENT -> list
5331 * `--SEMI -> ;
5332 * </pre>
5333 *
5334 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5335 * Generic Classes and Type Parameters</a>
5336 * @see #WILDCARD_TYPE
5337 * @see #TYPE_UPPER_BOUNDS
5338 * @see #TYPE_LOWER_BOUNDS
5339 */
5340 public static final int TYPE_ARGUMENT =
5341 JavaLanguageLexer.TYPE_ARGUMENT;
5342
5343 /**
5344 * The type that refers to all types. This node has no children.
5345 *
5346 * <p>For example: </p>
5347 * <pre>
5348 *
5349 * List<?> list;
5350 * </pre>
5351 *
5352 * <p>parses as:</p>
5353 * <pre>
5354 * |--VARIABLE_DEF -> VARIABLE_DEF
5355 * | |--MODIFIERS -> MODIFIERS
5356 * | |--TYPE -> TYPE
5357 * | | |--IDENT -> List
5358 * | | |`--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5359 * | | |--GENERIC_START -> <
5360 * | | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5361 * | | | `--WILDCARD_TYPE -> ?
5362 * | | `--GENERIC_END -> >
5363 * | `--IDENT -> list
5364 * |--SEMI -> ;
5365 * </pre>
5366 *
5367 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5368 * Generic Classes and Type Parameters</a>
5369 * @see #TYPE_ARGUMENT
5370 * @see #TYPE_UPPER_BOUNDS
5371 * @see #TYPE_LOWER_BOUNDS
5372 */
5373 public static final int WILDCARD_TYPE =
5374 JavaLanguageLexer.WILDCARD_TYPE;
5375
5376 /**
5377 * An upper bounds on a wildcard type argument or type parameter.
5378 * This node has one child - the type that is being used for
5379 * the bounding.
5380 *
5381 * <p>For example:</p>
5382 * <pre>List<? extends Number> list;</pre>
5383 *
5384 * <p>parses as:</p>
5385 * <pre>
5386 * --VARIABLE_DEF -> VARIABLE_DEF
5387 * |--MODIFIERS -> MODIFIERS
5388 * |--TYPE -> TYPE
5389 * | |--IDENT -> List
5390 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5391 * | |--GENERIC_START -> <
5392 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5393 * | | |--WILDCARD_TYPE -> ?
5394 * | | `--TYPE_UPPER_BOUNDS -> extends
5395 * | | `--IDENT -> Number
5396 * | `--GENERIC_END -> >
5397 * |--IDENT -> list
5398 * `--SEMI -> ;
5399 * </pre>
5400 *
5401 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5402 * Generic Classes and Type Parameters</a>
5403 * @see #TYPE_PARAMETER
5404 * @see #TYPE_ARGUMENT
5405 * @see #WILDCARD_TYPE
5406 */
5407 public static final int TYPE_UPPER_BOUNDS =
5408 JavaLanguageLexer.TYPE_UPPER_BOUNDS;
5409
5410 /**
5411 * A lower bounds on a wildcard type argument. This node has one child
5412 * - the type that is being used for the bounding.
5413 *
5414 * <p>For example:</p>
5415 * <pre>List<? super Integer> list;</pre>
5416 *
5417 * <p>parses as:</p>
5418 * <pre>
5419 * --VARIABLE_DEF -> VARIABLE_DEF
5420 * |--MODIFIERS -> MODIFIERS
5421 * |--TYPE -> TYPE
5422 * | |--IDENT -> List
5423 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
5424 * | |--GENERIC_START -> <
5425 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
5426 * | | |--WILDCARD_TYPE -> ?
5427 * | | `--TYPE_LOWER_BOUNDS -> super
5428 * | | `--IDENT -> Integer
5429 * | `--GENERIC_END -> >
5430 * |--IDENT -> list
5431 * `--SEMI -> ;
5432 * </pre>
5433 *
5434 * @see <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-8.html#jls-8.1.2">
5435 * Generic Classes and Type Parameters</a>
5436 * @see #TYPE_ARGUMENT
5437 * @see #WILDCARD_TYPE
5438 */
5439 public static final int TYPE_LOWER_BOUNDS =
5440 JavaLanguageLexer.TYPE_LOWER_BOUNDS;
5441
5442 /**
5443 * An {@code @} symbol - signifying an annotation instance or the prefix
5444 * to the interface literal signifying the definition of an annotation
5445 * declaration.
5446 *
5447 * <p>For example:</p>
5448 * <pre>
5449 * @Deprecated
5450 * private int value;
5451 * </pre>
5452 *
5453 * <p>parses as:</p>
5454 * <pre>
5455 * VARIABLE_DEF -> VARIABLE_DEF
5456 * |--MODIFIERS -> MODIFIERS
5457 * | |--ANNOTATION -> ANNOTATION
5458 * | | |--AT -> @
5459 * | | `--IDENT -> Deprecated
5460 * | `--LITERAL_PRIVATE -> private
5461 * |--TYPE -> TYPE
5462 * | `--LITERAL_INT -> int
5463 * |--IDENT -> value
5464 * `--SEMI -> ;
5465 * </pre>
5466 *
5467 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5468 * JSR201</a>
5469 */
5470 public static final int AT = JavaLanguageLexer.AT;
5471
5472 /**
5473 * A triple dot for variable-length parameters. This token only ever occurs
5474 * in a parameter declaration immediately after the type of the parameter.
5475 *
5476 * <p>For example:</p>
5477 * <pre>
5478 * public void myShape(int... dimension) {
5479 *
5480 * }
5481 * </pre>
5482 *
5483 * <p>parses as:</p>
5484 * <pre>
5485 * METHOD_DEF -> METHOD_DEF
5486 * |--MODIFIERS -> MODIFIERS
5487 * | `--LITERAL_PUBLIC -> public
5488 * |--TYPE -> TYPE
5489 * | `--LITERAL_VOID -> void
5490 * |--IDENT -> myShape
5491 * |--LPAREN -> (
5492 * |--PARAMETERS -> PARAMETERS
5493 * | `--PARAMETER_DEF -> PARAMETER_DEF
5494 * | |--MODIFIERS -> MODIFIERS
5495 * | |--TYPE -> TYPE
5496 * | | `--LITERAL_INT -> int
5497 * | |--ELLIPSIS -> ...
5498 * | `--IDENT -> dimension
5499 * |--RPAREN -> )
5500 * `--SLIST -> {
5501 * `--RCURLY -> }
5502 * </pre>
5503 *
5504 * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
5505 * JSR201</a>
5506 */
5507 public static final int ELLIPSIS = JavaLanguageLexer.ELLIPSIS;
5508
5509 /**
5510 * The {@code &} symbol when used to extend a generic upper or lower bounds constrain
5511 * or a type cast expression with an additional interface.
5512 *
5513 * <p>Generic type bounds extension:
5514 * {@code class Comparable<T extends Serializable & CharSequence>}</p>
5515 * <pre>
5516 * CLASS_DEF -> CLASS_DEF
5517 * |--MODIFIERS -> MODIFIERS
5518 * |--LITERAL_CLASS -> class
5519 * |--IDENT -> Comparable
5520 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5521 * |--GENERIC_START -> <
5522 * |--TYPE_PARAMETER -> TYPE_PARAMETER
5523 * | |--IDENT -> T
5524 * | `--TYPE_UPPER_BOUNDS -> extends
5525 * | |--IDENT -> Serializable
5526 * | |--TYPE_EXTENSION_AND -> &
5527 * | `--IDENT -> CharSequence
5528 * `--GENERIC_END -> >
5529 * </pre>
5530 *
5531 * <p>Type cast extension:
5532 * {@code return (Serializable & CharSequence) null;}</p>
5533 * <pre>
5534 * --LITERAL_RETURN -> return
5535 * |--EXPR -> EXPR
5536 * | `--TYPECAST -> (
5537 * | |--TYPE -> TYPE
5538 * | | `--IDENT -> Serializable
5539 * | |--TYPE_EXTENSION_AND -> &
5540 * | |--TYPE -> TYPE
5541 * | | `--IDENT -> CharSequence
5542 * | |--RPAREN -> )
5543 * | `--LITERAL_NULL -> null
5544 * `--SEMI -> ;
5545 * </pre>
5546 *
5547 * @see #EXTENDS_CLAUSE
5548 * @see #TYPECAST
5549 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4">
5550 * Java Language Specification, §4.4</a>
5551 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">
5552 * Java Language Specification, §15.16</a>
5553 */
5554 public static final int TYPE_EXTENSION_AND =
5555 JavaLanguageLexer.TYPE_EXTENSION_AND;
5556
5557 /**
5558 * A {@code <} symbol signifying the start of type arguments or type parameters.
5559 *
5560 * <p>For example:</p>
5561 * <pre>
5562 * class Test<T> {}
5563 * </pre>
5564 *
5565 * <p>parses as:</p>
5566 * <pre>
5567 * CLASS_DEF -> CLASS_DEF
5568 * |--MODIFIERS -> MODIFIERS
5569 * |--LITERAL_CLASS -> class
5570 * |--IDENT -> Test
5571 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5572 * | |--GENERIC_START -> <
5573 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5574 * | | `--IDENT -> T
5575 * | `--GENERIC_END -> >
5576 * `--OBJBLOCK -> OBJBLOCK
5577 * |--LCURLY -> {
5578 * `--RCURLY -> }
5579 * </pre>
5580 *
5581 * @see #MODIFIERS
5582 * @see #IDENT
5583 * @see #OBJBLOCK
5584 * @see #TYPE_PARAMETERS
5585 * @see #GENERIC_END
5586 */
5587 public static final int GENERIC_START =
5588 JavaLanguageLexer.GENERIC_START;
5589
5590 /**
5591 * A {@code >} symbol signifying the end of type arguments or type parameters.
5592 *
5593 * <p>For example:</p>
5594 * <pre>
5595 * class Test<T> {}
5596 * </pre>
5597 *
5598 * <p>parses as:</p>
5599 * <pre>
5600 * CLASS_DEF -> CLASS_DEF
5601 * |--MODIFIERS -> MODIFIERS
5602 * |--LITERAL_CLASS -> class
5603 * |--IDENT -> Test
5604 * |--TYPE_PARAMETERS -> TYPE_PARAMETERS
5605 * | |--GENERIC_START -> <
5606 * | |--TYPE_PARAMETER -> TYPE_PARAMETER
5607 * | | `--IDENT -> T
5608 * | `--GENERIC_END -> >
5609 * `--OBJBLOCK -> OBJBLOCK
5610 * |--LCURLY -> {
5611 * `--RCURLY -> }
5612 * </pre>
5613 *
5614 * @see #MODIFIERS
5615 * @see #IDENT
5616 * @see #OBJBLOCK
5617 * @see #TYPE_PARAMETERS
5618 * @see #GENERIC_START
5619 */
5620 public static final int GENERIC_END = JavaLanguageLexer.GENERIC_END;
5621
5622 /**
5623 * Special lambda symbol {@code ->}.
5624 *
5625 * <p>For example:</p>
5626 * <pre>
5627 * numbers.forEach((n) -> System.out.println(n));
5628 * </pre>
5629 *
5630 * <p>parses as:</p>
5631 * <pre>
5632 * METHOD_CALL -> (
5633 * |--DOT -> .
5634 * | |--IDENT -> numbers
5635 * | `--IDENT -> forEach
5636 * |--ELIST -> ELIST
5637 * | `--LAMBDA -> ->
5638 * | |--LPAREN -> (
5639 * | |--PARAMETERS -> PARAMETERS
5640 * | | `--PARAMETER_DEF -> PARAMETER_DEF
5641 * | | |--MODIFIERS -> MODIFIERS
5642 * | | |--TYPE -> TYPE
5643 * | | `--IDENT -> n
5644 * | |--RPAREN -> )
5645 * | `--EXPR -> EXPR
5646 * | `--METHOD_CALL -> (
5647 * | |--DOT -> .
5648 * | | |--DOT -> .
5649 * | | | |--IDENT -> System
5650 * | | | `--IDENT -> out
5651 * | | `--IDENT -> println
5652 * | |--ELIST -> ELIST
5653 * | | `--EXPR -> EXPR
5654 * | | `--IDENT -> n
5655 * | `--RPAREN -> )
5656 * `--RPAREN -> )
5657 * </pre>
5658 *
5659 */
5660 public static final int LAMBDA = JavaLanguageLexer.LAMBDA;
5661
5662 /**
5663 * Beginning of single-line comment: '//'.
5664 *
5665 * <pre>
5666 * SINGLE_LINE_COMMENT -> //
5667 * `--COMMENT_CONTENT -> \r\n
5668 * </pre>
5669 *
5670 * <p>For example:</p>
5671 * <pre>
5672 * // Comment content
5673 * </pre>
5674 *
5675 * <p>parses as:</p>
5676 * <pre>
5677 * SINGLE_LINE_COMMENT -> //
5678 * `--COMMENT_CONTENT -> Comment Content\n
5679 * </pre>
5680 */
5681 public static final int SINGLE_LINE_COMMENT =
5682 JavaLanguageLexer.SINGLE_LINE_COMMENT;
5683
5684 /**
5685 * Beginning of block comment: '/*'.
5686 *
5687 * <p>For example:</p>
5688 * <pre>
5689 * /* Comment content
5690 * */
5691 * </pre>
5692 *
5693 * <p>parses as:</p>
5694 * <pre>
5695 * --BLOCK_COMMENT_BEGIN -> /*
5696 * |--COMMENT_CONTENT -> Comment content\r\n
5697 * `--BLOCK_COMMENT_END -> */
5698 * </pre>
5699 */
5700 public static final int BLOCK_COMMENT_BEGIN =
5701 JavaLanguageLexer.BLOCK_COMMENT_BEGIN;
5702
5703 /**
5704 * End of block comment: '*/'.
5705 *
5706 * <p>For example:</p>
5707 * <pre>
5708 * /*comment*/
5709 * </pre>
5710 *
5711 * <p>parses as:</p>
5712 * <pre>
5713 * BLOCK_COMMENT_BEGIN -> /*
5714 * |--COMMENT_CONTENT -> comment
5715 * `--BLOCK_COMMENT_END -> */
5716 * </pre>
5717 *
5718 */
5719 public static final int BLOCK_COMMENT_END =
5720 JavaLanguageLexer.BLOCK_COMMENT_END;
5721
5722 /**
5723 * Text of single-line or block comment.
5724 *
5725 * <p>For example:</p>
5726 * <pre>
5727 * //this is single-line comment
5728 *
5729 * /*
5730 * this is multiline comment
5731 * */
5732 * </pre>
5733 *
5734 * <p>parses as:</p>
5735 * <pre>
5736 * |--SINGLE_LINE_COMMENT -> //
5737 * | `--COMMENT_CONTENT -> this is single-line comment\n
5738 * |--BLOCK_COMMENT_BEGIN -> /*
5739 * | |--COMMENT_CONTENT -> \n\t\t\tthis is multiline comment\n\t\t
5740 * | `--BLOCK_COMMENT_END -> */
5741 * </pre>
5742 *
5743 */
5744 public static final int COMMENT_CONTENT =
5745 JavaLanguageLexer.COMMENT_CONTENT;
5746
5747 /**
5748 * A pattern variable definition; when conditionally matched,
5749 * this variable is assigned with the defined type.
5750 *
5751 * <p>For example:</p>
5752 * <pre>
5753 * if (obj instanceof String str) { }
5754 * </pre>
5755 *
5756 * <p>parses as:</p>
5757 * <pre>
5758 * LITERAL_IF -> if
5759 * |--LPAREN -> (
5760 * |--EXPR -> EXPR
5761 * | `--LITERAL_INSTANCEOF -> instanceof
5762 * | |--IDENT -> obj
5763 * | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
5764 * | |--TYPE -> TYPE
5765 * | | `--IDENT -> String
5766 * | `--IDENT -> str
5767 * |--RPAREN -> )
5768 * `--SLIST -> {
5769 * `--RCURLY -> }
5770 * </pre>
5771 *
5772 * @see #LITERAL_INSTANCEOF
5773 * @since 8.35
5774 */
5775 public static final int PATTERN_VARIABLE_DEF =
5776 JavaLanguageLexer.PATTERN_VARIABLE_DEF;
5777
5778 /**
5779 * The {@code record} keyword. This element appears
5780 * as part of a record declaration.
5781 *
5782 * <p>For example:</p>
5783 * <pre>
5784 * public record MyRecord () {
5785 *
5786 * }
5787 * </pre>
5788 *
5789 * <p>parses as:</p>
5790 * <pre>
5791 * RECORD_DEF -> RECORD_DEF
5792 * |--MODIFIERS -> MODIFIERS
5793 * | `--LITERAL_PUBLIC -> public
5794 * |--LITERAL_RECORD -> record
5795 * |--IDENT -> MyRecord
5796 * |--LPAREN -> (
5797 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS
5798 * |--RPAREN -> )
5799 * `--OBJBLOCK -> OBJBLOCK
5800 * |--LCURLY -> {
5801 * `--RCURLY -> }
5802 * </pre>
5803 *
5804 * @since 8.35
5805 **/
5806 public static final int LITERAL_RECORD =
5807 JavaLanguageLexer.LITERAL_RECORD;
5808
5809 /**
5810 * A declaration of a record specifies a name, a header, and a body.
5811 * The header lists the components of the record, which are the variables
5812 * that make up its state.
5813 *
5814 * <p>For example:</p>
5815 * <pre>
5816 * public record MyRecord () {
5817 *
5818 * }
5819 * </pre>
5820 *
5821 * <p>parses as:</p>
5822 * <pre>
5823 * RECORD_DEF -> RECORD_DEF
5824 * |--MODIFIERS -> MODIFIERS
5825 * | `--LITERAL_PUBLIC -> public
5826 * |--LITERAL_RECORD -> record
5827 * |--IDENT -> MyRecord
5828 * |--LPAREN -> (
5829 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS
5830 * |--RPAREN -> )
5831 * `--OBJBLOCK -> OBJBLOCK
5832 * |--LCURLY -> {
5833 * `--RCURLY -> }
5834 * </pre>
5835 *
5836 * @since 8.35
5837 */
5838 public static final int RECORD_DEF =
5839 JavaLanguageLexer.RECORD_DEF;
5840
5841 /**
5842 * Record components are a (possibly empty) list containing the components of a record, which
5843 * are the variables that make up its state.
5844 *
5845 * <p>For example:</p>
5846 * <pre>
5847 * public record myRecord (Comp x, Comp y) { }
5848 * </pre>
5849 *
5850 * <p>parses as:</p>
5851 * <pre>
5852 * RECORD_DEF -> RECORD_DEF
5853 * |--MODIFIERS -> MODIFIERS
5854 * | `--LITERAL_PUBLIC -> public
5855 * |--LITERAL_RECORD -> record
5856 * |--IDENT -> myRecord
5857 * |--LPAREN -> (
5858 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS
5859 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
5860 * | | |--ANNOTATIONS -> ANNOTATIONS
5861 * | | |--TYPE -> TYPE
5862 * | | | `--IDENT -> Comp
5863 * | | `--IDENT -> x
5864 * | |--COMMA -> ,
5865 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
5866 * | |--ANNOTATIONS -> ANNOTATIONS
5867 * | |--TYPE -> TYPE
5868 * | | `--IDENT -> Comp
5869 * | `--IDENT -> y
5870 * |--RPAREN -> )
5871 * `--OBJBLOCK -> OBJBLOCK
5872 * |--LCURLY -> {
5873 * `--RCURLY -> }
5874 * </pre>
5875 *
5876 * @since 8.36
5877 */
5878 public static final int RECORD_COMPONENTS =
5879 JavaLanguageLexer.RECORD_COMPONENTS;
5880
5881 /**
5882 * A record component is a variable that comprises the state of a record. Record components
5883 * have annotations (possibly), a type definition, and an identifier. They can also be of
5884 * variable arity ('...').
5885 *
5886 * <p>For example:</p>
5887 * <pre>
5888 * public record MyRecord(Comp x, Comp... comps) {
5889 *
5890 * }
5891 * </pre>
5892 *
5893 * <p>parses as:</p>
5894 * <pre>
5895 * RECORD_DEF -> RECORD_DEF
5896 * |--MODIFIERS -> MODIFIERS
5897 * | `--LITERAL_PUBLIC -> public
5898 * |--LITERAL_RECORD -> record
5899 * |--IDENT -> MyRecord
5900 * |--LPAREN -> (
5901 * |--RECORD_COMPONENTS -> RECORD_COMPONENTS
5902 * | |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
5903 * | | |--ANNOTATIONS -> ANNOTATIONS
5904 * | | |--TYPE -> TYPE
5905 * | | | `--IDENT -> Comp
5906 * | | `--IDENT -> x
5907 * | |--COMMA -> ,
5908 * | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
5909 * | |--ANNOTATIONS -> ANNOTATIONS
5910 * | |--TYPE -> TYPE
5911 * | | `--IDENT -> Comp
5912 * | |--ELLIPSIS -> ...
5913 * | `--IDENT -> comps
5914 * |--RPAREN -> )
5915 * `--OBJBLOCK -> OBJBLOCK
5916 * |--LCURLY -> {
5917 * `--RCURLY -> }
5918 * </pre>
5919 *
5920 * @since 8.36
5921 */
5922 public static final int RECORD_COMPONENT_DEF =
5923 JavaLanguageLexer.RECORD_COMPONENT_DEF;
5924
5925 /**
5926 * A compact canonical constructor eliminates the list of formal parameters; they are
5927 * declared implicitly.
5928 *
5929 * <p>For example:</p>
5930 * <pre>
5931 * public record myRecord () {
5932 * public myRecord{}
5933 * }
5934 * </pre>
5935 *
5936 * <p>parses as:</p>
5937 * <pre>
5938 * RECORD_DEF
5939 * |--MODIFIERS
5940 * | `--LITERAL_PUBLIC (public)
5941 * |--LITERAL_RECORD (record)
5942 * |--IDENT (myRecord)
5943 * |--LPAREN (()
5944 * |--RECORD_COMPONENTS
5945 * |--RPAREN ())
5946 * `--OBJBLOCK
5947 * |--LCURLY ({)
5948 * |--COMPACT_CTOR_DEF
5949 * | |--MODIFIERS
5950 * | | `--LITERAL_PUBLIC (public)
5951 * | |--IDENT (myRecord)
5952 * | `--SLIST ({)
5953 * | `--RCURLY (})
5954 * `--RCURLY (})
5955 * </pre>
5956 *
5957 * @since 8.36
5958 */
5959 public static final int COMPACT_CTOR_DEF =
5960 JavaLanguageLexer.COMPACT_CTOR_DEF;
5961
5962 /**
5963 * Text blocks are a new feature added to to Java SE 15 and later
5964 * that will make writing multi-line strings much easier and cleaner.
5965 * Beginning of a Java 15 Text Block literal,
5966 * delimited by three double quotes.
5967 *
5968 * <p>For example:</p>
5969 * <pre>
5970 * String hello = """
5971 * Hello, world!
5972 * """;
5973 * </pre>
5974 *
5975 * <p>parses as:</p>
5976 * <pre>
5977 * |--VARIABLE_DEF -> VARIABLE_DEF
5978 * | |--MODIFIERS -> MODIFIERS
5979 * | |--TYPE -> TYPE
5980 * | | `--IDENT -> String
5981 * | |--IDENT -> hello
5982 * | `--ASSIGN -> =
5983 * | `--EXPR -> EXPR
5984 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """
5985 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n
5986 * | `--TEXT_BLOCK_LITERAL_END -> """
5987 * `--SEMI -> ;
5988 * </pre>
5989 *
5990 * @since 8.36
5991 */
5992 public static final int TEXT_BLOCK_LITERAL_BEGIN =
5993 JavaLanguageLexer.TEXT_BLOCK_LITERAL_BEGIN;
5994
5995 /**
5996 * Content of a Java 15 text block. This is a
5997 * sequence of characters, possibly escaped with '\'. Actual line terminators
5998 * are represented by '\n'.
5999 *
6000 * <p>For example:</p>
6001 * <pre>
6002 * String hello = """
6003 * Hello, world!
6004 * """;
6005 * </pre>
6006 *
6007 * <p>parses as:</p>
6008 * <pre>
6009 * |--VARIABLE_DEF -> VARIABLE_DEF
6010 * | |--MODIFIERS -> MODIFIERS
6011 * | |--TYPE -> TYPE
6012 * | | `--IDENT -> String
6013 * | |--IDENT -> hello
6014 * | `--ASSIGN -> =
6015 * | `--EXPR -> EXPR
6016 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """
6017 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n
6018 * | `--TEXT_BLOCK_LITERAL_END -> """
6019 * `--SEMI -> ;
6020 * </pre>
6021 *
6022 * @since 8.36
6023 */
6024 public static final int TEXT_BLOCK_CONTENT =
6025 JavaLanguageLexer.TEXT_BLOCK_CONTENT;
6026
6027 /**
6028 * End of a Java 15 text block literal, delimited by three
6029 * double quotes.
6030 *
6031 * <p>For example:</p>
6032 * <pre>
6033 * String hello = """
6034 * Hello, world!
6035 * """;
6036 * </pre>
6037 *
6038 * <p>parses as:</p>
6039 * <pre>
6040 * |--VARIABLE_DEF -> VARIABLE_DEF
6041 * | |--MODIFIERS -> MODIFIERS
6042 * | |--TYPE -> TYPE
6043 * | | `--IDENT -> String
6044 * | |--IDENT -> hello
6045 * | `--ASSIGN -> =
6046 * | `--EXPR -> EXPR
6047 * | `--TEXT_BLOCK_LITERAL_BEGIN -> """
6048 * | |--TEXT_BLOCK_CONTENT -> \n Hello, world!\n
6049 * | `--TEXT_BLOCK_LITERAL_END -> """
6050 * `--SEMI -> ;
6051 * </pre>
6052 *
6053 * @since 8.36
6054 */
6055 public static final int TEXT_BLOCK_LITERAL_END =
6056 JavaLanguageLexer.TEXT_BLOCK_LITERAL_END;
6057
6058 /**
6059 * The {@code yield} keyword. This element appears
6060 * as part of a yield statement.
6061 *
6062 * <p>For example:</p>
6063 * <pre>
6064 * int yield = 0; // not a keyword here
6065 * return switch (mode) {
6066 * case "a", "b":
6067 * yield 1;
6068 * default:
6069 * yield - 1;
6070 * };
6071 * </pre>
6072 *
6073 * <p>parses as:</p>
6074 * <pre>
6075 * |--VARIABLE_DEF -> VARIABLE_DEF
6076 * | |--MODIFIERS -> MODIFIERS
6077 * | |--TYPE -> TYPE
6078 * | | `--LITERAL_INT -> int
6079 * | |--IDENT -> yield
6080 * | `--ASSIGN -> =
6081 * | `--EXPR -> EXPR
6082 * | `--NUM_INT -> 0
6083 * |--SEMI -> ;
6084 * |--LITERAL_RETURN -> return
6085 * | |--EXPR -> EXPR
6086 * | | `--LITERAL_SWITCH -> switch
6087 * | | |--LPAREN -> (
6088 * | | |--EXPR -> EXPR
6089 * | | | `--IDENT -> mode
6090 * | | |--RPAREN -> )
6091 * | | |--LCURLY -> {
6092 * | | |--CASE_GROUP -> CASE_GROUP
6093 * | | | |--LITERAL_CASE -> case
6094 * | | | | |--EXPR -> EXPR
6095 * | | | | | `--STRING_LITERAL -> "a"
6096 * | | | | |--COMMA -> ,
6097 * | | | | |--EXPR -> EXPR
6098 * | | | | | `--STRING_LITERAL -> "b"
6099 * | | | | `--COLON -> :
6100 * | | | `--SLIST -> SLIST
6101 * | | | `--LITERAL_YIELD -> yield
6102 * | | | |--EXPR -> EXPR
6103 * | | | | `--NUM_INT -> 1
6104 * | | | `--SEMI -> ;
6105 * | | |--CASE_GROUP -> CASE_GROUP
6106 * | | | |--LITERAL_DEFAULT -> default
6107 * | | | | `--COLON -> :
6108 * | | | `--SLIST -> SLIST
6109 * | | | `--LITERAL_YIELD -> yield
6110 * | | | |--EXPR -> EXPR
6111 * | | | | `--UNARY_MINUS -> -
6112 * | | | | `--NUM_INT -> 1
6113 * | | | `--SEMI -> ;
6114 * | | `--RCURLY -> }
6115 * | `--SEMI -> ;
6116 * </pre>
6117 *
6118 *
6119 * @see #LITERAL_SWITCH
6120 * @see #CASE_GROUP
6121 * @see #SLIST
6122 * @see #SWITCH_RULE
6123 *
6124 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html">
6125 * Java Language Specification, §14.21</a>
6126 *
6127 * @since 8.36
6128 */
6129 public static final int LITERAL_YIELD =
6130 JavaLanguageLexer.LITERAL_YIELD;
6131
6132 /**
6133 * Switch Expressions.
6134 *
6135 * <p>For example:</p>
6136 * <pre>
6137 * return switch (day) {
6138 * case SAT, SUN -> "Weekend";
6139 * default -> "Working day";
6140 * };
6141 * </pre>
6142 *
6143 * <p>parses as:</p>
6144 * <pre>
6145 * LITERAL_RETURN -> return
6146 * |--EXPR -> EXPR
6147 * | `--LITERAL_SWITCH -> switch
6148 * | |--LPAREN -> (
6149 * | |--EXPR -> EXPR
6150 * | | `--IDENT -> day
6151 * | |--RPAREN -> )
6152 * | |--LCURLY -> {
6153 * | |--SWITCH_RULE -> SWITCH_RULE
6154 * | | |--LITERAL_CASE -> case
6155 * | | | |--EXPR -> EXPR
6156 * | | | | `--IDENT -> SAT
6157 * | | | |--COMMA -> ,
6158 * | | | `--EXPR -> EXPR
6159 * | | | `--IDENT -> SUN
6160 * | | |--LAMBDA -> ->
6161 * | | |--EXPR -> EXPR
6162 * | | | `--STRING_LITERAL -> "Weekend"
6163 * | | `--SEMI -> ;
6164 * | |--SWITCH_RULE -> SWITCH_RULE
6165 * | | |--LITERAL_DEFAULT -> default
6166 * | | |--LAMBDA -> ->
6167 * | | |--EXPR -> EXPR
6168 * | | | `--STRING_LITERAL -> "Working day"
6169 * | | `--SEMI -> ;
6170 * | `--RCURLY -> }
6171 * `--SEMI -> ;
6172 * </pre>
6173 *
6174 * @see #LITERAL_CASE
6175 * @see #LITERAL_DEFAULT
6176 * @see #LITERAL_SWITCH
6177 * @see #LITERAL_YIELD
6178 *
6179 * @see <a href="https://docs.oracle.com/javase/specs/jls/se13/preview/switch-expressions.html">
6180 * Java Language Specification, §14.21</a>
6181 *
6182 * @since 8.36
6183 */
6184 public static final int SWITCH_RULE =
6185 JavaLanguageLexer.SWITCH_RULE;
6186
6187 /**
6188 * The {@code non-sealed} keyword. This element appears
6189 * as part of a class or interface declaration.
6190 *
6191 * <p>For example:</p>
6192 * <pre>
6193 * non-sealed class Square extends Rectangle { }
6194 * </pre>
6195 *
6196 * <p>parses as:</p>
6197 * <pre>
6198 * CLASS_DEF -> CLASS_DEF
6199 * |--MODIFIERS -> MODIFIERS
6200 * | `--LITERAL_NON_SEALED -> non-sealed
6201 * |--LITERAL_CLASS -> class
6202 * |--IDENT -> Square
6203 * |--EXTENDS_CLAUSE -> extends
6204 * | `--IDENT -> Rectangle
6205 * `--OBJBLOCK -> OBJBLOCK
6206 * |--LCURLY -> {
6207 * `--RCURLY -> }
6208 * </pre>
6209 *
6210 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html">
6211 * Java Language Specification, §8.1.1.2</a>
6212 * @see #MODIFIERS
6213 *
6214 * @since 8.42
6215 */
6216 public static final int LITERAL_NON_SEALED =
6217 JavaLanguageLexer.LITERAL_NON_SEALED;
6218
6219 /**
6220 * The {@code sealed} restricted identifier. This element appears
6221 * as part of a class or interface declaration.
6222 *
6223 * <p>For example:</p>
6224 * <pre>
6225 * public sealed class Shape permits Circle, Square, Rectangle { }
6226 * </pre>
6227 *
6228 * <p>parses as:</p>
6229 * <pre>
6230 * CLASS_DEF -> CLASS_DEF
6231 * |--MODIFIERS -> MODIFIERS
6232 * | |--LITERAL_PUBLIC -> public
6233 * | `--LITERAL_SEALED -> sealed
6234 * |--LITERAL_CLASS -> class
6235 * |--IDENT -> Shape
6236 * |--PERMITS_CLAUSE -> permits
6237 * | |--IDENT -> Circle
6238 * | |--COMMA -> ,
6239 * | |--IDENT -> Square
6240 * | |--COMMA -> ,
6241 * | `--IDENT -> Rectangle
6242 * `--OBJBLOCK -> OBJBLOCK
6243 * |--LCURLY -> {
6244 * `--RCURLY -> }
6245 * </pre>
6246 *
6247 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html">
6248 * Java Language Specification, §8.1.1.2</a>
6249 * @see #MODIFIERS
6250 *
6251 * @since 8.42
6252 */
6253 public static final int LITERAL_SEALED =
6254 JavaLanguageLexer.LITERAL_SEALED;
6255
6256 /**
6257 * The {@code permits} restricted identifier. This element appears
6258 * as part of a class or interface declaration.
6259 *
6260 * <p>For example:</p>
6261 * <pre>
6262 * public sealed class Shape permits Circle, Square, Rectangle { }
6263 * </pre>
6264 *
6265 * <p>parses as:</p>
6266 * <pre>
6267 * CLASS_DEF -> CLASS_DEF
6268 * |--MODIFIERS -> MODIFIERS
6269 * | |--LITERAL_PUBLIC -> public
6270 * | `--LITERAL_SEALED -> sealed
6271 * |--LITERAL_CLASS -> class
6272 * |--IDENT -> Shape
6273 * |--PERMITS_CLAUSE -> permits
6274 * | |--IDENT -> Circle
6275 * | |--COMMA -> ,
6276 * | |--IDENT -> Square
6277 * | |--COMMA -> ,
6278 * | `--IDENT -> Rectangle
6279 * `--OBJBLOCK -> OBJBLOCK
6280 * |--LCURLY -> {
6281 * `--RCURLY -> }
6282 * </pre>
6283 *
6284 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html">
6285 * Java Language Specification, §9.1.4</a>
6286 * @see #MODIFIERS
6287 *
6288 * @since 8.42
6289 */
6290 public static final int LITERAL_PERMITS =
6291 JavaLanguageLexer.LITERAL_PERMITS;
6292
6293 /**
6294 * A permits clause. A permits clause's children are a comma separated list of one or
6295 * more identifiers.
6296 *
6297 * <p>For example:</p>
6298 * <pre>
6299 * public sealed class Shape permits Circle, Square, Rectangle { }
6300 * </pre>
6301 *
6302 * <p>parses as:</p>
6303 * <pre>
6304 * CLASS_DEF -> CLASS_DEF
6305 * |--MODIFIERS -> MODIFIERS
6306 * | |--LITERAL_PUBLIC -> public
6307 * | `--LITERAL_SEALED -> sealed
6308 * |--LITERAL_CLASS -> class
6309 * |--IDENT -> Shape
6310 * |--PERMITS_CLAUSE -> permits
6311 * | |--IDENT -> Circle
6312 * | |--COMMA -> ,
6313 * | |--IDENT -> Square
6314 * | |--COMMA -> ,
6315 * | `--IDENT -> Rectangle
6316 * `--OBJBLOCK -> OBJBLOCK
6317 * |--LCURLY -> {
6318 * `--RCURLY -> }
6319 * </pre>
6320 *
6321 * @see <a href="https://docs.oracle.com/en/java/javase/15/docs/specs/sealed-classes-jls.html">
6322 * Java Language Specification, §9.1.4</a>
6323 * @see #MODIFIERS
6324 * @see #CLASS_DEF
6325 * @see #INTERFACE_DEF
6326 * @see #COMMA
6327 * @see #IDENT
6328 *
6329 * @since 8.42
6330 */
6331 public static final int PERMITS_CLAUSE =
6332 JavaLanguageLexer.PERMITS_CLAUSE;
6333
6334 /**
6335 * A pattern definition, excluding simple type pattern (pattern variable)
6336 * definition such as {@code if (o instanceof Integer i){}}. Pattern definitions
6337 * appear as operands of statements and expressions.
6338 *
6339 * <p>For example:</p>
6340 * <pre>
6341 * switch(o) {
6342 * case String s when s.length() > 4: // guarded pattern, `PATTERN_DEF`
6343 * break;
6344 * case String s: // type pattern, no `PATTERN_DEF`
6345 * break;
6346 * }
6347 * </pre>
6348 *
6349 * <p>parses as:</p>
6350 * <pre>
6351 * LITERAL_SWITCH -> switch
6352 * | |--LPAREN -> (
6353 * | |--EXPR -> EXPR
6354 * | | `--IDENT -> o
6355 * | |--RPAREN -> )
6356 * | |--LCURLY -> {
6357 * | |--CASE_GROUP -> CASE_GROUP
6358 * | | |--LITERAL_CASE -> case
6359 * | | | |--PATTERN_DEF -> PATTERN_DEF
6360 * | | | | `--LITERAL_WHEN -> when
6361 * | | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6362 * | | | | | |--MODIFIERS -> MODIFIERS
6363 * | | | | | |--TYPE -> TYPE
6364 * | | | | | | `--IDENT -> String
6365 * | | | | | `--IDENT -> s
6366 * | | | | `--GT -> >
6367 * | | | | |--METHOD_CALL -> (
6368 * | | | | | |--DOT -> .
6369 * | | | | | | |--IDENT -> s
6370 * | | | | | | `--IDENT -> length
6371 * | | | | | |--ELIST -> ELIST
6372 * | | | | | `--RPAREN -> )
6373 * | | | | `--NUM_INT -> 4
6374 * | | | `--COLON -> :
6375 * | | `--SLIST -> SLIST
6376 * | | `--LITERAL_BREAK -> break
6377 * | | `--SEMI -> ;
6378 * | |--CASE_GROUP -> CASE_GROUP
6379 * | | |--LITERAL_CASE -> case
6380 * | | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6381 * | | | | |--MODIFIERS -> MODIFIERS
6382 * | | | | |--TYPE -> TYPE
6383 * | | | | | `--IDENT -> String
6384 * | | | | `--IDENT -> s
6385 * | | | `--COLON -> :
6386 * | | `--SLIST -> SLIST
6387 * | | `--LITERAL_BREAK -> break
6388 * | | `--SEMI -> ;
6389 * | `--RCURLY -> }
6390 * `--RCURLY -> }
6391 * </pre>
6392 *
6393 * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.30">
6394 * Java Language Specification, §14.30</a>
6395 * @see #LITERAL_SWITCH
6396 * @see #PATTERN_VARIABLE_DEF
6397 * @see #LITERAL_INSTANCEOF
6398 *
6399 * @since 9.3
6400 */
6401 public static final int PATTERN_DEF =
6402 JavaLanguageLexer.PATTERN_DEF;
6403
6404 /**
6405 * A {@code when} clause. Appears as part of a switch label in a guarded pattern definition.
6406 *
6407 * <p>For example:</p>
6408 * <pre>
6409 * return switch (o) {
6410 * case Integer i when i >= 0 -> i;
6411 * default -> 2;
6412 * };
6413 * </pre>
6414 *
6415 * <p>parses as:</p>
6416 * <pre>
6417 * LITERAL_RETURN -> return
6418 * `--EXPR -> EXPR
6419 * `--LITERAL_SWITCH -> switch
6420 * |--LPAREN -> (
6421 * |--EXPR -> EXPR
6422 * | `--IDENT -> o
6423 * |--RPAREN -> )
6424 * |--LCURLY -> {
6425 * |--SWITCH_RULE -> SWITCH_RULE
6426 * | |--LITERAL_CASE -> case
6427 * | | `--PATTERN_DEF -> PATTERN_DEF
6428 * | | `--LITERAL_WHEN -> when
6429 * | | |--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6430 * | | | |--MODIFIERS -> MODIFIERS
6431 * | | | |--TYPE -> TYPE
6432 * | | | | `--IDENT -> Integer
6433 * | | | `--IDENT -> i
6434 * | | `--GE -> >=
6435 * | | |--IDENT -> i
6436 * | | `--NUM_INT -> 0
6437 * | |--LAMBDA -> ->
6438 * | |--EXPR -> EXPR
6439 * | | `--IDENT -> i
6440 * | `--SEMI -> ;
6441 * |--SWITCH_RULE -> SWITCH_RULE
6442 * | |--LITERAL_DEFAULT -> default
6443 * | |--LAMBDA -> ->
6444 * | |--EXPR -> EXPR
6445 * | | `--NUM_INT -> 2
6446 * | `--SEMI -> ;
6447 * `--RCURLY -> }
6448 * </pre>
6449 *
6450 * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.30">
6451 * Java Language Specification, §14.30</a>
6452 * @see #LITERAL_SWITCH
6453 * @see #PATTERN_VARIABLE_DEF
6454 * @see #LITERAL_INSTANCEOF
6455 * @see #SWITCH_RULE
6456 *
6457 * @since 10.7.0
6458 */
6459 public static final int LITERAL_WHEN =
6460 JavaLanguageLexer.LITERAL_WHEN;
6461
6462 /**
6463 * A {@code record} pattern definition. A record pattern consists of a type,
6464 * a (possibly empty) record component pattern list which is used to match against
6465 * the corresponding record components, and an optional identifier. Appears as part of
6466 * an {@code instanceof} expression or a {@code case} label in a switch.
6467 *
6468 * <p>For example:</p>
6469 * <pre>
6470 * record R(Object o){}
6471 * if (o instanceof R(String s) myRecord) {}
6472 * switch (o) {
6473 * case R(String s) myRecord -> {}
6474 * }
6475 * </pre>
6476 *
6477 * <p>parses as:</p>
6478 * <pre>
6479 * |--RECORD_DEF -> RECORD_DEF
6480 * | |--MODIFIERS -> MODIFIERS
6481 * | |--LITERAL_RECORD -> record
6482 * | |--IDENT -> R
6483 * | |--LPAREN -> (
6484 * | |--RECORD_COMPONENTS -> RECORD_COMPONENTS
6485 * | | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
6486 * | | |--ANNOTATIONS -> ANNOTATIONS
6487 * | | |--TYPE -> TYPE
6488 * | | | `--IDENT -> Object
6489 * | | `--IDENT -> o
6490 * | |--RPAREN -> )
6491 * | `--OBJBLOCK -> OBJBLOCK
6492 * | |--LCURLY -> {
6493 * | `--RCURLY -> }
6494 * |--LITERAL_IF -> if
6495 * | |--LPAREN -> (
6496 * | |--EXPR -> EXPR
6497 * | | `--LITERAL_INSTANCEOF -> instanceof
6498 * | | |--IDENT -> o
6499 * | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6500 * | | |--MODIFIERS -> MODIFIERS
6501 * | | |--TYPE -> TYPE
6502 * | | | `--IDENT -> R
6503 * | | |--LPAREN -> (
6504 * | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6505 * | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6506 * | | | |--MODIFIERS -> MODIFIERS
6507 * | | | |--TYPE -> TYPE
6508 * | | | | `--IDENT -> String
6509 * | | | `--IDENT -> s
6510 * | | |--RPAREN -> )
6511 * | | `--IDENT -> myRecord
6512 * | |--RPAREN -> )
6513 * | `--SLIST -> {
6514 * | `--RCURLY -> }
6515 * |--LITERAL_SWITCH -> switch
6516 * | |--LPAREN -> (
6517 * | |--EXPR -> EXPR
6518 * | | `--IDENT -> o
6519 * | |--RPAREN -> )
6520 * | |--LCURLY -> {
6521 * | |--SWITCH_RULE -> SWITCH_RULE
6522 * | | |--LITERAL_CASE -> case
6523 * | | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6524 * | | | |--MODIFIERS -> MODIFIERS
6525 * | | | |--TYPE -> TYPE
6526 * | | | | `--IDENT -> R
6527 * | | | |--LPAREN -> (
6528 * | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6529 * | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6530 * | | | | |--MODIFIERS -> MODIFIERS
6531 * | | | | |--TYPE -> TYPE
6532 * | | | | | `--IDENT -> String
6533 * | | | | `--IDENT -> s
6534 * | | | |--RPAREN -> )
6535 * | | | `--IDENT -> myRecord
6536 * | | |--LAMBDA -> ->
6537 * | | `--SLIST -> {
6538 * | | `--RCURLY -> }
6539 * | `--RCURLY -> }
6540 * `--RCURLY -> }
6541 * </pre>
6542 *
6543 * @see <a href="https://openjdk.org/jeps/405">JEP 405: Record Patterns</a>
6544 * @see #LITERAL_WHEN
6545 * @see #PATTERN_VARIABLE_DEF
6546 * @see #LITERAL_INSTANCEOF
6547 * @see #SWITCH_RULE
6548 *
6549 * @since 10.12.0
6550 */
6551 public static final int RECORD_PATTERN_DEF =
6552 JavaLanguageLexer.RECORD_PATTERN_DEF;
6553
6554 /**
6555 * A (possibly empty) record component pattern list which is used to match against
6556 * the corresponding record components. Appears as part of a record pattern definition.
6557 *
6558 * <p>For example:</p>
6559 * <pre>
6560 * record R(Object o){}
6561 * if (o instanceof R(String myComponent)) {}
6562 * switch (o) {
6563 * case R(String myComponent) when "component".equalsIgnoreCase(myComponent) -> {}
6564 * }
6565 * </pre>
6566 *
6567 * <p>parses as:</p>
6568 * <pre>
6569 * |--RECORD_DEF -> RECORD_DEF
6570 * | |--MODIFIERS -> MODIFIERS
6571 * | |--LITERAL_RECORD -> record
6572 * | |--IDENT -> R
6573 * | |--LPAREN -> (
6574 * | |--RECORD_COMPONENTS -> RECORD_COMPONENTS
6575 * | | `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF
6576 * | | |--ANNOTATIONS -> ANNOTATIONS
6577 * | | |--TYPE -> TYPE
6578 * | | | `--IDENT -> Object
6579 * | | `--IDENT -> o
6580 * | |--RPAREN -> )
6581 * | `--OBJBLOCK -> OBJBLOCK
6582 * | |--LCURLY -> {
6583 * | `--RCURLY -> }
6584 * |--LITERAL_IF -> if
6585 * | |--LPAREN -> (
6586 * | |--EXPR -> EXPR
6587 * | | `--LITERAL_INSTANCEOF -> instanceof
6588 * | | |--IDENT -> o
6589 * | | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6590 * | | |--MODIFIERS -> MODIFIERS
6591 * | | |--TYPE -> TYPE
6592 * | | | `--IDENT -> R
6593 * | | |--LPAREN -> (
6594 * | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6595 * | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6596 * | | | |--MODIFIERS -> MODIFIERS
6597 * | | | |--TYPE -> TYPE
6598 * | | | | `--IDENT -> String
6599 * | | | `--IDENT -> myComponent
6600 * | | `--RPAREN -> )
6601 * | |--RPAREN -> )
6602 * | `--SLIST -> {
6603 * | `--RCURLY -> }
6604 * |--LITERAL_SWITCH -> switch
6605 * | |--LPAREN -> (
6606 * | |--EXPR -> EXPR
6607 * | | `--IDENT -> o
6608 * | |--RPAREN -> )
6609 * | |--LCURLY -> {
6610 * | |--SWITCH_RULE -> SWITCH_RULE
6611 * | | |--LITERAL_CASE -> case
6612 * | | | `--PATTERN_DEF -> PATTERN_DEF
6613 * | | | `--LITERAL_WHEN -> when
6614 * | | | |--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6615 * | | | | |--MODIFIERS -> MODIFIERS
6616 * | | | | |--TYPE -> TYPE
6617 * | | | | | `--IDENT -> R
6618 * | | | | |--LPAREN -> (
6619 * | | | | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6620 * | | | | | `--PATTERN_VARIABLE_DEF -> PATTERN_VARIABLE_DEF
6621 * | | | | | |--MODIFIERS -> MODIFIERS
6622 * | | | | | |--TYPE -> TYPE
6623 * | | | | | | `--IDENT -> String
6624 * | | | | | `--IDENT -> myComponent
6625 * | | | | `--RPAREN -> )
6626 * | | | `--METHOD_CALL -> (
6627 * | | | |--DOT -> .
6628 * | | | | |--STRING_LITERAL -> "component"
6629 * | | | | `--IDENT -> equalsIgnoreCase
6630 * | | | |--ELIST -> ELIST
6631 * | | | | `--EXPR -> EXPR
6632 * | | | | `--IDENT -> myComponent
6633 * | | | `--RPAREN -> )
6634 * | | |--LAMBDA -> ->
6635 * | | `--SLIST -> {
6636 * | | `--RCURLY -> }
6637 * | `--RCURLY -> }
6638 * `--RCURLY -> }
6639 * </pre>
6640 *
6641 * @see <a href="https://openjdk.org/jeps/405">JEP 405: Record Patterns</a>
6642 * @see #LITERAL_WHEN
6643 * @see #PATTERN_VARIABLE_DEF
6644 * @see #LITERAL_INSTANCEOF
6645 * @see #SWITCH_RULE
6646 *
6647 * @since 10.12.0
6648 */
6649 public static final int RECORD_PATTERN_COMPONENTS =
6650 JavaLanguageLexer.RECORD_PATTERN_COMPONENTS;
6651
6652 /**
6653 * An unnamed pattern variable definition. Appears as part of a pattern definition.
6654 *
6655 * <p>For example:</p>
6656 * <pre>
6657 * if (r instanceof R(_)) {}
6658 * </pre>
6659 *
6660 * <p>parses as:</p>
6661 * <pre>
6662 * LITERAL_IF -> if
6663 * |--LPAREN -> (
6664 * |--EXPR -> EXPR
6665 * | `--LITERAL_INSTANCEOF -> instanceof
6666 * | |--IDENT -> r
6667 * | `--RECORD_PATTERN_DEF -> RECORD_PATTERN_DEF
6668 * | |--MODIFIERS -> MODIFIERS
6669 * | |--TYPE -> TYPE
6670 * | | `--IDENT -> R
6671 * | |--LPAREN -> (
6672 * | |--RECORD_PATTERN_COMPONENTS -> RECORD_PATTERN_COMPONENTS
6673 * | | `--UNNAMED_PATTERN_DEF -> _
6674 * | `--RPAREN -> )
6675 * |--RPAREN -> )
6676 * `--SLIST -> {
6677 * `--RCURLY -> }
6678 * </pre>
6679 *
6680 * @see #RECORD_PATTERN_COMPONENTS
6681 * @see #RECORD_PATTERN_DEF
6682 * @see #LITERAL_SWITCH
6683 * @see #LITERAL_INSTANCEOF
6684 * @see #SWITCH_RULE
6685 * @see #LITERAL_WHEN
6686 * @see #PATTERN_VARIABLE_DEF
6687 * @see #PATTERN_DEF
6688 *
6689 * @since 10.14.0
6690 */
6691 public static final int UNNAMED_PATTERN_DEF =
6692 JavaLanguageLexer.UNNAMED_PATTERN_DEF;
6693
6694 /** Prevent instantiation. */
6695 private TokenTypes() {
6696 }
6697
6698 }