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