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