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