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