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