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