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