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