View Javadoc
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 -&gt; COMPILATION_UNIT
51       * |--IMPORT -&gt; import
52       * |   |--DOT -&gt; .
53       * |   |   |--DOT -&gt; .
54       * |   |   |   |--IDENT -&gt; java
55       * |   |   |   `--IDENT -&gt; util
56       * |   |   `--IDENT -&gt; List
57       * |   `--SEMI -&gt; ;
58       * |--CLASS_DEF -&gt; CLASS_DEF
59       * |   |--MODIFIERS -&gt; MODIFIERS
60       * |   |--LITERAL_CLASS -&gt; class
61       * |   |--IDENT -&gt; MyClass
62       * |   `--OBJBLOCK -&gt; OBJBLOCK
63       * |       |--LCURLY -&gt; {
64       * |       `--RCURLY -&gt; }
65       * |--INTERFACE_DEF -&gt; INTERFACE_DEF
66       * |   |--MODIFIERS -&gt; MODIFIERS
67       * |   |--LITERAL_INTERFACE -&gt; interface
68       * |   |--IDENT -&gt; MyInterface
69       * |   `--OBJBLOCK -&gt; OBJBLOCK
70       * |       |--LCURLY -&gt; {
71       * |       `--RCURLY -&gt; }
72       * `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
95       *  |--MODIFIERS -&gt; MODIFIERS
96       *  |   `--LITERAL_PUBLIC -&gt; public
97       *  |--TYPE -&gt; TYPE
98       *  |   `--LITERAL_INT -&gt; int
99       *  |--IDENT -&gt; x
100      *  `--SEMI -&gt; ;
101      * </pre>
102      *
103      * @see <a
104      * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java
105      * Language Specification, &sect;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 -&gt; CLASS_DEF
134      * |--MODIFIERS -&gt; MODIFIERS
135      * |--LITERAL_CLASS -&gt; class
136      * |--IDENT -&gt; Test
137      * `--OBJBLOCK -&gt; OBJBLOCK
138      *     |--LCURLY -&gt; {
139      *     `--RCURLY -&gt; }
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 -&gt; if
169      *  |--LPAREN -&gt; (
170      *  |--EXPR -&gt; EXPR
171      *  |   `--EQUAL -&gt; ==
172      *  |       |--IDENT -&gt; c
173      *  |       `--NUM_INT -&gt; 1
174      *  |--RPAREN -&gt; )
175      *  `--SLIST -&gt; {
176      *      |--EXPR -&gt; EXPR
177      *      |   `--ASSIGN -&gt; =
178      *      |       |--IDENT -&gt; c
179      *      |       `--NUM_INT -&gt; 0
180      *      |--SEMI -&gt; ;
181      *      `--RCURLY -&gt; }
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 -&gt; CTOR_DEF
213      *  |--MODIFIERS -&gt; MODIFIERS
214      *  |   `--LITERAL_PUBLIC -&gt; public
215      *  |--IDENT -&gt; SpecialEntry
216      *  |--LPAREN -&gt; (
217      *  |--PARAMETERS -&gt; PARAMETERS
218      *  |   |--PARAMETER_DEF -&gt; PARAMETER_DEF
219      *  |   |   |--MODIFIERS -&gt; MODIFIERS
220      *  |   |   |--TYPE -&gt; TYPE
221      *  |   |   |   `--LITERAL_INT -&gt; int
222      *  |   |   `--IDENT -&gt; value
223      *  |   |--COMMA -&gt; ,
224      *  |   `--PARAMETER_DEF -&gt; PARAMETER_DEF
225      *  |       |--MODIFIERS -&gt; MODIFIERS
226      *  |       |--TYPE -&gt; TYPE
227      *  |       |   `--IDENT -&gt; String
228      *  |       `--IDENT -&gt; text
229      *  |--RPAREN -&gt; )
230      *  `--SLIST -&gt; {
231      *      |--EXPR -&gt; EXPR
232      *      |   `--ASSIGN -&gt; =
233      *      |       |--DOT -&gt; .
234      *      |   |--LITERAL_THIS -&gt; this
235      *      |       |   `--IDENT -&gt; value
236      *      |       `--IDENT -&gt; value
237      *      |--SEMI -&gt; ;
238      *      |--EXPR -&gt; EXPR
239      *      |   `--ASSIGN -&gt; =
240      *      |       |--DOT -&gt; .
241      *      |       |   |--LITERAL_THIS -&gt; this
242      *      |       |   `--IDENT -&gt; text
243      *      |       `--IDENT -&gt; text
244      *      |--SEMI -&gt; ;
245      *      `--RCURLY -&gt; }
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 -&gt; METHOD_DEF
274      *    |--MODIFIERS -&gt; MODIFIERS
275      *    |   |--LITERAL_PUBLIC -&gt; public
276      *    |   `--LITERAL_STATIC -&gt; static
277      *    |--TYPE -&gt; TYPE
278      *    |   `--LITERAL_INT -&gt; int
279      *    |--IDENT -&gt; square
280      *    |--LPAREN -&gt; (
281      *    |--PARAMETERS -&gt; PARAMETERS
282      *    |   `--PARAMETER_DEF -&gt; PARAMETER_DEF
283      *    |       |--MODIFIERS -&gt; MODIFIERS
284      *    |       |--TYPE -&gt; TYPE
285      *    |       |   `--LITERAL_INT -&gt; int
286      *    |       `--IDENT -&gt; x
287      *    |--RPAREN -&gt; )
288      *    `--SLIST -&gt; {
289      *        |--LITERAL_RETURN -&gt; return
290      *        |   |--EXPR -&gt; EXPR
291      *        |   |   `--STAR -&gt; *
292      *        |   |       |--IDENT -&gt; x
293      *        |   |       `--IDENT -&gt; x
294      *        |   `--SEMI -&gt; ;
295      *        `--RCURLY -&gt; }
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 -&gt; VARIABLE_DEF
320      *  |--MODIFIERS -&gt; MODIFIERS
321      *  |   `--FINAL -&gt; final
322      *  |--TYPE -&gt; TYPE
323      *  |   `--LITERAL_DOUBLE -&gt; int
324      *  |--IDENT -&gt; PI
325      *  |--ASSIGN -&gt; =
326      *  |   `--EXPR -&gt; EXPR
327      *  |       `--NUM_FLOAT -&gt; 3.14
328      *  `--SEMI -&gt; ;
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 -&gt; CLASS_DEF
354      *  |--MODIFIERS -&gt; MODIFIERS
355      *  |   `--LITERAL_PUBLIC -&gt; public
356      *  |--LITERAL_CLASS -&gt; class
357      *  |--IDENT -&gt; MyClass
358      *  `--OBJBLOCK -&gt; OBJBLOCK
359      *      |--LCURLY -&gt; {
360      *      |--VARIABLE_DEF -&gt; VARIABLE_DEF
361      *      |   |--MODIFIERS -&gt; MODIFIERS
362      *      |   |   `--LITERAL_PRIVATE -&gt; private
363      *      |   |--TYPE -&gt; TYPE
364      *      |   |   `--LITERAL_INT -&gt; int
365      *      |   |--IDENT -&gt; foo
366      *      |   `--SEMI -&gt; ;
367      *      |--INSTANCE_INIT -&gt; INSTANCE_INIT
368      *      |   `--SLIST -&gt; {
369      *      |       |--EXPR -&gt; EXPR
370      *      |       |   `--ASSIGN -&gt; =
371      *      |       |       |--IDENT -&gt; foo
372      *      |       |       `--NUM_INT -&gt; 10
373      *      |       |--SEMI -&gt; ;
374      *      |       `--RCURLY -&gt; }
375      *      `--RCURLY -&gt; }
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&sect;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 -&gt; STATIC_INIT
402      *  `--SLIST -&gt; {
403      *      |--EXPR -&gt; EXPR
404      *      |   `--ASSIGN -&gt; =
405      *      |       |--IDENT -&gt; num
406      *      |       `--NUM_INT -&gt; 10
407      *      |--SEMI -&gt; ;
408      *      `--RCURLY -&gt; }
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, &sect;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 -&gt; VARIABLE_DEF
432      * |   |--MODIFIERS -&gt; MODIFIERS
433      * |   |--TYPE -&gt; TYPE
434      * |   |   `--LITERAL_BOOLEAN -&gt; boolean
435      * |   |--IDENT -&gt; var
436      * |   `--ASSIGN -&gt; =
437      * |       `--EXPR -&gt; EXPR
438      * |           `--LITERAL_TRUE -&gt; true
439      * |--SEMI -&gt; ;
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 -&gt; CLASS_DEF
471      * |--MODIFIERS -&gt; MODIFIERS
472      * |   `--LITERAL_PUBLIC -&gt; public
473      * |--LITERAL_CLASS -&gt; class
474      * |--IDENT -&gt; Test
475      * `--OBJBLOCK -&gt; OBJBLOCK
476      *     |--LCURLY -&gt; {
477      *     `--RCURLY -&gt; }
478      * </pre>
479      *
480      * @see <a
481      * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java
482      * Language Specification, &sect;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 -&gt; INTERFACE_DEF
506      * |--MODIFIERS -&gt; MODIFIERS
507      * |   `--LITERAL_PUBLIC -&gt; public
508      * |--LITERAL_INTERFACE -&gt; interface
509      * |--IDENT -&gt; MyInterface
510      * `--OBJBLOCK -&gt; OBJBLOCK
511      *     |--LCURLY -&gt; {
512      *     `--RCURLY -&gt; }
513      * </pre>
514      *
515      * @see <a
516      * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html">Java
517      * Language Specification, &sect;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 -&gt; package
543      * |--ANNOTATIONS -&gt; ANNOTATIONS
544      * |--DOT -&gt; .
545      * |   |--DOT -&gt; .
546      * |   |   |--DOT -&gt; .
547      * |   |   |   |--DOT -&gt; .
548      * |   |   |   |   |--IDENT -&gt; com
549      * |   |   |   |   `--IDENT -&gt; puppycrawl
550      * |   |   |   `--IDENT -&gt; tools
551      * |   |   `--IDENT -&gt; checkstyle
552      * |   `--IDENT -&gt; api
553      * `--SEMI -&gt; ;
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 &sect;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 -&gt; VARIABLE_DEF
582      *  |--MODIFIERS -&gt; MODIFIERS
583      *  |--TYPE -&gt; TYPE
584      *  |   |--LITERAL_INT -&gt; int
585      *  |   `--ARRAY_DECLARATOR -&gt; [
586      *  |       `--RBRACK -&gt; ]
587      *  |--IDENT -&gt; x
588      *  `--SEMI -&gt; ;
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 &sect;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 -&gt; CLASS_DEF
619      * |--MODIFIERS -&gt; MODIFIERS
620      * |   `--LITERAL_PUBLIC -&gt; public
621      * |--LITERAL_CLASS -&gt; class
622      * |--IDENT -&gt; Test
623      * |--EXTENDS_CLAUSE -&gt; extends
624      * |   `--IDENT -&gt; ArrayList
625      * `--OBJBLOCK -&gt; OBJBLOCK
626      *     |--LCURLY -&gt; {
627      *     `--RCURLY -&gt; }
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 -&gt; CLASS_DEF
654      * |--MODIFIERS -&gt; MODIFIERS
655      * |   `--LITERAL_PUBLIC -&gt; public
656      * |--LITERAL_CLASS -&gt; class
657      * |--IDENT -&gt; MyClass
658      * |--IMPLEMENTS_CLAUSE -&gt; implements
659      * |   `--IDENT -&gt; Collection
660      * `--OBJBLOCK -&gt; OBJBLOCK
661      *     |--LCURLY -&gt; {
662      *     `--RCURLY -&gt; }
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 -&gt; PARAMETERS
685      *  |--PARAMETER_DEF -&gt; PARAMETER_DEF
686      *  |   |--MODIFIERS -&gt; MODIFIERS
687      *  |   |--TYPE -&gt; TYPE
688      *  |   |   `--LITERAL_INT -&gt; int
689      *  |   `--IDENT -&gt; start
690      *  |--COMMA -&gt; ,
691      *  `--PARAMETER_DEF -&gt; PARAMETER_DEF
692      *      |--MODIFIERS -&gt; MODIFIERS
693      *      |--TYPE -&gt; TYPE
694      *      |   `--LITERAL_INT -&gt; int
695      *      `--IDENT -&gt; 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 -&gt; METHOD_DEF
715      *  |--MODIFIERS -&gt; MODIFIERS
716      *  |--TYPE -&gt; TYPE
717      *  |   `--LITERAL_VOID -&gt; void
718      *  |--IDENT -&gt; foo
719      *  |--LPAREN -&gt; (
720      *  |--PARAMETERS -&gt; PARAMETERS
721      *  |   |--PARAMETER_DEF -&gt; PARAMETER_DEF
722      *  |   |   |--MODIFIERS -&gt; MODIFIERS
723      *  |   |   |--TYPE -&gt; TYPE
724      *  |   |   |   `--IDENT -&gt; SomeType
725      *  |   |   `--DOT -&gt; .
726      *  |   |       |--IDENT -&gt; SomeType
727      *  |   |       `--LITERAL_THIS -&gt; this
728      *  |   |--COMMA -&gt; ,
729      *  |   |--PARAMETER_DEF -&gt; PARAMETER_DEF
730      *  |   |   |--MODIFIERS -&gt; MODIFIERS
731      *  |   |   |--TYPE -&gt; TYPE
732      *  |   |   |   `--LITERAL_INT -&gt; int
733      *  |   |   `--IDENT -&gt; firstParameter
734      *  |   |--COMMA -&gt; ,
735      *  |   `--PARAMETER_DEF -&gt; PARAMETER_DEF
736      *  |       |--MODIFIERS -&gt; MODIFIERS
737      *  |       |--TYPE -&gt; TYPE
738      *  |       |   `--LITERAL_INT -&gt; int
739      *  |       |--ELLIPSIS -&gt; ...
740      *  |       `--IDENT -&gt; secondParameter
741      *  |--RPAREN -&gt; )
742      *  `--SLIST -&gt; {
743      *      `--RCURLY -&gt; }
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 &lt; 10) {
763      *     if (i == 5)
764      *         continue outer;
765      *     i++;
766      * }
767      * </pre>
768      * <p>parses as:</p>
769      * <pre>
770      * LABELED_STAT -&gt; :
771      *  |--IDENT -&gt; outer
772      *  `--LITERAL_WHILE -&gt; while
773      *      |--LPAREN -&gt; (
774      *      |--EXPR -&gt; EXPR
775      *      |   `--LT -&gt; &lt;
776      *      |       |--IDENT -&gt; i
777      *      |       `--NUM_INT -&gt; 10
778      *      |--RPAREN -&gt; )
779      *      `--SLIST -&gt; {
780      *          |--LITERAL_IF -&gt; if
781      *          |   |--LPAREN -&gt; (
782      *          |   |--EXPR -&gt; EXPR
783      *          |   |   `--EQUAL -&gt; ==
784      *          |   |       |--IDENT -&gt; i
785      *          |   |       `--NUM_INT -&gt; 5
786      *          |   |--RPAREN -&gt; )
787      *          |   `--LITERAL_CONTINUE -&gt; continue
788      *          |       |--IDENT -&gt; outer
789      *          |       `--SEMI -&gt; ;
790      *          |--EXPR -&gt; EXPR
791      *          |   `--POST_INC -&gt; ++
792      *          |       `--IDENT -&gt; i
793      *          |--SEMI -&gt; ;
794      *          `--RCURLY -&gt; }
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, &sect;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 -&gt; (
815      *     |--TYPE -&gt; TYPE
816      *     |   `--IDENT -&gt; String
817      *     |--RPAREN -&gt; )
818      *     `--METHOD_CALL -&gt; (
819      *         |--DOT -&gt; .
820      *         |   |--IDENT -&gt; it
821      *         |   `--IDENT -&gt; next
822      *         |--ELIST -&gt; ELIST
823      *         `--RPAREN -&gt; )
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, &sect;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 -&gt; EXPR
845      * |   `--ASSIGN -&gt; =
846      * |       |--INDEX_OP -&gt; [
847      * |       |   |--IDENT -&gt; arr
848      * |       |   |--EXPR -&gt; EXPR
849      * |       |   |   `--NUM_INT -&gt; 0
850      * |       |   `--RBRACK -&gt; ]
851      * |       `--NUM_INT -&gt; 10
852      * |--SEMI -&gt; ;
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 -&gt; EXPR
868      * |   `--POST_INC -&gt; ++
869      * |       `--IDENT -&gt; a
870      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
890      * |   `--POST_DEC -&gt; --
891      * |       `--IDENT -&gt; a
892      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
914      * |   `--METHOD_CALL -&gt; (
915      * |       |--DOT -&gt; .
916      * |       |   |--IDENT -&gt; Integer
917      * |       |   `--IDENT -&gt; parseInt
918      * |       |--ELIST -&gt; ELIST
919      * |       |   `--EXPR -&gt; EXPR
920      * |       |       `--STRING_LITERAL -&gt; "123"
921      * |       `--RPAREN -&gt; )
922      * |--SEMI -&gt; ;
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&lt;String&gt; compare = String::compareToIgnoreCase;
943      * </pre>
944      *
945      * <p>parses as:
946      * <pre>
947      * |--VARIABLE_DEF -&gt; VARIABLE_DEF
948      * |   |--MODIFIERS -&gt; MODIFIERS
949      * |   |--TYPE -&gt; TYPE
950      * |   |   |--IDENT -&gt; Comparator
951      * |   |   `--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
952      * |   |       |--GENERIC_START -&gt; &lt;
953      * |   |       |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
954      * |   |       |   `--IDENT -&gt; String
955      * |   |       `--GENERIC_END -&gt; &gt;
956      * |   |--IDENT -&gt; compare
957      * |   `--ASSIGN -&gt; =
958      * |       `--EXPR -&gt; EXPR
959      * |           `--METHOD_REF -&gt; ::
960      * |               |--IDENT -&gt; String
961      * |               `--IDENT -&gt; compareToIgnoreCase
962      * |--SEMI -&gt; ;
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 &lt;&lt; 3) - 4 * 5;
977      * </pre>
978      * <p>parses as:</p>
979      * <pre>
980      * |--VARIABLE_DEF -&gt; VARIABLE_DEF
981      * |   |--MODIFIERS -&gt; MODIFIERS
982      * |   |--TYPE -&gt; TYPE
983      * |   |   `--LITERAL_INT -&gt; int
984      * |   |--IDENT -&gt; x
985      * |   `--ASSIGN -&gt; =
986      * |       `--EXPR -&gt; EXPR
987      * |           `--MINUS -&gt; -
988      * |               |--PLUS -&gt; +
989      * |               |   |--PLUS -&gt; +
990      * |               |   |   |--NUM_INT -&gt; 4
991      * |               |   |   `--STAR -&gt; *
992      * |               |   |       |--NUM_INT -&gt; 2
993      * |               |   |       |--LPAREN -&gt; (
994      * |               |   |       |--MOD -&gt; %
995      * |               |   |       |   |--NUM_INT -&gt; 5
996      * |               |   |       |   `--NUM_INT -&gt; 3
997      * |               |   |       `--RPAREN -&gt; )
998      * |               |   |--LPAREN -&gt; (
999      * |               |   |--SL -&gt; &lt;&lt;
1000      * |               |   |   |--NUM_INT -&gt; 1
1001      * |               |   |   `--NUM_INT -&gt; 3
1002      * |               |   `--RPAREN -&gt; )
1003      * |               `--STAR -&gt; *
1004      * |                   |--NUM_INT -&gt; 4
1005      * |                   `--NUM_INT -&gt; 5
1006      * |--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1030      *  |--MODIFIERS -&gt; MODIFIERS
1031      *  |--TYPE -&gt; TYPE
1032      *  |   |--LITERAL_INT -&gt; int
1033      *  |   `--ARRAY_DECLARATOR -&gt; [
1034      *  |       `--RBRACK -&gt; ]
1035      *  |--IDENT -&gt; y
1036      *  |--ASSIGN -&gt; =
1037      *  |   `--ARRAY_INIT -&gt; {
1038      *  |       |--EXPR -&gt; EXPR
1039      *  |       |   `--NUM_INT -&gt; 1
1040      *  |       |--COMMA -&gt; ,
1041      *  |       |--EXPR -&gt; EXPR
1042      *  |       |   `--NUM_INT -&gt; 2
1043      *  |       |--COMMA -&gt; ,
1044      *  |       `--RCURLY -&gt; }
1045      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1059      *  |--MODIFIERS -&gt; MODIFIERS
1060      *  |--TYPE -&gt; TYPE [2:4]
1061      *  |   |--LITERAL_INT -&gt; int
1062      *  |   `--ARRAY_DECLARATOR -&gt; [
1063      *  |       `--RBRACK -&gt; ]
1064      *  |--IDENT -&gt; z
1065      *  |--ASSIGN -&gt; =
1066      *  |   `--EXPR -&gt; EXPR
1067      *  |       `--LITERAL_NEW -&gt; new
1068      *  |           |--LITERAL_INT -&gt; int
1069      *  |           |--ARRAY_DECLARATOR -&gt; [
1070      *  |           |   `--RBRACK -&gt; ]
1071      *  |           `--ARRAY_INIT -&gt; {
1072      *  |               |--EXPR -&gt; EXPR
1073      *  |               |   `--NUM_INT -&gt; 1
1074      *  |               |--COMMA -&gt; ,
1075      *  |               |--EXPR -&gt; EXPR
1076      *  |               |   `--NUM_INT -&gt; 2
1077      *  |               |--COMMA -&gt; ,
1078      *  |               `--RCURLY -&gt; }
1079      *  `--SEMI -&gt; ;
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 -&gt; import
1103      * |--DOT -&gt; .
1104      * |   |--DOT -&gt; .
1105      * |   |   |--IDENT -&gt; java
1106      * |   |   `--IDENT -&gt; io
1107      * |   `--IDENT -&gt; IOException
1108      * `--SEMI -&gt; ;
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 &sect;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 -&gt; EXPR
1130      * |   `--ASSIGN -&gt; =
1131      * |       |--IDENT -&gt; a
1132      * |       `--UNARY_MINUS -&gt; -
1133      * |           `--IDENT -&gt; b
1134      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
1152      * |   `--ASSIGN -&gt; =
1153      * |       |--IDENT -&gt; a
1154      * |       `--UNARY_PLUS -&gt; +
1155      * |           `--IDENT -&gt; b
1156      * |--SEMI -&gt; ;
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, &sect;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 -&gt; CASE_GROUP
1182      *  |--LITERAL_CASE -&gt; case
1183      *  |   |--EXPR -&gt; EXPR
1184      *  |   |   `--NUM_INT -&gt; 0
1185      *  |   `--COLON -&gt; :
1186      *  |--LITERAL_CASE -&gt; case
1187      *  |   |--EXPR -&gt; EXPR
1188      *  |   |   `--NUM_INT -&gt; 1
1189      *  |   `--COLON -&gt; :
1190      *  |--LITERAL_CASE -&gt; case
1191      *  |   |--EXPR -&gt; EXPR
1192      *  |   |   `--NUM_INT -&gt; 2
1193      *  |   `--COLON -&gt; :
1194      *  `--SLIST -&gt; SLIST
1195      *      |--EXPR -&gt; EXPR
1196      *      |   `--ASSIGN -&gt; =
1197      *      |       |--IDENT -&gt; x
1198      *      |       `--NUM_INT -&gt; 3
1199      *      |--SEMI -&gt; ;
1200      *      `--LITERAL_BREAK -&gt; break
1201      *          `--SEMI -&gt; ;
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 -&gt; EXPR
1221      * |   `--LITERAL_NEW -&gt; new
1222      * |       |--IDENT -&gt; ArrayList
1223      * |       |--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
1224      * |       |   |--GENERIC_START -&gt; &lt;
1225      * |       |   `--GENERIC_END -&gt; &gt;
1226      * |       |--LPAREN -&gt; (
1227      * |       |--ELIST -&gt; ELIST
1228      * |       |   `--EXPR -&gt; EXPR
1229      * |       |       `--NUM_INT -&gt; 50
1230      * |       `--RPAREN -&gt; )
1231      * |--SEMI -&gt; ;
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 &lt; arr.length; i++) {}
1252      * </pre>
1253      * <p>parses as:</p>
1254      * <pre>
1255      * LITERAL_FOR -&gt; for
1256      *  |--LPAREN -&gt; (
1257      *  |--FOR_INIT -&gt; FOR_INIT
1258      *  |   `--VARIABLE_DEF -&gt; VARIABLE_DEF
1259      *  |       |--MODIFIERS -&gt; MODIFIERS
1260      *  |       |--TYPE -&gt; TYPE
1261      *  |       |   `--LITERAL_INT -&gt; int
1262      *  |       |--IDENT -&gt; i
1263      *  |       `--ASSIGN -&gt; =
1264      *  |           `--EXPR -&gt; EXPR
1265      *  |               `--NUM_INT -&gt; 0
1266      *  |--SEMI -&gt; ;
1267      *  |--FOR_CONDITION -&gt; FOR_CONDITION
1268      *  |   `--EXPR -&gt; EXPR
1269      *  |       `--LT -&gt; &lt;
1270      *  |           |--IDENT -&gt; i
1271      *  |           `--DOT -&gt; .
1272      *  |               |--IDENT -&gt; arr
1273      *  |               `--IDENT -&gt; length
1274      *  |--SEMI -&gt; ;
1275      *  |--FOR_ITERATOR -&gt; FOR_ITERATOR
1276      *  |   `--ELIST -&gt; ELIST
1277      *  |       `--EXPR -&gt; EXPR
1278      *  |           `--POST_INC -&gt; ++
1279      *  |               `--IDENT -&gt; i
1280      *  |--RPAREN -&gt; )
1281      *  `--SLIST -&gt; {
1282      *      `--RCURLY -&gt; }
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 &lt; arr.length; i++) {}
1298      * </pre>
1299      * <p>parses as:</p>
1300      * <pre>
1301      * LITERAL_FOR -&gt; for
1302      *  |--LPAREN -&gt; (
1303      *  |--FOR_INIT -&gt; FOR_INIT
1304      *  |   `--VARIABLE_DEF -&gt; VARIABLE_DEF
1305      *  |       |--MODIFIERS -&gt; MODIFIERS
1306      *  |       |--TYPE -&gt; TYPE
1307      *  |       |   `--LITERAL_INT -&gt; int
1308      *  |       |--IDENT -&gt; i
1309      *  |       `--ASSIGN -&gt; =
1310      *  |           `--EXPR -&gt; EXPR
1311      *  |               `--NUM_INT -&gt; 0
1312      *  |--SEMI -&gt; ;
1313      *  |--FOR_CONDITION -&gt; FOR_CONDITION
1314      *  |   `--EXPR -&gt; EXPR
1315      *  |       `--LT -&gt; &lt;
1316      *  |           |--IDENT -&gt; i
1317      *  |           `--DOT -&gt; .
1318      *  |               |--IDENT -&gt; arr
1319      *  |               `--IDENT -&gt; length
1320      *  |--SEMI -&gt; ;
1321      *  |--FOR_ITERATOR -&gt; FOR_ITERATOR
1322      *  |   `--ELIST -&gt; ELIST
1323      *  |       `--EXPR -&gt; EXPR
1324      *  |           `--POST_INC -&gt; ++
1325      *  |               `--IDENT -&gt; i
1326      *  |--RPAREN -&gt; )
1327      *  `--SLIST -&gt; {
1328      *      `--RCURLY -&gt; }
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 &lt; arr.length; i++) {}
1345      * </pre>
1346      * <p>parses as:</p>
1347      * <pre>
1348      * LITERAL_FOR -&gt; for
1349      *  |--LPAREN -&gt; (
1350      *  |--FOR_INIT -&gt; FOR_INIT
1351      *  |   `--VARIABLE_DEF -&gt; VARIABLE_DEF
1352      *  |       |--MODIFIERS -&gt; MODIFIERS
1353      *  |       |--TYPE -&gt; TYPE
1354      *  |       |   `--LITERAL_INT -&gt; int
1355      *  |       |--IDENT -&gt; i
1356      *  |       `--ASSIGN -&gt; =
1357      *  |           `--EXPR -&gt; EXPR
1358      *  |               `--NUM_INT -&gt; 0
1359      *  |--SEMI -&gt; ;
1360      *  |--FOR_CONDITION -&gt; FOR_CONDITION
1361      *  |   `--EXPR -&gt; EXPR
1362      *  |       `--LT -&gt; &lt;
1363      *  |           |--IDENT -&gt; i
1364      *  |           `--DOT -&gt; .
1365      *  |               |--IDENT -&gt; arr
1366      *  |               `--IDENT -&gt; length
1367      *  |--SEMI -&gt; ;
1368      *  |--FOR_ITERATOR -&gt; FOR_ITERATOR
1369      *  |   `--ELIST -&gt; ELIST
1370      *  |       `--EXPR -&gt; EXPR
1371      *  |           `--POST_INC -&gt; ++
1372      *  |               `--IDENT -&gt; i
1373      *  |--RPAREN -&gt; )
1374      *  `--SLIST -&gt; {
1375      *      `--RCURLY -&gt; }
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 -&gt; while
1396      *  |--LPAREN -&gt; (
1397      *  |--EXPR -&gt; EXPR
1398      *  |   `--LITERAL_TRUE -&gt; true
1399      *  |--RPAREN -&gt; )
1400      *  `--EMPTY_STAT -&gt; ;
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, &sect;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 -&gt; VARIABLE_DEF
1420      *  |--MODIFIERS -&gt; MODIFIERS
1421      *  |   |--LITERAL_PUBLIC -&gt; public
1422      *  |   `--FINAL -&gt; final
1423      *  |--TYPE -&gt; TYPE
1424      *  |   `--LITERAL_INT -&gt; int
1425      *  |--IDENT -&gt; x
1426      *  |--ASSIGN -&gt; =
1427      *  |   `--EXPR -&gt; EXPR
1428      *  |       `--NUM_INT -&gt; 0
1429      *  `--SEMI -&gt; ;
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 -&gt; CLASS_DEF
1469      * |--MODIFIERS -&gt; MODIFIERS
1470      * |   |--LITERAL_PUBLIC -&gt; public
1471      * |   `--STRICTFP -&gt; strictfp
1472      * |--LITERAL_CLASS -&gt; class
1473      * |--IDENT -&gt; Test
1474      * `--OBJBLOCK -&gt; OBJBLOCK
1475      *     |--LCURLY -&gt; {
1476      *     `--RCURLY -&gt; }
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 -&gt; super
1492      *  |--LPAREN -&gt; (
1493      *  |--ELIST -&gt; ELIST
1494      *  |   `--EXPR -&gt; EXPR
1495      *  |       `--NUM_INT -&gt; 1
1496      *  |--RPAREN -&gt; )
1497      *  `--SEMI -&gt; ;
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 -&gt; this
1518      *  |--LPAREN -&gt; (
1519      *  |--ELIST -&gt; ELIST
1520      *  |   `--EXPR -&gt; EXPR
1521      *  |       `--NUM_INT -&gt; 1
1522      *  |--RPAREN -&gt; )
1523      *  `--SEMI -&gt; ;
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 -&gt; for
1544      *  |--LPAREN -&gt; (
1545      *  |--FOR_INIT -&gt; FOR_INIT
1546      *  |--SEMI -&gt; ;
1547      *  |--FOR_CONDITION -&gt; FOR_CONDITION
1548      *  |--SEMI -&gt; ;
1549      *  |--FOR_ITERATOR -&gt; FOR_ITERATOR
1550      *  |--RPAREN -&gt; )
1551      *  `--EMPTY_STAT -&gt; ;
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 -&gt; VARIABLE_DEF
1572      *  |--MODIFIERS -&gt; MODIFIERS
1573      *  |--TYPE -&gt; TYPE
1574      *  |   |--LITERAL_INT -&gt; int
1575      *  |   `--ARRAY_DECLARATOR -&gt; [
1576      *  |       `--RBRACK -&gt; ]
1577      *  |--IDENT -&gt; a
1578      *  `--SEMI -&gt; ;
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 -&gt; METHOD_DEF
1595      *  |--MODIFIERS -&gt; MODIFIERS
1596      *  |--TYPE -&gt; TYPE
1597      *  |   `--LITERAL_VOID -&gt; void
1598      *  |--IDENT -&gt; 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 -&gt; VARIABLE_DEF
1616      *  |--MODIFIERS -&gt; MODIFIERS
1617      *  |   `--LITERAL_PUBLIC -&gt; public
1618      *  |--TYPE -&gt; TYPE
1619      *  |   `--LITERAL_BOOLEAN -&gt; boolean
1620      *  |--IDENT -&gt; flag
1621      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1639      *  |--MODIFIERS -&gt; MODIFIERS
1640      *  |   `--LITERAL_PUBLIC -&gt; public
1641      *  |--TYPE -&gt; TYPE
1642      *  |   `--LITERAL_BYTE -&gt; byte
1643      *  |--IDENT -&gt; x
1644      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1662      *  |--MODIFIERS -&gt; MODIFIERS
1663      *  |--TYPE -&gt; TYPE
1664      *  |   `--LITERAL_CHAR -&gt; char
1665      *  |--IDENT -&gt; a
1666      *  |--ASSIGN -&gt; =
1667      *  |   `--EXPR -&gt; EXPR
1668      *  |       `--CHAR_LITERAL -&gt; 'A'
1669      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1687      *  |--MODIFIERS -&gt; MODIFIERS
1688      *  |   `--LITERAL_PUBLIC -&gt; public
1689      *  |--TYPE -&gt; TYPE
1690      *  |   `--LITERAL_SHORT -&gt; short
1691      *  |--IDENT -&gt; x
1692      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1710      *  |--MODIFIERS -&gt; MODIFIERS
1711      *  |   `--LITERAL_PUBLIC -&gt; public
1712      *  |--TYPE -&gt; TYPE
1713      *  |   `--LITERAL_INT -&gt; int
1714      *  |--IDENT -&gt; x
1715      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1731      *  |--MODIFIERS -&gt; MODIFIERS
1732      *  |   `--LITERAL_PUBLIC -&gt; public
1733      *  |--TYPE -&gt; TYPE
1734      *  |   `--LITERAL_FLOAT -&gt; float
1735      *  |--IDENT -&gt; x
1736      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1754      *  |--MODIFIERS -&gt; MODIFIERS
1755      *  |   `--LITERAL_PUBLIC -&gt; public
1756      *  |--TYPE -&gt; TYPE
1757      *  |   `--LITERAL_LONG -&gt; long
1758      *  |--IDENT -&gt; x
1759      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1777      *  |--MODIFIERS -&gt; MODIFIERS
1778      *  |   `--LITERAL_PUBLIC -&gt; public
1779      *  |--TYPE -&gt; TYPE
1780      *  |   `--LITERAL_DOUBLE -&gt; double
1781      *  |--IDENT -&gt; x
1782      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1801      *  |--MODIFIERS -&gt; MODIFIERS
1802      *  |--TYPE -&gt; TYPE
1803      *  |   `--LITERAL_INT -&gt; int
1804      *  |--IDENT -&gt; a
1805      *  |   `--ASSIGN -&gt; =
1806      *  |       `--EXPR -&gt; EXPR
1807      *  |           `--NUM_INT -&gt; 10
1808      *  `--SEMI -&gt; ;
1809      * </pre>
1810      *
1811      **/
1812     public static final int IDENT = JavaLanguageLexer.IDENT;
1813     /**
1814      * The <code>&#46;</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 -&gt; return
1823      *    |--EXPR -&gt; EXPR
1824      *    |   `--DOT -&gt; .
1825      *    |       |--IDENT -&gt; person
1826      *    |       `--IDENT -&gt; name
1827      *    `--SEMI -&gt; ;
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 -&gt; EXPR
1846      * |   `--ASSIGN -&gt; =
1847      * |       |--IDENT -&gt; f
1848      * |       `--STAR -&gt; *
1849      * |           |--IDENT -&gt; m
1850      * |           `--IDENT -&gt; a
1851      * |--SEMI -&gt; ;
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, &sect;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, &sect;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 -&gt; VARIABLE_DEF
1874      *  |--MODIFIERS -&gt; MODIFIERS
1875      *  |   `--LITERAL_PRIVATE -&gt; private
1876      *  |--TYPE -&gt; TYPE
1877      *  |   `--LITERAL_INT -&gt; int
1878      *  |--IDENT -&gt; x
1879      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1897      *  |--MODIFIERS -&gt; MODIFIERS
1898      *  |   `--LITERAL_PUBLIC -&gt; public
1899      *  |--TYPE -&gt; TYPE
1900      *  |   `--LITERAL_INT -&gt; int
1901      *  |--IDENT -&gt; x
1902      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1920      *  |--MODIFIERS -&gt; MODIFIERS
1921      *  |   `--LITERAL_PROTECTED -&gt; protected
1922      *  |--TYPE -&gt; TYPE
1923      *  |   `--LITERAL_INT -&gt; int
1924      *  |--IDENT -&gt; x
1925      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1943      *  |--MODIFIERS -&gt; MODIFIERS
1944      *  |   |--LITERAL_PUBLIC -&gt; public
1945      *  |   `--LITERAL_STATIC -&gt; static
1946      *  |--TYPE -&gt; TYPE
1947      *  |   `--LITERAL_INT -&gt; int
1948      *  |--IDENT -&gt; x
1949      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
1967      *  |--MODIFIERS -&gt; MODIFIERS
1968      *  |   `--LITERAL_TRANSIENT -&gt; transient
1969      *  |--TYPE -&gt; TYPE
1970      *  |   `--LITERAL_INT -&gt; int
1971      *  |--IDENT -&gt; a
1972      *  `--SEMI -&gt; ;
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 -&gt; METHOD_DEF
1990      *  |--MODIFIERS -&gt; MODIFIERS
1991      *  |   `--LITERAL_NATIVE -&gt; native
1992      *  |--TYPE -&gt; TYPE
1993      *  |   `--LITERAL_VOID -&gt; void
1994      *  |--IDENT -&gt; foo
1995      *  |--LPAREN -&gt; (
1996      *  |--PARAMETERS -&gt; PARAMETERS
1997      *  |--RPAREN -&gt; )
1998      *  `--SLIST -&gt; {
1999      *      `--RCURLY -&gt; }
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 -&gt; synchronized
2025      * |   |--LPAREN -&gt; (
2026      * |   |--EXPR -&gt; EXPR
2027      * |   |   `--LITERAL_THIS -&gt; this
2028      * |   |--RPAREN -&gt; )
2029      * |   `--SLIST -&gt; {
2030      * |       |--EXPR -&gt; EXPR
2031      * |       |   `--POST_INC -&gt; ++
2032      * |       |       `--IDENT -&gt; x
2033      * |       |--SEMI -&gt; ;
2034      * |       `--RCURLY -&gt; }
2035      * `--RCURLY -&gt; }
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 -&gt; VARIABLE_DEF
2058      * |--MODIFIERS -&gt; MODIFIERS
2059      * |   |--LITERAL_PRIVATE -&gt; private
2060      * |   `--LITERAL_VOLATILE -&gt; volatile
2061      * |--TYPE -&gt; TYPE
2062      * |   `--LITERAL_INT -&gt; int
2063      * |--IDENT -&gt; x
2064      * `--SEMI -&gt; ;
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 -&gt; CLASS_DEF
2085      * |--MODIFIERS -&gt; MODIFIERS
2086      * |--LITERAL_CLASS -&gt; class
2087      * |--IDENT -&gt; Test
2088      * `--OBJBLOCK -&gt; OBJBLOCK
2089      *     |--LCURLY -&gt; {
2090      *     `--RCURLY -&gt; }
2091      * </pre>
2092      *
2093      * <p>For example:</p>
2094      * <pre> int.class
2095      * </pre>
2096      * <p>parses as:</p>
2097      * <pre>
2098      * EXPR -&gt; EXPR
2099      *  `--DOT -&gt; .
2100      *      |--LITERAL_INT -&gt; int
2101      *      `--LITERAL_CLASS -&gt; 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 -&gt; INTERFACE_DEF
2128      * |--MODIFIERS -&gt; MODIFIERS
2129      * |   `--LITERAL_PUBLIC -&gt; public
2130      * |--LITERAL_INTERFACE -&gt; interface
2131      * |--IDENT -&gt; MyInterface
2132      * `--OBJBLOCK -&gt; OBJBLOCK
2133      *     |--LCURLY -&gt; {
2134      *     `--RCURLY -&gt; }
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 -&gt; CLASS_DEF
2155      * |--MODIFIERS -&gt; MODIFIERS
2156      * |--LITERAL_CLASS -&gt; class
2157      * |--IDENT -&gt; App
2158      * `--OBJBLOCK -&gt; OBJBLOCK
2159      *     |--LCURLY -&gt; {
2160      *     |--VARIABLE_DEF -&gt; VARIABLE_DEF
2161      *     |   |--MODIFIERS -&gt; MODIFIERS
2162      *     |   |--TYPE -&gt; TYPE
2163      *     |   |   `--LITERAL_INT -&gt; int
2164      *     |   |--IDENT -&gt; num
2165      *     |   `--SEMI -&gt; ;
2166      *     `--RCURLY -&gt; }
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 -&gt; METHOD_DEF
2186      *  |--MODIFIERS -&gt; MODIFIERS
2187      *  |--TYPE -&gt; TYPE
2188      *  |   `--LITERAL_VOID -&gt; void
2189      *  |--IDENT -&gt; foo
2190      *  |--LPAREN -&gt; (
2191      *  |--PARAMETERS -&gt; PARAMETERS
2192      *  |--RPAREN -&gt; )
2193      *  `--SLIST -&gt; {
2194      *      `--RCURLY -&gt; }
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 -&gt; VARIABLE_DEF
2213      * |   |--MODIFIERS -&gt; MODIFIERS
2214      * |   |--TYPE -&gt; TYPE
2215      * |   |   `--LITERAL_INT -&gt; int
2216      * |   `--IDENT -&gt; a
2217      * |--COMMA -&gt; ,
2218      * |--VARIABLE_DEF -&gt; VARIABLE_DEF
2219      * |   |--MODIFIERS -&gt; MODIFIERS
2220      * |   |--TYPE -&gt; TYPE
2221      * |   |   `--LITERAL_INT -&gt; int
2222      * |   `--IDENT -&gt; b
2223      * |--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
2247      *  |   |--MODIFIERS -&gt; MODIFIERS
2248      *  |   |--TYPE -&gt; TYPE
2249      *  |   |   `--IDENT -&gt; Integer
2250      *  |   |--IDENT -&gt; val
2251      *  |   `--ASSIGN -&gt; =
2252      *  |       `--EXPR -&gt; EXPR
2253      *  |           `--LITERAL_NEW -&gt; new
2254      *  |               |--IDENT -&gt; Integer
2255      *  |               |--LPAREN -&gt; (
2256      *  |               |--ELIST -&gt; ELIST
2257      *  |               `--RPAREN -&gt; )
2258      *  |--SEMI -&gt; ;
2259      *  |--LITERAL_WHILE -&gt; while
2260      *  |   |--LPAREN -&gt; (
2261      *  |   |--EXPR -&gt; EXPR
2262      *  |   |   `--LITERAL_FALSE -&gt; false
2263      *  |   |--RPAREN -&gt; )
2264      *  |   `--SLIST -&gt; {
2265      *  |       |--EXPR -&gt; EXPR
2266      *  |       |   `--PLUS_ASSIGN -&gt; +=
2267      *  |       |       |--IDENT -&gt; val
2268      *  |       |       |--LPAREN -&gt; (
2269      *  |       |       |--UNARY_MINUS -&gt; -
2270      *  |       |       |   `--NUM_INT -&gt; 3
2271      *  |       |       `--RPAREN -&gt; )
2272      *  |       |--SEMI -&gt; ;
2273      *  |       `--RCURLY -&gt; }
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 -&gt; METHOD_DEF
2294      *  |--MODIFIERS -&gt; MODIFIERS
2295      *  |--TYPE -&gt; TYPE
2296      *  |   `--LITERAL_VOID -&gt; void
2297      *  |--IDENT -&gt; check
2298      *  |--LPAREN -&gt; (
2299      *  |--PARAMETERS -&gt; PARAMETERS
2300      *  |--RPAREN -&gt; )
2301      *  `--SLIST -&gt; {
2302      *      `--RCURLY -&gt; }
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 -&gt; EXPR
2325      *  `--ASSIGN -&gt; =
2326      *      |--DOT -&gt; .
2327      *      |   |--LITERAL_THIS -&gt; this
2328      *      |   `--IDENT -&gt; name
2329      *      `--IDENT -&gt; name
2330      * SEMI -&gt; ;
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 -&gt; this
2339      *  |--LPAREN -&gt; (
2340      *  |--ELIST -&gt; ELIST
2341      *  |   |--EXPR -&gt; EXPR
2342      *  |   |   `--NUM_INT -&gt; 1
2343      *  |   |--COMMA -&gt; ,
2344      *  |   `--EXPR -&gt; EXPR
2345      *  |       `--STRING_LITERAL -&gt; "NULL"
2346      *  |--RPAREN -&gt; )
2347      *  `--SEMI -&gt; ;
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 -&gt; EXPR
2366      * |   `--METHOD_CALL -&gt; (
2367      * |       |--DOT -&gt; .
2368      * |       |  |--LITERAL_SUPER -&gt; super
2369      * |       |  `--IDENT -&gt; toString
2370      * |       |--ELIST -&gt; ELIST
2371      * |       `--RPAREN -&gt; )
2372      * |--SEMI -&gt; ;
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 -&gt; EXPR
2391      * |   `--ASSIGN -&gt; =
2392      * |       |--IDENT -&gt; a
2393      * |       `--IDENT -&gt; b
2394      * |--SEMI -&gt; ;
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, &sect;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 -&gt; METHOD_DEF
2415      *  |--MODIFIERS -&gt; MODIFIERS
2416      *  |--TYPE -&gt; TYPE
2417      *  |   `--LITERAL_VOID -&gt; void
2418      *  |--IDENT -&gt; test
2419      *  |--LPAREN -&gt; (
2420      *  |--PARAMETERS -&gt; PARAMETERS
2421      *  |--RPAREN -&gt; )
2422      *  |--LITERAL_THROWS -&gt; throws
2423      *  |   |--IDENT -&gt; FileNotFoundException
2424      *  |   |--COMMA -&gt; ,
2425      *  |   `--IDENT -&gt; EOFException
2426      *  `--SLIST -&gt; {
2427      *      `--RCURLY -&gt; }
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, &sect;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 -&gt; EXPR
2453      * |   `--ASSIGN -&gt; =
2454      * |       |--IDENT -&gt; num
2455      * |       `--QUESTION -&gt; ?
2456      * |           |--IDENT -&gt; isValid
2457      * |           |--NUM_INT -&gt; 1
2458      * |           |--COLON -&gt; :
2459      * |           `--NUM_INT -&gt; 0
2460      * |--SEMI -&gt; ;
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&lt;Double, Double&gt; square = MyClass::square;
2477      * </pre>
2478      * <p>parses as:</p>
2479      * <pre>
2480      * VARIABLE_DEF -&gt; VARIABLE_DEF
2481      *  |--MODIFIERS -&gt; MODIFIERS
2482      *  |--TYPE -&gt; TYPE
2483      *  |   |--IDENT -&gt; Function
2484      *  |   |   `--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
2485      *  |   |       |--GENERIC_START -&gt; &lt;
2486      *  |   |       |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
2487      *  |   |       |   `--IDENT -&gt; Double
2488      *  |   |       |--COMMA -&gt; ,
2489      *  |   |       |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
2490      *  |   |       |   `--IDENT -&gt; Double
2491      *  |   |       `--GENERIC_END -&gt; &gt;
2492      *  |   |--IDENT -&gt; square
2493      *  |   |--ASSIGN -&gt; =
2494      *  |   |   `--EXPR -&gt; EXPR
2495      *  |   |       `--METHOD_REF -&gt; ::
2496      *  |   |           |--IDENT -&gt; MyClass
2497      *  |   |           `--IDENT -&gt; square
2498      *  |   `--SEMI -&gt; ;
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 -&gt; if
2521      *  |--LPAREN -&gt; (
2522      *  |--EXPR -&gt; EXPR
2523      *  |   `--IDENT -&gt; optimistic
2524      *  |--RPAREN -&gt; )
2525      *  |--SLIST -&gt; {
2526      *  |   |--EXPR -&gt; EXPR
2527      *  |   |   `--ASSIGN -&gt; =
2528      *  |   |       |--IDENT -&gt; message
2529      *  |   |       `--STRING_LITERAL -&gt; "half full"
2530      *  |   |--SEMI -&gt; ;
2531      *  |   `--RCURLY -&gt; }
2532      *  `--LITERAL_ELSE -&gt; else
2533      *      `--SLIST -&gt; {
2534      *          |--EXPR -&gt; EXPR
2535      *          |   `--ASSIGN -&gt; =
2536      *          |       |--IDENT -&gt; message
2537      *          |       `--STRING_LITERAL -&gt; "half empty"
2538      *          |--SEMI -&gt; ;
2539      *          `--RCURLY -&gt; }
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 &lt; arr.length; i++) {}
2559      * </pre>
2560      * <p>parses as:</p>
2561      * <pre>
2562      * LITERAL_FOR -&gt; for
2563      *  |--LPAREN -&gt; (
2564      *  |--FOR_INIT -&gt; FOR_INIT
2565      *  |   `--VARIABLE_DEF -&gt; VARIABLE_DEF
2566      *  |       |--MODIFIERS -&gt; MODIFIERS
2567      *  |       |--TYPE -&gt; TYPE
2568      *  |       |   `--LITERAL_INT -&gt; int
2569      *  |       |--IDENT -&gt; i
2570      *  |       `--ASSIGN -&gt; =
2571      *  |           `--EXPR -&gt; EXPR
2572      *  |               `--NUM_INT -&gt; 0
2573      *  |--SEMI -&gt; ;
2574      *  |--FOR_CONDITION -&gt; FOR_CONDITION
2575      *  |   `--EXPR -&gt; EXPR
2576      *  |       `--LT -&gt; &lt;
2577      *  |           |--IDENT -&gt; i
2578      *  |           `--DOT -&gt; .
2579      *  |               |--IDENT -&gt; arr
2580      *  |               `--IDENT -&gt; length
2581      *  |--SEMI -&gt; ;
2582      *  |--FOR_ITERATOR -&gt; FOR_ITERATOR
2583      *  |   `--ELIST -&gt; ELIST
2584      *  |       `--EXPR -&gt; EXPR
2585      *  |           `--POST_INC -&gt; ++
2586      *  |               `--IDENT -&gt; i
2587      *  |--RPAREN -&gt; )
2588      *  `--SLIST -&gt; {
2589      *      `--RCURLY -&gt; }
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 &lt; 5) {
2609      *     i++;
2610      * }
2611      * </pre>
2612      * <p>parses as:</p>
2613      * <pre>
2614      * LITERAL_WHILE -&gt; while
2615      *  |--LPAREN -&gt; (
2616      *  |--EXPR -&gt; EXPR
2617      *  |   `--LT -&gt; &lt;
2618      *  |       |--IDENT -&gt; i
2619      *  |       `--NUM_INT -&gt; 5
2620      *  |--RPAREN -&gt; )
2621      *  `--SLIST -&gt; {
2622      *      |--EXPR -&gt; EXPR
2623      *      |   `--POST_INC -&gt; ++
2624      *      |       `--IDENT -&gt; i
2625      *      |--SEMI -&gt; ;
2626      *      `--RCURLY -&gt; }
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 &lt; 5);
2641      * </pre>
2642      * <p>parses as:</p>
2643      * <pre>
2644      * LITERAL_DO -&gt; do
2645      *  |--SLIST -&gt; {
2646      *  |   |--EXPR -&gt; EXPR
2647      *  |   |   `--ASSIGN -&gt; =
2648      *  |   |       |--IDENT -&gt; x
2649      *  |   |       `--METHOD_CALL -&gt; (
2650      *  |   |           |--DOT -&gt; .
2651      *  |   |           |   |--IDENT -&gt; rand
2652      *  |   |           |   `--IDENT -&gt; nextInt
2653      *  |   |           |--ELIST -&gt; ELIST
2654      *  |   |           `--RPAREN -&gt; )
2655      *  |   |--SEMI -&gt; ;
2656      *  |   `--RCURLY -&gt; }
2657      *  |--DO_WHILE -&gt; while
2658      *  |--LPAREN -&gt; (
2659      *  |--EXPR -&gt; EXPR
2660      *  |   `--LT -&gt; &lt;
2661      *  |       |--IDENT -&gt; x
2662      *  |       `--NUM_INT -&gt; 5
2663      *  |--RPAREN -&gt; )
2664      *  `--SEMI -&gt; ;
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 &gt; 0);
2683      * </pre>
2684      * <p>parses as:</p>
2685      * <pre>
2686      * --LITERAL_DO -&gt; do
2687      *    |--SLIST -&gt; {
2688      *    |   `--RCURLY -&gt; }
2689      *    |--DO_WHILE -&gt; while
2690      *    |--LPAREN -&gt; (
2691      *    |--EXPR -&gt; EXPR
2692      *    |   `--GT -&gt; &gt;
2693      *    |       |--IDENT -&gt; a
2694      *    |       `--NUM_INT -&gt; 0
2695      *    |--RPAREN -&gt; )
2696      *    `--SEMI -&gt; ;
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 -&gt; for
2715      *  |--LPAREN -&gt; (
2716      *  |--FOR_INIT -&gt; FOR_INIT
2717      *  |--SEMI -&gt; ;
2718      *  |--FOR_CONDITION -&gt; FOR_CONDITION
2719      *  |--SEMI -&gt; ;
2720      *  |--FOR_ITERATOR -&gt; FOR_ITERATOR
2721      *  |--RPAREN -&gt; )
2722      *  `--SLIST -&gt; {
2723      *      |--LITERAL_BREAK -&gt; break
2724      *      |   `--SEMI -&gt; ;
2725      *      `--RCURLY -&gt; }
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 -&gt; for
2748      *  |--LPAREN -&gt; (
2749      *  |--FOR_INIT -&gt; FOR_INIT
2750      *  |--SEMI -&gt; ;
2751      *  |--FOR_CONDITION -&gt; FOR_CONDITION
2752      *  |--SEMI -&gt; ;
2753      *  |--FOR_ITERATOR -&gt; FOR_ITERATOR
2754      *  |--RPAREN -&gt; )
2755      *  `--SLIST -&gt; {
2756      *      |--LITERAL_CONTINUE -&gt; continue
2757      *      |   `--SEMI -&gt; ;
2758      *      `--RCURLY -&gt; }
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 -&gt; METHOD_DEF
2782      *  |--MODIFIERS -&gt; MODIFIERS
2783      *  |   `--LITERAL_PUBLIC -&gt; public
2784      *  |--TYPE -&gt; TYPE
2785      *  |   `--LITERAL_INT -&gt; int
2786      *  |--IDENT -&gt; foo
2787      *  |--LPAREN -&gt; (
2788      *  |--PARAMETERS -&gt; PARAMETERS
2789      *  |   `--PARAMETER_DEF -&gt; PARAMETER_DEF
2790      *  |       |--MODIFIERS -&gt; MODIFIERS
2791      *  |       |--TYPE -&gt; TYPE
2792      *  |       |   `--LITERAL_INT -&gt; int
2793      *  |       `--IDENT -&gt; i
2794      *  |--RPAREN -&gt; )
2795      *  `--SLIST -&gt; {
2796      *      |--LITERAL_RETURN -&gt; return
2797      *      |   |--EXPR -&gt; EXPR
2798      *      |   |   `--PLUS -&gt; +
2799      *      |   |       |--IDENT -&gt; i
2800      *      |   |       `--NUM_INT -&gt; 1
2801      *      |   `--SEMI -&gt; ;
2802      *      `--RCURLY -&gt; }
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 -&gt; switch
2831      *  |--LPAREN -&gt; (
2832      *  |--EXPR -&gt; EXPR
2833      *  |   `--IDENT -&gt; type
2834      *  |--RPAREN -&gt; )
2835      *  |--LCURLY -&gt; {
2836      *  |--CASE_GROUP -&gt; CASE_GROUP
2837      *  |   |--LITERAL_CASE -&gt; case
2838      *  |   |   |--EXPR -&gt; EXPR
2839      *  |   |   |   `--NUM_INT -&gt; 0
2840      *  |   |   `--COLON -&gt; :
2841      *  |   `--SLIST -&gt; SLIST
2842      *  |       |--EXPR -&gt; EXPR
2843      *  |       |   `--ASSIGN -&gt; =
2844      *  |       |       |--IDENT -&gt; background
2845      *  |       |       `--DOT -&gt; .
2846      *  |       |           |--IDENT -&gt; Color
2847      *  |       |           `--IDENT -&gt; red
2848      *  |       |--SEMI -&gt; ;
2849      *  |       `--LITERAL_BREAK -&gt; break
2850      *  |           `--SEMI -&gt; ;
2851      *  |--CASE_GROUP -&gt; CASE_GROUP
2852      *  |   |--LITERAL_CASE -&gt; case
2853      *  |   |   |--EXPR -&gt; EXPR
2854      *  |   |   |   `--NUM_INT -&gt; 1
2855      *  |   |   `--COLON -&gt; :
2856      *  |   `--SLIST -&gt; SLIST
2857      *  |       |--EXPR -&gt; EXPR
2858      *  |       |   `--ASSIGN -&gt; =
2859      *  |       |       |--IDENT -&gt; background
2860      *  |       |       `--DOT -&gt; .
2861      *  |       |           |--IDENT -&gt; Color
2862      *  |       |           `--IDENT -&gt; blue
2863      *  |       |--SEMI -&gt; ;
2864      *  |       `--LITERAL_BREAK -&gt; break
2865      *  |           `--SEMI -&gt; ;
2866      *  |--CASE_GROUP -&gt; CASE_GROUP
2867      *  |   |--LITERAL_DEFAULT -&gt; default
2868      *  |   |   `--COLON -&gt; :
2869      *  |   `--SLIST -&gt; SLIST
2870      *  |       |--EXPR -&gt; EXPR
2871      *  |       |   `--ASSIGN -&gt; =
2872      *  |       |       |--IDENT -&gt; background
2873      *  |       |       `--DOT -&gt; .
2874      *  |       |           |--IDENT -&gt; Color
2875      *  |       |           `--IDENT -&gt; green
2876      *  |       `--SEMI -&gt; ;
2877      *  `--RCURLY -&gt; }
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, &sect;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(&quot;An exception occurred.&quot;);
2902      * </pre>
2903      * <p>parses as:</p>
2904      * <pre>
2905      * LITERAL_THROW -&gt; throw
2906      *  |--EXPR -&gt; EXPR
2907      *  |   `--LITERAL_NEW -&gt; new
2908      *  |       |--IDENT -&gt; ArithmeticException
2909      *  |       |--LPAREN -&gt; (
2910      *  |       |--ELIST -&gt; ELIST
2911      *  |       |   `--EXPR -&gt; EXPR
2912      *  |       |       `--STRING_LITERAL -&gt; &quot;An exception occurred.&quot;
2913      *  |       `--RPAREN -&gt; )
2914      *  `--SEMI -&gt; ;
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, &sect;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 -&gt; if
2941      *  |--LPAREN -&gt; (
2942      *  |--EXPR -&gt; EXPR
2943      *  |   `--IDENT -&gt; flag
2944      *  |--RPAREN -&gt; )
2945      *  |--SLIST -&gt; {
2946      *  |   `--RCURLY -&gt; }
2947      *  `--LITERAL_ELSE -&gt; else
2948      *      `--SLIST -&gt; {
2949      *          `--RCURLY -&gt; }
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 -&gt; CASE_GROUP
2975      *    |--LITERAL_CASE -&gt; cas
2976      *    |   |--EXPR -&gt; EXPR
2977      *    |   |   `--NUM_INT -&gt; 0
2978      *    |   `--COLON -&gt; :
2979      *    `--SLIST -&gt; SLIST
2980      *         |--EXPR -&gt; EXPR
2981      *         |   `--ASSIGN -&gt; =
2982      *         |       |--IDENT -&gt; num
2983      *         |       `--NUM_INT -&gt; 1
2984      *         `--SEMI -&gt; ;
2985      * </pre>
2986      * <p>For example:</p>
2987      * <pre>
2988      * switch(num){
2989      *    case 1 -&gt; num = -1
2990      * }
2991      * </pre>
2992      * <p>parses as:</p>
2993      * <pre>
2994      * SWITCH_RULE -&gt; SWITCH_RULE
2995      *   |--LITERAL_CASE -&gt; case
2996      *   |   `--EXPR -&gt; EXPR
2997      *   |       `--NUM_INT -&gt; 1
2998      *   |--LAMBDA -&gt; -&gt;
2999      *   |--EXPR -&gt; EXPR
3000      *   |   `--ASSIGN -&gt; =
3001      *   |       |--IDENT -&gt; num
3002      *   |       `--UNARY_MINUS -&gt; -
3003      *   |           `--NUM_INT -&gt; 1
3004      *   `--SEMI -&gt; ;
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 -&gt; switch
3030      *  |--LPAREN -&gt; (
3031      *  |--EXPR -&gt; EXPR
3032      *  |   `--IDENT -&gt; type
3033      *  |--RPAREN -&gt; )
3034      *  |--LCURLY -&gt; {
3035      *  |--CASE_GROUP -&gt; CASE_GROUP
3036      *  |   |--LITERAL_CASE -&gt; case
3037      *  |   |   |--EXPR -&gt; EXPR
3038      *  |   |   |   `--NUM_INT -&gt; 1
3039      *  |   |   `--COLON -&gt; :
3040      *  |   `--SLIST -&gt; SLIST
3041      *  |       |--EXPR -&gt; EXPR
3042      *  |       |   `--ASSIGN -&gt; =
3043      *  |       |       |--IDENT -&gt; x
3044      *  |       |       `--NUM_INT -&gt; 1
3045      *  |       |   |       |--SEMI -&gt; ;
3046      *  |       `--LITERAL_BREAK -&gt; break
3047      *  |           `--SEMI -&gt; ;
3048      *  |--CASE_GROUP -&gt; CASE_GROUP
3049      *  |   |--LITERAL_DEFAULT -&gt; default
3050      *  |   |   `--COLON -&gt; :
3051      *  |   `--SLIST -&gt; SLIST
3052      *  |       |--EXPR -&gt; EXPR
3053      *  |       |   `--ASSIGN -&gt; =
3054      *  |       |       |--IDENT -&gt; x
3055      *  |       |       `--NUM_INT -&gt; 3
3056      *  |       `--SEMI -&gt; ;
3057      *  `--RCURLY -&gt; }
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 -&gt; try
3079      *  |--SLIST -&gt; {
3080      *  |   `--RCURLY -&gt; }
3081      *  `--LITERAL_FINALLY -&gt; finally
3082      *      `--SLIST -&gt; {
3083      *          `--RCURLY -&gt; }
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, &sect;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 -&gt; try
3106      *  |--RESOURCE_SPECIFICATION -&gt; RESOURCE_SPECIFICATION
3107      *  |   |--LPAREN -&gt; (
3108      *  |   |--RESOURCES -&gt; RESOURCES
3109      *  |   |   |--RESOURCE -&gt; RESOURCE
3110      *  |   |   |   |--MODIFIERS -&gt; MODIFIERS
3111      *  |   |   |   |--TYPE -&gt; TYPE
3112      *  |   |   |   |   `--IDENT -&gt; Foo
3113      *  |   |   |   |--IDENT -&gt; foo
3114      *  |   |   |   `--ASSIGN -&gt; =
3115      *  |   |   |       `--EXPR -&gt; EXPR
3116      *  |   |   |           `--LITERAL_NEW -&gt; new
3117      *  |   |   |               |--IDENT -&gt; Foo
3118      *  |   |   |               |--LPAREN -&gt; (
3119      *  |   |   |               |--ELIST -&gt; ELIST
3120      *  |   |   |               `--RPAREN -&gt; )
3121      *  |   |   |--SEMI -&gt; ;
3122      *  |   |   `--RESOURCE -&gt; RESOURCE
3123      *  |   |       |--MODIFIERS -&gt; MODIFIERS
3124      *  |   |       |--TYPE -&gt; TYPE
3125      *  |   |       |   `--IDENT -&gt; Bar
3126      *  |   |       |--IDENT -&gt; bar
3127      *  |   |       `--ASSIGN -&gt; =
3128      *  |   |           `--EXPR -&gt; EXPR
3129      *  |   |               `--LITERAL_NEW -&gt; new
3130      *  |   |                   |--IDENT -&gt; Bar
3131      *  |   |                   |--LPAREN -&gt; (
3132      *  |   |                   |--ELIST -&gt; ELIST
3133      *  |   |                   `--RPAREN -&gt; )
3134      *  |   `--RPAREN -&gt; )
3135      *  `--SLIST -&gt; {
3136      *      `--RCURLY -&gt; }
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 -&gt; try
3147      *  |--RESOURCE_SPECIFICATION -&gt; RESOURCE_SPECIFICATION
3148      *  |   |--LPAREN -&gt; (
3149      *  |   |--RESOURCES -&gt; RESOURCES
3150      *  |   |   `--RESOURCE -&gt; RESOURCE
3151      *  |   |       |--MODIFIERS -&gt; MODIFIERS
3152      *  |   |       |--TYPE -&gt; TYPE
3153      *  |   |       |   `--IDENT -&gt; BufferedReader
3154      *  |   |       |--IDENT -&gt; br
3155      *  |   |       `--ASSIGN -&gt; =
3156      *  |   |           `--EXPR -&gt; EXPR
3157      *  |   |               `--LITERAL_NEW -&gt; new
3158      *  |   |                   |--IDENT -&gt; BufferedReader
3159      *  |   |                   |--LPAREN -&gt; (
3160      *  |   |                   |--ELIST -&gt; ELIST
3161      *  |   |                   |   `--EXPR -&gt; EXPR
3162      *  |   |                   |       `--LITERAL_NEW -&gt; new
3163      *  |   |                   |           |--IDENT -&gt; FileReader
3164      *  |   |                   |           |--LPAREN -&gt; (
3165      *  |   |                   |           |--ELIST -&gt; ELIST
3166      *  |   |                   |           |   `--EXPR -&gt; EXPR
3167      *  |   |                   |           |       `--IDENT -&gt; path
3168      *  |   |                   |           `--RPAREN -&gt; )
3169      *  |   |                   `--RPAREN -&gt; )
3170      *  |   `--RPAREN -&gt; )
3171      *  `--SLIST -&gt; {
3172      *      `--RCURLY -&gt; }
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 -&gt; try
3197      *  |--RESOURCE_SPECIFICATION -&gt; RESOURCE_SPECIFICATION
3198      *  |   |--LPAREN -&gt; (
3199      *  |   |--RESOURCES -&gt; RESOURCES
3200      *  |   |   `--RESOURCE -&gt; RESOURCE
3201      *  |   |       |--MODIFIERS -&gt; MODIFIERS
3202      *  |   |       |--TYPE -&gt; TYPE
3203      *  |   |       |   `--IDENT -&gt; FileReader
3204      *  |   |       |--IDENT -&gt; fr
3205      *  |   |       `--ASSIGN -&gt; =
3206      *  |   |           `--EXPR -&gt; EXPR
3207      *  |   |               `--LITERAL_NEW -&gt; new
3208      *  |   |                   |--IDENT -&gt; FileReader
3209      *  |   |                   |--LPAREN -&gt; (
3210      *  |   |                   |--ELIST -&gt; ELIST
3211      *  |   |                   |   `--EXPR -&gt; EXPR
3212      *  |   |                   |       `--STRING_LITERAL -&gt; "config.xml"
3213      *  |   |                   `--RPAREN -&gt; )
3214      *  |   `--RPAREN -&gt; )
3215      *  |--SLIST -&gt; {
3216      *  |   `--RCURLY -&gt; }
3217      *  `--LITERAL_FINALLY -&gt; finally
3218      *      `--SLIST -&gt; {
3219      *          `--RCURLY -&gt; }
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 -&gt; try
3238      *  |--RESOURCE_SPECIFICATION -&gt; RESOURCE_SPECIFICATION
3239      *  |   |--LPAREN -&gt; (
3240      *  |   |--RESOURCES -&gt; RESOURCES
3241      *  |   |   |--RESOURCE -&gt; RESOURCE
3242      *  |   |   |   |--MODIFIERS -&gt; MODIFIERS
3243      *  |   |   |   |--TYPE -&gt; TYPE
3244      *  |   |   |   |   `--IDENT -&gt; Foo
3245      *  |   |   |   |--IDENT -&gt; foo
3246      *  |   |   |   `--ASSIGN -&gt; =
3247      *  |   |   |       `--EXPR -&gt; EXPR
3248      *  |   |   |           `--LITERAL_NEW -&gt; new
3249      *  |   |   |               |--IDENT -&gt; Foo
3250      *  |   |   |               |--LPAREN -&gt; (
3251      *  |   |   |               |--ELIST -&gt; ELIST
3252      *  |   |   |               `--RPAREN -&gt; )
3253      *  |   |   |--SEMI -&gt; ;
3254      *  |   |   `--RESOURCE -&gt; RESOURCE
3255      *  |   |       |--MODIFIERS -&gt; MODIFIERS
3256      *  |   |       |--TYPE -&gt; TYPE
3257      *  |   |       |   `--IDENT -&gt; Bar
3258      *  |   |       |--IDENT -&gt; bar
3259      *  |   |       `--ASSIGN -&gt; =
3260      *  |   |           `--EXPR -&gt; EXPR
3261      *  |   |               `--LITERAL_NEW -&gt; new
3262      *  |   |                   |--IDENT -&gt; Bar
3263      *  |   |                   |--LPAREN -&gt; (
3264      *  |   |                   |--ELIST -&gt; ELIST
3265      *  |   |                   `--RPAREN -&gt; )
3266      *  |   `--RPAREN -&gt; )
3267      *  `--SLIST -&gt; {
3268      *      `--RCURLY -&gt; }
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 -&gt; try
3291      *  |--SLIST -&gt; {
3292      *  |   |--VARIABLE_DEF -&gt; VARIABLE_DEF
3293      *  |   |   |--MODIFIERS -&gt; MODIFIERS
3294      *  |   |   |--TYPE -&gt; TYPE
3295      *  |   |   |   `--IDENT -&gt; FileReader
3296      *  |   |   |--IDENT -&gt; fr
3297      *  |   |   `--ASSIGN -&gt; =
3298      *  |   |       `--EXPR -&gt; EXPR
3299      *  |   |           `--LITERAL_NEW -&gt; new
3300      *  |   |               |--IDENT -&gt; FileReader
3301      *  |   |               |--LPAREN -&gt; (
3302      *  |   |               |--ELIST -&gt; ELIST
3303      *  |   |               |   `--EXPR -&gt; EXPR
3304      *  |   |               |       `--STRING_LITERAL -&gt; "Test.txt"
3305      *  |   |               `--RPAREN -&gt; )
3306      *  |   |--SEMI -&gt; ;
3307      *  |   `--RCURLY -&gt; }
3308      *  `--LITERAL_CATCH -&gt; catch
3309      *      |--LPAREN -&gt; (
3310      *      |--PARAMETER_DEF -&gt; PARAMETER_DEF
3311      *      |   |--MODIFIERS -&gt; MODIFIERS
3312      *      |   |--TYPE -&gt; TYPE
3313      *      |   |   `--IDENT -&gt; FileNotFoundException
3314      *      |   `--IDENT -&gt; e
3315      *      |--RPAREN -&gt; )
3316      *      `--SLIST -&gt; {
3317      *          `--RCURLY -&gt; }
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 -&gt; try
3339      *  |--SLIST -&gt; {
3340      *  |   `--RCURLY -&gt; }
3341      *  `--LITERAL_FINALLY -&gt; finally
3342      *      `--SLIST -&gt; {
3343      *          `--RCURLY -&gt; }
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 -&gt; EXPR
3362      * |   `--PLUS_ASSIGN -&gt; +=
3363      * |       |--IDENT -&gt; a
3364      * |       `--IDENT -&gt; b
3365      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
3384      * |   `--MINUS_ASSIGN -&gt; -=
3385      * |       |--IDENT -&gt; a
3386      * |       `--IDENT -&gt; b
3387      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
3408      * |   `--STAR_ASSIGN -&gt; *=
3409      * |       |--IDENT -&gt; a
3410      * |       `--IDENT -&gt; b
3411      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
3430      * |   `--DIV_ASSIGN -&gt; /=
3431      * |       |--IDENT -&gt; a
3432      * |       `--IDENT -&gt; b
3433      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
3449      * |   `--MOD_ASSIGN -&gt; %=
3450      * |       |--IDENT -&gt; a
3451      * |       `--NUM_INT -&gt; 2
3452      * |--SEMI -&gt; ;
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, &sect;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 &gt;&gt;= b;
3468      * </pre>
3469      * <p>parses as:</p>
3470      * <pre>
3471      * |--EXPR -&gt; EXPR
3472      * |   `--SR_ASSIGN -&gt; &gt;&gt;=
3473      * |       |--IDENT -&gt; a
3474      * |       `--IDENT -&gt; b
3475      * |--SEMI -&gt; ;
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, &sect;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 &gt;&gt;&gt;= b;
3491      * </pre>
3492      * <p>parses as:</p>
3493      * <pre>
3494      * |--EXPR -&gt; EXPR
3495      * |   `--BSR_ASSIGN -&gt; &gt;&gt;&gt;=
3496      * |       |--IDENT -&gt; a
3497      * |       `--IDENT -&gt; b
3498      * |--SEMI -&gt; ;
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, &sect;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, &sect;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 &amp;= b;
3522      * </pre>
3523      * <p>parses as:</p>
3524      * <pre>
3525      * |--EXPR -&gt; EXPR
3526      * |   `--BAND_ASSIGN -&gt; &amp;=
3527      * |       |--IDENT -&gt; a
3528      * |       `--IDENT -&gt; b
3529      * |--SEMI -&gt; ;
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, &sect;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, &sect;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 -&gt; EXPR
3557      * |   `--BOR_ASSIGN -&gt; |=
3558      * |       |--IDENT -&gt; a
3559      * |       `--IDENT -&gt; b
3560      * |--SEMI -&gt; ;
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, &sect;15.26.2</a>
3566      * @see #EXPR
3567      **/
3568     public static final int BOR_ASSIGN = JavaLanguageLexer.BOR_ASSIGN;
3569     /**
3570      * The <code>&#63;</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 -&gt; VARIABLE_DEF
3581      * |   |--MODIFIERS -&gt; MODIFIERS
3582      * |   |--TYPE -&gt; TYPE
3583      * |   |   `--IDENT -&gt; String
3584      * |   |--IDENT -&gt; variable
3585      * |   `--ASSIGN -&gt; =
3586      * |       `--EXPR -&gt; EXPR
3587      * |           `--QUESTION -&gt; ?
3588      * |               |--LPAREN -&gt; (
3589      * |               |--EQUAL -&gt; ==
3590      * |               |   |--IDENT -&gt; quantity
3591      * |               |   `--NUM_INT -&gt; 1
3592      * |               |--RPAREN -&gt; )
3593      * |               |--STRING_LITERAL -&gt; "true"
3594      * |               |--COLON -&gt; :
3595      * |               `--STRING_LITERAL -&gt; "false"
3596      * |--SEMI -&gt; ;
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, &sect;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 -&gt; if
3622      *  |--LPAREN -&gt; (
3623      *  |--EXPR -&gt; EXPR
3624      *  |   `--LOR -&gt; ||
3625      *  |       |--IDENT -&gt; a
3626      *  |       `--IDENT -&gt; b
3627      *  |--RPAREN -&gt; )
3628      *  |--SLIST -&gt; {
3629      *  |   |--RCURLY -&gt; }
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, &sect;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 &amp;&amp; b) {
3644      * }
3645      * </pre>
3646      * <p>parses as:</p>
3647      * <pre>
3648      * LITERAL_IF -&gt; if
3649      *  |--LPAREN -&gt; (
3650      *  |--EXPR -&gt; EXPR
3651      *  |   `--LAND -&gt; &amp;&amp;
3652      *  |       |--IDENT -&gt; a
3653      *  |       `--IDENT -&gt; b
3654      *  |--RPAREN -&gt; )
3655      *  |--SLIST -&gt; {
3656      *  |   |--RCURLY -&gt; }
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, &sect;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 -&gt; EXPR
3675      * |   `--ASSIGN -&gt; =
3676      * |       |--IDENT -&gt; a
3677      * |       `--BOR -&gt; |
3678      * |           |--IDENT -&gt; a
3679      * |           `--IDENT -&gt; b
3680      * |--SEMI -&gt; ;
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, &sect;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, &sect;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 &amp; b;
3704      * </pre>
3705      * <p>parses as:</p>
3706      * <pre>
3707      * |--EXPR -&gt; EXPR
3708      * |   `--ASSIGN -&gt; =
3709      * |       |--IDENT -&gt; c
3710      * |       `--BAND -&gt; &amp;
3711      * |           |--IDENT -&gt; a
3712      * |           `--IDENT -&gt; b
3713      * |--SEMI -&gt; ;
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, &sect;15.22.1</a>
3719      * @see #EXPR
3720      **/
3721     public static final int BAND = JavaLanguageLexer.BAND;
3722     /**
3723      * The <code>&#33;=</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 -&gt; EXPR
3732      * |   `--NOT_EQUAL -&gt; !=
3733      * |       |--IDENT -&gt; a
3734      * |       `--IDENT -&gt; b
3735      * `--SEMI -&gt; ;
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 -&gt; EXPR
3754      * |   `--EQUAL -&gt; ==
3755      * |       |--IDENT -&gt; a
3756      * |       `--IDENT -&gt; b
3757      * `--SEMI -&gt; ;
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 &lt; b;
3769      * </pre>
3770      * <p>parses as:</p>
3771      * <pre>
3772      * |--EXPR -&gt; EXPR
3773      * |   `--ASSIGN -&gt; =
3774      * |       |--IDENT -&gt; c
3775      * |       `--LT -&gt; &lt;
3776      * |           |--IDENT -&gt; a
3777      * |           `--IDENT -&gt; b
3778      * |--SEMI -&gt; ;
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 &gt; b;
3790      * </pre>
3791      * <p>parses as:</p>
3792      * <pre>
3793      * |--EXPR -&gt; EXPR
3794      * |   `--ASSIGN -&gt; =
3795      * |       |--IDENT -&gt; c
3796      * |       `--BAND -&gt; &gt;
3797      * |           |--IDENT -&gt; a
3798      * |           `--IDENT -&gt; b
3799      * |--SEMI -&gt; ;
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 &lt;= b;
3811      * </pre>
3812      * <p>parses as:</p>
3813      * <pre>
3814      * |--EXPR -&gt; EXPR
3815      * |   `--ASSIGN -&gt; =
3816      * |       |--IDENT -&gt; c
3817      * |       `--LE -&gt; &lt;=
3818      * |           |--IDENT -&gt; a
3819      * |           `--IDENT -&gt; b
3820      * |--SEMI -&gt; ;
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 &gt;= 3;
3832      * </pre>
3833      * <p>parses as:</p>
3834      * <pre>
3835      * VARIABLE_DEF -&gt; VARIABLE_DEF
3836      *  |--MODIFIERS -&gt; MODIFIERS
3837      *  |--TYPE -&gt; TYPE
3838      *  |   `--LITERAL_BOOLEAN -&gt; boolean
3839      *  |--IDENT -&gt; b
3840      *  `--ASSIGN -&gt; =
3841      *      `--EXPR -&gt; EXPR
3842      *          `--GE -&gt; &gt;=
3843      *              |--IDENT -&gt; a
3844      *              `--NUM_INT -&gt; 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 &amp;&amp; sb.isEmpty());  // guarded pattern, `PATTERN_DEF`
3861      * </pre>
3862      * <p>parses as:</p>
3863      * <pre>
3864      * |--VARIABLE_DEF -&gt; VARIABLE_DEF
3865      * |   |--MODIFIERS -&gt; MODIFIERS
3866      * |   |--TYPE -&gt; TYPE
3867      * |   |   `--LITERAL_BOOLEAN -&gt; boolean
3868      * |   |--IDENT -&gt; isBuilderReferenceType
3869      * |   `--ASSIGN -&gt; =
3870      * |       `--EXPR -&gt; EXPR
3871      * |           `--LITERAL_INSTANCEOF -&gt; instanceof
3872      * |               |--IDENT -&gt; text
3873      * |               `--TYPE -&gt; TYPE
3874      * |                   `--IDENT -&gt; StringBuilder
3875      * |--SEMI -&gt; ;
3876      * |--VARIABLE_DEF -&gt; VARIABLE_DEF
3877      * |   |--MODIFIERS -&gt; MODIFIERS
3878      * |   |--TYPE -&gt; TYPE
3879      * |   |   `--LITERAL_BOOLEAN -&gt; boolean
3880      * |   |--IDENT -&gt; isBuilderPatternWithPattern
3881      * |   `--ASSIGN -&gt; =
3882      * |       `--EXPR -&gt; EXPR
3883      * |           `--LITERAL_INSTANCEOF -&gt; instanceof
3884      * |               |--IDENT -&gt; text
3885      * |               `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
3886      * |                   |--MODIFIERS -&gt; MODIFIERS
3887      * |                   |--TYPE -&gt; TYPE
3888      * |                   |   `--IDENT -&gt; StringBuilder
3889      * |                   `--IDENT -&gt; s
3890      * |--SEMI -&gt; ;
3891      * |--VARIABLE_DEF -&gt; VARIABLE_DEF
3892      * |   |--MODIFIERS -&gt; MODIFIERS
3893      * |   |--TYPE -&gt; TYPE
3894      * |   |   `--LITERAL_BOOLEAN -&gt; boolean
3895      * |   |--IDENT -&gt; isBuilderEmpty
3896      * |   `--ASSIGN -&gt; =
3897      * |       `--EXPR -&gt; EXPR
3898      * |           `--LITERAL_INSTANCEOF -&gt; instanceof
3899      * |               |--IDENT -&gt; text
3900      * |               `--PATTERN_DEF -&gt; PATTERN_DEF
3901      * |                   `--LPAREN -&gt; (
3902      * |                       |--LAND -&gt; &amp;&amp;
3903      * |                       |   |--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
3904      * |                       |   |   |--MODIFIERS -&gt; MODIFIERS
3905      * |                       |   |   |--TYPE -&gt; TYPE
3906      * |                       |   |   |   `--IDENT -&gt; StringBuilder
3907      * |                       |   |   `--IDENT -&gt; sb
3908      * |                       |   `--METHOD_CALL -&gt; (
3909      * |                       |       |--DOT -&gt; .
3910      * |                       |       |   |--IDENT -&gt; sb
3911      * |                       |       |   `--IDENT -&gt; isEmpty
3912      * |                       |       |--ELIST -&gt; ELIST
3913      * |                       |       `--RPAREN -&gt; )
3914      * |                       `--RPAREN -&gt; )
3915      * `--SEMI -&gt; ;
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, &sect;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 &lt;&lt; b;
3939      * </pre>
3940      * <p>parses as:</p>
3941      * <pre>
3942      * |--EXPR -&gt; EXPR
3943      * |   `--ASSIGN -&gt; =
3944      * |       |--IDENT -&gt; a
3945      * |       `--SR -&gt; &lt;&lt;
3946      * |           |--IDENT -&gt; a
3947      * |           `--IDENT -&gt; b
3948      * |--SEMI -&gt; ;
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, &sect;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 &gt;&gt; b;
3963      * </pre>
3964      * <p>parses as:</p>
3965      * <pre>
3966      * |--EXPR -&gt; EXPR
3967      * |   `--ASSIGN -&gt; =
3968      * |       |--IDENT -&gt; a
3969      * |       `--SR -&gt; &gt;&gt;
3970      * |           |--IDENT -&gt; a
3971      * |           `--IDENT -&gt; b
3972      * |--SEMI -&gt; ;
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, &sect;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 &gt;&gt;&gt; b;
3987      * </pre>
3988      * <p>parses as:</p>
3989      * <pre>
3990      * |--EXPR -&gt; EXPR
3991      * |   `--BSR -&gt; &gt;&gt;&gt;
3992      * |       |--IDENT -&gt; a
3993      * |       `--IDENT -&gt; b
3994      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4013      * |   `--ASSIGN -&gt; =
4014      * |       |--IDENT -&gt; c
4015      * |       `--PLUS -&gt; +
4016      * |           |--IDENT -&gt; a
4017      * |           `--IDENT -&gt; b
4018      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4037      * |   `--ASSIGN -&gt; =
4038      * |       |--IDENT -&gt; c
4039      * |       `--MINUS -&gt; -
4040      * |           |--IDENT -&gt; a
4041      * |           `--IDENT -&gt; b
4042      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4061      * |   `--ASSIGN -&gt; =
4062      * |       |--IDENT -&gt; a
4063      * |       `--DIV -&gt; /
4064      * |           |--NUM_INT -&gt; 4
4065      * |           `--NUM_INT -&gt; 2
4066      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4085      *  `--ASSIGN -&gt; =
4086      *      |--IDENT -&gt; c
4087      *      `--MOD -&gt; %
4088      *          |--IDENT -&gt; a
4089      *          `--IDENT -&gt; b
4090      * SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4109      * |   `--INC -&gt; ++
4110      * |       `--IDENT -&gt; a
4111      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4131      * |   `--DEC -&gt; --
4132      * |       `--IDENT -&gt; a
4133      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4153      * |   `--ASSIGN -&gt; =
4154      * |       |--IDENT -&gt; a
4155      * |       `--BNOT -&gt; ~
4156      * |           `--IDENT -&gt; a
4157      * |--SEMI -&gt; ;
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, &sect;15.15.5</a>
4163      * @see #EXPR
4164      **/
4165     public static final int BNOT = JavaLanguageLexer.BNOT;
4166     /**
4167      * The <code>&#33;</code> (logical complement) operator.
4168      *
4169      * <p>For example:</p>
4170      * <pre>
4171      * c = &#33; a;
4172      * </pre>
4173      * <p>parses as:</p>
4174      * <pre>
4175      * |--EXPR -&gt; EXPR
4176      * |   `--ASSIGN -&gt; =
4177      * |       |--IDENT -&gt; c
4178      * |       `--LNOT -&gt; &#33;
4179      * |           `--IDENT -&gt; a
4180      * |--SEMI -&gt; ;
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, &sect;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 -&gt; VARIABLE_DEF
4202      * |   |--MODIFIERS -&gt; MODIFIERS
4203      * |   |--TYPE -&gt; TYPE
4204      * |   |   `--LITERAL_BOOLEAN -&gt; boolean
4205      * |   |--IDENT -&gt; a
4206      * |   `--ASSIGN -&gt; =
4207      * |       `--EXPR -&gt; EXPR
4208      * |           `--LITERAL_TRUE -&gt; true
4209      * |--SEMI -&gt; ;
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, &sect;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 -&gt; VARIABLE_DEF
4231      *  |--MODIFIERS -&gt; MODIFIERS
4232      *  |--TYPE -&gt; TYPE
4233      *  |   `--LITERAL_BOOLEAN -&gt; boolean
4234      *  |--IDENT -&gt; a
4235      *  |--ASSIGN -&gt; =
4236      *  |   `--EXPR -&gt; EXPR
4237      *  |       `--LITERAL_FALSE -&gt; false
4238      *  `--SEMI -&gt; ;
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, &sect;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 -&gt; VARIABLE_DEF
4260      *  |--MODIFIERS -&gt; MODIFIERS
4261      *  |--TYPE -&gt; TYPE
4262      *  |   `--IDENT -&gt; String
4263      *  |--IDENT -&gt; s
4264      *  |--ASSIGN -&gt; =
4265      *  |   `--EXPR -&gt; EXPR
4266      *  |       `--LITERAL_NULL -&gt; null
4267      *  `--SEMI -&gt; ;
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, &sect;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&lt;String&gt; l = new ArrayList&lt;String&gt;();
4287      * </pre>
4288      *
4289      * <p>parses as:</p>
4290      * <pre>
4291      * VARIABLE_DEF -&gt; VARIABLE_DEF
4292      *  |--MODIFIERS -&gt; MODIFIERS
4293      *  |--TYPE -&gt; TYPE
4294      *  |   |--IDENT -&gt; List
4295      *  |   `--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
4296      *  |       |--GENERIC_START -&gt; &lt;
4297      *  |       |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
4298      *  |       |   `--IDENT -&gt; String
4299      *  |       `--GENERIC_END -&gt; &gt;
4300      *  |--IDENT -&gt; l
4301      *  |--ASSIGN -&gt; =
4302      *  |   `--EXPR -&gt; EXPR
4303      *  |       `--LITERAL_NEW -&gt; new
4304      *  |           |--IDENT -&gt; ArrayList
4305      *  |           |--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
4306      *  |           |   |--GENERIC_START -&gt; &lt;
4307      *  |           |   |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
4308      *  |           |   |   `--IDENT -&gt; String
4309      *  |           |   `--GENERIC_END -&gt; &gt;
4310      *  |           |--LPAREN -&gt; (
4311      *  |           |--ELIST -&gt; ELIST
4312      *  |           `--RPAREN -&gt; )
4313      *  `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
4324      *  |--MODIFIERS -&gt; MODIFIERS
4325      *  |--TYPE -&gt; TYPE
4326      *  |   |--IDENT -&gt; String
4327      *  |   `--ARRAY_DECLARATOR -&gt; [
4328      *  |       `--RBRACK -&gt; ]
4329      *  |--IDENT -&gt; strings
4330      *  |--ASSIGN -&gt; =
4331      *  |   `--EXPR -&gt; EXPR
4332      *  |       `--LITERAL_NEW -&gt; new
4333      *  |           |--IDENT -&gt; String
4334      *  |           `--ARRAY_DECLARATOR -&gt; [
4335      *  |               |--EXPR -&gt; EXPR
4336      *  |               |   `--NUM_INT -&gt; 3
4337      *  |               `--RBRACK -&gt; ]
4338      *  `--SEMI -&gt; ;
4339      * </pre>
4340      *
4341      * <p>For example:</p>
4342      * <pre>
4343      * Supplier&lt;Integer&gt; s = new Supplier&lt;&gt;() {
4344      *     &#064;Override
4345      *     public Integer get() {
4346      *         return 42;
4347      *     }
4348      * };
4349      * </pre>
4350      *
4351      * <p>parses as:</p>
4352      * <pre>
4353      * VARIABLE_DEF -&gt; VARIABLE_DEF
4354      *  |--MODIFIERS -&gt; MODIFIERS
4355      *  |--TYPE -&gt; TYPE
4356      *  |   |--IDENT -&gt; Supplier
4357      *  |   `--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
4358      *  |       |--GENERIC_START -&gt; &lt;
4359      *  |       |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
4360      *  |       |   `--IDENT -&gt; Integer
4361      *  |       `--GENERIC_END -&gt; &gt;
4362      *  |--IDENT -&gt; s
4363      *  |--ASSIGN -&gt; =
4364      *  |   `--EXPR -&gt; EXPR
4365      *  |       `--LITERAL_NEW -&gt; new
4366      *  |           |--IDENT -&gt; Supplier
4367      *  |           |--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
4368      *  |           |   |--GENERIC_START -&gt; &lt;
4369      *  |           |   `--GENERIC_END -&gt; &gt;
4370      *  |           |--LPAREN -&gt; (
4371      *  |           |--ELIST -&gt; ELIST
4372      *  |           |--RPAREN -&gt; )
4373      *  |           `--OBJBLOCK -&gt; OBJBLOCK
4374      *  |               |--LCURLY -&gt; {
4375      *  |               |--METHOD_DEF -&gt; METHOD_DEF
4376      *  |               |   |--MODIFIERS -&gt; MODIFIERS
4377      *  |               |   |   |--ANNOTATION -&gt; ANNOTATION
4378      *  |               |   |   |   |--AT -&gt; @
4379      *  |               |   |   |   `--IDENT -&gt; Override
4380      *  |               |   |   `--LITERAL_PUBLIC -&gt; public
4381      *  |               |   |--TYPE -&gt; TYPE
4382      *  |               |   |   `--IDENT -&gt; Integer
4383      *  |               |   |--IDENT -&gt; get
4384      *  |               |   |--LPAREN -&gt; (
4385      *  |               |   |--PARAMETERS -&gt; PARAMETERS
4386      *  |               |   |--RPAREN -&gt; )
4387      *  |               |   `--SLIST -&gt; {
4388      *  |               |       |--LITERAL_RETURN -&gt; return
4389      *  |               |       |   |--EXPR -&gt; EXPR
4390      *  |               |       |   |   `--NUM_INT -&gt; 42
4391      *  |               |       |   `--SEMI -&gt; ;
4392      *  |               |       `--RCURLY -&gt; }
4393      *  |               `--RCURLY -&gt; }
4394      *  `--SEMI -&gt; ;
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 -&gt; EXPR
4418      * |   `--ASSIGN -&gt; =
4419      * |       |--IDENT -&gt; a
4420      * |       `--NUM_INT -&gt; 3
4421      * |--SEMI -&gt; ;
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, &sect;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 -&gt; return
4442      *    |--EXPR -&gt; EXPR
4443      *    |   `--CHAR_LITERAL -&gt; 'a'
4444      *    `--SEMI -&gt; ;
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, &sect;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 -&gt; VARIABLE_DEF
4464      *  |   |--MODIFIERS -&gt; MODIFIERS
4465      *  |   |--TYPE -&gt; TYPE
4466      *  |   |   `--IDENT -&gt; String
4467      *  |   |--IDENT -&gt; str
4468      *  |   `--ASSIGN -&gt; =
4469      *  |       `--EXPR -&gt; EXPR
4470      *  |           `--STRING_LITERAL -&gt; "StringLiteral"
4471      *  |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4493      * |   `--ASSIGN -&gt; =
4494      * |       |--IDENT -&gt; a
4495      * |       `--NUM_FLOAT -&gt; 3.14f
4496      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4518      * |   `--ASSIGN -&gt; =
4519      * |       |--IDENT -&gt; a
4520      * |       `--NUM_LONG -&gt; 3l
4521      * |--SEMI -&gt; ;
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, &sect;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 -&gt; EXPR
4543      * |   `--ASSIGN -&gt; =
4544      * |       |--IDENT -&gt; a
4545      * |       `--NUM_DOUBLE -&gt; 3.14d
4546      * |--SEMI -&gt; ;
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, &sect;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 -&gt; assert
4568      *  |--EXPR -&gt; EXPR
4569      *  |   |--LPAREN -&gt; (
4570      *  |   |--EQUAL -&gt; ==
4571      *  |   |   |--IDENT -&gt; x
4572      *  |   |   `--NUM_INT -&gt; 4
4573      *  |   `--RPAREN -&gt; )
4574      *  `--SEMI -&gt; ;
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 -&gt; import
4591      * |--LITERAL_STATIC -&gt; static
4592      * |--DOT -&gt; .
4593      * |   |--DOT -&gt; .
4594      * |   |   |--IDENT -&gt; java
4595      * |   |   `--IDENT -&gt; io
4596      * |   `--IDENT -&gt; IOException
4597      * `--SEMI -&gt; ;
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 -&gt; ENUM_DEF
4633      *  |--MODIFIERS -&gt; MODIFIERS
4634      *  |   `--LITERAL_PUBLIC -&gt; public
4635      *  |--ENUM -&gt; enum
4636      *  |--IDENT -&gt; MyEnum
4637      *  |--IMPLEMENTS_CLAUSE -&gt; implements
4638      *  |   `--IDENT -&gt; Serializable
4639      *  `--OBJBLOCK -&gt; OBJBLOCK
4640      *      |--LCURLY -&gt; {
4641      *      |--ENUM_CONSTANT_DEF -&gt; ENUM_CONSTANT_DEF
4642      *      |   |--ANNOTATIONS -&gt; ANNOTATIONS
4643      *      |   `--IDENT -&gt; FIRST_CONSTANT
4644      *      |--COMMA -&gt; ,
4645      *      |--ENUM_CONSTANT_DEF -&gt; ENUM_CONSTANT_DEF
4646      *      |   |--ANNOTATIONS -&gt; ANNOTATIONS
4647      *      |   `--IDENT -&gt; SECOND_CONSTANT
4648      *      |--SEMI -&gt; ;
4649      *      |--METHOD_DEF -&gt; METHOD_DEF
4650      *      |   |--MODIFIERS -&gt; MODIFIERS
4651      *      |   |   `--LITERAL_PUBLIC -&gt; public
4652      *      |   |--TYPE -&gt; TYPE
4653      *      |   |   `--LITERAL_VOID -&gt; void
4654      *      |   |--IDENT -&gt; someMethod
4655      *      |   |--LPAREN -&gt; (
4656      *      |   |--PARAMETERS -&gt; PARAMETERS
4657      *      |   |--RPAREN -&gt; )
4658      *      |   `--SLIST -&gt; {
4659      *      |       `--RCURLY -&gt; }
4660      *      `--RCURLY -&gt; }
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 -&gt; ENUM_DEF
4688      *  |--MODIFIERS -&gt; MODIFIERS
4689      *  |  `--LITERAL_PUBLIC -&gt; public
4690      *  |--ENUM -&gt; enum
4691      *  |--IDENT -&gt; Count
4692      *  `--OBJBLOCK -&gt; OBJBLOCK
4693      *      |--LCURLY -&gt; {
4694      *      `--RCURLY -&gt; }
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 -&gt; ENUM_CONSTANT_DEF
4723      *   |   |--ANNOTATIONS -&gt; ANNOTATIONS
4724      *   |   |--IDENT -&gt; SOME_CONSTANT
4725      *   |   |--LPAREN -&gt; (
4726      *   |   |--ELIST -&gt; ELIST
4727      *   |   |   `--EXPR -&gt; EXPR
4728      *   |   |       `--NUM_INT -&gt; 1
4729      *   |   |--RPAREN -&gt; )
4730      *   |   `--OBJBLOCK -&gt; OBJBLOCK
4731      *   |       |--LCURLY -&gt; {
4732      *   |       |--METHOD_DEF -&gt; METHOD_DEF
4733      *   |       |   |--MODIFIERS -&gt; MODIFIERS
4734      *   |       |   |   `--LITERAL_PUBLIC -&gt; public
4735      *   |       |   |--TYPE -&gt; TYPE
4736      *   |       |   |   `--LITERAL_VOID -&gt; void
4737      *   |       |   |--IDENT -&gt; someMethodOverriddenFromMainBody
4738      *   |       |   |--LPAREN -&gt; (
4739      *   |       |   |--PARAMETERS -&gt; PARAMETERS
4740      *   |       |   |--RPAREN -&gt; )
4741      *   |       |   `--SLIST -&gt; {
4742      *   |       |       `--RCURLY -&gt; }
4743      *   |       `--RCURLY -&gt; }
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 -&gt; for
4771      *  |--LPAREN -&gt; (
4772      *  |--FOR_EACH_CLAUSE -&gt; FOR_EACH_CLAUSE
4773      *  |   |--VARIABLE_DEF -&gt; VARIABLE_DEF
4774      *  |   |   |--MODIFIERS -&gt; MODIFIERS
4775      *  |   |   |--TYPE -&gt; TYPE
4776      *  |   |   |   `--LITERAL_INT -&gt; int
4777      *  |   |   `--IDENT -&gt; value
4778      *  |   |--COLON -&gt; :
4779      *  |   `--EXPR -&gt; EXPR
4780      *  |       `--IDENT -&gt; values
4781      *  |--RPAREN -&gt; )
4782      *  `--SLIST -&gt; {
4783      *      |--EXPR -&gt; EXPR
4784      *      |   `--METHOD_CALL -&gt; (
4785      *      |       |--IDENT -&gt; doSmth
4786      *      |       |--ELIST -&gt; ELIST
4787      *      |       `--RPAREN -&gt; )
4788      *      |--SEMI -&gt; ;
4789      *      `--RCURLY -&gt; }
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 -&gt; ANNOTATION_DEF
4813      *  |--MODIFIERS -&gt; MODIFIERS
4814      *  |   `--LITERAL_PUBLIC -&gt; public
4815      *  |--AT -&gt; @
4816      *  |--LITERAL_INTERFACE -&gt; interface
4817      *  |--IDENT -&gt; MyAnnotation
4818      *  `--OBJBLOCK -&gt; OBJBLOCK
4819      *      |--LCURLY -&gt; {
4820      *      |--ANNOTATION_FIELD_DEF -&gt; ANNOTATION_FIELD_DEF
4821      *      |   |--MODIFIERS -&gt; MODIFIERS
4822      *      |   |--TYPE -&gt; TYPE
4823      *      |   |   `--LITERAL_INT -&gt; int
4824      *      |   |--IDENT -&gt; someValue
4825      *      |   |--LPAREN -&gt; (
4826      *      |   |--RPAREN -&gt; )
4827      *      |   `--SEMI -&gt; ;
4828      *      `--RCURLY -&gt; }
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 -&gt; ANNOTATION_FIELD_DEF
4858      *  |--MODIFIERS -&gt; MODIFIERS
4859      *  |--TYPE -&gt; TYPE
4860      *  |   `--IDENT -&gt; String
4861      *  |--IDENT -&gt; someField
4862      *  |--LPAREN -&gt; (
4863      *  |--RPAREN -&gt; )
4864      *  |--LITERAL_DEFAULT -&gt; default
4865      *  |   `--EXPR -&gt; EXPR
4866      *  |       `--STRING_LITERAL -&gt; "Hello world"
4867      *  `--SEMI -&gt; ;
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: &#064; 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      *     &#064;MyAnnotation package blah;
4892      * </pre>
4893      *
4894      * <p>parses as:</p>
4895      *
4896      * <pre>
4897      * PACKAGE_DEF -&gt; package
4898      *  |--ANNOTATIONS -&gt; ANNOTATIONS
4899      *  |   `--ANNOTATION -&gt; ANNOTATION
4900      *  |       |--AT -&gt; @
4901      *  |       `--IDENT -&gt; MyAnnotation
4902      *  |--IDENT -&gt; blah
4903      *  `--SEMI -&gt; ;
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: &#064; 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      *     &#064;MyAnnotation(someField1 = "Hello",
4928      *                    someField2 = &#064;SomeOtherAnnotation)
4929      * </pre>
4930      * <p>parses as:</p>
4931      * <pre>
4932      * ANNOTATION -&gt; ANNOTATION
4933      *  |--AT -&gt; @
4934      *  |--IDENT -&gt; MyAnnotation
4935      *  |--LPAREN -&gt; (
4936      *  |--ANNOTATION_MEMBER_VALUE_PAIR -&gt; ANNOTATION_MEMBER_VALUE_PAIR
4937      *  |   |--IDENT -&gt; someField1
4938      *  |   |--ASSIGN -&gt; =
4939      *  |   `--EXPR -&gt; EXPR
4940      *  |       `--STRING_LITERAL -&gt; "Hello"
4941      *  |--COMMA -&gt; ,
4942      *  |--ANNOTATION_MEMBER_VALUE_PAIR -&gt; ANNOTATION_MEMBER_VALUE_PAIR
4943      *  |   |--IDENT -&gt; someField2
4944      *  |   |--ASSIGN -&gt; =
4945      *  |   `--ANNOTATION -&gt; ANNOTATION
4946      *  |       |--AT -&gt; @
4947      *  |       `--IDENT -&gt; SomeOtherAnnotation
4948      *  `--RPAREN -&gt; )
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      * &#064;Annotation(
4968      *     value="123"
4969      * )
4970      * </pre>
4971      * <p>parses as:</p>
4972      * <pre>
4973      * ANNOTATION -&gt; ANNOTATION
4974      *  |--AT -&gt; &#64;
4975      *  |--IDENT -&gt; Annotation
4976      *  |--LPAREN -&gt; (
4977      *  |--ANNOTATION_MEMBER_VALUE_PAIR -&gt; ANNOTATION_MEMBER_VALUE_PAIR
4978      *  |   |--IDENT -&gt; value
4979      *  |   |--ASSIGN -&gt; =
4980      *  |   `--EXPR -&gt; EXPR
4981      *  |       `--STRING_LITERAL -&gt; "123"
4982      *  `--RPAREN -&gt; )
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      * &#64;Annotation({1, 2})
5004      * </pre>
5005      * <p>parses as:</p>
5006      * <pre>
5007      * ANNOTATION -&gt; ANNOTATION
5008      *  |--AT -&gt; &#64;
5009      *  |--IDENT -&gt; Annotation
5010      *  |--LPAREN -&gt; (
5011      *  |--ANNOTATION_ARRAY_INIT -&gt; {
5012      *  |   |--EXPR -&gt; EXPR
5013      *  |   |   `--NUM_INT -&gt; 1
5014      *  |   |--COMMA -&gt; ,
5015      *  |   |--EXPR -&gt; EXPR
5016      *  |   |   `--NUM_INT -&gt; 2
5017      *  |   `--RCURLY -&gt; }
5018      *  `--RPAREN -&gt; )
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&lt;A, B&gt; {
5040      *
5041      * }
5042      * </pre>
5043      *
5044      * <p>parses as:</p>
5045      *
5046      * <pre>
5047      * CLASS_DEF -&gt; CLASS_DEF
5048      * |--MODIFIERS -&gt; MODIFIERS
5049      * |   `--LITERAL_PUBLIC -&gt; public
5050      * |--LITERAL_CLASS -&gt; class
5051      * |--IDENT -&gt; MyClass
5052      * |--TYPE_PARAMETERS -&gt; TYPE_PARAMETERS
5053      * |   |--GENERIC_START -&gt; &lt;
5054      * |   |--TYPE_PARAMETER -&gt; TYPE_PARAMETER
5055      * |   |   `--IDENT -&gt; A
5056      * |   |--COMMA -&gt; ,
5057      * |   |--TYPE_PARAMETER -&gt; TYPE_PARAMETER
5058      * |   |   `--IDENT -&gt; B
5059      * |   `--GENERIC_END -&gt; &gt;
5060      * `--OBJBLOCK -&gt; OBJBLOCK
5061      *     |--LCURLY -&gt; {
5062      *     `--RCURLY -&gt; }
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 &lt;A extends Collection&gt; {
5083      *
5084      * }
5085      * </pre>
5086      *
5087      * <p>parses as:</p>
5088      *
5089      * <pre>
5090      * CLASS_DEF -&gt; CLASS_DEF
5091      * |--MODIFIERS -&gt; MODIFIERS
5092      * |   `--LITERAL_PUBLIC -&gt; public
5093      * |--LITERAL_CLASS -&gt; class
5094      * |--IDENT -&gt; MyClass
5095      * |--TYPE_PARAMETERS -&gt; TYPE_PARAMETERS
5096      * |   |--GENERIC_START -&gt; &lt;
5097      * |   |--TYPE_PARAMETER -&gt; TYPE_PARAMETER
5098      * |   |   |--IDENT -&gt; A
5099      * |   |   `--TYPE_UPPER_BOUNDS -&gt; extends
5100      * |   |       `--IDENT -&gt; Collection
5101      * |   `--GENERIC_END -&gt; &gt;
5102      * `--OBJBLOCK -&gt; OBJBLOCK
5103      *     |--LCURLY -&gt; {
5104      *     `--RCURLY -&gt; }
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&lt;?&gt; a;
5126      * </pre>
5127      *
5128      * <p>parses as:</p>
5129      *
5130      * <pre>
5131      * VARIABLE_DEF -&gt; VARIABLE_DEF
5132      *  |--MODIFIERS -&gt; MODIFIERS
5133      *  |   `--LITERAL_PUBLIC -&gt; public
5134      *  |--TYPE -&gt; TYPE
5135      *  |   |--IDENT -&gt; Collection
5136      *  |   `--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
5137      *  |       |--GENERIC_START -&gt; &lt;
5138      *  |       |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
5139      *  |       |   `--WILDCARD_TYPE -&gt; ?
5140      *  |       `--GENERIC_END -&gt; &gt;
5141      *  |--IDENT -&gt; a
5142      *  `--SEMI -&gt; ;
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&lt;? super List&gt; list;</pre>
5159      * <p>parses as:</p>
5160      * <pre>
5161      * VARIABLE_DEF -&gt; VARIABLE_DEF
5162      *  |--MODIFIERS -&gt; MODIFIERS
5163      *  |--TYPE -&gt; TYPE
5164      *  |   |--IDENT -&gt; List
5165      *  |   `--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
5166      *  |       |--GENERIC_START -&gt; &lt;
5167      *  |       |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
5168      *  |       |   |--WILDCARD_TYPE -&gt; ?
5169      *  |       |   `--TYPE_LOWER_BOUNDS -&gt; super
5170      *  |       |       `--IDENT -&gt; List
5171      *  |       `--GENERIC_END -&gt; &gt;
5172      *  |--IDENT -&gt; list
5173      *  `--SEMI -&gt; ;
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&lt;?&gt; list;
5191      * </pre>
5192      * <p>parses as:</p>
5193      * <pre>
5194      * |--VARIABLE_DEF -&gt; VARIABLE_DEF
5195      * |   |--MODIFIERS -&gt; MODIFIERS
5196      * |   |--TYPE -&gt; TYPE
5197      * |   |   |--IDENT -&gt; List
5198      * |   |   |`--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
5199      * |   |        |--GENERIC_START -&gt; &lt;
5200      * |   |        |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
5201      * |   |        |  `--WILDCARD_TYPE -&gt; ?
5202      * |   |        `--GENERIC_END -&gt; &gt;
5203      * |   `--IDENT -&gt; list
5204      * |--SEMI -&gt; ;
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&lt;? extends Number&gt; list;</pre>
5222      *
5223      * <p>parses as:</p>
5224      * <pre>
5225      * --VARIABLE_DEF -&gt; VARIABLE_DEF
5226      *  |--MODIFIERS -&gt; MODIFIERS
5227      *  |--TYPE -&gt; TYPE
5228      *  |   |--IDENT -&gt; List
5229      *  |   `--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
5230      *  |       |--GENERIC_START -&gt; &lt;
5231      *  |       |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
5232      *  |       |   |--WILDCARD_TYPE -&gt; ?
5233      *  |       |   `--TYPE_UPPER_BOUNDS -&gt; extends
5234      *  |       |       `--IDENT -&gt; Number
5235      *  |       `--GENERIC_END -&gt; &gt;
5236      *  |--IDENT -&gt; list
5237      *  `--SEMI -&gt; ;
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&lt;? super Integer&gt; list;</pre>
5255      *
5256      *  <p>parses as:</p>
5257      *  <pre>
5258      *  --VARIABLE_DEF -&gt; VARIABLE_DEF
5259      *     |--MODIFIERS -&gt; MODIFIERS
5260      *     |--TYPE -&gt; TYPE
5261      *     |   |--IDENT -&gt; List
5262      *     |   `--TYPE_ARGUMENTS -&gt; TYPE_ARGUMENTS
5263      *     |       |--GENERIC_START -&gt; &lt;
5264      *     |       |--TYPE_ARGUMENT -&gt; TYPE_ARGUMENT
5265      *     |       |   |--WILDCARD_TYPE -&gt; ?
5266      *     |       |   `--TYPE_LOWER_BOUNDS -&gt; super
5267      *     |       |       `--IDENT -&gt; Integer
5268      *     |       `--GENERIC_END -&gt; &gt;
5269      *     |--IDENT -&gt; list
5270      *     `--SEMI -&gt; ;
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      * &#64;Deprecated
5289      * private int value;
5290      * </pre>
5291      *
5292      * <p>parses as:</p>
5293      * <pre>
5294      * VARIABLE_DEF -&gt; VARIABLE_DEF
5295      * |--MODIFIERS -&gt; MODIFIERS
5296      * |  |--ANNOTATION -&gt; ANNOTATION
5297      * |  |  |--AT -&gt; &#64;
5298      * |  |  `--IDENT -&gt; Deprecated
5299      * |  `--LITERAL_PRIVATE -&gt; private
5300      * |--TYPE -&gt; TYPE
5301      * |  `--LITERAL_INT -&gt; int
5302      * |--IDENT -&gt; value
5303      * `--SEMI -&gt; ;
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 -&gt; METHOD_DEF
5325      *   |--MODIFIERS -&gt; MODIFIERS
5326      *   |   `--LITERAL_PUBLIC -&gt; public
5327      *   |--TYPE -&gt; TYPE
5328      *   |   `--LITERAL_VOID -&gt; void
5329      *   |--IDENT -&gt; myShape
5330      *   |--LPAREN -&gt; (
5331      *   |--PARAMETERS -&gt; PARAMETERS
5332      *   |   `--PARAMETER_DEF -&gt; PARAMETER_DEF
5333      *   |       |--MODIFIERS -&gt; MODIFIERS
5334      *   |       |--TYPE -&gt; TYPE
5335      *   |       |   `--LITERAL_INT -&gt; int
5336      *   |       |--ELLIPSIS -&gt; ...
5337      *   |       `--IDENT -&gt; dimension
5338      *   |--RPAREN -&gt; )
5339      *   `--SLIST -&gt; {
5340      *       `--RCURLY -&gt; }
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 -&gt; CLASS_DEF
5356      * |--MODIFIERS -&gt; MODIFIERS
5357      * |--LITERAL_CLASS -&gt; class
5358      * |--IDENT -&gt; Comparable
5359      * |--TYPE_PARAMETERS -&gt; TYPE_PARAMETERS
5360      *     |--GENERIC_START -&gt; &lt;
5361      *     |--TYPE_PARAMETER -&gt; TYPE_PARAMETER
5362      *     |   |--IDENT -&gt; T
5363      *     |   `--TYPE_UPPER_BOUNDS -&gt; extends
5364      *     |       |--IDENT -&gt; Serializable
5365      *     |       |--TYPE_EXTENSION_AND -&gt; &#38;
5366      *     |       `--IDENT -&gt; CharSequence
5367      *     `--GENERIC_END -&gt; &gt;
5368      * </pre>
5369      *
5370      * <p>Type cast extension:
5371      * {@code return (Serializable & CharSequence) null;}</p>
5372      * <pre>
5373      * --LITERAL_RETURN -&gt; return
5374      *    |--EXPR -&gt; EXPR
5375      *    |   `--TYPECAST -&gt; (
5376      *    |       |--TYPE -&gt; TYPE
5377      *    |       |   `--IDENT -&gt; Serializable
5378      *    |       |--TYPE_EXTENSION_AND -&gt; &#38;
5379      *    |       |--TYPE -&gt; TYPE
5380      *    |       |   `--IDENT -&gt; CharSequence
5381      *    |       |--RPAREN -&gt; )
5382      *    |       `--LITERAL_NULL -&gt; null
5383      *    `--SEMI -&gt; ;
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, &sect;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, &sect;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&lt;T&gt; {}
5402      * </pre>
5403      * <p>parses as:</p>
5404      * <pre>
5405      * CLASS_DEF -&gt; CLASS_DEF
5406      *  |--MODIFIERS -&gt; MODIFIERS
5407      *  |--LITERAL_CLASS -&gt; class
5408      *  |--IDENT -&gt; Test
5409      *  |--TYPE_PARAMETERS -&gt; TYPE_PARAMETERS
5410      *  |   |--GENERIC_START -&gt; &lt;
5411      *  |   |--TYPE_PARAMETER -&gt; TYPE_PARAMETER
5412      *  |   |   `--IDENT -&gt; T
5413      *  |   `--GENERIC_END -&gt; &gt;
5414      *  `--OBJBLOCK -&gt; OBJBLOCK
5415      *      |--LCURLY -&gt; {
5416      *      `--RCURLY -&gt; }
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&lt;T&gt; {}
5434      * </pre>
5435      * <p>parses as:</p>
5436      * <pre>
5437      * CLASS_DEF -&gt; CLASS_DEF
5438      *  |--MODIFIERS -&gt; MODIFIERS
5439      *  |--LITERAL_CLASS -&gt; class
5440      *  |--IDENT -&gt; Test
5441      *  |--TYPE_PARAMETERS -&gt; TYPE_PARAMETERS
5442      *  |   |--GENERIC_START -&gt; &lt;
5443      *  |   |--TYPE_PARAMETER -&gt; TYPE_PARAMETER
5444      *  |   |   `--IDENT -&gt; T
5445      *  |   `--GENERIC_END -&gt; &gt;
5446      *  `--OBJBLOCK -&gt; OBJBLOCK
5447      *      |--LCURLY -&gt; {
5448      *      `--RCURLY -&gt; }
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) -&gt; System.out.println(n));
5465      * </pre>
5466      * <p>parses as:</p>
5467      * <pre>
5468      * METHOD_CALL -&gt; (
5469      *  |--DOT -&gt; .
5470      *  |   |--IDENT -&gt; numbers
5471      *  |   `--IDENT -&gt; forEach
5472      *  |--ELIST -&gt; ELIST
5473      *  |   `--LAMBDA -&gt; -&gt;
5474      *  |       |--LPAREN -&gt; (
5475      *  |       |--PARAMETERS -&gt; PARAMETERS
5476      *  |       |   `--PARAMETER_DEF -&gt; PARAMETER_DEF
5477      *  |       |       |--MODIFIERS -&gt; MODIFIERS
5478      *  |       |       |--TYPE -&gt; TYPE
5479      *  |       |       `--IDENT -&gt; n
5480      *  |       |--RPAREN -&gt; )
5481      *  |       `--EXPR -&gt; EXPR
5482      *  |           `--METHOD_CALL -&gt; (
5483      *  |               |--DOT -&gt; .
5484      *  |               |   |--DOT -&gt; .
5485      *  |               |   |   |--IDENT -&gt; System
5486      *  |               |   |   `--IDENT -&gt; out
5487      *  |               |   `--IDENT -&gt; println
5488      *  |               |--ELIST -&gt; ELIST
5489      *  |               |   `--EXPR -&gt; EXPR
5490      *  |               |       `--IDENT -&gt; n
5491      *  |               `--RPAREN -&gt; )
5492      *  `--RPAREN -&gt; )
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 -&gt; //
5503      *  `--COMMENT_CONTENT -&gt; \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 -&gt; //
5513      *  `--COMMENT_CONTENT -&gt;  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      * /&#42; Comment content
5524      * &#42;/
5525      * </pre>
5526      * <p>parses as:</p>
5527      * <pre>
5528      * --BLOCK_COMMENT_BEGIN -&gt; /&#42;
5529      *    |--COMMENT_CONTENT -&gt;  Comment content\r\n
5530      *    `--BLOCK_COMMENT_END -&gt; &#42;/
5531      * </pre>
5532      */
5533     public static final int BLOCK_COMMENT_BEGIN =
5534             JavaLanguageLexer.BLOCK_COMMENT_BEGIN;
5535 
5536     /**
5537      * End of block comment: '&#42;/'.
5538      *
5539      * <p>For example:</p>
5540      * <pre>
5541      * /&#42;comment&#42;/
5542      * </pre>
5543      * <p>parses as:</p>
5544      * <pre>
5545      * BLOCK_COMMENT_BEGIN -&gt; /&#42;
5546      *  |--COMMENT_CONTENT -&gt; comment
5547      *  `--BLOCK_COMMENT_END -&gt; &#42;/
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      * /&#42;
5562      * this is multiline comment
5563      * &#42;/
5564      * </pre>
5565      * <p>parses as:</p>
5566      * <pre>
5567      * |--SINGLE_LINE_COMMENT -&gt; //
5568      * |   `--COMMENT_CONTENT -&gt; this is single-line comment\n
5569      * |--BLOCK_COMMENT_BEGIN -&gt; /&#42;
5570      * |   |--COMMENT_CONTENT -&gt; \n\t\t\tthis is multiline comment\n\t\t
5571      * |   `--BLOCK_COMMENT_END -&gt; &#42;/
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 -&gt; if
5589      *  |--LPAREN -&gt; (
5590      *  |--EXPR -&gt; EXPR
5591      *  |   `--LITERAL_INSTANCEOF -&gt; instanceof
5592      *  |       |--IDENT -&gt; obj
5593      *  |       `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
5594      *  |           |--TYPE -&gt; TYPE
5595      *  |           |   `--IDENT -&gt; String
5596      *  |           `--IDENT -&gt; str
5597      *  |--RPAREN -&gt; )
5598      *  `--SLIST -&gt; {
5599      *      `--RCURLY -&gt; }
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 -&gt; RECORD_DEF
5621      * |--MODIFIERS -&gt; MODIFIERS
5622      * |   `--LITERAL_PUBLIC -&gt; public
5623      * |--LITERAL_RECORD -&gt; record
5624      * |--IDENT -&gt; MyRecord
5625      * |--LPAREN -&gt; (
5626      * |--RECORD_COMPONENTS -&gt; RECORD_COMPONENTS
5627      * |--RPAREN -&gt; )
5628      * `--OBJBLOCK -&gt; OBJBLOCK
5629      *     |--LCURLY -&gt; {
5630      *     `--RCURLY -&gt; }
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 -&gt; RECORD_DEF
5652      * |--MODIFIERS -&gt; MODIFIERS
5653      * |   `--LITERAL_PUBLIC -&gt; public
5654      * |--LITERAL_RECORD -&gt; record
5655      * |--IDENT -&gt; MyRecord
5656      * |--LPAREN -&gt; (
5657      * |--RECORD_COMPONENTS -&gt; RECORD_COMPONENTS
5658      * |--RPAREN -&gt; )
5659      * `--OBJBLOCK -&gt; OBJBLOCK
5660      *     |--LCURLY -&gt; {
5661      *     `--RCURLY -&gt; }
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 -&gt; RECORD_DEF
5680      *  |--MODIFIERS -&gt; MODIFIERS
5681      *  |   `--LITERAL_PUBLIC -&gt; public
5682      *  |--LITERAL_RECORD -&gt; record
5683      *  |--IDENT -&gt; myRecord
5684      *  |--LPAREN -&gt; (
5685      *  |--RECORD_COMPONENTS -&gt; RECORD_COMPONENTS
5686      *  |   |--RECORD_COMPONENT_DEF -&gt; RECORD_COMPONENT_DEF
5687      *  |   |   |--ANNOTATIONS -&gt; ANNOTATIONS
5688      *  |   |   |--TYPE -&gt; TYPE
5689      *  |   |   |   `--IDENT -&gt; Comp
5690      *  |   |   `--IDENT -&gt; x
5691      *  |   |--COMMA -&gt; ,
5692      *  |   `--RECORD_COMPONENT_DEF -&gt; RECORD_COMPONENT_DEF
5693      *  |       |--ANNOTATIONS -&gt; ANNOTATIONS
5694      *  |       |--TYPE -&gt; TYPE
5695      *  |       |   `--IDENT -&gt; Comp
5696      *  |       `--IDENT -&gt; y
5697      *  |--RPAREN -&gt; )
5698      *  `--OBJBLOCK -&gt; OBJBLOCK
5699      *      |--LCURLY -&gt; {
5700      *      `--RCURLY -&gt; }
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 -&gt; RECORD_DEF
5722      * |--MODIFIERS -&gt; MODIFIERS
5723      * |   `--LITERAL_PUBLIC -&gt; public
5724      * |--LITERAL_RECORD -&gt; record
5725      * |--IDENT -&gt; MyRecord
5726      * |--LPAREN -&gt; (
5727      * |--RECORD_COMPONENTS -&gt; RECORD_COMPONENTS
5728      * |   |--RECORD_COMPONENT_DEF -&gt; RECORD_COMPONENT_DEF
5729      * |   |   |--ANNOTATIONS -&gt; ANNOTATIONS
5730      * |   |   |--TYPE -&gt; TYPE
5731      * |   |   |   `--IDENT -&gt; Comp
5732      * |   |   `--IDENT -&gt; x
5733      * |   |--COMMA -&gt; ,
5734      * |   `--RECORD_COMPONENT_DEF -&gt; RECORD_COMPONENT_DEF
5735      * |       |--ANNOTATIONS -&gt; ANNOTATIONS
5736      * |       |--TYPE -&gt; TYPE
5737      * |       |   `--IDENT -&gt; Comp
5738      * |       |--ELLIPSIS -&gt; ...
5739      * |       `--IDENT -&gt; comps
5740      * |--RPAREN -&gt; )
5741      * `--OBJBLOCK -&gt; OBJBLOCK
5742      *     |--LCURLY -&gt; {
5743      *     `--RCURLY -&gt; }
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 -&gt; VARIABLE_DEF
5802      * |   |--MODIFIERS -&gt; MODIFIERS
5803      * |   |--TYPE -&gt; TYPE
5804      * |   |   `--IDENT -&gt; String
5805      * |   |--IDENT -&gt; hello
5806      * |   `--ASSIGN -&gt; =
5807      * |       `--EXPR -&gt; EXPR
5808      * |           `--TEXT_BLOCK_LITERAL_BEGIN -&gt; """
5809      * |               |--TEXT_BLOCK_CONTENT -&gt; \n                Hello, world!\n
5810      * |               `--TEXT_BLOCK_LITERAL_END -&gt; """
5811      * `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
5833      * |   |--MODIFIERS -&gt; MODIFIERS
5834      * |   |--TYPE -&gt; TYPE
5835      * |   |   `--IDENT -&gt; String
5836      * |   |--IDENT -&gt; hello
5837      * |   `--ASSIGN -&gt; =
5838      * |       `--EXPR -&gt; EXPR
5839      * |           `--TEXT_BLOCK_LITERAL_BEGIN -&gt; """
5840      * |               |--TEXT_BLOCK_CONTENT -&gt; \n                Hello, world!\n
5841      * |               `--TEXT_BLOCK_LITERAL_END -&gt; """
5842      * `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
5863      * |   |--MODIFIERS -&gt; MODIFIERS
5864      * |   |--TYPE -&gt; TYPE
5865      * |   |   `--IDENT -&gt; String
5866      * |   |--IDENT -&gt; hello
5867      * |   `--ASSIGN -&gt; =
5868      * |       `--EXPR -&gt; EXPR
5869      * |           `--TEXT_BLOCK_LITERAL_BEGIN -&gt; """
5870      * |               |--TEXT_BLOCK_CONTENT -&gt; \n                Hello, world!\n
5871      * |               `--TEXT_BLOCK_LITERAL_END -&gt; """
5872      * `--SEMI -&gt; ;
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 -&gt; VARIABLE_DEF
5897      * |   |--MODIFIERS -&gt; MODIFIERS
5898      * |   |--TYPE -&gt; TYPE
5899      * |   |   `--LITERAL_INT -&gt; int
5900      * |   |--IDENT -&gt; yield
5901      * |   `--ASSIGN -&gt; =
5902      * |       `--EXPR -&gt; EXPR
5903      * |           `--NUM_INT -&gt; 0
5904      * |--SEMI -&gt; ;
5905      * |--LITERAL_RETURN -&gt; return
5906      * |   |--EXPR -&gt; EXPR
5907      * |   |   `--LITERAL_SWITCH -&gt; switch
5908      * |   |       |--LPAREN -&gt; (
5909      * |   |       |--EXPR -&gt; EXPR
5910      * |   |       |   `--IDENT -&gt; mode
5911      * |   |       |--RPAREN -&gt; )
5912      * |   |       |--LCURLY -&gt; {
5913      * |   |       |--CASE_GROUP -&gt; CASE_GROUP
5914      * |   |       |   |--LITERAL_CASE -&gt; case
5915      * |   |       |   |   |--EXPR -&gt; EXPR
5916      * |   |       |   |   |   `--STRING_LITERAL -&gt; "a"
5917      * |   |       |   |   |--COMMA -&gt; ,
5918      * |   |       |   |   |--EXPR -&gt; EXPR
5919      * |   |       |   |   |   `--STRING_LITERAL -&gt; "b"
5920      * |   |       |   |   `--COLON -&gt; :
5921      * |   |       |   `--SLIST -&gt; SLIST
5922      * |   |       |       `--LITERAL_YIELD -&gt; yield
5923      * |   |       |           |--EXPR -&gt; EXPR
5924      * |   |       |           |   `--NUM_INT -&gt; 1
5925      * |   |       |           `--SEMI -&gt; ;
5926      * |   |       |--CASE_GROUP -&gt; CASE_GROUP
5927      * |   |       |   |--LITERAL_DEFAULT -&gt; default
5928      * |   |       |   |   `--COLON -&gt; :
5929      * |   |       |   `--SLIST -&gt; SLIST
5930      * |   |       |       `--LITERAL_YIELD -&gt; yield
5931      * |   |       |           |--EXPR -&gt; EXPR
5932      * |   |       |           |   `--UNARY_MINUS -&gt; -
5933      * |   |       |           |       `--NUM_INT -&gt; 1
5934      * |   |       |           `--SEMI -&gt; ;
5935      * |   |       `--RCURLY -&gt; }
5936      * |   `--SEMI -&gt; ;
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, &sect;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 -&gt; "Weekend";
5960      *     default -&gt; "Working day";
5961      * };
5962      * </pre>
5963      * <p>parses as:</p>
5964      * <pre>
5965      * LITERAL_RETURN -&gt; return
5966      *  |--EXPR -&gt; EXPR
5967      *  |   `--LITERAL_SWITCH -&gt; switch
5968      *  |       |--LPAREN -&gt; (
5969      *  |       |--EXPR -&gt; EXPR
5970      *  |       |   `--IDENT -&gt; day
5971      *  |       |--RPAREN -&gt; )
5972      *  |       |--LCURLY -&gt; {
5973      *  |       |--SWITCH_RULE -&gt; SWITCH_RULE
5974      *  |       |   |--LITERAL_CASE -&gt; case
5975      *  |       |   |   |--EXPR -&gt; EXPR
5976      *  |       |   |   |   `--IDENT -&gt; SAT
5977      *  |       |   |   |--COMMA -&gt; ,
5978      *  |       |   |   `--EXPR -&gt; EXPR
5979      *  |       |   |       `--IDENT -&gt; SUN
5980      *  |       |   |--LAMBDA -&gt; -&gt;
5981      *  |       |   |--EXPR -&gt; EXPR
5982      *  |       |   |   `--STRING_LITERAL -&gt; "Weekend"
5983      *  |       |   `--SEMI -&gt; ;
5984      *  |       |--SWITCH_RULE -&gt; SWITCH_RULE
5985      *  |       |   |--LITERAL_DEFAULT -&gt; default
5986      *  |       |   |--LAMBDA -&gt; -&gt;
5987      *  |       |   |--EXPR -&gt; EXPR
5988      *  |       |   |   `--STRING_LITERAL -&gt; "Working day"
5989      *  |       |   `--SEMI -&gt; ;
5990      *  |       `--RCURLY -&gt; }
5991      *  `--SEMI -&gt; ;
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, &sect;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 -&gt; CLASS_DEF
6018      * |--MODIFIERS -&gt; MODIFIERS
6019      * |   `--LITERAL_NON_SEALED -&gt; non-sealed
6020      * |--LITERAL_CLASS -&gt; class
6021      * |--IDENT -&gt; Square
6022      * |--EXTENDS_CLAUSE -&gt; extends
6023      * |   `--IDENT -&gt; Rectangle
6024      * `--OBJBLOCK -&gt; OBJBLOCK
6025      *     |--LCURLY -&gt; {
6026      *     `--RCURLY -&gt; }
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, &sect;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 -&gt; CLASS_DEF
6049      * |--MODIFIERS -&gt; MODIFIERS
6050      * |   |--LITERAL_PUBLIC -&gt; public
6051      * |   `--LITERAL_SEALED -&gt; sealed
6052      * |--LITERAL_CLASS -&gt; class
6053      * |--IDENT -&gt; Shape
6054      * |--PERMITS_CLAUSE -&gt; permits
6055      * |   |--IDENT -&gt; Circle
6056      * |   |--COMMA -&gt; ,
6057      * |   |--IDENT -&gt; Square
6058      * |   |--COMMA -&gt; ,
6059      * |   `--IDENT -&gt; Rectangle
6060      * `--OBJBLOCK -&gt; OBJBLOCK
6061      *     |--LCURLY -&gt; {
6062      *     `--RCURLY -&gt; }
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, &sect;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 -&gt; CLASS_DEF
6085      * |--MODIFIERS -&gt; MODIFIERS
6086      * |   |--LITERAL_PUBLIC -&gt; public
6087      * |   `--LITERAL_SEALED -&gt; sealed
6088      * |--LITERAL_CLASS -&gt; class
6089      * |--IDENT -&gt; Shape
6090      * |--PERMITS_CLAUSE -&gt; permits
6091      * |   |--IDENT -&gt; Circle
6092      * |   |--COMMA -&gt; ,
6093      * |   |--IDENT -&gt; Square
6094      * |   |--COMMA -&gt; ,
6095      * |   `--IDENT -&gt; Rectangle
6096      * `--OBJBLOCK -&gt; OBJBLOCK
6097      *     |--LCURLY -&gt; {
6098      *     `--RCURLY -&gt; }
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, &sect;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 -&gt; CLASS_DEF
6121      * |--MODIFIERS -&gt; MODIFIERS
6122      * |   |--LITERAL_PUBLIC -&gt; public
6123      * |   `--LITERAL_SEALED -&gt; sealed
6124      * |--LITERAL_CLASS -&gt; class
6125      * |--IDENT -&gt; Shape
6126      * |--PERMITS_CLAUSE -&gt; permits
6127      * |   |--IDENT -&gt; Circle
6128      * |   |--COMMA -&gt; ,
6129      * |   |--IDENT -&gt; Square
6130      * |   |--COMMA -&gt; ,
6131      * |   `--IDENT -&gt; Rectangle
6132      * `--OBJBLOCK -&gt; OBJBLOCK
6133      *     |--LCURLY -&gt; {
6134      *     `--RCURLY -&gt; }
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, &sect;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() &gt; 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 -&gt; switch
6167      * |   |--LPAREN -&gt; (
6168      * |   |--EXPR -&gt; EXPR
6169      * |   |   `--IDENT -&gt; o
6170      * |   |--RPAREN -&gt; )
6171      * |   |--LCURLY -&gt; {
6172      * |   |--CASE_GROUP -&gt; CASE_GROUP
6173      * |   |   |--LITERAL_CASE -&gt; case
6174      * |   |   |   |--PATTERN_DEF -&gt; PATTERN_DEF
6175      * |   |   |   |   `--LITERAL_WHEN -&gt; when
6176      * |   |   |   |       |--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
6177      * |   |   |   |       |   |--MODIFIERS -&gt; MODIFIERS
6178      * |   |   |   |       |   |--TYPE -&gt; TYPE
6179      * |   |   |   |       |   |   `--IDENT -&gt; String
6180      * |   |   |   |       |   `--IDENT -&gt; s
6181      * |   |   |   |       `--GT -&gt; &gt;
6182      * |   |   |   |           |--METHOD_CALL -&gt; (
6183      * |   |   |   |           |   |--DOT -&gt; .
6184      * |   |   |   |           |   |   |--IDENT -&gt; s
6185      * |   |   |   |           |   |   `--IDENT -&gt; length
6186      * |   |   |   |           |   |--ELIST -&gt; ELIST
6187      * |   |   |   |           |   `--RPAREN -&gt; )
6188      * |   |   |   |           `--NUM_INT -&gt; 4
6189      * |   |   |   `--COLON -&gt; :
6190      * |   |   `--SLIST -&gt; SLIST
6191      * |   |       `--LITERAL_BREAK -&gt; break
6192      * |   |           `--SEMI -&gt; ;
6193      * |   |--CASE_GROUP -&gt; CASE_GROUP
6194      * |   |   |--LITERAL_CASE -&gt; case
6195      * |   |   |   |--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
6196      * |   |   |   |   |--MODIFIERS -&gt; MODIFIERS
6197      * |   |   |   |   |--TYPE -&gt; TYPE
6198      * |   |   |   |   |   `--IDENT -&gt; String
6199      * |   |   |   |   `--IDENT -&gt; s
6200      * |   |   |   `--COLON -&gt; :
6201      * |   |   `--SLIST -&gt; SLIST
6202      * |   |       `--LITERAL_BREAK -&gt; break
6203      * |   |           `--SEMI -&gt; ;
6204      * |   `--RCURLY -&gt; }
6205      * `--RCURLY -&gt; }
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, &sect;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 &gt;= 0 -&gt; i;
6226      *     default -&gt; 2;
6227      * };
6228      * </pre>
6229      * <p>parses as:</p>
6230      * <pre>
6231      * LITERAL_RETURN -&gt; return
6232      *  `--EXPR -&gt; EXPR
6233      *      `--LITERAL_SWITCH -&gt; switch
6234      *          |--LPAREN -&gt; (
6235      *          |--EXPR -&gt; EXPR
6236      *          |   `--IDENT -&gt; o
6237      *          |--RPAREN -&gt; )
6238      *          |--LCURLY -&gt; {
6239      *          |--SWITCH_RULE -&gt; SWITCH_RULE
6240      *          |   |--LITERAL_CASE -&gt; case
6241      *          |   |   `--PATTERN_DEF -&gt; PATTERN_DEF
6242      *          |   |       `--LITERAL_WHEN -&gt; when
6243      *          |   |           |--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
6244      *          |   |           |   |--MODIFIERS -&gt; MODIFIERS
6245      *          |   |           |   |--TYPE -&gt; TYPE
6246      *          |   |           |   |   `--IDENT -&gt; Integer
6247      *          |   |           |   `--IDENT -&gt; i
6248      *          |   |           `--GE -&gt; &gt;=
6249      *          |   |               |--IDENT -&gt; i
6250      *          |   |               `--NUM_INT -&gt; 0
6251      *          |   |--LAMBDA -&gt; -&gt;
6252      *          |   |--EXPR -&gt; EXPR
6253      *          |   |   `--IDENT -&gt; i
6254      *          |   `--SEMI -&gt; ;
6255      *          |--SWITCH_RULE -&gt; SWITCH_RULE
6256      *          |   |--LITERAL_DEFAULT -&gt; default
6257      *          |   |--LAMBDA -&gt; -&gt;
6258      *          |   |--EXPR -&gt; EXPR
6259      *          |   |   `--NUM_INT -&gt; 2
6260      *          |   `--SEMI -&gt; ;
6261      *          `--RCURLY -&gt; }
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, &sect;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 -&gt; {}
6288      * }
6289      * </pre>
6290      * <p>parses as:</p>
6291      * <pre>
6292      * |--RECORD_DEF -&gt; RECORD_DEF
6293      * |   |--MODIFIERS -&gt; MODIFIERS
6294      * |   |--LITERAL_RECORD -&gt; record
6295      * |   |--IDENT -&gt; R
6296      * |   |--LPAREN -&gt; (
6297      * |   |--RECORD_COMPONENTS -&gt; RECORD_COMPONENTS
6298      * |   |   `--RECORD_COMPONENT_DEF -&gt; RECORD_COMPONENT_DEF
6299      * |   |       |--ANNOTATIONS -&gt; ANNOTATIONS
6300      * |   |       |--TYPE -&gt; TYPE
6301      * |   |       |   `--IDENT -&gt; Object
6302      * |   |       `--IDENT -&gt; o
6303      * |   |--RPAREN -&gt; )
6304      * |   `--OBJBLOCK -&gt; OBJBLOCK
6305      * |       |--LCURLY -&gt; {
6306      * |       `--RCURLY -&gt; }
6307      * |--LITERAL_IF -&gt; if
6308      * |   |--LPAREN -&gt; (
6309      * |   |--EXPR -&gt; EXPR
6310      * |   |   `--LITERAL_INSTANCEOF -&gt; instanceof
6311      * |   |       |--IDENT -&gt; o
6312      * |   |       `--RECORD_PATTERN_DEF -&gt; RECORD_PATTERN_DEF
6313      * |   |           |--MODIFIERS -&gt; MODIFIERS
6314      * |   |           |--TYPE -&gt; TYPE
6315      * |   |           |   `--IDENT -&gt; R
6316      * |   |           |--LPAREN -&gt; (
6317      * |   |           |--RECORD_PATTERN_COMPONENTS -&gt; RECORD_PATTERN_COMPONENTS
6318      * |   |           |   `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
6319      * |   |           |       |--MODIFIERS -&gt; MODIFIERS
6320      * |   |           |       |--TYPE -&gt; TYPE
6321      * |   |           |       |   `--IDENT -&gt; String
6322      * |   |           |       `--IDENT -&gt; s
6323      * |   |           |--RPAREN -&gt; )
6324      * |   |           `--IDENT -&gt; myRecord
6325      * |   |--RPAREN -&gt; )
6326      * |   `--SLIST -&gt; {
6327      * |       `--RCURLY -&gt; }
6328      * |--LITERAL_SWITCH -&gt; switch
6329      * |   |--LPAREN -&gt; (
6330      * |   |--EXPR -&gt; EXPR
6331      * |   |   `--IDENT -&gt; o
6332      * |   |--RPAREN -&gt; )
6333      * |   |--LCURLY -&gt; {
6334      * |   |--SWITCH_RULE -&gt; SWITCH_RULE
6335      * |   |   |--LITERAL_CASE -&gt; case
6336      * |   |   |   `--RECORD_PATTERN_DEF -&gt; RECORD_PATTERN_DEF
6337      * |   |   |       |--MODIFIERS -&gt; MODIFIERS
6338      * |   |   |       |--TYPE -&gt; TYPE
6339      * |   |   |       |   `--IDENT -&gt; R
6340      * |   |   |       |--LPAREN -&gt; (
6341      * |   |   |       |--RECORD_PATTERN_COMPONENTS -&gt; RECORD_PATTERN_COMPONENTS
6342      * |   |   |       |   `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
6343      * |   |   |       |       |--MODIFIERS -&gt; MODIFIERS
6344      * |   |   |       |       |--TYPE -&gt; TYPE
6345      * |   |   |       |       |   `--IDENT -&gt; String
6346      * |   |   |       |       `--IDENT -&gt; s
6347      * |   |   |       |--RPAREN -&gt; )
6348      * |   |   |       `--IDENT -&gt; myRecord
6349      * |   |   |--LAMBDA -&gt; -&gt;
6350      * |   |   `--SLIST -&gt; {
6351      * |   |       `--RCURLY -&gt; }
6352      * |   `--RCURLY -&gt; }
6353      * `--RCURLY -&gt; }
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) -&gt; {}
6377      * }
6378      * </pre>
6379      * <p>parses as:</p>
6380      * <pre>
6381      * |--RECORD_DEF -&gt; RECORD_DEF
6382      * |   |--MODIFIERS -&gt; MODIFIERS
6383      * |   |--LITERAL_RECORD -&gt; record
6384      * |   |--IDENT -&gt; R
6385      * |   |--LPAREN -&gt; (
6386      * |   |--RECORD_COMPONENTS -&gt; RECORD_COMPONENTS
6387      * |   |   `--RECORD_COMPONENT_DEF -&gt; RECORD_COMPONENT_DEF
6388      * |   |       |--ANNOTATIONS -&gt; ANNOTATIONS
6389      * |   |       |--TYPE -&gt; TYPE
6390      * |   |       |   `--IDENT -&gt; Object
6391      * |   |       `--IDENT -&gt; o
6392      * |   |--RPAREN -&gt; )
6393      * |   `--OBJBLOCK -&gt; OBJBLOCK
6394      * |       |--LCURLY -&gt; {
6395      * |       `--RCURLY -&gt; }
6396      * |--LITERAL_IF -&gt; if
6397      * |   |--LPAREN -&gt; (
6398      * |   |--EXPR -&gt; EXPR
6399      * |   |   `--LITERAL_INSTANCEOF -&gt; instanceof
6400      * |   |       |--IDENT -&gt; o
6401      * |   |       `--RECORD_PATTERN_DEF -&gt; RECORD_PATTERN_DEF
6402      * |   |           |--MODIFIERS -&gt; MODIFIERS
6403      * |   |           |--TYPE -&gt; TYPE
6404      * |   |           |   `--IDENT -&gt; R
6405      * |   |           |--LPAREN -&gt; (
6406      * |   |           |--RECORD_PATTERN_COMPONENTS -&gt; RECORD_PATTERN_COMPONENTS
6407      * |   |           |   `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
6408      * |   |           |       |--MODIFIERS -&gt; MODIFIERS
6409      * |   |           |       |--TYPE -&gt; TYPE
6410      * |   |           |       |   `--IDENT -&gt; String
6411      * |   |           |       `--IDENT -&gt; myComponent
6412      * |   |           `--RPAREN -&gt; )
6413      * |   |--RPAREN -&gt; )
6414      * |   `--SLIST -&gt; {
6415      * |       `--RCURLY -&gt; }
6416      * |--LITERAL_SWITCH -&gt; switch
6417      * |   |--LPAREN -&gt; (
6418      * |   |--EXPR -&gt; EXPR
6419      * |   |   `--IDENT -&gt; o
6420      * |   |--RPAREN -&gt; )
6421      * |   |--LCURLY -&gt; {
6422      * |   |--SWITCH_RULE -&gt; SWITCH_RULE
6423      * |   |   |--LITERAL_CASE -&gt; case
6424      * |   |   |   `--PATTERN_DEF -&gt; PATTERN_DEF
6425      * |   |   |       `--LITERAL_WHEN -&gt; when
6426      * |   |   |           |--RECORD_PATTERN_DEF -&gt; RECORD_PATTERN_DEF
6427      * |   |   |           |   |--MODIFIERS -&gt; MODIFIERS
6428      * |   |   |           |   |--TYPE -&gt; TYPE
6429      * |   |   |           |   |   `--IDENT -&gt; R
6430      * |   |   |           |   |--LPAREN -&gt; (
6431      * |   |   |           |   |--RECORD_PATTERN_COMPONENTS -&gt; RECORD_PATTERN_COMPONENTS
6432      * |   |   |           |   |   `--PATTERN_VARIABLE_DEF -&gt; PATTERN_VARIABLE_DEF
6433      * |   |   |           |   |       |--MODIFIERS -&gt; MODIFIERS
6434      * |   |   |           |   |       |--TYPE -&gt; TYPE
6435      * |   |   |           |   |       |   `--IDENT -&gt; String
6436      * |   |   |           |   |       `--IDENT -&gt; myComponent
6437      * |   |   |           |   `--RPAREN -&gt; )
6438      * |   |   |           `--METHOD_CALL -&gt; (
6439      * |   |   |               |--DOT -&gt; .
6440      * |   |   |               |   |--STRING_LITERAL -&gt; "component"
6441      * |   |   |               |   `--IDENT -&gt; equalsIgnoreCase
6442      * |   |   |               |--ELIST -&gt; ELIST
6443      * |   |   |               |   `--EXPR -&gt; EXPR
6444      * |   |   |               |       `--IDENT -&gt; myComponent
6445      * |   |   |               `--RPAREN -&gt; )
6446      * |   |   |--LAMBDA -&gt; -&gt;
6447      * |   |   `--SLIST -&gt; {
6448      * |   |       `--RCURLY -&gt; }
6449      * |   `--RCURLY -&gt; }
6450      * `--RCURLY -&gt; }
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 -&gt; VARIABLE_DEF
6474      *  |--MODIFIERS -&gt; MODIFIERS
6475      *  |--TYPE -&gt; TYPE
6476      *  |   `--IDENT -&gt; String
6477      *  |--IDENT -&gt; s
6478      *  `--ASSIGN -&gt; =
6479      *      `--EXPR -&gt; EXPR
6480      *          `--DOT -&gt; .
6481      *              |--IDENT -&gt; STR
6482      *              `--STRING_TEMPLATE_BEGIN -&gt; "
6483      *                  |--STRING_TEMPLATE_CONTENT -&gt; Hello,
6484      *                  |--EMBEDDED_EXPRESSION_BEGIN -&gt; \{
6485      *                  |--EMBEDDED_EXPRESSION -&gt; EMBEDDED_EXPRESSION
6486      *                  |   `--PLUS -&gt; +
6487      *                  |       |--PLUS -&gt; +
6488      *                  |       |   |--IDENT -&gt; firstName
6489      *                  |       |   `--STRING_LITERAL -&gt; " "
6490      *                  |       `--IDENT -&gt; lastName
6491      *                  |--EMBEDDED_EXPRESSION_END -&gt; }
6492      *                  |--STRING_TEMPLATE_CONTENT -&gt; !
6493      *                  `--STRING_TEMPLATE_END -&gt; "
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 -&gt; VARIABLE_DEF
6518      *  |--MODIFIERS -&gt; MODIFIERS
6519      *  |--TYPE -&gt; TYPE
6520      *  |   `--IDENT -&gt; String
6521      *  |--IDENT -&gt; s
6522      *  `--ASSIGN -&gt; =
6523      *      `--EXPR -&gt; EXPR
6524      *          `--DOT -&gt; .
6525      *              |--IDENT -&gt; STR
6526      *              `--STRING_TEMPLATE_BEGIN -&gt; "
6527      *                  |--STRING_TEMPLATE_CONTENT -&gt; Hello,
6528      *                  |--EMBEDDED_EXPRESSION_BEGIN -&gt; \{
6529      *                  |--EMBEDDED_EXPRESSION -&gt; EMBEDDED_EXPRESSION
6530      *                  |   `--PLUS -&gt; +
6531      *                  |       |--PLUS -&gt; +
6532      *                  |       |   |--IDENT -&gt; firstName
6533      *                  |       |   `--STRING_LITERAL -&gt; " "
6534      *                  |       `--IDENT -&gt; lastName
6535      *                  |--EMBEDDED_EXPRESSION_END -&gt; }
6536      *                  |--STRING_TEMPLATE_CONTENT -&gt; !
6537      *                  `--STRING_TEMPLATE_END -&gt; "
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 -&gt; VARIABLE_DEF
6562      *  |--MODIFIERS -&gt; MODIFIERS
6563      *  |--TYPE -&gt; TYPE
6564      *  |   `--IDENT -&gt; String
6565      *  |--IDENT -&gt; s
6566      *  `--ASSIGN -&gt; =
6567      *      `--EXPR -&gt; EXPR
6568      *          `--DOT -&gt; .
6569      *              |--IDENT -&gt; STR
6570      *              `--STRING_TEMPLATE_BEGIN -&gt; "
6571      *                  |--STRING_TEMPLATE_CONTENT -&gt; Hello,
6572      *                  |--EMBEDDED_EXPRESSION_BEGIN -&gt; \{
6573      *                  |--EMBEDDED_EXPRESSION -&gt; EMBEDDED_EXPRESSION
6574      *                  |   `--PLUS -&gt; +
6575      *                  |       |--PLUS -&gt; +
6576      *                  |       |   |--IDENT -&gt; firstName
6577      *                  |       |   `--STRING_LITERAL -&gt; " "
6578      *                  |       `--IDENT -&gt; lastName
6579      *                  |--EMBEDDED_EXPRESSION_END -&gt; }
6580      *                  `--STRING_TEMPLATE_END -&gt; "
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 -&gt; VARIABLE_DEF
6604      *  |--MODIFIERS -&gt; MODIFIERS
6605      *  |--TYPE -&gt; TYPE
6606      *  |   `--IDENT -&gt; String
6607      *  |--IDENT -&gt; s
6608      *  `--ASSIGN -&gt; =
6609      *      `--EXPR -&gt; EXPR
6610      *          `--DOT -&gt; .
6611      *              |--IDENT -&gt; STR
6612      *              `--STRING_TEMPLATE_BEGIN -&gt; "
6613      *                  |--STRING_TEMPLATE_CONTENT -&gt; Hello,
6614      *                  |--EMBEDDED_EXPRESSION_BEGIN -&gt; \{
6615      *                  |--EMBEDDED_EXPRESSION -&gt; EMBEDDED_EXPRESSION
6616      *                  |   `--METHOD_CALL -&gt; (
6617      *                  |       |--IDENT -&gt; getName
6618      *                  |       |--ELIST -&gt; ELIST
6619      *                  |       |   |--EXPR -&gt; EXPR
6620      *                  |       |   |   `--STRING_LITERAL -&gt; "Mr. "
6621      *                  |       |   |--COMMA -&gt; ,
6622      *                  |       |   |--EXPR -&gt; EXPR
6623      *                  |       |   |   `--IDENT -&gt; firstName
6624      *                  |       |   |--COMMA -&gt; ,
6625      *                  |       |   `--EXPR -&gt; EXPR
6626      *                  |       |       `--IDENT -&gt; lastName
6627      *                  |       `--RPAREN -&gt; )
6628      *                  |--EMBEDDED_EXPRESSION_END -&gt; }
6629      *                  |--STRING_TEMPLATE_CONTENT -&gt; !
6630      *                  `--STRING_TEMPLATE_END -&gt; "
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 -&gt; VARIABLE_DEF
6654      *  |--MODIFIERS -&gt; MODIFIERS
6655      *  |--TYPE -&gt; TYPE
6656      *  |   `--IDENT -&gt; String
6657      *  |--IDENT -&gt; s
6658      *  `--ASSIGN -&gt; =
6659      *      `--EXPR -&gt; EXPR
6660      *          `--DOT -&gt; .
6661      *              |--IDENT -&gt; STR
6662      *              `--STRING_TEMPLATE_BEGIN -&gt; "
6663      *                  |--STRING_TEMPLATE_CONTENT -&gt; Hello,
6664      *                  |--EMBEDDED_EXPRESSION_BEGIN -&gt; \{
6665      *                  |--EMBEDDED_EXPRESSION -&gt; EMBEDDED_EXPRESSION
6666      *                  |   `--METHOD_CALL -&gt; (
6667      *                  |       |--IDENT -&gt; getName
6668      *                  |       |--ELIST -&gt; ELIST
6669      *                  |       |   |--EXPR -&gt; EXPR
6670      *                  |       |   |   `--STRING_LITERAL -&gt; "Mr. "
6671      *                  |       |   |--COMMA -&gt; ,
6672      *                  |       |   |--EXPR -&gt; EXPR
6673      *                  |       |   |   `--IDENT -&gt; firstName
6674      *                  |       |   |--COMMA -&gt; ,
6675      *                  |       |   `--EXPR -&gt; EXPR
6676      *                  |       |       `--IDENT -&gt; lastName
6677      *                  |       `--RPAREN -&gt; )
6678      *                  |--EMBEDDED_EXPRESSION_END -&gt; }
6679      *                  |--STRING_TEMPLATE_CONTENT -&gt; !
6680      *                  `--STRING_TEMPLATE_END -&gt; "
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 -&gt; VARIABLE_DEF
6705      *  |--MODIFIERS -&gt; MODIFIERS
6706      *  |--TYPE -&gt; TYPE
6707      *  |   `--IDENT -&gt; String
6708      *  |--IDENT -&gt; s
6709      *  `--ASSIGN -&gt; =
6710      *      `--EXPR -&gt; EXPR
6711      *          `--DOT -&gt; .
6712      *              |--IDENT -&gt; STR
6713      *              `--STRING_TEMPLATE_BEGIN -&gt; "
6714      *                  |--STRING_TEMPLATE_CONTENT -&gt; Hello,
6715      *                  |--EMBEDDED_EXPRESSION_BEGIN -&gt; \{
6716      *                  |--EMBEDDED_EXPRESSION -&gt; EMBEDDED_EXPRESSION
6717      *                  |   `--METHOD_CALL -&gt; (
6718      *                  |       |--IDENT -&gt; getName
6719      *                  |       |--ELIST -&gt; ELIST
6720      *                  |       |   |--EXPR -&gt; EXPR
6721      *                  |       |   |   `--STRING_LITERAL -&gt; "Mr. "
6722      *                  |       |   |--COMMA -&gt; ,
6723      *                  |       |   |--EXPR -&gt; EXPR
6724      *                  |       |   |   `--IDENT -&gt; firstName
6725      *                  |       |   |--COMMA -&gt; ,
6726      *                  |       |   `--EXPR -&gt; EXPR
6727      *                  |       |       `--IDENT -&gt; lastName
6728      *                  |       `--RPAREN -&gt; )
6729      *                  |--EMBEDDED_EXPRESSION_END -&gt; }
6730      *                  |--STRING_TEMPLATE_CONTENT -&gt; !
6731      *                  `--STRING_TEMPLATE_END -&gt; "
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 -&gt; if
6755      *  |--LPAREN -&gt; (
6756      *  |--EXPR -&gt; EXPR
6757      *  |   `--LITERAL_INSTANCEOF -&gt; instanceof
6758      *  |       |--IDENT -&gt; r
6759      *  |       `--RECORD_PATTERN_DEF -&gt; RECORD_PATTERN_DEF
6760      *  |           |--MODIFIERS -&gt; MODIFIERS
6761      *  |           |--TYPE -&gt; TYPE
6762      *  |           |   `--IDENT -&gt; R
6763      *  |           |--LPAREN -&gt; (
6764      *  |           |--RECORD_PATTERN_COMPONENTS -&gt; RECORD_PATTERN_COMPONENTS
6765      *  |           |   `--UNNAMED_PATTERN_DEF -&gt; _
6766      *  |           `--RPAREN -&gt; )
6767      *  |--RPAREN -&gt; )
6768      *  `--SLIST -&gt; {
6769      *      `--RCURLY -&gt; }
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 }