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