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