View Javadoc
1   ////////////////////////////////////////////////////////////////////////////////
2   // checkstyle: Checks Java source code for adherence to a set of rules.
3   // Copyright (C) 2001-2017 the original author or authors.
4   //
5   // This library is free software; you can redistribute it and/or
6   // modify it under the terms of the GNU Lesser General Public
7   // License as published by the Free Software Foundation; either
8   // version 2.1 of the License, or (at your option) any later version.
9   //
10  // This library is distributed in the hope that it will be useful,
11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  // Lesser General Public License for more details.
14  //
15  // You should have received a copy of the GNU Lesser General Public
16  // License along with this library; if not, write to the Free Software
17  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  ////////////////////////////////////////////////////////////////////////////////
19  
20  package com.puppycrawl.tools.checkstyle.api;
21  
22  import com.puppycrawl.tools.checkstyle.grammars.GeneratedJavaTokenTypes;
23  
24  /**
25   * Contains the constants for all the tokens contained in the Abstract
26   * Syntax Tree.
27   *
28   * <p>Implementation detail: This class has been introduced to break
29   * the circular dependency between packages.</p>
30   *
31   * @author Oliver Burn
32   * @author <a href="mailto:dobratzp@ele.uri.edu">Peter Dobratz</a>
33   * @noinspection ClassWithTooManyDependents
34   */
35  public final class TokenTypes {
36      // The following three types are never part of an AST,
37      // left here as a reminder so nobody will read them accidentally
38  
39      // These are the types that can actually occur in an AST
40      // it makes sense to register Checks for these types
41  
42      /**
43       * The end of file token.  This is the root node for the source
44       * file.  It's children are an optional package definition, zero
45       * or more import statements, and one or more class or interface
46       * definitions.
47       *
48       * @see #PACKAGE_DEF
49       * @see #IMPORT
50       * @see #CLASS_DEF
51       * @see #INTERFACE_DEF
52       **/
53      public static final int EOF = GeneratedJavaTokenTypes.EOF;
54      /**
55       * Modifiers for type, method, and field declarations.  The
56       * modifiers element is always present even though it may have no
57       * children.
58       *
59       * @see <a
60       * href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html">Java
61       * Language Specification, &sect;8</a>
62       * @see #LITERAL_PUBLIC
63       * @see #LITERAL_PROTECTED
64       * @see #LITERAL_PRIVATE
65       * @see #ABSTRACT
66       * @see #LITERAL_STATIC
67       * @see #FINAL
68       * @see #LITERAL_TRANSIENT
69       * @see #LITERAL_VOLATILE
70       * @see #LITERAL_SYNCHRONIZED
71       * @see #LITERAL_NATIVE
72       * @see #STRICTFP
73       * @see #ANNOTATION
74       * @see #LITERAL_DEFAULT
75       **/
76      public static final int MODIFIERS = GeneratedJavaTokenTypes.MODIFIERS;
77  
78      /**
79       * An object block.  These are children of class, interface, enum,
80       * annotation and enum constant declarations.
81       * Also, object blocks are children of the new keyword when defining
82       * anonymous inner types.
83       *
84       * @see #LCURLY
85       * @see #INSTANCE_INIT
86       * @see #STATIC_INIT
87       * @see #CLASS_DEF
88       * @see #CTOR_DEF
89       * @see #METHOD_DEF
90       * @see #VARIABLE_DEF
91       * @see #RCURLY
92       * @see #INTERFACE_DEF
93       * @see #LITERAL_NEW
94       * @see #ENUM_DEF
95       * @see #ENUM_CONSTANT_DEF
96       * @see #ANNOTATION_DEF
97       **/
98      public static final int OBJBLOCK = GeneratedJavaTokenTypes.OBJBLOCK;
99      /**
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 }