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