001////////////////////////////////////////////////////////////////////////////////
002// checkstyle: Checks Java source code for adherence to a set of rules.
003// Copyright (C) 2001-2017 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.grammars.GeneratedJavaTokenTypes;
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 * @author Oliver Burn
032 * @author <a href="mailto:dobratzp@ele.uri.edu">Peter Dobratz</a>
033 * @noinspection ClassWithTooManyDependents
034 */
035public final class TokenTypes {
036    // The following three types are never part of an AST,
037    // left here as a reminder so nobody will read them accidentally
038
039    // These are the types that can actually occur in an AST
040    // it makes sense to register Checks for these types
041
042    /**
043     * The end of file token.  This is the root node for the source
044     * file.  It's children are an optional package definition, zero
045     * or more import statements, and one or more class or interface
046     * definitions.
047     *
048     * @see #PACKAGE_DEF
049     * @see #IMPORT
050     * @see #CLASS_DEF
051     * @see #INTERFACE_DEF
052     **/
053    public static final int EOF = GeneratedJavaTokenTypes.EOF;
054    /**
055     * Modifiers for type, method, and field declarations.  The
056     * modifiers element is always present even though it may have no
057     * children.
058     *
059     * @see <a
060     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java
061     * Language Specification, &sect;8</a>
062     * @see #LITERAL_PUBLIC
063     * @see #LITERAL_PROTECTED
064     * @see #LITERAL_PRIVATE
065     * @see #ABSTRACT
066     * @see #LITERAL_STATIC
067     * @see #FINAL
068     * @see #LITERAL_TRANSIENT
069     * @see #LITERAL_VOLATILE
070     * @see #LITERAL_SYNCHRONIZED
071     * @see #LITERAL_NATIVE
072     * @see #STRICTFP
073     * @see #ANNOTATION
074     * @see #LITERAL_DEFAULT
075     **/
076    public static final int MODIFIERS = GeneratedJavaTokenTypes.MODIFIERS;
077
078    /**
079     * An object block.  These are children of class, interface, enum,
080     * annotation and enum constant declarations.
081     * Also, object blocks are children of the new keyword when defining
082     * anonymous inner types.
083     *
084     * @see #LCURLY
085     * @see #INSTANCE_INIT
086     * @see #STATIC_INIT
087     * @see #CLASS_DEF
088     * @see #CTOR_DEF
089     * @see #METHOD_DEF
090     * @see #VARIABLE_DEF
091     * @see #RCURLY
092     * @see #INTERFACE_DEF
093     * @see #LITERAL_NEW
094     * @see #ENUM_DEF
095     * @see #ENUM_CONSTANT_DEF
096     * @see #ANNOTATION_DEF
097     **/
098    public static final int OBJBLOCK = GeneratedJavaTokenTypes.OBJBLOCK;
099    /**
100     * A list of statements.
101     *
102     * @see #RCURLY
103     * @see #EXPR
104     * @see #LABELED_STAT
105     * @see #LITERAL_THROWS
106     * @see #LITERAL_RETURN
107     * @see #SEMI
108     * @see #METHOD_DEF
109     * @see #CTOR_DEF
110     * @see #LITERAL_FOR
111     * @see #LITERAL_WHILE
112     * @see #LITERAL_IF
113     * @see #LITERAL_ELSE
114     * @see #CASE_GROUP
115     **/
116    public static final int SLIST = GeneratedJavaTokenTypes.SLIST;
117    /**
118     * A constructor declaration.
119     *
120     * <p>For example:</p>
121     * <pre>
122     * public SpecialEntry(int value, String text)
123     * {
124     *   this.value = value;
125     *   this.text = text;
126     * }
127     * </pre>
128     * <p>parses as:</p>
129     * <pre>
130     * +--CTOR_DEF
131     *     |
132     *     +--MODIFIERS
133     *         |
134     *         +--LITERAL_PUBLIC (public)
135     *     +--IDENT (SpecialEntry)
136     *     +--LPAREN (()
137     *     +--PARAMETERS
138     *         |
139     *         +--PARAMETER_DEF
140     *             |
141     *             +--MODIFIERS
142     *             +--TYPE
143     *                 |
144     *                 +--LITERAL_INT (int)
145     *             +--IDENT (value)
146     *         +--COMMA (,)
147     *         +--PARAMETER_DEF
148     *             |
149     *             +--MODIFIERS
150     *             +--TYPE
151     *                 |
152     *                 +--IDENT (String)
153     *             +--IDENT (text)
154     *     +--RPAREN ())
155     *     +--SLIST ({)
156     *         |
157     *         +--EXPR
158     *             |
159     *             +--ASSIGN (=)
160     *                 |
161     *                 +--DOT (.)
162     *                     |
163     *                     +--LITERAL_THIS (this)
164     *                     +--IDENT (value)
165     *                 +--IDENT (value)
166     *         +--SEMI (;)
167     *         +--EXPR
168     *             |
169     *             +--ASSIGN (=)
170     *                 |
171     *                 +--DOT (.)
172     *                     |
173     *                     +--LITERAL_THIS (this)
174     *                     +--IDENT (text)
175     *                 +--IDENT (text)
176     *         +--SEMI (;)
177     *         +--RCURLY (})
178     * </pre>
179     *
180     * @see #OBJBLOCK
181     * @see #CLASS_DEF
182     **/
183    public static final int CTOR_DEF = GeneratedJavaTokenTypes.CTOR_DEF;
184    /**
185     * A method declaration.  The children are modifiers, type parameters,
186     * return type, method name, parameter list, an optional throws list, and
187     * statement list.  The statement list is omitted if the method
188     * declaration appears in an interface declaration.  Method
189     * declarations may appear inside object blocks of class
190     * declarations, interface declarations, enum declarations,
191     * enum constant declarations or anonymous inner-class declarations.
192     *
193     * <p>For example:</p>
194     *
195     * <pre>
196     *  public static int square(int x)
197     *  {
198     *    return x*x;
199     *  }
200     * </pre>
201     *
202     * <p>parses as:</p>
203     *
204     * <pre>
205     * +--METHOD_DEF
206     *     |
207     *     +--MODIFIERS
208     *         |
209     *         +--LITERAL_PUBLIC (public)
210     *         +--LITERAL_STATIC (static)
211     *     +--TYPE
212     *         |
213     *         +--LITERAL_INT (int)
214     *     +--IDENT (square)
215     *     +--PARAMETERS
216     *         |
217     *         +--PARAMETER_DEF
218     *             |
219     *             +--MODIFIERS
220     *             +--TYPE
221     *                 |
222     *                 +--LITERAL_INT (int)
223     *             +--IDENT (x)
224     *     +--SLIST ({)
225     *         |
226     *         +--LITERAL_RETURN (return)
227     *             |
228     *             +--EXPR
229     *                 |
230     *                 +--STAR (*)
231     *                     |
232     *                     +--IDENT (x)
233     *                     +--IDENT (x)
234     *             +--SEMI (;)
235     *         +--RCURLY (})
236     * </pre>
237     *
238     * @see #MODIFIERS
239     * @see #TYPE_PARAMETERS
240     * @see #TYPE
241     * @see #IDENT
242     * @see #PARAMETERS
243     * @see #LITERAL_THROWS
244     * @see #SLIST
245     * @see #OBJBLOCK
246     **/
247    public static final int METHOD_DEF = GeneratedJavaTokenTypes.METHOD_DEF;
248    /**
249     * A field or local variable declaration.  The children are
250     * modifiers, type, the identifier name, and an optional
251     * assignment statement.
252     *
253     * @see #MODIFIERS
254     * @see #TYPE
255     * @see #IDENT
256     * @see #ASSIGN
257     **/
258    public static final int VARIABLE_DEF =
259        GeneratedJavaTokenTypes.VARIABLE_DEF;
260
261    /**
262     * An instance initializer.  Zero or more instance initializers
263     * may appear in class and enum definitions.  This token will be a child
264     * of the object block of the declaring type.
265     *
266     * @see <a
267     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.6">Java
268     * Language Specification&sect;8.6</a>
269     * @see #SLIST
270     * @see #OBJBLOCK
271     **/
272    public static final int INSTANCE_INIT =
273        GeneratedJavaTokenTypes.INSTANCE_INIT;
274
275    /**
276     * A static initialization block.  Zero or more static
277     * initializers may be children of the object block of a class
278     * or enum declaration (interfaces cannot have static initializers).  The
279     * first and only child is a statement list.
280     *
281     * @see <a
282     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.7">Java
283     * Language Specification, &sect;8.7</a>
284     * @see #SLIST
285     * @see #OBJBLOCK
286     **/
287    public static final int STATIC_INIT =
288        GeneratedJavaTokenTypes.STATIC_INIT;
289
290    /**
291     * A type.  This is either a return type of a method or a type of
292     * a variable or field.  The first child of this element is the
293     * actual type.  This may be a primitive type, an identifier, a
294     * dot which is the root of a fully qualified type, or an array of
295     * any of these. The second child may be type arguments to the type.
296     *
297     * @see #VARIABLE_DEF
298     * @see #METHOD_DEF
299     * @see #PARAMETER_DEF
300     * @see #IDENT
301     * @see #DOT
302     * @see #LITERAL_VOID
303     * @see #LITERAL_BOOLEAN
304     * @see #LITERAL_BYTE
305     * @see #LITERAL_CHAR
306     * @see #LITERAL_SHORT
307     * @see #LITERAL_INT
308     * @see #LITERAL_FLOAT
309     * @see #LITERAL_LONG
310     * @see #LITERAL_DOUBLE
311     * @see #ARRAY_DECLARATOR
312     * @see #TYPE_ARGUMENTS
313     **/
314    public static final int TYPE = GeneratedJavaTokenTypes.TYPE;
315    /**
316     * A class declaration.
317     *
318     * <p>For example:</p>
319     * <pre>
320     * public class MyClass
321     *   implements Serializable
322     * {
323     * }
324     * </pre>
325     * <p>parses as:</p>
326     * <pre>
327     * +--CLASS_DEF
328     *     |
329     *     +--MODIFIERS
330     *         |
331     *         +--LITERAL_PUBLIC (public)
332     *     +--LITERAL_CLASS (class)
333     *     +--IDENT (MyClass)
334     *     +--EXTENDS_CLAUSE
335     *     +--IMPLEMENTS_CLAUSE
336     *         |
337     *         +--IDENT (Serializable)
338     *     +--OBJBLOCK
339     *         |
340     *         +--LCURLY ({)
341     *         +--RCURLY (})
342     * </pre>
343     *
344     * @see <a
345     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java
346     * Language Specification, &sect;8</a>
347     * @see #MODIFIERS
348     * @see #IDENT
349     * @see #EXTENDS_CLAUSE
350     * @see #IMPLEMENTS_CLAUSE
351     * @see #OBJBLOCK
352     * @see #LITERAL_NEW
353     **/
354    public static final int CLASS_DEF = GeneratedJavaTokenTypes.CLASS_DEF;
355    /**
356     * An interface declaration.
357     *
358     * <p>For example:</p>
359     *
360     * <pre>
361     *   public interface MyInterface
362     *   {
363     *   }
364     *
365     * </pre>
366     *
367     * <p>parses as:</p>
368     *
369     * <pre>
370     * +--INTERFACE_DEF
371     *     |
372     *     +--MODIFIERS
373     *         |
374     *         +--LITERAL_PUBLIC (public)
375     *     +--LITERAL_INTERFACE (interface)
376     *     +--IDENT (MyInterface)
377     *     +--EXTENDS_CLAUSE
378     *     +--OBJBLOCK
379     *         |
380     *         +--LCURLY ({)
381     *         +--RCURLY (})
382     * </pre>
383     *
384     * @see <a
385     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html">Java
386     * Language Specification, &sect;9</a>
387     * @see #MODIFIERS
388     * @see #IDENT
389     * @see #EXTENDS_CLAUSE
390     * @see #OBJBLOCK
391     **/
392    public static final int INTERFACE_DEF =
393        GeneratedJavaTokenTypes.INTERFACE_DEF;
394
395    /**
396     * The package declaration.  This is optional, but if it is
397     * included, then there is only one package declaration per source
398     * file and it must be the first non-comment in the file. A package
399     * declaration may be annotated in which case the annotations comes
400     * before the rest of the declaration (and are the first children).
401     *
402     * <p>For example:</p>
403     *
404     * <pre>
405     *   package com.puppycrawl.tools.checkstyle.api;
406     * </pre>
407     *
408     * <p>parses as:</p>
409     *
410     * <pre>
411     * +--PACKAGE_DEF (package)
412     *     |
413     *     +--ANNOTATIONS
414     *     +--DOT (.)
415     *         |
416     *         +--DOT (.)
417     *             |
418     *             +--DOT (.)
419     *                 |
420     *                 +--DOT (.)
421     *                     |
422     *                     +--IDENT (com)
423     *                     +--IDENT (puppycrawl)
424     *                 +--IDENT (tools)
425     *             +--IDENT (checkstyle)
426     *         +--IDENT (api)
427     *     +--SEMI (;)
428     * </pre>
429     *
430     * @see <a
431     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.4">Java
432     * Language Specification &sect;7.4</a>
433     * @see #DOT
434     * @see #IDENT
435     * @see #SEMI
436     * @see #ANNOTATIONS
437     * @see FullIdent
438     **/
439    public static final int PACKAGE_DEF = GeneratedJavaTokenTypes.PACKAGE_DEF;
440    /**
441     * An array declaration.
442     *
443     * <p>If the array declaration represents a type, then the type of
444     * the array elements is the first child.  Multidimensional arrays
445     * may be regarded as arrays of arrays.  In other words, the first
446     * child of the array declaration is another array
447     * declaration.</p>
448     *
449     * <p>For example:</p>
450     * <pre>
451     *   int[] x;
452     * </pre>
453     * <p>parses as:</p>
454     * <pre>
455     * +--VARIABLE_DEF
456     *     |
457     *     +--MODIFIERS
458     *     +--TYPE
459     *         |
460     *         +--ARRAY_DECLARATOR ([)
461     *             |
462     *             +--LITERAL_INT (int)
463     *     +--IDENT (x)
464     * +--SEMI (;)
465     * </pre>
466     *
467     * <p>The array declaration may also represent an inline array
468     * definition.  In this case, the first child will be either an
469     * expression specifying the length of the array or an array
470     * initialization block.</p>
471     *
472     * @see <a
473     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-10.html">Java
474     * Language Specification &sect;10</a>
475     * @see #TYPE
476     * @see #ARRAY_INIT
477     **/
478    public static final int ARRAY_DECLARATOR =
479        GeneratedJavaTokenTypes.ARRAY_DECLARATOR;
480
481    /**
482     * An extends clause.  This appear as part of class and interface
483     * definitions.  This element appears even if the
484     * {@code extends} keyword is not explicitly used.  The child
485     * is an optional identifier.
486     *
487     * <p>For example:</p>
488     *
489     * <pre>
490     * extends java.util.LinkedList
491     * </pre>
492     *
493     * <p>parses as:</p>
494     * <pre>
495     * +--EXTENDS_CLAUSE
496     *     |
497     *     +--DOT (.)
498     *         |
499     *         +--DOT (.)
500     *             |
501     *             +--IDENT (java)
502     *             +--IDENT (util)
503     *         +--IDENT (LinkedList)
504     * </pre>
505     *
506     * @see #IDENT
507     * @see #DOT
508     * @see #CLASS_DEF
509     * @see #INTERFACE_DEF
510     * @see FullIdent
511     **/
512    public static final int EXTENDS_CLAUSE =
513        GeneratedJavaTokenTypes.EXTENDS_CLAUSE;
514
515    /**
516     * An implements clause.  This always appears in a class or enum
517     * declaration, even if there are no implemented interfaces.  The
518     * children are a comma separated list of zero or more
519     * identifiers.
520     *
521     * <p>For example:</p>
522     * <pre>
523     * implements Serializable, Comparable
524     * </pre>
525     * <p>parses as:</p>
526     * <pre>
527     * +--IMPLEMENTS_CLAUSE
528     *     |
529     *     +--IDENT (Serializable)
530     *     +--COMMA (,)
531     *     +--IDENT (Comparable)
532     * </pre>
533     *
534     * @see #IDENT
535     * @see #DOT
536     * @see #COMMA
537     * @see #CLASS_DEF
538     * @see #ENUM_DEF
539     **/
540    public static final int IMPLEMENTS_CLAUSE =
541        GeneratedJavaTokenTypes.IMPLEMENTS_CLAUSE;
542
543    /**
544     * A list of parameters to a method or constructor.  The children
545     * are zero or more parameter declarations separated by commas.
546     *
547     * <p>For example</p>
548     * <pre>
549     * int start, int end
550     * </pre>
551     * <p>parses as:</p>
552     * <pre>
553     * +--PARAMETERS
554     *     |
555     *     +--PARAMETER_DEF
556     *         |
557     *         +--MODIFIERS
558     *         +--TYPE
559     *             |
560     *             +--LITERAL_INT (int)
561     *         +--IDENT (start)
562     *     +--COMMA (,)
563     *     +--PARAMETER_DEF
564     *         |
565     *         +--MODIFIERS
566     *         +--TYPE
567     *             |
568     *             +--LITERAL_INT (int)
569     *         +--IDENT (end)
570     * </pre>
571     *
572     * @see #PARAMETER_DEF
573     * @see #COMMA
574     * @see #METHOD_DEF
575     * @see #CTOR_DEF
576     **/
577    public static final int PARAMETERS = GeneratedJavaTokenTypes.PARAMETERS;
578    /**
579     * A parameter declaration. The last parameter in a list of parameters may
580     * be variable length (indicated by the ELLIPSIS child node immediately
581     * after the TYPE child).
582     *
583     * @see #MODIFIERS
584     * @see #TYPE
585     * @see #IDENT
586     * @see #PARAMETERS
587     * @see #ELLIPSIS
588     **/
589    public static final int PARAMETER_DEF =
590        GeneratedJavaTokenTypes.PARAMETER_DEF;
591
592    /**
593     * A labeled statement.
594     *
595     * <p>For example:</p>
596     * <pre>
597     * outside: ;
598     * </pre>
599     * <p>parses as:</p>
600     * <pre>
601     * +--LABELED_STAT (:)
602     *     |
603     *     +--IDENT (outside)
604     *     +--EMPTY_STAT (;)
605     * </pre>
606     *
607     * @see <a
608     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.7">Java
609     * Language Specification, &sect;14.7</a>
610     * @see #SLIST
611     **/
612    public static final int LABELED_STAT =
613        GeneratedJavaTokenTypes.LABELED_STAT;
614
615    /**
616     * A type-cast.
617     *
618     * <p>For example:</p>
619     * <pre>
620     * (String)it.next()
621     * </pre>
622     * <p>parses as:</p>
623     * <pre>
624     * +--TYPECAST (()
625     *     |
626     *     +--TYPE
627     *         |
628     *         +--IDENT (String)
629     *     +--RPAREN ())
630     *     +--METHOD_CALL (()
631     *         |
632     *         +--DOT (.)
633     *             |
634     *             +--IDENT (it)
635     *             +--IDENT (next)
636     *         +--ELIST
637     *         +--RPAREN ())
638     * </pre>
639     * @see <a
640     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.16">Java
641     * Language Specification, &sect;15.16</a>
642     * @see #EXPR
643     * @see #TYPE
644     * @see #TYPE_ARGUMENTS
645     * @see #RPAREN
646     **/
647    public static final int TYPECAST = GeneratedJavaTokenTypes.TYPECAST;
648    /**
649     * The array index operator.
650     *
651     * <p>For example:</p>
652     * <pre>
653     * ar[2] = 5;
654     * </pre>
655     * <p>parses as:</p>
656     * <pre>
657     * +--EXPR
658     *     |
659     *     +--ASSIGN (=)
660     *         |
661     *         +--INDEX_OP ([)
662     *             |
663     *             +--IDENT (ar)
664     *             +--EXPR
665     *                 |
666     *                 +--NUM_INT (2)
667     *         +--NUM_INT (5)
668     * +--SEMI (;)
669     * </pre>
670     *
671     * @see #EXPR
672     **/
673    public static final int INDEX_OP = GeneratedJavaTokenTypes.INDEX_OP;
674    /**
675     * The {@code ++} (postfix increment) operator.
676     *
677     * @see <a
678     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.1">Java
679     * Language Specification, &sect;15.14.1</a>
680     * @see #EXPR
681     * @see #INC
682     **/
683    public static final int POST_INC = GeneratedJavaTokenTypes.POST_INC;
684    /**
685     * The {@code --} (postfix decrement) operator.
686     *
687     * @see <a
688     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.14.2">Java
689     * Language Specification, &sect;15.14.2</a>
690     * @see #EXPR
691     * @see #DEC
692     **/
693    public static final int POST_DEC = GeneratedJavaTokenTypes.POST_DEC;
694    /**
695     * A method call. A method call may have type arguments however these
696     * are attached to the appropriate node in the qualified method name.
697     *
698     * <p>For example:</p>
699     * <pre>
700     * Math.random()
701     * </pre>
702     *
703     * <p>parses as:
704     * <pre>
705     * +--METHOD_CALL (()
706     *     |
707     *     +--DOT (.)
708     *         |
709     *         +--IDENT (Math)
710     *         +--IDENT (random)
711     *     +--ELIST
712     *     +--RPAREN ())
713     * </pre>
714     *
715     *
716     * @see #IDENT
717     * @see #TYPE_ARGUMENTS
718     * @see #DOT
719     * @see #ELIST
720     * @see #RPAREN
721     * @see FullIdent
722     **/
723    public static final int METHOD_CALL = GeneratedJavaTokenTypes.METHOD_CALL;
724
725    /**
726     * A reference to a method or constructor without arguments. Part of Java 8 syntax.
727     * The token should be used for subscribing for double colon literal.
728     * {@link #DOUBLE_COLON} token does not appear in the tree.
729     *
730     * <p>For example:</p>
731     * <pre>
732     * String::compareToIgnoreCase
733     * </pre>
734     *
735     * <p>parses as:
736     * <pre>
737     * +--METHOD_REF (::)
738     *     |
739     *     +--IDENT (String)
740     *     +--IDENT (compareToIgnoreCase)
741     * </pre>
742     *
743     * @see #IDENT
744     * @see #DOUBLE_COLON
745     */
746    public static final int METHOD_REF = GeneratedJavaTokenTypes.METHOD_REF;
747    /**
748     * An expression.  Operators with lower precedence appear at a
749     * higher level in the tree than operators with higher precedence.
750     * Parentheses are siblings to the operator they enclose.
751     *
752     * <p>For example:</p>
753     * <pre>
754     * x = 4 + 3 * 5 + (30 + 26) / 4 + 5 % 4 + (1&lt;&lt;3);
755     * </pre>
756     * <p>parses as:</p>
757     * <pre>
758     * +--EXPR
759     *     |
760     *     +--ASSIGN (=)
761     *         |
762     *         +--IDENT (x)
763     *         +--PLUS (+)
764     *             |
765     *             +--PLUS (+)
766     *                 |
767     *                 +--PLUS (+)
768     *                     |
769     *                     +--PLUS (+)
770     *                         |
771     *                         +--NUM_INT (4)
772     *                         +--STAR (*)
773     *                             |
774     *                             +--NUM_INT (3)
775     *                             +--NUM_INT (5)
776     *                     +--DIV (/)
777     *                         |
778     *                         +--LPAREN (()
779     *                         +--PLUS (+)
780     *                             |
781     *                             +--NUM_INT (30)
782     *                             +--NUM_INT (26)
783     *                         +--RPAREN ())
784     *                         +--NUM_INT (4)
785     *                 +--MOD (%)
786     *                     |
787     *                     +--NUM_INT (5)
788     *                     +--NUM_INT (4)
789     *             +--LPAREN (()
790     *             +--SL (&lt;&lt;)
791     *                 |
792     *                 +--NUM_INT (1)
793     *                 +--NUM_INT (3)
794     *             +--RPAREN ())
795     * +--SEMI (;)
796     * </pre>
797     *
798     * @see #ELIST
799     * @see #ASSIGN
800     * @see #LPAREN
801     * @see #RPAREN
802     **/
803    public static final int EXPR = GeneratedJavaTokenTypes.EXPR;
804    /**
805     * An array initialization.  This may occur as part of an array
806     * declaration or inline with {@code new}.
807     *
808     * <p>For example:</p>
809     * <pre>
810     *   int[] y =
811     *     {
812     *       1,
813     *       2,
814     *     };
815     * </pre>
816     * <p>parses as:</p>
817     * <pre>
818     * +--VARIABLE_DEF
819     *     |
820     *     +--MODIFIERS
821     *     +--TYPE
822     *         |
823     *         +--ARRAY_DECLARATOR ([)
824     *             |
825     *             +--LITERAL_INT (int)
826     *     +--IDENT (y)
827     *     +--ASSIGN (=)
828     *         |
829     *         +--ARRAY_INIT ({)
830     *             |
831     *             +--EXPR
832     *                 |
833     *                 +--NUM_INT (1)
834     *             +--COMMA (,)
835     *             +--EXPR
836     *                 |
837     *                 +--NUM_INT (2)
838     *             +--COMMA (,)
839     *             +--RCURLY (})
840     * +--SEMI (;)
841     * </pre>
842     *
843     * <p>Also consider:</p>
844     * <pre>
845     *   int[] z = new int[]
846     *     {
847     *       1,
848     *       2,
849     *     };
850     * </pre>
851     * <p>which parses as:</p>
852     * <pre>
853     * +--VARIABLE_DEF
854     *     |
855     *     +--MODIFIERS
856     *     +--TYPE
857     *         |
858     *         +--ARRAY_DECLARATOR ([)
859     *             |
860     *             +--LITERAL_INT (int)
861     *     +--IDENT (z)
862     *     +--ASSIGN (=)
863     *         |
864     *         +--EXPR
865     *             |
866     *             +--LITERAL_NEW (new)
867     *                 |
868     *                 +--LITERAL_INT (int)
869     *                 +--ARRAY_DECLARATOR ([)
870     *                 +--ARRAY_INIT ({)
871     *                     |
872     *                     +--EXPR
873     *                         |
874     *                         +--NUM_INT (1)
875     *                     +--COMMA (,)
876     *                     +--EXPR
877     *                         |
878     *                         +--NUM_INT (2)
879     *                     +--COMMA (,)
880     *                     +--RCURLY (})
881     * </pre>
882     *
883     * @see #ARRAY_DECLARATOR
884     * @see #TYPE
885     * @see #LITERAL_NEW
886     * @see #COMMA
887     **/
888    public static final int ARRAY_INIT = GeneratedJavaTokenTypes.ARRAY_INIT;
889    /**
890     * An import declaration.  Import declarations are option, but
891     * must appear after the package declaration and before the first type
892     * declaration.
893     *
894     * <p>For example:</p>
895     *
896     * <pre>
897     *   import java.io.IOException;
898     * </pre>
899     *
900     * <p>parses as:</p>
901     *
902     * <pre>
903     * +--IMPORT (import)
904     *     |
905     *     +--DOT (.)
906     *         |
907     *         +--DOT (.)
908     *             |
909     *             +--IDENT (java)
910     *             +--IDENT (io)
911     *         +--IDENT (IOException)
912     *     +--SEMI (;)
913     * </pre>
914     *
915     * @see <a
916     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5">Java
917     * Language Specification &sect;7.5</a>
918     * @see #DOT
919     * @see #IDENT
920     * @see #STAR
921     * @see #SEMI
922     * @see FullIdent
923     **/
924    public static final int IMPORT = GeneratedJavaTokenTypes.IMPORT;
925    /**
926     * The {@code -} (unary minus) operator.
927     *
928     * @see <a
929     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.4">Java
930     * Language Specification, &sect;15.15.4</a>
931     * @see #EXPR
932     **/
933    public static final int UNARY_MINUS = GeneratedJavaTokenTypes.UNARY_MINUS;
934    /**
935     * The {@code +} (unary plus) operator.
936     *
937     * @see <a
938     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.3">Java
939     * Language Specification, &sect;15.15.3</a>
940     * @see #EXPR
941     **/
942    public static final int UNARY_PLUS = GeneratedJavaTokenTypes.UNARY_PLUS;
943    /**
944     * A group of case clauses.  Case clauses with no associated
945     * statements are grouped together into a case group.  The last
946     * child is a statement list containing the statements to execute
947     * upon a match.
948     *
949     * <p>For example:</p>
950     * <pre>
951     * case 0:
952     * case 1:
953     * case 2:
954     *   x = 3;
955     *   break;
956     * </pre>
957     * <p>parses as:</p>
958     * <pre>
959     * +--CASE_GROUP
960     *     |
961     *     +--LITERAL_CASE (case)
962     *         |
963     *         +--EXPR
964     *             |
965     *             +--NUM_INT (0)
966     *     +--LITERAL_CASE (case)
967     *         |
968     *         +--EXPR
969     *             |
970     *             +--NUM_INT (1)
971     *     +--LITERAL_CASE (case)
972     *         |
973     *         +--EXPR
974     *             |
975     *             +--NUM_INT (2)
976     *     +--SLIST
977     *         |
978     *         +--EXPR
979     *             |
980     *             +--ASSIGN (=)
981     *                 |
982     *                 +--IDENT (x)
983     *                 +--NUM_INT (3)
984     *         +--SEMI (;)
985     *         +--LITERAL_BREAK (break)
986     *             |
987     *             +--SEMI (;)
988     * </pre>
989     *
990     * @see #LITERAL_CASE
991     * @see #LITERAL_DEFAULT
992     * @see #LITERAL_SWITCH
993     **/
994    public static final int CASE_GROUP = GeneratedJavaTokenTypes.CASE_GROUP;
995    /**
996     * An expression list.  The children are a comma separated list of
997     * expressions.
998     *
999     * @see #LITERAL_NEW
1000     * @see #FOR_INIT
1001     * @see #FOR_ITERATOR
1002     * @see #EXPR
1003     * @see #METHOD_CALL
1004     * @see #CTOR_CALL
1005     * @see #SUPER_CTOR_CALL
1006     **/
1007    public static final int ELIST = GeneratedJavaTokenTypes.ELIST;
1008    /**
1009     * A for loop initializer.  This is a child of
1010     * {@code LITERAL_FOR}.  The children of this element may be
1011     * a comma separated list of variable declarations, an expression
1012     * list, or empty.
1013     *
1014     * @see #VARIABLE_DEF
1015     * @see #ELIST
1016     * @see #LITERAL_FOR
1017     **/
1018    public static final int FOR_INIT = GeneratedJavaTokenTypes.FOR_INIT;
1019    /**
1020     * A for loop condition.  This is a child of
1021     * {@code LITERAL_FOR}.  The child of this element is an
1022     * optional expression.
1023     *
1024     * @see #EXPR
1025     * @see #LITERAL_FOR
1026     **/
1027    public static final int FOR_CONDITION =
1028        GeneratedJavaTokenTypes.FOR_CONDITION;
1029
1030    /**
1031     * A for loop iterator.  This is a child of
1032     * {@code LITERAL_FOR}.  The child of this element is an
1033     * optional expression list.
1034     *
1035     * @see #ELIST
1036     * @see #LITERAL_FOR
1037     **/
1038    public static final int FOR_ITERATOR =
1039        GeneratedJavaTokenTypes.FOR_ITERATOR;
1040
1041    /**
1042     * The empty statement.  This goes in place of an
1043     * {@code SLIST} for a {@code for} or {@code while}
1044     * loop body.
1045     *
1046     * @see <a
1047     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.6">Java
1048     * Language Specification, &sect;14.6</a>
1049     * @see #LITERAL_FOR
1050     * @see #LITERAL_WHILE
1051     **/
1052    public static final int EMPTY_STAT = GeneratedJavaTokenTypes.EMPTY_STAT;
1053    /**
1054     * The {@code final} keyword.
1055     *
1056     * @see #MODIFIERS
1057     **/
1058    public static final int FINAL = GeneratedJavaTokenTypes.FINAL;
1059    /**
1060     * The {@code abstract} keyword.
1061     *
1062     * @see #MODIFIERS
1063     **/
1064    public static final int ABSTRACT = GeneratedJavaTokenTypes.ABSTRACT;
1065    /**
1066     * The {@code strictfp} keyword.
1067     *
1068     * @see #MODIFIERS
1069     **/
1070    public static final int STRICTFP = GeneratedJavaTokenTypes.STRICTFP;
1071    /**
1072     * A super constructor call.
1073     *
1074     * @see #ELIST
1075     * @see #RPAREN
1076     * @see #SEMI
1077     * @see #CTOR_CALL
1078     **/
1079    public static final int SUPER_CTOR_CALL =
1080        GeneratedJavaTokenTypes.SUPER_CTOR_CALL;
1081
1082    /**
1083     * A constructor call.
1084     *
1085     * <p>For example:</p>
1086     * <pre>
1087     * this(1);
1088     * </pre>
1089     * <p>parses as:</p>
1090     * <pre>
1091     * +--CTOR_CALL (this)
1092     *     |
1093     *     +--LPAREN (()
1094     *     +--ELIST
1095     *         |
1096     *         +--EXPR
1097     *             |
1098     *             +--NUM_INT (1)
1099     *     +--RPAREN ())
1100     *     +--SEMI (;)
1101     * </pre>
1102     *
1103     * @see #ELIST
1104     * @see #RPAREN
1105     * @see #SEMI
1106     * @see #SUPER_CTOR_CALL
1107     **/
1108    public static final int CTOR_CALL = GeneratedJavaTokenTypes.CTOR_CALL;
1109
1110    /**
1111     * The statement terminator ({@code ;}).  Depending on the
1112     * context, this make occur as a sibling, a child, or not at all.
1113     *
1114     * @see #PACKAGE_DEF
1115     * @see #IMPORT
1116     * @see #SLIST
1117     * @see #ARRAY_INIT
1118     * @see #LITERAL_FOR
1119     **/
1120    public static final int SEMI = GeneratedJavaTokenTypes.SEMI;
1121
1122    /**
1123     * The {@code ]} symbol.
1124     *
1125     * @see #INDEX_OP
1126     * @see #ARRAY_DECLARATOR
1127     **/
1128    public static final int RBRACK = GeneratedJavaTokenTypes.RBRACK;
1129    /**
1130     * The {@code void} keyword.
1131     *
1132     * @see #TYPE
1133     **/
1134    public static final int LITERAL_VOID =
1135        GeneratedJavaTokenTypes.LITERAL_void;
1136
1137    /**
1138     * The {@code boolean} keyword.
1139     *
1140     * @see #TYPE
1141     **/
1142    public static final int LITERAL_BOOLEAN =
1143        GeneratedJavaTokenTypes.LITERAL_boolean;
1144
1145    /**
1146     * The {@code byte} keyword.
1147     *
1148     * @see #TYPE
1149     **/
1150    public static final int LITERAL_BYTE =
1151        GeneratedJavaTokenTypes.LITERAL_byte;
1152
1153    /**
1154     * The {@code char} keyword.
1155     *
1156     * @see #TYPE
1157     **/
1158    public static final int LITERAL_CHAR =
1159        GeneratedJavaTokenTypes.LITERAL_char;
1160
1161    /**
1162     * The {@code short} keyword.
1163     *
1164     * @see #TYPE
1165     **/
1166    public static final int LITERAL_SHORT =
1167        GeneratedJavaTokenTypes.LITERAL_short;
1168
1169    /**
1170     * The {@code int} keyword.
1171     *
1172     * @see #TYPE
1173     **/
1174    public static final int LITERAL_INT = GeneratedJavaTokenTypes.LITERAL_int;
1175    /**
1176     * The {@code float} keyword.
1177     *
1178     * @see #TYPE
1179     **/
1180    public static final int LITERAL_FLOAT =
1181        GeneratedJavaTokenTypes.LITERAL_float;
1182
1183    /**
1184     * The {@code long} keyword.
1185     *
1186     * @see #TYPE
1187     **/
1188    public static final int LITERAL_LONG =
1189        GeneratedJavaTokenTypes.LITERAL_long;
1190
1191    /**
1192     * The {@code double} keyword.
1193     *
1194     * @see #TYPE
1195     **/
1196    public static final int LITERAL_DOUBLE =
1197        GeneratedJavaTokenTypes.LITERAL_double;
1198
1199    /**
1200     * An identifier.  These can be names of types, subpackages,
1201     * fields, methods, parameters, and local variables.
1202     **/
1203    public static final int IDENT = GeneratedJavaTokenTypes.IDENT;
1204    /**
1205     * The {@code &#46;} (dot) operator.
1206     *
1207     * @see FullIdent
1208     **/
1209    public static final int DOT = GeneratedJavaTokenTypes.DOT;
1210    /**
1211     * The {@code *} (multiplication or wildcard) operator.
1212     *
1213     * @see <a
1214     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-7.html#jls-7.5.2">Java
1215     * Language Specification, &sect;7.5.2</a>
1216     * @see <a
1217     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.1">Java
1218     * Language Specification, &sect;15.17.1</a>
1219     * @see #EXPR
1220     * @see #IMPORT
1221     **/
1222    public static final int STAR = GeneratedJavaTokenTypes.STAR;
1223    /**
1224     * The {@code private} keyword.
1225     *
1226     * @see #MODIFIERS
1227     **/
1228    public static final int LITERAL_PRIVATE =
1229        GeneratedJavaTokenTypes.LITERAL_private;
1230
1231    /**
1232     * The {@code public} keyword.
1233     *
1234     * @see #MODIFIERS
1235     **/
1236    public static final int LITERAL_PUBLIC =
1237        GeneratedJavaTokenTypes.LITERAL_public;
1238
1239    /**
1240     * The {@code protected} keyword.
1241     *
1242     * @see #MODIFIERS
1243     **/
1244    public static final int LITERAL_PROTECTED =
1245        GeneratedJavaTokenTypes.LITERAL_protected;
1246
1247    /**
1248     * The {@code static} keyword.
1249     *
1250     * @see #MODIFIERS
1251     **/
1252    public static final int LITERAL_STATIC =
1253        GeneratedJavaTokenTypes.LITERAL_static;
1254
1255    /**
1256     * The {@code transient} keyword.
1257     *
1258     * @see #MODIFIERS
1259     **/
1260    public static final int LITERAL_TRANSIENT =
1261        GeneratedJavaTokenTypes.LITERAL_transient;
1262
1263    /**
1264     * The {@code native} keyword.
1265     *
1266     * @see #MODIFIERS
1267     **/
1268    public static final int LITERAL_NATIVE =
1269        GeneratedJavaTokenTypes.LITERAL_native;
1270
1271    /**
1272     * The {@code synchronized} keyword.  This may be used as a
1273     * modifier of a method or in the definition of a synchronized
1274     * block.
1275     *
1276     * <p>For example:</p>
1277     *
1278     * <pre>
1279     * synchronized(this)
1280     * {
1281     *   x++;
1282     * }
1283     * </pre>
1284     *
1285     * <p>parses as:</p>
1286     *
1287     * <pre>
1288     * +--LITERAL_SYNCHRONIZED (synchronized)
1289     *     |
1290     *     +--LPAREN (()
1291     *     +--EXPR
1292     *         |
1293     *         +--LITERAL_THIS (this)
1294     *     +--RPAREN ())
1295     *     +--SLIST ({)
1296     *         |
1297     *         +--EXPR
1298     *             |
1299     *             +--POST_INC (++)
1300     *                 |
1301     *                 +--IDENT (x)
1302     *         +--SEMI (;)
1303     *         +--RCURLY (})
1304     * +--RCURLY (})
1305     * </pre>
1306     *
1307     * @see #MODIFIERS
1308     * @see #LPAREN
1309     * @see #EXPR
1310     * @see #RPAREN
1311     * @see #SLIST
1312     * @see #RCURLY
1313     **/
1314    public static final int LITERAL_SYNCHRONIZED =
1315        GeneratedJavaTokenTypes.LITERAL_synchronized;
1316
1317    /**
1318     * The {@code volatile} keyword.
1319     *
1320     * @see #MODIFIERS
1321     **/
1322    public static final int LITERAL_VOLATILE =
1323        GeneratedJavaTokenTypes.LITERAL_volatile;
1324
1325    /**
1326     * The {@code class} keyword.  This element appears both
1327     * as part of a class declaration, and inline to reference a
1328     * class object.
1329     *
1330     * <p>For example:</p>
1331     *
1332     * <pre>
1333     * int.class
1334     * </pre>
1335     * <p>parses as:</p>
1336     * <pre>
1337     * +--EXPR
1338     *     |
1339     *     +--DOT (.)
1340     *         |
1341     *         +--LITERAL_INT (int)
1342     *         +--LITERAL_CLASS (class)
1343     * </pre>
1344     *
1345     * @see #DOT
1346     * @see #IDENT
1347     * @see #CLASS_DEF
1348     * @see FullIdent
1349     **/
1350    public static final int LITERAL_CLASS =
1351        GeneratedJavaTokenTypes.LITERAL_class;
1352
1353    /**
1354     * The {@code interface} keyword. This token appears in
1355     * interface definition.
1356     *
1357     * @see #INTERFACE_DEF
1358     **/
1359    public static final int LITERAL_INTERFACE =
1360        GeneratedJavaTokenTypes.LITERAL_interface;
1361
1362    /**
1363     * A left (curly) brace ({@code &#123;}).
1364     *
1365     * @see #OBJBLOCK
1366     * @see #ARRAY_INIT
1367     * @see #SLIST
1368     **/
1369    public static final int LCURLY = GeneratedJavaTokenTypes.LCURLY;
1370    /**
1371     * A right (curly) brace ({@code &#125;}).
1372     *
1373     * @see #OBJBLOCK
1374     * @see #ARRAY_INIT
1375     * @see #SLIST
1376     **/
1377    public static final int RCURLY = GeneratedJavaTokenTypes.RCURLY;
1378    /**
1379     * The {@code ,} (comma) operator.
1380     *
1381     * @see #ARRAY_INIT
1382     * @see #FOR_INIT
1383     * @see #FOR_ITERATOR
1384     * @see #LITERAL_THROWS
1385     * @see #IMPLEMENTS_CLAUSE
1386     **/
1387    public static final int COMMA = GeneratedJavaTokenTypes.COMMA;
1388
1389    /**
1390     * A left parenthesis ({@code (}).
1391     *
1392     * @see #LITERAL_FOR
1393     * @see #LITERAL_NEW
1394     * @see #EXPR
1395     * @see #LITERAL_SWITCH
1396     * @see #LITERAL_CATCH
1397     **/
1398    public static final int LPAREN = GeneratedJavaTokenTypes.LPAREN;
1399    /**
1400     * A right parenthesis ({@code )}).
1401     *
1402     * @see #LITERAL_FOR
1403     * @see #LITERAL_NEW
1404     * @see #METHOD_CALL
1405     * @see #TYPECAST
1406     * @see #EXPR
1407     * @see #LITERAL_SWITCH
1408     * @see #LITERAL_CATCH
1409     **/
1410    public static final int RPAREN = GeneratedJavaTokenTypes.RPAREN;
1411    /**
1412     * The {@code this} keyword.
1413     *
1414     * @see #EXPR
1415     * @see #CTOR_CALL
1416     **/
1417    public static final int LITERAL_THIS =
1418        GeneratedJavaTokenTypes.LITERAL_this;
1419
1420    /**
1421     * The {@code super} keyword.
1422     *
1423     * @see #EXPR
1424     * @see #SUPER_CTOR_CALL
1425     **/
1426    public static final int LITERAL_SUPER =
1427        GeneratedJavaTokenTypes.LITERAL_super;
1428
1429    /**
1430     * The {@code =} (assignment) operator.
1431     *
1432     * @see <a
1433     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.1">Java
1434     * Language Specification, &sect;15.26.1</a>
1435     * @see #EXPR
1436     **/
1437    public static final int ASSIGN = GeneratedJavaTokenTypes.ASSIGN;
1438    /**
1439     * The {@code throws} keyword.  The children are a number of
1440     * one or more identifiers separated by commas.
1441     *
1442     * @see <a
1443     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.4">Java
1444     * Language Specification, &sect;8.4.4</a>
1445     * @see #IDENT
1446     * @see #DOT
1447     * @see #COMMA
1448     * @see #METHOD_DEF
1449     * @see #CTOR_DEF
1450     * @see FullIdent
1451     **/
1452    public static final int LITERAL_THROWS =
1453        GeneratedJavaTokenTypes.LITERAL_throws;
1454
1455    /**
1456     * The {@code :} (colon) operator.  This will appear as part
1457     * of the conditional operator ({@code ? :}).
1458     *
1459     * @see #QUESTION
1460     * @see #LABELED_STAT
1461     * @see #CASE_GROUP
1462     **/
1463    public static final int COLON = GeneratedJavaTokenTypes.COLON;
1464
1465    /**
1466     * The {@code ::} (double colon) separator.
1467     * It is part of Java 8 syntax that is used for method reference.
1468     * The token does not appear in tree, {@link #METHOD_REF} should be used instead.
1469     *
1470     * @see #METHOD_REF
1471     */
1472    public static final int DOUBLE_COLON = GeneratedJavaTokenTypes.DOUBLE_COLON;
1473    /**
1474     * The {@code if} keyword.
1475     *
1476     * <p>For example:</p>
1477     * <pre>
1478     * if(optimistic)
1479     * {
1480     *   message = "half full";
1481     * }
1482     * else
1483     * {
1484     *   message = "half empty";
1485     * }
1486     * </pre>
1487     * <p>parses as:</p>
1488     * <pre>
1489     * +--LITERAL_IF (if)
1490     *     |
1491     *     +--LPAREN (()
1492     *     +--EXPR
1493     *         |
1494     *         +--IDENT (optimistic)
1495     *     +--RPAREN ())
1496     *     +--SLIST ({)
1497     *         |
1498     *         +--EXPR
1499     *             |
1500     *             +--ASSIGN (=)
1501     *                 |
1502     *                 +--IDENT (message)
1503     *                 +--STRING_LITERAL ("half full")
1504     *         +--SEMI (;)
1505     *         +--RCURLY (})
1506     *     +--LITERAL_ELSE (else)
1507     *         |
1508     *         +--SLIST ({)
1509     *             |
1510     *             +--EXPR
1511     *                 |
1512     *                 +--ASSIGN (=)
1513     *                     |
1514     *                     +--IDENT (message)
1515     *                     +--STRING_LITERAL ("half empty")
1516     *             +--SEMI (;)
1517     *             +--RCURLY (})
1518     * </pre>
1519     *
1520     * @see #LPAREN
1521     * @see #EXPR
1522     * @see #RPAREN
1523     * @see #SLIST
1524     * @see #EMPTY_STAT
1525     * @see #LITERAL_ELSE
1526     **/
1527    public static final int LITERAL_IF = GeneratedJavaTokenTypes.LITERAL_if;
1528    /**
1529     * The {@code for} keyword.  The children are {@code (},
1530     * an initializer, a condition, an iterator, a {@code )} and
1531     * either a statement list, a single expression, or an empty
1532     * statement.
1533     *
1534     * <p>For example:</p>
1535     * <pre>
1536     * for(int i = 0, n = myArray.length; i &lt; n; i++)
1537     * {
1538     * }
1539     * </pre>
1540     *
1541     * <p>parses as:</p>
1542     * <pre>
1543     * +--LITERAL_FOR (for)
1544     *     |
1545     *     +--LPAREN (()
1546     *     +--FOR_INIT
1547     *         |
1548     *         +--VARIABLE_DEF
1549     *             |
1550     *             +--MODIFIERS
1551     *             +--TYPE
1552     *                 |
1553     *                 +--LITERAL_INT (int)
1554     *             +--IDENT (i)
1555     *             +--ASSIGN (=)
1556     *                 |
1557     *                 +--EXPR
1558     *                     |
1559     *                     +--NUM_INT (0)
1560     *         +--COMMA (,)
1561     *         +--VARIABLE_DEF
1562     *             |
1563     *             +--MODIFIERS
1564     *             +--TYPE
1565     *                 |
1566     *                 +--LITERAL_INT (int)
1567     *             +--IDENT (n)
1568     *             +--ASSIGN (=)
1569     *                 |
1570     *                 +--EXPR
1571     *                     |
1572     *                     +--DOT (.)
1573     *                         |
1574     *                         +--IDENT (myArray)
1575     *                         +--IDENT (length)
1576     *     +--SEMI (;)
1577     *     +--FOR_CONDITION
1578     *         |
1579     *         +--EXPR
1580     *             |
1581     *             +--LT (&lt;)
1582     *                 |
1583     *                 +--IDENT (i)
1584     *                 +--IDENT (n)
1585     *     +--SEMI (;)
1586     *     +--FOR_ITERATOR
1587     *         |
1588     *         +--ELIST
1589     *             |
1590     *             +--EXPR
1591     *                 |
1592     *                 +--POST_INC (++)
1593     *                     |
1594     *                     +--IDENT (i)
1595     *     +--RPAREN ())
1596     *     +--SLIST ({)
1597     *         |
1598     *         +--RCURLY (})
1599     * </pre>
1600     *
1601     * @see #LPAREN
1602     * @see #FOR_INIT
1603     * @see #SEMI
1604     * @see #FOR_CONDITION
1605     * @see #FOR_ITERATOR
1606     * @see #RPAREN
1607     * @see #SLIST
1608     * @see #EMPTY_STAT
1609     * @see #EXPR
1610     **/
1611    public static final int LITERAL_FOR = GeneratedJavaTokenTypes.LITERAL_for;
1612    /**
1613     * The {@code while} keyword.
1614     *
1615     * <p>For example:</p>
1616     * <pre>
1617     * while(line != null)
1618     * {
1619     *   process(line);
1620     *   line = in.readLine();
1621     * }
1622     * </pre>
1623     * <p>parses as:</p>
1624     * <pre>
1625     * +--LITERAL_WHILE (while)
1626     *     |
1627     *     +--LPAREN (()
1628     *     +--EXPR
1629     *         |
1630     *         +--NOT_EQUAL (!=)
1631     *             |
1632     *             +--IDENT (line)
1633     *             +--LITERAL_NULL (null)
1634     *     +--RPAREN ())
1635     *     +--SLIST ({)
1636     *         |
1637     *         +--EXPR
1638     *             |
1639     *             +--METHOD_CALL (()
1640     *                 |
1641     *                 +--IDENT (process)
1642     *                 +--ELIST
1643     *                     |
1644     *                     +--EXPR
1645     *                         |
1646     *                         +--IDENT (line)
1647     *                 +--RPAREN ())
1648     *         +--SEMI (;)
1649     *         +--EXPR
1650     *             |
1651     *             +--ASSIGN (=)
1652     *                 |
1653     *                 +--IDENT (line)
1654     *                 +--METHOD_CALL (()
1655     *                     |
1656     *                     +--DOT (.)
1657     *                         |
1658     *                         +--IDENT (in)
1659     *                         +--IDENT (readLine)
1660     *                     +--ELIST
1661     *                     +--RPAREN ())
1662     *         +--SEMI (;)
1663     *         +--RCURLY (})
1664     * </pre>
1665     **/
1666    public static final int LITERAL_WHILE =
1667        GeneratedJavaTokenTypes.LITERAL_while;
1668
1669    /**
1670     * The {@code do} keyword.  Note the the while token does not
1671     * appear as part of the do-while construct.
1672     *
1673     * <p>For example:</p>
1674     * <pre>
1675     * do
1676     * {
1677     *   x = rand.nextInt(10);
1678     * }
1679     * while(x &lt; 5);
1680     * </pre>
1681     * <p>parses as:</p>
1682     * <pre>
1683     * +--LITERAL_DO (do)
1684     *     |
1685     *     +--SLIST ({)
1686     *         |
1687     *         +--EXPR
1688     *             |
1689     *             +--ASSIGN (=)
1690     *                 |
1691     *                 +--IDENT (x)
1692     *                 +--METHOD_CALL (()
1693     *                     |
1694     *                     +--DOT (.)
1695     *                         |
1696     *                         +--IDENT (rand)
1697     *                         +--IDENT (nextInt)
1698     *                     +--ELIST
1699     *                         |
1700     *                         +--EXPR
1701     *                             |
1702     *                             +--NUM_INT (10)
1703     *                     +--RPAREN ())
1704     *         +--SEMI (;)
1705     *         +--RCURLY (})
1706     *     +--DO_WHILE (while)
1707     *     +--LPAREN (()
1708     *     +--EXPR
1709     *         |
1710     *         +--LT (&lt;)
1711     *             |
1712     *             +--IDENT (x)
1713     *             +--NUM_INT (5)
1714     *     +--RPAREN ())
1715     *     +--SEMI (;)
1716     * </pre>
1717     *
1718     * @see #SLIST
1719     * @see #EXPR
1720     * @see #EMPTY_STAT
1721     * @see #LPAREN
1722     * @see #RPAREN
1723     * @see #SEMI
1724     **/
1725    public static final int LITERAL_DO = GeneratedJavaTokenTypes.LITERAL_do;
1726    /**
1727     * Literal {@code while} in do-while loop.
1728     * @see #LITERAL_DO
1729     */
1730    public static final int DO_WHILE = GeneratedJavaTokenTypes.DO_WHILE;
1731    /**
1732     * The {@code break} keyword.  The first child is an optional
1733     * identifier and the last child is a semicolon.
1734     *
1735     * @see #IDENT
1736     * @see #SEMI
1737     * @see #SLIST
1738     **/
1739    public static final int LITERAL_BREAK =
1740        GeneratedJavaTokenTypes.LITERAL_break;
1741
1742    /**
1743     * The {@code continue} keyword.  The first child is an
1744     * optional identifier and the last child is a semicolon.
1745     *
1746     * @see #IDENT
1747     * @see #SEMI
1748     * @see #SLIST
1749     **/
1750    public static final int LITERAL_CONTINUE =
1751        GeneratedJavaTokenTypes.LITERAL_continue;
1752
1753    /**
1754     * The {@code return} keyword.  The first child is an
1755     * optional expression for the return value.  The last child is a
1756     * semi colon.
1757     *
1758     * @see #EXPR
1759     * @see #SEMI
1760     * @see #SLIST
1761     **/
1762    public static final int LITERAL_RETURN =
1763        GeneratedJavaTokenTypes.LITERAL_return;
1764
1765    /**
1766     * The {@code switch} keyword.
1767     *
1768     * <p>For example:</p>
1769     * <pre>
1770     * switch(type)
1771     * {
1772     *   case 0:
1773     *     background = Color.blue;
1774     *     break;
1775     *   case 1:
1776     *     background = Color.red;
1777     *     break;
1778     *   default:
1779     *     background = Color.green;
1780     *     break;
1781     * }
1782     * </pre>
1783     * <p>parses as:</p>
1784     * <pre>
1785     * +--LITERAL_SWITCH (switch)
1786     *     |
1787     *     +--LPAREN (()
1788     *     +--EXPR
1789     *         |
1790     *         +--IDENT (type)
1791     *     +--RPAREN ())
1792     *     +--LCURLY ({)
1793     *     +--CASE_GROUP
1794     *         |
1795     *         +--LITERAL_CASE (case)
1796     *             |
1797     *             +--EXPR
1798     *                 |
1799     *                 +--NUM_INT (0)
1800     *         +--SLIST
1801     *             |
1802     *             +--EXPR
1803     *                 |
1804     *                 +--ASSIGN (=)
1805     *                     |
1806     *                     +--IDENT (background)
1807     *                     +--DOT (.)
1808     *                         |
1809     *                         +--IDENT (Color)
1810     *                         +--IDENT (blue)
1811     *             +--SEMI (;)
1812     *             +--LITERAL_BREAK (break)
1813     *                 |
1814     *                 +--SEMI (;)
1815     *     +--CASE_GROUP
1816     *         |
1817     *         +--LITERAL_CASE (case)
1818     *             |
1819     *             +--EXPR
1820     *                 |
1821     *                 +--NUM_INT (1)
1822     *         +--SLIST
1823     *             |
1824     *             +--EXPR
1825     *                 |
1826     *                 +--ASSIGN (=)
1827     *                     |
1828     *                     +--IDENT (background)
1829     *                     +--DOT (.)
1830     *                         |
1831     *                         +--IDENT (Color)
1832     *                         +--IDENT (red)
1833     *             +--SEMI (;)
1834     *             +--LITERAL_BREAK (break)
1835     *                 |
1836     *                 +--SEMI (;)
1837     *     +--CASE_GROUP
1838     *         |
1839     *         +--LITERAL_DEFAULT (default)
1840     *         +--SLIST
1841     *             |
1842     *             +--EXPR
1843     *                 |
1844     *                 +--ASSIGN (=)
1845     *                     |
1846     *                     +--IDENT (background)
1847     *                     +--DOT (.)
1848     *                         |
1849     *                         +--IDENT (Color)
1850     *                         +--IDENT (green)
1851     *             +--SEMI (;)
1852     *             +--LITERAL_BREAK (break)
1853     *                 |
1854     *                 +--SEMI (;)
1855     *     +--RCURLY (})
1856     * </pre>
1857     *
1858     * @see <a
1859     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.10">Java
1860     * Language Specification, &sect;14.10</a>
1861     * @see #LPAREN
1862     * @see #EXPR
1863     * @see #RPAREN
1864     * @see #LCURLY
1865     * @see #CASE_GROUP
1866     * @see #RCURLY
1867     * @see #SLIST
1868     **/
1869    public static final int LITERAL_SWITCH =
1870        GeneratedJavaTokenTypes.LITERAL_switch;
1871
1872    /**
1873     * The {@code throw} keyword.  The first child is an
1874     * expression that evaluates to a {@code Throwable} instance.
1875     *
1876     * @see <a
1877     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.17">Java
1878     * Language Specification, &sect;14.17</a>
1879     * @see #SLIST
1880     * @see #EXPR
1881     **/
1882    public static final int LITERAL_THROW =
1883        GeneratedJavaTokenTypes.LITERAL_throw;
1884
1885    /**
1886     * The {@code else} keyword.  This appears as a child of an
1887     * {@code if} statement.
1888     *
1889     * @see #SLIST
1890     * @see #EXPR
1891     * @see #EMPTY_STAT
1892     * @see #LITERAL_IF
1893     **/
1894    public static final int LITERAL_ELSE =
1895        GeneratedJavaTokenTypes.LITERAL_else;
1896
1897    /**
1898     * The {@code case} keyword.  The first child is a constant
1899     * expression that evaluates to a integer.
1900     *
1901     * @see #CASE_GROUP
1902     * @see #EXPR
1903     **/
1904    public static final int LITERAL_CASE =
1905        GeneratedJavaTokenTypes.LITERAL_case;
1906
1907    /**
1908     * The {@code default} keyword.  This element has no
1909     * children.
1910     *
1911     * @see #CASE_GROUP
1912     * @see #MODIFIERS
1913     **/
1914    public static final int LITERAL_DEFAULT =
1915        GeneratedJavaTokenTypes.LITERAL_default;
1916
1917    /**
1918     * The {@code try} keyword.  The children are a statement
1919     * list, zero or more catch blocks and then an optional finally
1920     * block.
1921     *
1922     * <p>For example:</p>
1923     * <pre>
1924     * try
1925     * {
1926     *   FileReader in = new FileReader("abc.txt");
1927     * }
1928     * catch(IOException ioe)
1929     * {
1930     * }
1931     * finally
1932     * {
1933     * }
1934     * </pre>
1935     * <p>parses as:</p>
1936     * <pre>
1937     * +--LITERAL_TRY (try)
1938     *     |
1939     *     +--SLIST ({)
1940     *         |
1941     *         +--VARIABLE_DEF
1942     *             |
1943     *             +--MODIFIERS
1944     *             +--TYPE
1945     *                 |
1946     *                 +--IDENT (FileReader)
1947     *             +--IDENT (in)
1948     *             +--ASSIGN (=)
1949     *                 |
1950     *                 +--EXPR
1951     *                     |
1952     *                     +--LITERAL_NEW (new)
1953     *                         |
1954     *                         +--IDENT (FileReader)
1955     *                         +--LPAREN (()
1956     *                         +--ELIST
1957     *                             |
1958     *                             +--EXPR
1959     *                                 |
1960     *                                 +--STRING_LITERAL ("abc.txt")
1961     *                         +--RPAREN ())
1962     *         +--SEMI (;)
1963     *         +--RCURLY (})
1964     *     +--LITERAL_CATCH (catch)
1965     *         |
1966     *         +--LPAREN (()
1967     *         +--PARAMETER_DEF
1968     *             |
1969     *             +--MODIFIERS
1970     *             +--TYPE
1971     *                 |
1972     *                 +--IDENT (IOException)
1973     *             +--IDENT (ioe)
1974     *         +--RPAREN ())
1975     *         +--SLIST ({)
1976     *             |
1977     *             +--RCURLY (})
1978     *     +--LITERAL_FINALLY (finally)
1979     *         |
1980     *         +--SLIST ({)
1981     *             |
1982     *             +--RCURLY (})
1983     * +--RCURLY (})
1984     * </pre>
1985     *
1986     * @see <a
1987     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19">Java
1988     * Language Specification, &sect;14.19</a>
1989     * @see #SLIST
1990     * @see #LITERAL_CATCH
1991     * @see #LITERAL_FINALLY
1992     **/
1993    public static final int LITERAL_TRY = GeneratedJavaTokenTypes.LITERAL_try;
1994
1995    /**
1996     * The Java 7 try-with-resources construct.
1997     *
1998     * <p>For example:</p>
1999     * <pre>
2000     * try (Foo foo = new Foo(); Bar bar = new Bar()) { }
2001     * </pre>
2002     * <p>parses as:</p>
2003     * <pre>
2004     * +--LITERAL_TRY (try)
2005     *     |
2006     *     +--RESOURCE_SPECIFICATION
2007     *         |
2008     *         +--LPAREN (()
2009     *         +--RESOURCES
2010     *             |
2011     *             +--RESOURCE
2012     *                 |
2013     *                 +--MODIFIERS
2014     *                 +--TYPE
2015     *                     |
2016     *                     +--IDENT (Foo)
2017     *                 +--IDENT (foo)
2018     *                 +--ASSIGN (=)
2019     *                 +--EXPR
2020     *                    |
2021     *                    +--LITERAL_NEW (new)
2022     *                       |
2023     *                       +--IDENT (Foo)
2024     *                       +--LPAREN (()
2025     *                       +--ELIST
2026     *                       +--RPAREN ())
2027     *             +--SEMI (;)
2028     *             +--RESOURCE
2029     *                 |
2030     *                 +--MODIFIERS
2031     *                 +--TYPE
2032     *                     |
2033     *                     +--IDENT (Bar)
2034     *                 +--IDENT (bar)
2035     *                 +--ASSIGN (=)
2036     *                 +--EXPR
2037     *                    |
2038     *                    +--LITERAL_NEW (new)
2039     *                       |
2040     *                       +--IDENT (Bar)
2041     *                       +--LPAREN (()
2042     *                       +--ELIST
2043     *                       +--RPAREN ())
2044     *         +--RPAREN ())
2045     *     +--SLIST ({)
2046     *         +--RCURLY (})
2047     * </pre>
2048     *
2049     * <p>Also consider:</p>
2050     * <pre>
2051     * try (BufferedReader br = new BufferedReader(new FileReader(path)))
2052     * {
2053     *  return br.readLine();
2054     * }
2055     * </pre>
2056     * <p>which parses as:</p>
2057     * <pre>
2058     * +--LITERAL_TRY (try)
2059     *     |
2060     *     +--RESOURCE_SPECIFICATION
2061     *         |
2062     *         +--LPAREN (()
2063     *         +--RESOURCES
2064     *             |
2065     *             +--RESOURCE
2066     *                 |
2067     *                 +--MODIFIERS
2068     *                 +--TYPE
2069     *                     |
2070     *                     +--IDENT (BufferedReader)
2071     *                 +--IDENT (br)
2072     *                 +--ASSIGN (=)
2073     *                 +--EXPR
2074     *                     |
2075     *                     +--LITERAL_NEW (new)
2076     *                         |
2077     *                         +--IDENT (FileReader)
2078     *                         +--LPAREN (()
2079     *                         +--ELIST
2080     *                             |
2081     *                             +--EXPR
2082     *                                 |
2083     *                                 +--LITERAL_NEW (new)
2084     *                                     |
2085     *                                     +--IDENT (BufferedReader)
2086     *                                     +--LPAREN (()
2087     *                                     +--ELIST
2088     *                                         |
2089     *                                         +--EXPR
2090     *                                             |
2091     *                                             +--IDENT (path)
2092     *                                     +--RPAREN ())
2093     *                         +--RPAREN ())
2094     *         +--RPAREN ())
2095     *     +--SLIST ({)
2096     *         |
2097     *         +--LITERAL_RETURN (return)
2098     *             |
2099     *             +--EXPR
2100     *                 |
2101     *                 +--METHOD_CALL (()
2102     *                     |
2103     *                     +--DOT (.)
2104     *                         |
2105     *                         +--IDENT (br)
2106     *                         +--IDENT (readLine)
2107     *                     +--ELIST
2108     *                     +--RPAREN ())
2109     *             +--SEMI (;)
2110     *         +--RCURLY (})
2111     * </pre>
2112     *
2113     * @see #LPAREN
2114     * @see #RESOURCES
2115     * @see #RESOURCE
2116     * @see #SEMI
2117     * @see #RPAREN
2118     * @see #LITERAL_TRY
2119     **/
2120    public static final int RESOURCE_SPECIFICATION =
2121        GeneratedJavaTokenTypes.RESOURCE_SPECIFICATION;
2122
2123    /**
2124     * A list of resources in the Java 7 try-with-resources construct.
2125     * This is a child of RESOURCE_SPECIFICATION.
2126     *
2127     * @see #RESOURCE_SPECIFICATION
2128     **/
2129    public static final int RESOURCES =
2130        GeneratedJavaTokenTypes.RESOURCES;
2131
2132    /**
2133     * A resource in the Java 7 try-with-resources construct.
2134     * This is a child of RESOURCES.
2135     *
2136     * @see #RESOURCES
2137     * @see #RESOURCE_SPECIFICATION
2138     **/
2139    public static final int RESOURCE =
2140        GeneratedJavaTokenTypes.RESOURCE;
2141
2142    /**
2143     * The {@code catch} keyword.
2144     *
2145     * @see #LPAREN
2146     * @see #PARAMETER_DEF
2147     * @see #RPAREN
2148     * @see #SLIST
2149     * @see #LITERAL_TRY
2150     **/
2151    public static final int LITERAL_CATCH =
2152        GeneratedJavaTokenTypes.LITERAL_catch;
2153
2154    /**
2155     * The {@code finally} keyword.
2156     *
2157     * @see #SLIST
2158     * @see #LITERAL_TRY
2159     **/
2160    public static final int LITERAL_FINALLY =
2161        GeneratedJavaTokenTypes.LITERAL_finally;
2162
2163    /**
2164     * The {@code +=} (addition assignment) operator.
2165     *
2166     * @see <a
2167     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2168     * Language Specification, &sect;15.26.2</a>
2169     * @see #EXPR
2170     **/
2171    public static final int PLUS_ASSIGN = GeneratedJavaTokenTypes.PLUS_ASSIGN;
2172    /**
2173     * The {@code -=} (subtraction assignment) operator.
2174     *
2175     * @see <a
2176     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2177     * Language Specification, &sect;15.26.2</a>
2178     * @see #EXPR
2179     **/
2180    public static final int MINUS_ASSIGN =
2181        GeneratedJavaTokenTypes.MINUS_ASSIGN;
2182
2183    /**
2184     * The {@code *=} (multiplication assignment) operator.
2185     *
2186     * @see <a
2187     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2188     * Language Specification, &sect;15.26.2</a>
2189     * @see #EXPR
2190     **/
2191    public static final int STAR_ASSIGN = GeneratedJavaTokenTypes.STAR_ASSIGN;
2192    /**
2193     * The {@code /=} (division assignment) operator.
2194     *
2195     * @see <a
2196     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2197     * Language Specification, &sect;15.26.2</a>
2198     * @see #EXPR
2199     **/
2200    public static final int DIV_ASSIGN = GeneratedJavaTokenTypes.DIV_ASSIGN;
2201    /**
2202     * The {@code %=} (remainder assignment) operator.
2203     *
2204     * @see <a
2205     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2206     * Language Specification, &sect;15.26.2</a>
2207     * @see #EXPR
2208     **/
2209    public static final int MOD_ASSIGN = GeneratedJavaTokenTypes.MOD_ASSIGN;
2210    /**
2211     * The {@code &gt;&gt;=} (signed right shift assignment)
2212     * operator.
2213     *
2214     * @see <a
2215     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2216     * Language Specification, &sect;15.26.2</a>
2217     * @see #EXPR
2218     **/
2219    public static final int SR_ASSIGN = GeneratedJavaTokenTypes.SR_ASSIGN;
2220    /**
2221     * The {@code &gt;&gt;&gt;=} (unsigned right shift assignment)
2222     * operator.
2223     *
2224     * @see <a
2225     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2226     * Language Specification, &sect;15.26.2</a>
2227     * @see #EXPR
2228     **/
2229    public static final int BSR_ASSIGN = GeneratedJavaTokenTypes.BSR_ASSIGN;
2230    /**
2231     * The {@code &lt;&lt;=} (left shift assignment) operator.
2232     *
2233     * @see <a
2234     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2235     * Language Specification, &sect;15.26.2</a>
2236     * @see #EXPR
2237     **/
2238    public static final int SL_ASSIGN = GeneratedJavaTokenTypes.SL_ASSIGN;
2239    /**
2240     * The {@code &amp;=} (bitwise AND assignment) operator.
2241     *
2242     * @see <a
2243     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2244     * Language Specification, &sect;15.26.2</a>
2245     * @see #EXPR
2246     **/
2247    public static final int BAND_ASSIGN = GeneratedJavaTokenTypes.BAND_ASSIGN;
2248    /**
2249     * The {@code ^=} (bitwise exclusive OR assignment) operator.
2250     *
2251     * @see <a
2252     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2253     * Language Specification, &sect;15.26.2</a>
2254     * @see #EXPR
2255     **/
2256    public static final int BXOR_ASSIGN = GeneratedJavaTokenTypes.BXOR_ASSIGN;
2257    /**
2258     * The {@code |=} (bitwise OR assignment) operator.
2259     *
2260     * @see <a
2261     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.26.2">Java
2262     * Language Specification, &sect;15.26.2</a>
2263     * @see #EXPR
2264     **/
2265    public static final int BOR_ASSIGN = GeneratedJavaTokenTypes.BOR_ASSIGN;
2266    /**
2267     * The {@code &#63;} (conditional) operator.  Technically,
2268     * the colon is also part of this operator, but it appears as a
2269     * separate token.
2270     *
2271     * <p>For example:</p>
2272     * <pre>
2273     * (quantity == 1) ? "": "s"
2274     * </pre>
2275     * <p>
2276     * parses as:
2277     * </p>
2278     * <pre>
2279     * +--QUESTION (?)
2280     *     |
2281     *     +--LPAREN (()
2282     *     +--EQUAL (==)
2283     *         |
2284     *         +--IDENT (quantity)
2285     *         +--NUM_INT (1)
2286     *     +--RPAREN ())
2287     *     +--STRING_LITERAL ("")
2288     *     +--COLON (:)
2289     *     +--STRING_LITERAL ("s")
2290     * </pre>
2291     *
2292     * @see <a
2293     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.25">Java
2294     * Language Specification, &sect;15.25</a>
2295     * @see #EXPR
2296     * @see #COLON
2297     **/
2298    public static final int QUESTION = GeneratedJavaTokenTypes.QUESTION;
2299    /**
2300     * The {@code ||} (conditional OR) operator.
2301     *
2302     * @see <a
2303     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.24">Java
2304     * Language Specification, &sect;15.24</a>
2305     * @see #EXPR
2306     **/
2307    public static final int LOR = GeneratedJavaTokenTypes.LOR;
2308    /**
2309     * The {@code &amp;&amp;} (conditional AND) operator.
2310     *
2311     * @see <a
2312     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.23">Java
2313     * Language Specification, &sect;15.23</a>
2314     * @see #EXPR
2315     **/
2316    public static final int LAND = GeneratedJavaTokenTypes.LAND;
2317    /**
2318     * The {@code |} (bitwise OR) operator.
2319     *
2320     * @see <a
2321     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java
2322     * Language Specification, &sect;15.22.1</a>
2323     * @see #EXPR
2324     **/
2325    public static final int BOR = GeneratedJavaTokenTypes.BOR;
2326    /**
2327     * The {@code ^} (bitwise exclusive OR) operator.
2328     *
2329     * @see <a
2330     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java
2331     * Language Specification, &sect;15.22.1</a>
2332     * @see #EXPR
2333     **/
2334    public static final int BXOR = GeneratedJavaTokenTypes.BXOR;
2335    /**
2336     * The {@code &amp;} (bitwise AND) operator.
2337     *
2338     * @see <a
2339     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.22.1">Java
2340     * Language Specification, &sect;15.22.1</a>
2341     * @see #EXPR
2342     **/
2343    public static final int BAND = GeneratedJavaTokenTypes.BAND;
2344    /**
2345     * The {@code &#33;=} (not equal) operator.
2346     *
2347     * @see #EXPR
2348     **/
2349    public static final int NOT_EQUAL = GeneratedJavaTokenTypes.NOT_EQUAL;
2350    /**
2351     * The {@code ==} (equal) operator.
2352     *
2353     * @see #EXPR
2354     **/
2355    public static final int EQUAL = GeneratedJavaTokenTypes.EQUAL;
2356    /**
2357     * The {@code &lt;} (less than) operator.
2358     *
2359     * @see #EXPR
2360     **/
2361    public static final int LT = GeneratedJavaTokenTypes.LT;
2362    /**
2363     * The {@code &gt;} (greater than) operator.
2364     *
2365     * @see #EXPR
2366     **/
2367    public static final int GT = GeneratedJavaTokenTypes.GT;
2368    /**
2369     * The {@code &lt;=} (less than or equal) operator.
2370     *
2371     * @see #EXPR
2372     **/
2373    public static final int LE = GeneratedJavaTokenTypes.LE;
2374    /**
2375     * The {@code &gt;=} (greater than or equal) operator.
2376     *
2377     * @see #EXPR
2378     **/
2379    public static final int GE = GeneratedJavaTokenTypes.GE;
2380    /**
2381     * The {@code instanceof} operator.  The first child is an
2382     * object reference or something that evaluates to an object
2383     * reference.  The second child is a reference type.
2384     *
2385     * @see <a
2386     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2">Java
2387     * Language Specification, &sect;15.20.2</a>
2388     * @see #EXPR
2389     * @see #METHOD_CALL
2390     * @see #IDENT
2391     * @see #DOT
2392     * @see #TYPE
2393     * @see FullIdent
2394     **/
2395    public static final int LITERAL_INSTANCEOF =
2396        GeneratedJavaTokenTypes.LITERAL_instanceof;
2397
2398    /**
2399     * The {@code &lt;&lt;} (shift left) operator.
2400     *
2401     * @see <a
2402     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java
2403     * Language Specification, &sect;15.19</a>
2404     * @see #EXPR
2405     **/
2406    public static final int SL = GeneratedJavaTokenTypes.SL;
2407    /**
2408     * The {@code &gt;&gt;} (signed shift right) operator.
2409     *
2410     * @see <a
2411     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java
2412     * Language Specification, &sect;15.19</a>
2413     * @see #EXPR
2414     **/
2415    public static final int SR = GeneratedJavaTokenTypes.SR;
2416    /**
2417     * The {@code &gt;&gt;&gt;} (unsigned shift right) operator.
2418     *
2419     * @see <a
2420     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.19">Java
2421     * Language Specification, &sect;15.19</a>
2422     * @see #EXPR
2423     **/
2424    public static final int BSR = GeneratedJavaTokenTypes.BSR;
2425    /**
2426     * The {@code +} (addition) operator.
2427     *
2428     * @see <a
2429     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java
2430     * Language Specification, &sect;15.18</a>
2431     * @see #EXPR
2432     **/
2433    public static final int PLUS = GeneratedJavaTokenTypes.PLUS;
2434    /**
2435     * The {@code -} (subtraction) operator.
2436     *
2437     * @see <a
2438     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18">Java
2439     * Language Specification, &sect;15.18</a>
2440     * @see #EXPR
2441     **/
2442    public static final int MINUS = GeneratedJavaTokenTypes.MINUS;
2443    /**
2444     * The {@code /} (division) operator.
2445     *
2446     * @see <a
2447     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.2">Java
2448     * Language Specification, &sect;15.17.2</a>
2449     * @see #EXPR
2450     **/
2451    public static final int DIV = GeneratedJavaTokenTypes.DIV;
2452    /**
2453     * The {@code %} (remainder) operator.
2454     *
2455     * @see <a
2456     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.17.3">Java
2457     * Language Specification, &sect;15.17.3</a>
2458     * @see #EXPR
2459     **/
2460    public static final int MOD = GeneratedJavaTokenTypes.MOD;
2461    /**
2462     * The {@code ++} (prefix increment) operator.
2463     *
2464     * @see <a
2465     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.1">Java
2466     * Language Specification, &sect;15.15.1</a>
2467     * @see #EXPR
2468     * @see #POST_INC
2469     **/
2470    public static final int INC = GeneratedJavaTokenTypes.INC;
2471    /**
2472     * The {@code --} (prefix decrement) operator.
2473     *
2474     * @see <a
2475     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.2">Java
2476     * Language Specification, &sect;15.15.2</a>
2477     * @see #EXPR
2478     * @see #POST_DEC
2479     **/
2480    public static final int DEC = GeneratedJavaTokenTypes.DEC;
2481    /**
2482     * The {@code ~} (bitwise complement) operator.
2483     *
2484     * @see <a
2485     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.5">Java
2486     * Language Specification, &sect;15.15.5</a>
2487     * @see #EXPR
2488     **/
2489    public static final int BNOT = GeneratedJavaTokenTypes.BNOT;
2490    /**
2491     * The {@code &#33;} (logical complement) operator.
2492     *
2493     * @see <a
2494     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.15.6">Java
2495     * Language Specification, &sect;15.15.6</a>
2496     * @see #EXPR
2497     **/
2498    public static final int LNOT = GeneratedJavaTokenTypes.LNOT;
2499    /**
2500     * The {@code true} keyword.
2501     *
2502     * @see <a
2503     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java
2504     * Language Specification, &sect;3.10.3</a>
2505     * @see #EXPR
2506     * @see #LITERAL_FALSE
2507     **/
2508    public static final int LITERAL_TRUE =
2509        GeneratedJavaTokenTypes.LITERAL_true;
2510
2511    /**
2512     * The {@code false} keyword.
2513     *
2514     * @see <a
2515     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.3">Java
2516     * Language Specification, &sect;3.10.3</a>
2517     * @see #EXPR
2518     * @see #LITERAL_TRUE
2519     **/
2520    public static final int LITERAL_FALSE =
2521        GeneratedJavaTokenTypes.LITERAL_false;
2522
2523    /**
2524     * The {@code null} keyword.
2525     *
2526     * @see <a
2527     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.7">Java
2528     * Language Specification, &sect;3.10.7</a>
2529     * @see #EXPR
2530     **/
2531    public static final int LITERAL_NULL =
2532        GeneratedJavaTokenTypes.LITERAL_null;
2533
2534    /**
2535     * The {@code new} keyword.  This element is used to define
2536     * new instances of objects, new arrays, and new anonymous inner
2537     * classes.
2538     *
2539     * <p>For example:</p>
2540     *
2541     * <pre>
2542     * new ArrayList(50)
2543     * </pre>
2544     *
2545     * <p>parses as:</p>
2546     * <pre>
2547     * +--LITERAL_NEW (new)
2548     *     |
2549     *     +--IDENT (ArrayList)
2550     *     +--LPAREN (()
2551     *     +--ELIST
2552     *         |
2553     *         +--EXPR
2554     *             |
2555     *             +--NUM_INT (50)
2556     *     +--RPAREN ())
2557     * </pre>
2558     *
2559     * <p>For example:</p>
2560     * <pre>
2561     * new float[]
2562     *   {
2563     *     3.0f,
2564     *     4.0f
2565     *   };
2566     * </pre>
2567     *
2568     * <p>parses as:</p>
2569     * <pre>
2570     * +--LITERAL_NEW (new)
2571     *     |
2572     *     +--LITERAL_FLOAT (float)
2573     *     +--ARRAY_DECLARATOR ([)
2574     *     +--ARRAY_INIT ({)
2575     *         |
2576     *         +--EXPR
2577     *             |
2578     *             +--NUM_FLOAT (3.0f)
2579     *         +--COMMA (,)
2580     *         +--EXPR
2581     *             |
2582     *             +--NUM_FLOAT (4.0f)
2583     *         +--RCURLY (})
2584     * </pre>
2585     *
2586     * <p>For example:</p>
2587     * <pre>
2588     * new FilenameFilter()
2589     * {
2590     *   public boolean accept(File dir, String name)
2591     *   {
2592     *     return name.endsWith(".java");
2593     *   }
2594     * }
2595     * </pre>
2596     *
2597     * <p>parses as:</p>
2598     * <pre>
2599     * +--LITERAL_NEW (new)
2600     *     |
2601     *     +--IDENT (FilenameFilter)
2602     *     +--LPAREN (()
2603     *     +--ELIST
2604     *     +--RPAREN ())
2605     *     +--OBJBLOCK
2606     *         |
2607     *         +--LCURLY ({)
2608     *         +--METHOD_DEF
2609     *             |
2610     *             +--MODIFIERS
2611     *                 |
2612     *                 +--LITERAL_PUBLIC (public)
2613     *             +--TYPE
2614     *                 |
2615     *                 +--LITERAL_BOOLEAN (boolean)
2616     *             +--IDENT (accept)
2617     *             +--PARAMETERS
2618     *                 |
2619     *                 +--PARAMETER_DEF
2620     *                     |
2621     *                     +--MODIFIERS
2622     *                     +--TYPE
2623     *                         |
2624     *                         +--IDENT (File)
2625     *                     +--IDENT (dir)
2626     *                 +--COMMA (,)
2627     *                 +--PARAMETER_DEF
2628     *                     |
2629     *                     +--MODIFIERS
2630     *                     +--TYPE
2631     *                         |
2632     *                         +--IDENT (String)
2633     *                     +--IDENT (name)
2634     *             +--SLIST ({)
2635     *                 |
2636     *                 +--LITERAL_RETURN (return)
2637     *                     |
2638     *                     +--EXPR
2639     *                         |
2640     *                         +--METHOD_CALL (()
2641     *                             |
2642     *                             +--DOT (.)
2643     *                                 |
2644     *                                 +--IDENT (name)
2645     *                                 +--IDENT (endsWith)
2646     *                             +--ELIST
2647     *                                 |
2648     *                                 +--EXPR
2649     *                                     |
2650     *                                     +--STRING_LITERAL (".java")
2651     *                             +--RPAREN ())
2652     *                     +--SEMI (;)
2653     *                 +--RCURLY (})
2654     *         +--RCURLY (})
2655     * </pre>
2656     *
2657     * @see #IDENT
2658     * @see #DOT
2659     * @see #LPAREN
2660     * @see #ELIST
2661     * @see #RPAREN
2662     * @see #OBJBLOCK
2663     * @see #ARRAY_INIT
2664     * @see FullIdent
2665     **/
2666    public static final int LITERAL_NEW = GeneratedJavaTokenTypes.LITERAL_new;
2667    /**
2668     * An integer literal.  These may be specified in decimal,
2669     * hexadecimal, or octal form.
2670     *
2671     * @see <a
2672     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java
2673     * Language Specification, &sect;3.10.1</a>
2674     * @see #EXPR
2675     * @see #NUM_LONG
2676     **/
2677    public static final int NUM_INT = GeneratedJavaTokenTypes.NUM_INT;
2678    /**
2679     * A character literal.  This is a (possibly escaped) character
2680     * enclosed in single quotes.
2681     *
2682     * @see <a
2683     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.4">Java
2684     * Language Specification, &sect;3.10.4</a>
2685     * @see #EXPR
2686     **/
2687    public static final int CHAR_LITERAL =
2688        GeneratedJavaTokenTypes.CHAR_LITERAL;
2689
2690    /**
2691     * A string literal.  This is a sequence of (possibly escaped)
2692     * characters enclosed in double quotes.
2693     *
2694     * @see <a
2695     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.5">Java
2696     * Language Specification, &sect;3.10.5</a>
2697     * @see #EXPR
2698     **/
2699    public static final int STRING_LITERAL =
2700        GeneratedJavaTokenTypes.STRING_LITERAL;
2701
2702    /**
2703     * A single precision floating point literal.  This is a floating
2704     * point number with an {@code F} or {@code f} suffix.
2705     *
2706     * @see <a
2707     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java
2708     * Language Specification, &sect;3.10.2</a>
2709     * @see #EXPR
2710     * @see #NUM_DOUBLE
2711     **/
2712    public static final int NUM_FLOAT = GeneratedJavaTokenTypes.NUM_FLOAT;
2713    /**
2714     * A long integer literal.  These are almost the same as integer
2715     * literals, but they have an {@code L} or {@code l}
2716     * (ell) suffix.
2717     *
2718     * @see <a
2719     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.1">Java
2720     * Language Specification, &sect;3.10.1</a>
2721     * @see #EXPR
2722     * @see #NUM_INT
2723     **/
2724    public static final int NUM_LONG = GeneratedJavaTokenTypes.NUM_LONG;
2725    /**
2726     * A double precision floating point literal.  This is a floating
2727     * point number with an optional {@code D} or {@code d}
2728     * suffix.
2729     *
2730     * @see <a
2731     * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2">Java
2732     * Language Specification, &sect;3.10.2</a>
2733     * @see #EXPR
2734     * @see #NUM_FLOAT
2735     **/
2736    public static final int NUM_DOUBLE = GeneratedJavaTokenTypes.NUM_DOUBLE;
2737
2738    /**
2739     * The {@code assert} keyword.  This is only for Java 1.4 and
2740     * later.
2741     *
2742     * <p>For example:</p>
2743     * <pre>
2744     * assert(x==4);
2745     * </pre>
2746     * <p>parses as:</p>
2747     * <pre>
2748     * +--LITERAL_ASSERT (assert)
2749     *     |
2750     *     +--EXPR
2751     *         |
2752     *         +--LPAREN (()
2753     *         +--EQUAL (==)
2754     *             |
2755     *             +--IDENT (x)
2756     *             +--NUM_INT (4)
2757     *         +--RPAREN ())
2758     *     +--SEMI (;)
2759     * </pre>
2760     **/
2761    public static final int LITERAL_ASSERT = GeneratedJavaTokenTypes.ASSERT;
2762
2763    /**
2764     * A static import declaration.  Static import declarations are optional,
2765     * but must appear after the package declaration and before the type
2766     * declaration.
2767     *
2768     * <p>For example:</p>
2769     *
2770     * <pre>
2771     *   import static java.io.IOException;
2772     * </pre>
2773     *
2774     * <p>parses as:</p>
2775     *
2776     * <pre>
2777     * +--STATIC_IMPORT (import)
2778     *     |
2779     *     +--LITERAL_STATIC
2780     *     +--DOT (.)
2781     *         |
2782     *         +--DOT (.)
2783     *             |
2784     *             +--IDENT (java)
2785     *             +--IDENT (io)
2786     *         +--IDENT (IOException)
2787     *     +--SEMI (;)
2788     * </pre>
2789     *
2790     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
2791     * JSR201</a>
2792     * @see #LITERAL_STATIC
2793     * @see #DOT
2794     * @see #IDENT
2795     * @see #STAR
2796     * @see #SEMI
2797     * @see FullIdent
2798     **/
2799    public static final int STATIC_IMPORT =
2800        GeneratedJavaTokenTypes.STATIC_IMPORT;
2801
2802    /**
2803     * An enum declaration. Its notable children are
2804     * enum constant declarations followed by
2805     * any construct that may be expected in a class body.
2806     *
2807     * <p>For example:</p>
2808     * <pre>
2809     * public enum MyEnum
2810     *   implements Serializable
2811     * {
2812     *     FIRST_CONSTANT,
2813     *     SECOND_CONSTANT;
2814     *
2815     *     public void someMethod()
2816     *     {
2817     *     }
2818     * }
2819     * </pre>
2820     * <p>parses as:</p>
2821     * <pre>
2822     * +--ENUM_DEF
2823     *     |
2824     *     +--MODIFIERS
2825     *         |
2826     *         +--LITERAL_PUBLIC (public)
2827     *     +--ENUM (enum)
2828     *     +--IDENT (MyEnum)
2829     *     +--EXTENDS_CLAUSE
2830     *     +--IMPLEMENTS_CLAUSE
2831     *         |
2832     *         +--IDENT (Serializable)
2833     *     +--OBJBLOCK
2834     *         |
2835     *         +--LCURLY ({)
2836     *         +--ENUM_CONSTANT_DEF
2837     *             |
2838     *             +--IDENT (FIRST_CONSTANT)
2839     *         +--COMMA (,)
2840     *         +--ENUM_CONSTANT_DEF
2841     *             |
2842     *             +--IDENT (SECOND_CONSTANT)
2843     *         +--SEMI (;)
2844     *         +--METHOD_DEF
2845     *             |
2846     *             +--MODIFIERS
2847     *                 |
2848     *                 +--LITERAL_PUBLIC (public)
2849     *             +--TYPE
2850     *                 |
2851     *                 +--LITERAL_void (void)
2852     *             +--IDENT (someMethod)
2853     *             +--LPAREN (()
2854     *             +--PARAMETERS
2855     *             +--RPAREN ())
2856     *             +--SLIST ({)
2857     *                 |
2858     *                 +--RCURLY (})
2859     *         +--RCURLY (})
2860     * </pre>
2861     *
2862     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
2863     * JSR201</a>
2864     * @see #MODIFIERS
2865     * @see #ENUM
2866     * @see #IDENT
2867     * @see #EXTENDS_CLAUSE
2868     * @see #IMPLEMENTS_CLAUSE
2869     * @see #OBJBLOCK
2870     * @see #LITERAL_NEW
2871     * @see #ENUM_CONSTANT_DEF
2872     **/
2873    public static final int ENUM_DEF =
2874        GeneratedJavaTokenTypes.ENUM_DEF;
2875
2876    /**
2877     * The {@code enum} keyword.  This element appears
2878     * as part of an enum declaration.
2879     **/
2880    public static final int ENUM =
2881        GeneratedJavaTokenTypes.ENUM;
2882
2883    /**
2884     * An enum constant declaration. Its notable children are annotations,
2885     * arguments and object block akin to an anonymous
2886     * inner class' body.
2887     *
2888     * <p>For example:</p>
2889     * <pre>
2890     * SOME_CONSTANT(1)
2891     * {
2892     *     public void someMethodOverriddenFromMainBody()
2893     *     {
2894     *     }
2895     * }
2896     * </pre>
2897     * <p>parses as:</p>
2898     * <pre>
2899     * +--ENUM_CONSTANT_DEF
2900     *     |
2901     *     +--ANNOTATIONS
2902     *     +--IDENT (SOME_CONSTANT)
2903     *     +--LPAREN (()
2904     *     +--ELIST
2905     *         |
2906     *         +--EXPR
2907     *             |
2908     *             +--NUM_INT (1)
2909     *     +--RPAREN ())
2910     *     +--OBJBLOCK
2911     *         |
2912     *         +--LCURLY ({)
2913     *         |
2914     *         +--METHOD_DEF
2915     *             |
2916     *             +--MODIFIERS
2917     *                 |
2918     *                 +--LITERAL_PUBLIC (public)
2919     *             +--TYPE
2920     *                 |
2921     *                 +--LITERAL_void (void)
2922     *             +--IDENT (someMethodOverriddenFromMainBody)
2923     *             +--LPAREN (()
2924     *             +--PARAMETERS
2925     *             +--RPAREN ())
2926     *             +--SLIST ({)
2927     *                 |
2928     *                 +--RCURLY (})
2929     *         +--RCURLY (})
2930     * </pre>
2931     *
2932     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
2933     * JSR201</a>
2934     * @see #ANNOTATIONS
2935     * @see #MODIFIERS
2936     * @see #IDENT
2937     * @see #ELIST
2938     * @see #OBJBLOCK
2939     **/
2940    public static final int ENUM_CONSTANT_DEF =
2941        GeneratedJavaTokenTypes.ENUM_CONSTANT_DEF;
2942
2943    /**
2944     * A for-each clause.  This is a child of
2945     * {@code LITERAL_FOR}.  The children of this element may be
2946     * a parameter definition, the colon literal and an expression.
2947     *
2948     * <p>For example:</p>
2949     * <pre>
2950     * for (int value : values) {
2951     *     doSmth();
2952     * }
2953     * </pre>
2954     * <p>parses as:</p>
2955     * <pre>
2956     * --LITERAL_FOR (for)
2957     *    |--LPAREN (()
2958     *    |--FOR_EACH_CLAUSE
2959     *    |   |--VARIABLE_DEF
2960     *    |   |   |--MODIFIERS
2961     *    |   |   |--TYPE
2962     *    |   |   |   `--LITERAL_INT (int)
2963     *    |   |   `--IDENT (value)
2964     *    |   |--COLON (:)
2965     *    |   `--EXPR
2966     *    |       `--IDENT (values
2967     *    |--RPAREN ())
2968     *    `--SLIST ({)
2969     *        |--EXPR
2970     *        |   `--METHOD_CALL (()
2971     *        |       |--IDENT (doSmth)
2972     *        |       |--ELIST
2973     *        |       `--RPAREN ())
2974     *        |--SEMI (;)
2975     *        `--RCURLY (})
2976     *
2977     * </pre>
2978     *
2979     * @see #VARIABLE_DEF
2980     * @see #ELIST
2981     * @see #LITERAL_FOR
2982     **/
2983    public static final int FOR_EACH_CLAUSE =
2984        GeneratedJavaTokenTypes.FOR_EACH_CLAUSE;
2985
2986    /**
2987     * An annotation declaration. The notable children are the name of the
2988     * annotation type, annotation field declarations and (constant) fields.
2989     *
2990     * <p>For example:</p>
2991     * <pre>
2992     * public @interface MyAnnotation
2993     * {
2994     *     int someValue();
2995     * }
2996     * </pre>
2997     * <p>parses as:</p>
2998     * <pre>
2999     * +--ANNOTATION_DEF
3000     *     |
3001     *     +--MODIFIERS
3002     *         |
3003     *         +--LITERAL_PUBLIC (public)
3004     *     +--AT (@)
3005     *     +--LITERAL_INTERFACE (interface)
3006     *     +--IDENT (MyAnnotation)
3007     *     +--OBJBLOCK
3008     *         |
3009     *         +--LCURLY ({)
3010     *         +--ANNOTATION_FIELD_DEF
3011     *             |
3012     *             +--MODIFIERS
3013     *             +--TYPE
3014     *                 |
3015     *                 +--LITERAL_INT (int)
3016     *             +--IDENT (someValue)
3017     *             +--LPAREN (()
3018     *             +--RPAREN ())
3019     *             +--SEMI (;)
3020     *         +--RCURLY (})
3021     * </pre>
3022     *
3023     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
3024     * JSR201</a>
3025     * @see #MODIFIERS
3026     * @see #LITERAL_INTERFACE
3027     * @see #IDENT
3028     * @see #OBJBLOCK
3029     * @see #ANNOTATION_FIELD_DEF
3030     **/
3031    public static final int ANNOTATION_DEF =
3032        GeneratedJavaTokenTypes.ANNOTATION_DEF;
3033
3034    /**
3035     * An annotation field declaration.  The notable children are modifiers,
3036     * field type, field name and an optional default value (a conditional
3037     * compile-time constant expression). Default values may also by
3038     * annotations.
3039     *
3040     * <p>For example:</p>
3041     *
3042     * <pre>
3043     *     String someField() default "Hello world";
3044     * </pre>
3045     *
3046     * <p>parses as:</p>
3047     *
3048     * <pre>
3049     * +--ANNOTATION_FIELD_DEF
3050     *     |
3051     *     +--MODIFIERS
3052     *     +--TYPE
3053     *         |
3054     *         +--IDENT (String)
3055     *     +--IDENT (someField)
3056     *     +--LPAREN (()
3057     *     +--RPAREN ())
3058     *     +--LITERAL_DEFAULT (default)
3059     *     +--STRING_LITERAL ("Hello world")
3060     *     +--SEMI (;)
3061     * </pre>
3062     *
3063     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
3064     * JSR201</a>
3065     * @see #MODIFIERS
3066     * @see #TYPE
3067     * @see #LITERAL_DEFAULT
3068     */
3069    public static final int ANNOTATION_FIELD_DEF =
3070        GeneratedJavaTokenTypes.ANNOTATION_FIELD_DEF;
3071
3072    // note: &#064; is the html escape for '@',
3073    // used here to avoid confusing the javadoc tool
3074    /**
3075     * A collection of annotations on a package or enum constant.
3076     * A collections of annotations will only occur on these nodes
3077     * as all other nodes that may be qualified with an annotation can
3078     * be qualified with any other modifier and hence these annotations
3079     * would be contained in a {@link #MODIFIERS} node.
3080     *
3081     * <p>For example:</p>
3082     *
3083     * <pre>
3084     *     &#064;MyAnnotation package blah;
3085     * </pre>
3086     *
3087     * <p>parses as:</p>
3088     *
3089     * <pre>
3090     * +--PACKAGE_DEF (package)
3091     *     |
3092     *     +--ANNOTATIONS
3093     *         |
3094     *         +--ANNOTATION
3095     *             |
3096     *             +--AT (&#064;)
3097     *             +--IDENT (MyAnnotation)
3098     *     +--IDENT (blah)
3099     *     +--SEMI (;)
3100     * </pre>
3101     *
3102     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
3103     * JSR201</a>
3104     * @see #ANNOTATION
3105     * @see #AT
3106     * @see #IDENT
3107     */
3108    public static final int ANNOTATIONS =
3109        GeneratedJavaTokenTypes.ANNOTATIONS;
3110
3111    // note: &#064; is the html escape for '@',
3112    // used here to avoid confusing the javadoc tool
3113    /**
3114     * An annotation of a package, type, field, parameter or variable.
3115     * An annotation may occur anywhere modifiers occur (it is a
3116     * type of modifier) and may also occur prior to a package definition.
3117     * The notable children are: The annotation name and either a single
3118     * default annotation value or a sequence of name value pairs.
3119     * Annotation values may also be annotations themselves.
3120     *
3121     * <p>For example:</p>
3122     *
3123     * <pre>
3124     *     &#064;MyAnnotation(someField1 = "Hello",
3125     *                    someField2 = &#064;SomeOtherAnnotation)
3126     * </pre>
3127     *
3128     * <p>parses as:</p>
3129     *
3130     * <pre>
3131     * +--ANNOTATION
3132     *     |
3133     *     +--AT (&#064;)
3134     *     +--IDENT (MyAnnotation)
3135     *     +--LPAREN (()
3136     *     +--ANNOTATION_MEMBER_VALUE_PAIR
3137     *         |
3138     *         +--IDENT (someField1)
3139     *         +--ASSIGN (=)
3140     *         +--ANNOTATION
3141     *             |
3142     *             +--AT (&#064;)
3143     *             +--IDENT (SomeOtherAnnotation)
3144     *     +--ANNOTATION_MEMBER_VALUE_PAIR
3145     *         |
3146     *         +--IDENT (someField2)
3147     *         +--ASSIGN (=)
3148     *         +--STRING_LITERAL ("Hello")
3149     *     +--RPAREN ())
3150     * </pre>
3151     *
3152     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
3153     * JSR201</a>
3154     * @see #MODIFIERS
3155     * @see #IDENT
3156     * @see #ANNOTATION_MEMBER_VALUE_PAIR
3157     */
3158    public static final int ANNOTATION =
3159        GeneratedJavaTokenTypes.ANNOTATION;
3160
3161    /**
3162     * An initialisation of an annotation member with a value.
3163     * Its children are the name of the member, the assignment literal
3164     * and the (compile-time constant conditional expression) value.
3165     *
3166     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
3167     * JSR201</a>
3168     * @see #ANNOTATION
3169     * @see #IDENT
3170     */
3171    public static final int ANNOTATION_MEMBER_VALUE_PAIR =
3172        GeneratedJavaTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR;
3173
3174    /**
3175     * An annotation array member initialisation.
3176     * Initializers can not be nested.
3177     * Am initializer may be present as a default to a annotation
3178     * member, as the single default value to an annotation
3179     * (e.g. @Annotation({1,2})) or as the value of an annotation
3180     * member value pair.
3181     *
3182     * <p>For example:</p>
3183     *
3184     * <pre>
3185     *     { 1, 2 }
3186     * </pre>
3187     *
3188     * <p>parses as:</p>
3189     *
3190     * <pre>
3191     * +--ANNOTATION_ARRAY_INIT ({)
3192     *     |
3193     *     +--NUM_INT (1)
3194     *     +--COMMA (,)
3195     *     +--NUM_INT (2)
3196     *     +--RCURLY (})
3197     * </pre>
3198     *
3199     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
3200     * JSR201</a>
3201     * @see #ANNOTATION
3202     * @see #IDENT
3203     * @see #ANNOTATION_MEMBER_VALUE_PAIR
3204     */
3205    public static final int ANNOTATION_ARRAY_INIT =
3206        GeneratedJavaTokenTypes.ANNOTATION_ARRAY_INIT;
3207
3208    /**
3209     * A list of type parameters to a class, interface or
3210     * method definition. Children are LT, at least one
3211     * TYPE_PARAMETER, zero or more of: a COMMAs followed by a single
3212     * TYPE_PARAMETER and a final GT.
3213     *
3214     * <p>For example:</p>
3215     *
3216     * <pre>
3217     *     public class Blah&lt;A, B&gt;
3218     *     {
3219     *     }
3220     * </pre>
3221     *
3222     * <p>parses as:</p>
3223     *
3224     * <pre>
3225     * +--CLASS_DEF ({)
3226     *     |
3227     *     +--MODIFIERS
3228     *         |
3229     *         +--LITERAL_PUBLIC (public)
3230     *     +--LITERAL_CLASS (class)
3231     *     +--IDENT (Blah)
3232     *     +--TYPE_PARAMETERS
3233     *         |
3234     *         +--GENERIC_START (&lt;)
3235     *         +--TYPE_PARAMETER
3236     *             |
3237     *             +--IDENT (A)
3238     *         +--COMMA (,)
3239     *         +--TYPE_PARAMETER
3240     *             |
3241     *             +--IDENT (B)
3242     *         +--GENERIC_END (&gt;)
3243     *     +--OBJBLOCK
3244     *         |
3245     *         +--LCURLY ({)
3246     *     +--NUM_INT (1)
3247     *     +--COMMA (,)
3248     *     +--NUM_INT (2)
3249     *     +--RCURLY (})
3250     * </pre>
3251     *
3252     * @see <a href="https://www.jcp.org/en/jsr/detail?id=14">
3253     * JSR14</a>
3254     * @see #GENERIC_START
3255     * @see #GENERIC_END
3256     * @see #TYPE_PARAMETER
3257     * @see #COMMA
3258     */
3259    public static final int TYPE_PARAMETERS =
3260        GeneratedJavaTokenTypes.TYPE_PARAMETERS;
3261
3262    /**
3263     * A type parameter to a class, interface or method definition.
3264     * Children are the type name and an optional TYPE_UPPER_BOUNDS.
3265     *
3266     * <p>For example:</p>
3267     *
3268     * <pre>
3269     *     A extends Collection
3270     * </pre>
3271     *
3272     * <p>parses as:</p>
3273     *
3274     * <pre>
3275     * +--TYPE_PARAMETER
3276     *     |
3277     *     +--IDENT (A)
3278     *     +--TYPE_UPPER_BOUNDS
3279     *         |
3280     *         +--IDENT (Collection)
3281     * </pre>
3282     *
3283     * @see <a href="https://www.jcp.org/en/jsr/detail?id=14">
3284     * JSR14</a>
3285     * @see #IDENT
3286     * @see #WILDCARD_TYPE
3287     * @see #TYPE_UPPER_BOUNDS
3288     */
3289    public static final int TYPE_PARAMETER =
3290        GeneratedJavaTokenTypes.TYPE_PARAMETER;
3291
3292    /**
3293     * A list of type arguments to a type reference or
3294     * a method/ctor invocation. Children are GENERIC_START, at least one
3295     * TYPE_ARGUMENT, zero or more of a COMMAs followed by a single
3296     * TYPE_ARGUMENT, and a final GENERIC_END.
3297     *
3298     * <p>For example:</p>
3299     *
3300     * <pre>
3301     *     public Collection&lt;?&gt; a;
3302     * </pre>
3303     *
3304     * <p>parses as:</p>
3305     *
3306     * <pre>
3307     * +--VARIABLE_DEF
3308     *     |
3309     *     +--MODIFIERS
3310     *         |
3311     *         +--LITERAL_PUBLIC (public)
3312     *     +--TYPE
3313     *         |
3314     *         +--IDENT (Collection)
3315     *             |
3316     *             +--TYPE_ARGUMENTS
3317     *                 |
3318     *                 +--GENERIC_START (&lt;)
3319     *                 +--TYPE_ARGUMENT
3320     *                     |
3321     *                     +--WILDCARD_TYPE (?)
3322     *                 +--GENERIC_END (&gt;)
3323     *     +--IDENT (a)
3324     *     +--SEMI (;)
3325     * </pre>
3326     *
3327     * @see #GENERIC_START
3328     * @see #GENERIC_END
3329     * @see #TYPE_ARGUMENT
3330     * @see #COMMA
3331     */
3332    public static final int TYPE_ARGUMENTS =
3333        GeneratedJavaTokenTypes.TYPE_ARGUMENTS;
3334
3335    /**
3336     * A type arguments to a type reference or a method/ctor invocation.
3337     * Children are either: type name or wildcard type with possible type
3338     * upper or lower bounds.
3339     *
3340     * <p>For example:</p>
3341     *
3342     * <pre>
3343     *     ? super List
3344     * </pre>
3345     *
3346     * <p>parses as:</p>
3347     *
3348     * <pre>
3349     * +--TYPE_ARGUMENT
3350     *     |
3351     *     +--WILDCARD_TYPE (?)
3352     *     +--TYPE_LOWER_BOUNDS
3353     *         |
3354     *         +--IDENT (List)
3355     * </pre>
3356     *
3357     * @see <a href="https://www.jcp.org/en/jsr/detail?id=14">
3358     * JSR14</a>
3359     * @see #WILDCARD_TYPE
3360     * @see #TYPE_UPPER_BOUNDS
3361     * @see #TYPE_LOWER_BOUNDS
3362     */
3363    public static final int TYPE_ARGUMENT =
3364        GeneratedJavaTokenTypes.TYPE_ARGUMENT;
3365
3366    /**
3367     * The type that refers to all types. This node has no children.
3368     *
3369     * @see <a href="https://www.jcp.org/en/jsr/detail?id=14">
3370     * JSR14</a>
3371     * @see #TYPE_ARGUMENT
3372     * @see #TYPE_UPPER_BOUNDS
3373     * @see #TYPE_LOWER_BOUNDS
3374     */
3375    public static final int WILDCARD_TYPE =
3376        GeneratedJavaTokenTypes.WILDCARD_TYPE;
3377
3378    /**
3379     * An upper bounds on a wildcard type argument or type parameter.
3380     * This node has one child - the type that is being used for
3381     * the bounding.
3382     *
3383     * @see <a href="https://www.jcp.org/en/jsr/detail?id=14">
3384     * JSR14</a>
3385     * @see #TYPE_PARAMETER
3386     * @see #TYPE_ARGUMENT
3387     * @see #WILDCARD_TYPE
3388     */
3389    public static final int TYPE_UPPER_BOUNDS =
3390        GeneratedJavaTokenTypes.TYPE_UPPER_BOUNDS;
3391
3392    /**
3393     * A lower bounds on a wildcard type argument. This node has one child
3394     *  - the type that is being used for the bounding.
3395     *
3396     * @see <a href="https://www.jcp.org/en/jsr/detail?id=14">
3397     * JSR14</a>
3398     * @see #TYPE_ARGUMENT
3399     * @see #WILDCARD_TYPE
3400     */
3401    public static final int TYPE_LOWER_BOUNDS =
3402        GeneratedJavaTokenTypes.TYPE_LOWER_BOUNDS;
3403
3404    /**
3405     * An 'at' symbol - signifying an annotation instance or the prefix
3406     * to the interface literal signifying the definition of an annotation
3407     * declaration.
3408     *
3409     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
3410     * JSR201</a>
3411     */
3412    public static final int AT = GeneratedJavaTokenTypes.AT;
3413
3414    /**
3415     * A triple dot for variable-length parameters. This token only ever occurs
3416     * in a parameter declaration immediately after the type of the parameter.
3417     *
3418     * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
3419     * JSR201</a>
3420     */
3421    public static final int ELLIPSIS = GeneratedJavaTokenTypes.ELLIPSIS;
3422
3423    /**
3424     * '&amp;' symbol when used in a generic upper or lower bounds constrain
3425     * e.g. {@code Comparable&lt;<? extends Serializable, CharSequence>}.
3426     */
3427    public static final int TYPE_EXTENSION_AND =
3428        GeneratedJavaTokenTypes.TYPE_EXTENSION_AND;
3429
3430    /**
3431     * '&lt;' symbol signifying the start of type arguments or type
3432     * parameters.
3433     */
3434    public static final int GENERIC_START =
3435        GeneratedJavaTokenTypes.GENERIC_START;
3436
3437    /**
3438     * '&gt;' symbol signifying the end of type arguments or type parameters.
3439     */
3440    public static final int GENERIC_END = GeneratedJavaTokenTypes.GENERIC_END;
3441
3442    /**
3443     * Special lambda symbol '-&gt;'.
3444     */
3445    public static final int LAMBDA = GeneratedJavaTokenTypes.LAMBDA;
3446
3447    /**
3448     * Beginning of single line comment: '//'.
3449     *
3450     * <pre>
3451     * +--SINGLE_LINE_COMMENT
3452     *         |
3453     *         +--COMMENT_CONTENT
3454     * </pre>
3455     */
3456    public static final int SINGLE_LINE_COMMENT =
3457            GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT;
3458
3459    /**
3460     * Beginning of block comment: '/*'.
3461     *
3462     * <pre>
3463     * +--BLOCK_COMMENT_BEGIN
3464     *         |
3465     *         +--COMMENT_CONTENT
3466     *         +--BLOCK_COMMENT_END
3467     * </pre>
3468     */
3469    public static final int BLOCK_COMMENT_BEGIN =
3470            GeneratedJavaTokenTypes.BLOCK_COMMENT_BEGIN;
3471
3472    /**
3473     * End of block comment: '* /'.
3474     *
3475     * <pre>
3476     * +--BLOCK_COMMENT_BEGIN
3477     *         |
3478     *         +--COMMENT_CONTENT
3479     *         +--BLOCK_COMMENT_END
3480     * </pre>
3481     */
3482    public static final int BLOCK_COMMENT_END =
3483            GeneratedJavaTokenTypes.BLOCK_COMMENT_END;
3484
3485    /**
3486     * Text of single-line or block comment.
3487     *
3488     * <pre>
3489     * +--SINGLE_LINE_COMMENT
3490     *         |
3491     *         +--COMMENT_CONTENT
3492     * </pre>
3493     *
3494     * <pre>
3495     * +--BLOCK_COMMENT_BEGIN
3496     *         |
3497     *         +--COMMENT_CONTENT
3498     *         +--BLOCK_COMMENT_END
3499     * </pre>
3500     */
3501    public static final int COMMENT_CONTENT =
3502            GeneratedJavaTokenTypes.COMMENT_CONTENT;
3503
3504    /** Prevent instantiation. */
3505    private TokenTypes() {
3506    }
3507
3508}