001/////////////////////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code and other text files for adherence to a set of rules. 003// Copyright (C) 2001-2025 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.javadoc.JavadocCommentsLexer; 023 024/** 025 * Contains the constants for all the tokens contained in the Abstract 026 * Syntax Tree for the javadoc grammar. 027 * 028 * @see <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html"> 029 * javadoc - The Java API Documentation Generator</a> 030 */ 031public final class JavadocCommentsTokenTypes { 032 033 /** 034 * Root node of any Javadoc comment. 035 * 036 * <p><b>Tree for example:</b></p> 037 * <pre>{@code 038 * JAVADOC_CONTENT -> JAVADOC_CONTENT 039 * |--LEADING_ASTERISK -> * 040 * |--NEWLINE -> \n 041 * |--LEADING_ASTERISK -> * 042 * |--NEWLINE -> \n 043 * |--LEADING_ASTERISK -> * 044 * `--NEWLINE -> \n 045 * }</pre> 046 */ 047 public static final int JAVADOC_CONTENT = JavadocCommentsLexer.JAVADOC; 048 049 /** 050 * Leading asterisk used to format Javadoc lines. 051 */ 052 public static final int LEADING_ASTERISK = JavadocCommentsLexer.LEADING_ASTERISK; 053 054 /** 055 * Newline character in a Javadoc comment. 056 */ 057 public static final int NEWLINE = JavadocCommentsLexer.NEWLINE; 058 059 /** 060 * Plain text content within a Javadoc comment. 061 */ 062 public static final int TEXT = JavadocCommentsLexer.TEXT; 063 064 // Block tags 065 066 /** 067 * General block tag (e.g. {@code @param}, {@code @return}). 068 */ 069 public static final int JAVADOC_BLOCK_TAG = JavadocCommentsLexer.JAVADOC_BLOCK_TAG; 070 071 /** 072 * At-sign {@code @} that starts a block tag. 073 */ 074 public static final int AT_SIGN = JavadocCommentsLexer.AT_SIGN; 075 076 /** 077 * {@code @author} Javadoc block tag. 078 * 079 * <p>Such Javadoc tag can have one child:</p> 080 * <ol> 081 * <li>{@link #DESCRIPTION}</li> 082 * </ol> 083 * 084 * <p><b>Example:</b></p> 085 * <pre>{@code * @author name.}</pre> 086 * <b>Tree:</b> 087 * <pre>{@code 088 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 089 * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG 090 * |--AT_SIGN -> @ 091 * |--TAG_NAME -> author 092 * `--DESCRIPTION -> DESCRIPTION 093 * `--TEXT -> name. 094 * }</pre> 095 * 096 * @see #JAVADOC_BLOCK_TAG 097 */ 098 public static final int AUTHOR_BLOCK_TAG = JavadocCommentsLexer.AUTHOR_BLOCK_TAG; 099 100 /** 101 * {@code @deprecated} block tag. 102 * 103 * <p>Such Javadoc tag can have one child:</p> 104 * <ol> 105 * <li>{@link #DESCRIPTION}</li> 106 * </ol> 107 * 108 * <p><b>Example:</b></p> 109 * <pre>{@code * @deprecated deprecated text.}</pre> 110 * 111 * <b>Tree:</b> 112 * <pre>{@code 113 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 114 * `--DEPRECATED_BLOCK_TAG -> DEPRECATED_BLOCK_TAG 115 * |--AT_SIGN -> @ 116 * |--TAG_NAME -> deprecated 117 * `--DESCRIPTION -> DESCRIPTION 118 * `--TEXT -> deprecated text. 119 * }</pre> 120 * 121 * @see #JAVADOC_BLOCK_TAG 122 */ 123 public static final int DEPRECATED_BLOCK_TAG = JavadocCommentsLexer.DEPRECATED_BLOCK_TAG; 124 125 /** 126 * {@code @param} Javadoc block tag. 127 * 128 * <p>Such Javadoc tag can have two children:</p> 129 * <ol> 130 * <li>{@link #PARAMETER_NAME}</li> 131 * <li>{@link #DESCRIPTION}</li> 132 * </ol> 133 * 134 * <p><b>Example:</b></p> 135 * <pre>{@code * @param value The parameter of method.}</pre> 136 * <b>Tree:</b> 137 * <pre>{@code 138 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 139 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 140 * |--AT_SIGN -> @ 141 * |--TAG_NAME -> param 142 * |--TEXT -> 143 * |--PARAMETER_NAME -> value 144 * `--DESCRIPTION -> DESCRIPTION 145 * `--TEXT -> The parameter of method. 146 * }</pre> 147 * 148 * @see #JAVADOC_BLOCK_TAG 149 */ 150 public static final int PARAM_BLOCK_TAG = JavadocCommentsLexer.PARAM_BLOCK_TAG; 151 152 /** 153 * {@code @return} Javadoc block tag. 154 * 155 * <p>Such Javadoc tag can have one child:</p> 156 * <ol> 157 * <li>{@link #DESCRIPTION}</li> 158 * </ol> 159 * 160 * <p><b>Example:</b></p> 161 * <pre>{@code * @return The return of method.}</pre> 162 * <b>Tree:</b> 163 * <pre>{@code 164 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 165 * `--RETURN_BLOCK_TAG -> RETURN_BLOCK_TAG 166 * |--AT_SIGN -> @ 167 * |--TAG_NAME -> return 168 * `--DESCRIPTION -> DESCRIPTION 169 * `--TEXT -> The return of method. 170 * }</pre> 171 * 172 * @see #JAVADOC_BLOCK_TAG 173 */ 174 public static final int RETURN_BLOCK_TAG = JavadocCommentsLexer.RETURN_BLOCK_TAG; 175 176 /** 177 * {@code @throws} Javadoc block tag. 178 * 179 * <p>Such Javadoc tag can have two children:</p> 180 * <ol> 181 * <li>{@link #IDENTIFIER} - the exception class</li> 182 * <li>{@link #DESCRIPTION} - description</li> 183 * </ol> 184 * 185 * <p><b>Example:</b></p> 186 * <pre>{@code * @throws IOException if an I/O error occurs}</pre> 187 * <b>Tree:</b> 188 * <pre>{@code 189 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 190 * `--THROWS_BLOCK_TAG -> THROWS_BLOCK_TAG 191 * |--AT_SIGN -> @ 192 * |--TAG_NAME -> throws 193 * |--TEXT -> 194 * |--IDENTIFIER -> IOException 195 * `--DESCRIPTION -> DESCRIPTION 196 * `--TEXT -> if an I/O error occurs 197 * }</pre> 198 * 199 * @see #JAVADOC_BLOCK_TAG 200 */ 201 public static final int THROWS_BLOCK_TAG = JavadocCommentsLexer.THROWS_BLOCK_TAG; 202 203 /** 204 * {@code @exception} Javadoc block tag. 205 * 206 * <p>Such Javadoc tag can have two children:</p> 207 * <ol> 208 * <li>{@link #IDENTIFIER}</li> 209 * <li>{@link #DESCRIPTION}</li> 210 * </ol> 211 * 212 * <p><b>Example:</b></p> 213 * <pre>{@code * @exception FileNotFoundException when file is not found.}</pre> 214 * <b>Tree:</b> 215 * <pre>{@code 216 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 217 * `--EXCEPTION_BLOCK_TAG -> EXCEPTION_BLOCK_TAG 218 * |--AT_SIGN -> @ 219 * |--TAG_NAME -> exception 220 * |--TEXT -> 221 * |--IDENTIFIER -> FileNotFoundException 222 * `--DESCRIPTION -> DESCRIPTION 223 * `--TEXT -> when file is not found. 224 * }</pre> 225 * 226 * @see #JAVADOC_BLOCK_TAG 227 */ 228 public static final int EXCEPTION_BLOCK_TAG = JavadocCommentsLexer.EXCEPTION_BLOCK_TAG; 229 230 /** 231 * {@code @since} Javadoc block tag. 232 * 233 * <p>Such Javadoc tag can have one child:</p> 234 * <ol> 235 * <li>{@link #DESCRIPTION}</li> 236 * </ol> 237 * 238 * <p><b>Example:</b></p> 239 * <pre>{@code * @since 1.0}</pre> 240 * 241 * <b>Tree:</b> 242 * <pre>{@code 243 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 244 * `--SINCE_BLOCK_TAG -> SINCE_BLOCK_TAG 245 * |--AT_SIGN -> @ 246 * |--TAG_NAME -> since 247 * `--DESCRIPTION -> DESCRIPTION 248 * `--TEXT -> 1.0 249 * }</pre> 250 * 251 * @see #JAVADOC_BLOCK_TAG 252 */ 253 public static final int SINCE_BLOCK_TAG = JavadocCommentsLexer.SINCE_BLOCK_TAG; 254 255 /** 256 * {@code @version} Javadoc block tag. 257 * 258 * <p>This tag has only one argument — {@link #TEXT}:</p> 259 * 260 * <p><b>Example:</b></p> 261 * <pre>{@code * @version value}</pre> 262 * <b>Tree:</b> 263 * <pre>{@code 264 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 265 * `--VERSION_BLOCK_TAG -> VERSION_BLOCK_TAG 266 * |--AT_SIGN -> @ 267 * |--TAG_NAME -> version 268 * `--DESCRIPTION -> DESCRIPTION 269 * `--TEXT -> value 270 * }</pre> 271 * 272 * @see #JAVADOC_BLOCK_TAG 273 */ 274 public static final int VERSION_BLOCK_TAG = JavadocCommentsLexer.VERSION_BLOCK_TAG; 275 276 /** 277 * {@code @see} Javadoc block tag. 278 * 279 * <p>Such Javadoc tag can have three children:</p> 280 * <ol> 281 * <li>{@link #REFERENCE}</li> 282 * <li>{@link #DESCRIPTION}</li> 283 * <li>{@link #HTML_ELEMENT}</li> 284 * </ol> 285 * 286 * <p><b>Example:</b></p> 287 * <pre>{@code * @see SomeClass#Field}</pre> 288 * 289 * <b>Tree:</b> 290 * <pre>{@code 291 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 292 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 293 * |--AT_SIGN -> @ 294 * |--TAG_NAME -> see 295 * |--TEXT -> 296 * `--REFERENCE -> REFERENCE 297 * |--IDENTIFIER -> SomeClass 298 * |--HASH -> # 299 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE 300 * `--IDENTIFIER -> Field 301 * }</pre> 302 * 303 * @see #JAVADOC_BLOCK_TAG 304 */ 305 public static final int SEE_BLOCK_TAG = JavadocCommentsLexer.SEE_BLOCK_TAG; 306 307 /** 308 * {@code @hidden} Javadoc block tag. 309 * 310 * <p>Such Javadoc tag can have one child:</p> 311 * <ol> 312 * <li>{@link #DESCRIPTION} – optional description text</li> 313 * </ol> 314 * 315 * <p><b>Example:</b></p> 316 * <pre>{@code * @hidden value}</pre> 317 * 318 * <b>Tree:</b> 319 * <pre>{@code 320 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 321 * `--HIDDEN_BLOCK_TAG -> HIDDEN_BLOCK_TAG 322 * |--AT_SIGN -> @ 323 * |--TAG_NAME -> hidden 324 * `--DESCRIPTION -> DESCRIPTION 325 * `--TEXT -> value 326 * }</pre> 327 * 328 * @see #JAVADOC_BLOCK_TAG 329 */ 330 public static final int HIDDEN_BLOCK_TAG = JavadocCommentsLexer.HIDDEN_BLOCK_TAG; 331 332 /** 333 * {@code @uses} Javadoc block tag. 334 * 335 * <p>Such Javadoc tag can have one child:</p> 336 * <ol> 337 * <li>{@link #IDENTIFIER} – the referenced service type</li> 338 * </ol> 339 * 340 * <p><b>Example:</b></p> 341 * <pre>{@code * @uses com.example.app.MyService}</pre> 342 * 343 * <b>Tree:</b> 344 * <pre>{@code 345 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 346 * `--USES_BLOCK_TAG -> USES_BLOCK_TAG 347 * |--AT_SIGN -> @ 348 * |--TAG_NAME -> uses 349 * |--TEXT -> 350 * `--IDENTIFIER -> com.example.app.MyService 351 * }</pre> 352 * 353 * @see #JAVADOC_BLOCK_TAG 354 */ 355 public static final int USES_BLOCK_TAG = JavadocCommentsLexer.USES_BLOCK_TAG; 356 357 /** 358 * {@code @provides} block tag. 359 * 360 * <p>Such Javadoc tag can have two children:</p> 361 * <ol> 362 * <li>{@link #IDENTIFIER}</li> 363 * <li>{@link #DESCRIPTION}</li> 364 * </ol> 365 * 366 * <p><b>Example:</b></p> 367 * <pre>{@code * @provides com.example.MyService with com.example.MyServiceImpl}</pre> 368 * 369 * <b>Tree:</b> 370 * <pre>{@code 371 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 372 * `--PROVIDES_BLOCK_TAG -> PROVIDES_BLOCK_TAG 373 * |--AT_SIGN -> @ 374 * |--TAG_NAME -> provides 375 * |--TEXT -> 376 * |--IDENTIFIER -> com.example.MyService 377 * `--DESCRIPTION -> DESCRIPTION 378 * `--TEXT -> with com.example.MyServiceImpl 379 * }</pre> 380 * 381 * @see #JAVADOC_BLOCK_TAG 382 */ 383 public static final int PROVIDES_BLOCK_TAG = JavadocCommentsLexer.PROVIDES_BLOCK_TAG; 384 385 /** 386 * {@code @serial} block tag. 387 * 388 * <p>Such Javadoc tag can have one child:</p> 389 * <ol> 390 * <li>{@link #DESCRIPTION} – optional description text</li> 391 * </ol> 392 * 393 * <p><b>Example:</b></p> 394 * <pre>{@code * @serial include}</pre> 395 * 396 * <b>Tree:</b> 397 * <pre>{@code 398 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 399 * `--SERIAL_BLOCK_TAG -> SERIAL_BLOCK_TAG 400 * |--AT_SIGN -> @ 401 * |--TAG_NAME -> serial 402 * `--DESCRIPTION -> DESCRIPTION 403 * `--TEXT -> include 404 * }</pre> 405 * 406 * @see #JAVADOC_BLOCK_TAG 407 */ 408 public static final int SERIAL_BLOCK_TAG = JavadocCommentsLexer.SERIAL_BLOCK_TAG; 409 410 /** 411 * {@code @serialData} block tag. 412 * 413 * <p>Such Javadoc tag can have one child:</p> 414 * <ol> 415 * <li>{@link #DESCRIPTION} – optional description text</li> 416 * </ol> 417 * 418 * <p><b>Example:</b></p> 419 * <pre>{@code * @serialData data description value}</pre> 420 * 421 * <b>Tree:</b> 422 * <pre>{@code 423 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 424 * `--SERIAL_DATA_BLOCK_TAG -> SERIAL_DATA_BLOCK_TAG 425 * |--AT_SIGN -> @ 426 * |--TAG_NAME -> serialData 427 * `--DESCRIPTION -> DESCRIPTION 428 * `--TEXT -> data description value 429 * }</pre> 430 * 431 * @see #JAVADOC_BLOCK_TAG 432 */ 433 public static final int SERIAL_DATA_BLOCK_TAG = JavadocCommentsLexer.SERIAL_DATA_BLOCK_TAG; 434 435 /** 436 * {@code @serialField} Javadoc block tag. 437 * 438 * <p>Such Javadoc tag can have three children:</p> 439 * <ol> 440 * <li>{@link #IDENTIFIER} – field name</li> 441 * <li>{@link #FIELD_TYPE} – field type</li> 442 * <li>{@link #DESCRIPTION} – field description</li> 443 * </ol> 444 * 445 * <p><b>Example:</b></p> 446 * <pre>{@code * @serialField name String The person's full name.}</pre> 447 * 448 * <b>Tree:</b> 449 * <pre>{@code 450 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 451 * `--SERIAL_FIELD_BLOCK_TAG -> SERIAL_FIELD_BLOCK_TAG 452 * |--AT_SIGN -> @ 453 * |--TAG_NAME -> serialField 454 * |--TEXT -> 455 * |--IDENTIFIER -> name 456 * |--TEXT -> 457 * |--FIELD_TYPE -> String 458 * `--DESCRIPTION -> DESCRIPTION 459 * `--TEXT -> The person's full name. 460 * }</pre> 461 * 462 * @see #JAVADOC_BLOCK_TAG 463 */ 464 public static final int SERIAL_FIELD_BLOCK_TAG = JavadocCommentsLexer.SERIAL_FIELD_BLOCK_TAG; 465 466 /** 467 * {@code @customBlock} Javadoc block tag. 468 * 469 * <p>This type represents any block tag that is not explicitly recognized by Checkstyle, 470 * such as a project-specific or malformed tag.</p> 471 * 472 * <p><b>Example:</b></p> 473 * <pre>{@code * @mycustomtag This is a custom block tag.}</pre> 474 * <b>Tree:</b> 475 * <pre>{@code 476 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 477 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 478 * |--AT_SIGN -> @ 479 * |--TAG_NAME -> customBlock 480 * |--TEXT -> 481 * `--DESCRIPTION -> DESCRIPTION 482 * `--TEXT -> This is a custom block tag. 483 * }</pre> 484 * 485 * @see #JAVADOC_BLOCK_TAG 486 */ 487 public static final int CUSTOM_BLOCK_TAG = JavadocCommentsLexer.CUSTOM_BLOCK_TAG; 488 489 // Inline tags 490 491 /** 492 * General inline tag (e.g. {@code @link}). 493 */ 494 public static final int JAVADOC_INLINE_TAG = JavadocCommentsLexer.JAVADOC_INLINE_TAG; 495 496 /** 497 * Start of an inline tag <code>{</code>. 498 */ 499 public static final int JAVADOC_INLINE_TAG_START = 500 JavadocCommentsLexer.JAVADOC_INLINE_TAG_START; 501 502 /** 503 * End of an inline tag <code>}</code>. 504 */ 505 public static final int JAVADOC_INLINE_TAG_END = JavadocCommentsLexer.JAVADOC_INLINE_TAG_END; 506 507 /** 508 * {@code {@code}} Javadoc inline tag. 509 * 510 * <p>Such Javadoc tag can have no children:</p> 511 * 512 * <p><b>Example:</b></p> 513 * <pre>{@code * {@code println("Hello");}}</pre> 514 * 515 * <b>Tree:</b> 516 * <pre>{@code 517 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 518 * |--CODE_INLINE_TAG -> CODE_INLINE_TAG 519 * |--JAVADOC_INLINE_TAG_START -> { @ 520 * |--TAG_NAME -> code 521 * |--TEXT -> println("Hello"); 522 * `--JAVADOC_INLINE_TAG_END -> } 523 * }</pre> 524 * 525 * @see #JAVADOC_INLINE_TAG 526 */ 527 public static final int CODE_INLINE_TAG = JavadocCommentsLexer.CODE_INLINE_TAG; 528 529 /** 530 * {@code {@link}} Javadoc inline tag. 531 * 532 * <p>Such Javadoc tag can have two children:</p> 533 * <ol> 534 * <li>{@link #REFERENCE}</li> 535 * <li>{@link #DESCRIPTION}</li> 536 * </ol> 537 * 538 * <p><b>Example:</b></p> 539 * <pre>{@code * {@link Math#max(int, int) label}}</pre> 540 * 541 * <b>Tree:</b> 542 * <pre>{@code 543 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 544 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 545 * |--JAVADOC_INLINE_TAG_START -> { @ 546 * |--TAG_NAME -> link 547 * |--TEXT -> 548 * |--REFERENCE -> REFERENCE 549 * | |--IDENTIFIER -> Math 550 * | |--HASH -> # 551 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 552 * | |--IDENTIFIER -> max 553 * | |--LPAREN -> ( 554 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 555 * | | |--PARAMETER_TYPE -> int 556 * | | |--COMMA -> , 557 * | | |--TEXT -> 558 * | | `--PARAMETER_TYPE -> int 559 * | `--RPAREN -> ) 560 * |--DESCRIPTION -> DESCRIPTION 561 * | `--TEXT -> label 562 * `--JAVADOC_INLINE_TAG_END -> } 563 * }</pre> 564 * 565 * @see #JAVADOC_INLINE_TAG 566 */ 567 public static final int LINK_INLINE_TAG = JavadocCommentsLexer.LINK_INLINE_TAG; 568 569 /** 570 * {@code {@linkplain}} Javadoc inline tag. 571 * 572 * <p>Such Javadoc tag can have two children:</p> 573 * <ol> 574 * <li>{@link #REFERENCE}</li> 575 * <li>{@link #DESCRIPTION}</li> 576 * </ol> 577 * 578 * <p><b>Example:</b></p> 579 * <pre>{@code * {@linkplain String#indexOf(int, int) label}}</pre> 580 * 581 * <b>Tree:</b> 582 * <pre>{@code 583 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 584 * `--LINKPLAIN_INLINE_TAG -> LINKPLAIN_INLINE_TAG 585 * |--JAVADOC_INLINE_TAG_START -> { @ 586 * |--TAG_NAME -> linkplain 587 * |--TEXT -> 588 * |--REFERENCE -> REFERENCE 589 * | |--IDENTIFIER -> String 590 * | |--HASH -> # 591 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 592 * | |--IDENTIFIER -> indexOf 593 * | |--LPAREN -> ( 594 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 595 * | | |--PARAMETER_TYPE -> int 596 * | | |--COMMA -> , 597 * | | |--TEXT -> 598 * | | `--PARAMETER_TYPE -> int 599 * | `--RPAREN -> ) 600 * |--DESCRIPTION -> DESCRIPTION 601 * | `--TEXT -> label 602 * `--JAVADOC_INLINE_TAG_END -> } 603 * }</pre> 604 * 605 * @see #JAVADOC_INLINE_TAG 606 */ 607 public static final int LINKPLAIN_INLINE_TAG = JavadocCommentsLexer.LINKPLAIN_INLINE_TAG; 608 609 /** 610 * {@code {@value}} Javadoc inline tag. 611 * 612 * <p>Such Javadoc tag can have one child:</p> 613 * <ol> 614 * <li>{@link #REFERENCE}</li> 615 * </ol> 616 * 617 * <p><b>Example:</b></p> 618 * <pre>{@code * {@value Integer#MAX_VALUE}}</pre> 619 * 620 * <b>Tree:</b> 621 * <pre>{@code 622 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 623 * `--VALUE_INLINE_TAG -> VALUE_INLINE_TAG 624 * |--JAVADOC_INLINE_TAG_START -> { @ 625 * |--TAG_NAME -> value 626 * |--TEXT -> 627 * |--REFERENCE -> REFERENCE 628 * | |--IDENTIFIER -> Integer 629 * | |--HASH -> # 630 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 631 * | `--IDENTIFIER -> MAX_VALUE 632 * |--TEXT -> 633 * `--JAVADOC_INLINE_TAG_END -> } 634 * }</pre> 635 * 636 * @see #JAVADOC_INLINE_TAG 637 */ 638 public static final int VALUE_INLINE_TAG = JavadocCommentsLexer.VALUE_INLINE_TAG; 639 640 /** 641 * Inline {@code {@summary ...}} tag inside Javadoc. 642 * 643 * <p>This node represents an inline {@code {@summary ...}} tag used to provide a 644 * short summary description within a Javadoc sentence.</p> 645 * 646 * <p><b>Example:</b></p> 647 * <pre>{@code * Example showing {@summary This is a short summary.}}</pre> 648 * 649 * <b>Tree:</b> 650 * <pre>{@code 651 * |--LEADING_ASTERISK -> * 652 * |--TEXT -> Example showing 653 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 654 * `--SUMMARY_INLINE_TAG -> SUMMARY_INLINE_TAG 655 * |--JAVADOC_INLINE_TAG_START -> { @ 656 * |--TAG_NAME -> summary 657 * |--DESCRIPTION -> DESCRIPTION 658 * | `--TEXT -> This is a short summary. 659 * `--JAVADOC_INLINE_TAG_END -> } 660 * }</pre> 661 * 662 * @see #JAVADOC_INLINE_TAG 663 */ 664 665 public static final int SUMMARY_INLINE_TAG = JavadocCommentsLexer.SUMMARY_INLINE_TAG; 666 667 /** 668 * {@code {@inheritDoc}} inline tag. 669 */ 670 public static final int INHERIT_DOC_INLINE_TAG = JavadocCommentsLexer.INHERIT_DOC_INLINE_TAG; 671 672 /** 673 * {@code {@systemProperty}} inline tag. 674 */ 675 public static final int SYSTEM_PROPERTY_INLINE_TAG = 676 JavadocCommentsLexer.SYSTEM_PROPERTY_INLINE_TAG; 677 678 /** 679 * {@code {@literal}} inline tag. 680 */ 681 public static final int LITERAL_INLINE_TAG = JavadocCommentsLexer.LITERAL_INLINE_TAG; 682 683 /** 684 * Inline {@code return} tag inside Javadoc. 685 * 686 * <p>This node represents an inline {@code {@return ...}} tag used to 687 * describe the returned value directly within a Javadoc sentence.</p> 688 * 689 * <p><b>Example:</b></p> 690 * <pre>{@code Example showing result {@return The computed value.}}</pre> 691 * 692 * <b>Tree:</b> 693 * <pre>{@code 694 * |--LEADING_ASTERISK -> * 695 * |--TEXT -> Example showing result 696 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 697 * `--RETURN_INLINE_TAG -> RETURN_INLINE_TAG 698 * |--JAVADOC_INLINE_TAG_START -> { @ 699 * |--TAG_NAME -> return 700 * |--DESCRIPTION -> DESCRIPTION 701 * | `--TEXT -> The computed value. 702 * `--JAVADOC_INLINE_TAG_END -> } 703 * }</pre> 704 * 705 * @see #JAVADOC_INLINE_TAG 706 */ 707 708 public static final int RETURN_INLINE_TAG = JavadocCommentsLexer.RETURN_INLINE_TAG; 709 710 /** 711 * {@code {@index}} inline tag. 712 * 713 * <p>This node represents an inline {@code {@index ...}} tag used to mark an 714 * index term inside a Javadoc sentence.</p> 715 * 716 * <p><b>Example:</b></p> 717 * <pre>{@code * Example showing {@index keyword description of the index term}.}</pre> 718 * 719 * <b>Tree:</b> 720 * <pre>{@code 721 * |--LEADING_ASTERISK -> * 722 * |--TEXT -> Example showing 723 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 724 * `--INDEX_INLINE_TAG -> INDEX_INLINE_TAG 725 * |--JAVADOC_INLINE_TAG_START -> { @ 726 * |--TAG_NAME -> index 727 * |--TEXT -> 728 * |--INDEX_TERM -> keyword 729 * |--DESCRIPTION -> DESCRIPTION 730 * | `--TEXT -> description of the index term 731 * `--JAVADOC_INLINE_TAG_END -> } 732 * |--TEXT -> . 733 * }</pre> 734 * 735 * @see #JAVADOC_INLINE_TAG 736 */ 737 738 public static final int INDEX_INLINE_TAG = JavadocCommentsLexer.INDEX_INLINE_TAG; 739 740 /** 741 * {@code @snippet} inline tag. 742 * 743 * <p>This node represents an inline { @code { @snippet :}} tag used to embed 744 * code snippets directly inside a Javadoc sentence.</p> 745 * 746 * <p><b>Example:</b></p> 747 * <pre>{ @code * Example showing { @snippet :java | 748 * System.out.println("hello"); 749 * }}</pre> 750 * 751 * <b>Tree:</b> 752 * <pre>{@code 753 * |--LEADING_ASTERISK -> * 754 * |--TEXT -> Example showing 755 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 756 * `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 757 * |--JAVADOC_INLINE_TAG_START -> { @ 758 * |--COLON -> : 759 * |--SNIPPET_BODY -> SNIPPET_BODY 760 * | |--TEXT -> java | 761 * | |--NEWLINE -> \n 762 * | |--LEADING_ASTERISK -> * 763 * | |--TEXT -> System.out.println("hello"); 764 * | |--NEWLINE -> \n 765 * | |--LEADING_ASTERISK -> * 766 * | `--TEXT -> 767 * `--JAVADOC_INLINE_TAG_END -> } 768 * }</pre> 769 * 770 * @see #JAVADOC_INLINE_TAG 771 */ 772 public static final int SNIPPET_INLINE_TAG = JavadocCommentsLexer.SNIPPET_INLINE_TAG; 773 774 /** 775 * Custom or unrecognized inline tag. 776 */ 777 public static final int CUSTOM_INLINE_TAG = JavadocCommentsLexer.CUSTOM_INLINE_TAG; 778 779 // Components 780 781 /** 782 * Identifier token. 783 */ 784 public static final int IDENTIFIER = JavadocCommentsLexer.IDENTIFIER; 785 786 /** 787 * Hash symbol {@code #} used in references. 788 */ 789 public static final int HASH = JavadocCommentsLexer.HASH; 790 791 /** 792 * Left parenthesis {@code ( }. 793 */ 794 public static final int LPAREN = JavadocCommentsLexer.LPAREN; 795 796 /** 797 * Right parenthesis {@code ) }. 798 */ 799 public static final int RPAREN = JavadocCommentsLexer.RPAREN; 800 801 /** 802 * Comma symbol {@code , }. 803 */ 804 public static final int COMMA = JavadocCommentsLexer.COMMA; 805 806 /** 807 * Slash symbol {@code / }. 808 */ 809 public static final int SLASH = JavadocCommentsLexer.SLASH; 810 811 /** 812 * Question mark symbol {@code ? }. 813 */ 814 public static final int QUESTION = JavadocCommentsLexer.QUESTION; 815 816 /** 817 * Less-than symbol {@code < }. 818 */ 819 public static final int LT = JavadocCommentsLexer.LT; 820 821 /** 822 * Greater-than symbol {@code > }. 823 */ 824 public static final int GT = JavadocCommentsLexer.GT; 825 826 /** 827 * {@code extends} keyword inside type arguments of a Javadoc inline tag. 828 * 829 * <p>This node represents the {@code extends} bound used inside a 830 * parameterized type within an inline Javadoc tag.</p> 831 * 832 * <p><b>Example:</b></p> 833 * <pre>{@code 834 * * {@link java.util.List<? extends Number> list of any subtype of Number} 835 * }</pre> 836 * 837 * <b>Tree:</b> 838 * <pre>{@code 839 * |--LEADING_ASTERISK -> * 840 * |--TEXT -> 841 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 842 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 843 * |--JAVADOC_INLINE_TAG_START -> { @ 844 * |--TAG_NAME -> link 845 * |--TEXT -> 846 * |--REFERENCE -> REFERENCE 847 * | |--IDENTIFIER -> java.util.List 848 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 849 * | |--LT -> < 850 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 851 * | | |--QUESTION -> ? 852 * | | |--TEXT -> 853 * | | |--EXTENDS -> extends 854 * | | |--TEXT -> 855 * | | `--IDENTIFIER -> Number 856 * | `--GT -> > 857 * |--DESCRIPTION -> DESCRIPTION 858 * | `--TEXT -> list of any subtype of Number 859 * `--JAVADOC_INLINE_TAG_END -> } 860 * }</pre> 861 * 862 * @see #JAVADOC_INLINE_TAG 863 */ 864 public static final int EXTENDS = JavadocCommentsLexer.EXTENDS; 865 866 /** 867 * Keyword {@code super} in type parameters. 868 */ 869 public static final int SUPER = JavadocCommentsLexer.SUPER; 870 871 /** 872 * Parameter type reference. 873 */ 874 public static final int PARAMETER_TYPE = JavadocCommentsLexer.PARAMETER_TYPE; 875 876 /** 877 * General reference within Javadoc. 878 */ 879 public static final int REFERENCE = JavadocCommentsLexer.REFERENCE; 880 881 /** 882 * Type name reference. 883 */ 884 public static final int TYPE_NAME = JavadocCommentsLexer.TYPE_NAME; 885 886 /** 887 * Member reference (e.g. method or field). 888 */ 889 public static final int MEMBER_REFERENCE = JavadocCommentsLexer.MEMBER_REFERENCE; 890 891 /** 892 * List of parameter types in a reference. 893 */ 894 public static final int PARAMETER_TYPE_LIST = JavadocCommentsLexer.PARAMETER_TYPE_LIST; 895 896 /** 897 * Type arguments in generics. 898 */ 899 public static final int TYPE_ARGUMENTS = JavadocCommentsLexer.TYPE_ARGUMENTS; 900 901 /** 902 * Single type argument in generics. 903 */ 904 public static final int TYPE_ARGUMENT = JavadocCommentsLexer.TYPE_ARGUMENT; 905 906 /** 907 * Description part of a Javadoc tag. 908 */ 909 public static final int DESCRIPTION = JavadocCommentsLexer.DESCRIPTION; 910 911 /** 912 * Format specifier inside Javadoc content. 913 */ 914 public static final int FORMAT_SPECIFIER = JavadocCommentsLexer.FORMAT_SPECIFIER; 915 916 /** 917 * Attribute name in a {@code @snippet}. 918 */ 919 public static final int SNIPPET_ATTR_NAME = JavadocCommentsLexer.SNIPPET_ATTR_NAME; 920 921 /** 922 * Equals sign {@code = }. 923 */ 924 public static final int EQUALS = JavadocCommentsLexer.EQUALS; 925 926 /** 927 * Value assigned to an attribute. 928 */ 929 public static final int ATTRIBUTE_VALUE = JavadocCommentsLexer.ATTRIBUTE_VALUE; 930 931 /** 932 * Colon symbol {@code : }. 933 */ 934 public static final int COLON = JavadocCommentsLexer.COLON; 935 936 /** 937 * Term used in {@code {@index}} tag. 938 */ 939 public static final int INDEX_TERM = JavadocCommentsLexer.INDEX_TERM; 940 941 /** 942 * Single snippet attribute. 943 */ 944 public static final int SNIPPET_ATTRIBUTE = JavadocCommentsLexer.SNIPPET_ATTRIBUTE; 945 946 /** 947 * Collection of snippet attributes. 948 */ 949 public static final int SNIPPET_ATTRIBUTES = JavadocCommentsLexer.SNIPPET_ATTRIBUTES; 950 951 /** 952 * Body content of a {@code @snippet}. 953 */ 954 public static final int SNIPPET_BODY = JavadocCommentsLexer.SNIPPET_BODY; 955 956 /** 957 * Field type reference. 958 */ 959 public static final int FIELD_TYPE = JavadocCommentsLexer.FIELD_TYPE; 960 961 /** 962 * Parameter name reference. 963 */ 964 public static final int PARAMETER_NAME = JavadocCommentsLexer.PARAMETER_NAME; 965 966 /** 967 * String literal inside Javadoc. 968 */ 969 public static final int STRING_LITERAL = JavadocCommentsLexer.STRING_LITERAL; 970 971 // HTML 972 973 /** 974 * General HTML element. 975 */ 976 public static final int HTML_ELEMENT = JavadocCommentsLexer.HTML_ELEMENT; 977 978 /** 979 * Void HTML element (self-closing). 980 */ 981 public static final int VOID_ELEMENT = JavadocCommentsLexer.VOID_ELEMENT; 982 983 /** 984 * Content inside an HTML element. 985 * 986 * <p>This node represents the textual content between an HTML start tag and 987 * the corresponding end tag inside a Javadoc comment.</p> 988 * 989 * <p><b>Example:</b></p> 990 * <pre>{@code * <a href="https://example.com">link</a>}</pre> 991 * 992 * <b>Tree:</b> 993 * <pre>{@code 994 * |--LEADING_ASTERISK -> * 995 * `--HTML_ELEMENT -> HTML_ELEMENT 996 * |--HTML_TAG_START -> HTML_TAG_START 997 * | |--TAG_OPEN -> < 998 * | |--TAG_NAME -> a 999 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1000 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1001 * | | |--TEXT -> (whitespace) 1002 * | | |--TAG_ATTR_NAME -> href 1003 * | | |--EQUALS -> = 1004 * | | `--ATTRIBUTE_VALUE -> "https://example.com" 1005 * | `--TAG_CLOSE -> > 1006 * |--HTML_CONTENT -> HTML_CONTENT 1007 * | `--TEXT -> link 1008 * `--HTML_TAG_END -> HTML_TAG_END 1009 * |--TAG_OPEN -> < 1010 * |--TAG_SLASH -> / 1011 * |--TAG_NAME -> a 1012 * `--TAG_CLOSE -> > 1013 * }</pre> 1014 * 1015 * @see #HTML_ELEMENT 1016 */ 1017 1018 public static final int HTML_CONTENT = JavadocCommentsLexer.HTML_CONTENT; 1019 1020 /** 1021 * Single HTML attribute. 1022 */ 1023 public static final int HTML_ATTRIBUTE = JavadocCommentsLexer.HTML_ATTRIBUTE; 1024 1025 /** 1026 * List of HTML attributes. 1027 */ 1028 public static final int HTML_ATTRIBUTES = JavadocCommentsLexer.HTML_ATTRIBUTES; 1029 1030 /** 1031 * Start of an HTML tag (the opening tag node). 1032 * 1033 * <p>This node represents the opening part of an HTML element and contains 1034 * the opening delimiter, tag name, optional attributes, and the closing 1035 * delimiter of the opening tag.</p> 1036 * 1037 * <p><b>Example:</b></p> 1038 * <pre>{@code * <a href="https://example.com">link</a>}</pre> 1039 * 1040 * <b>Tree:</b> 1041 * <pre>{@code 1042 * |--LEADING_ASTERISK -> * 1043 * `--HTML_ELEMENT -> HTML_ELEMENT 1044 * `--HTML_TAG_START -> HTML_TAG_START 1045 * |--TAG_OPEN -> < 1046 * |--TAG_NAME -> a 1047 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1048 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1049 * | |--TEXT -> 1050 * | |--TAG_ATTR_NAME -> href 1051 * | |--EQUALS -> = 1052 * | `--ATTRIBUTE_VALUE -> "https://example.com" 1053 * `--TAG_CLOSE -> > 1054 * }</pre> 1055 * 1056 * @see #HTML_ELEMENT 1057 */ 1058 1059 public static final int HTML_TAG_START = JavadocCommentsLexer.HTML_TAG_START; 1060 1061 /** 1062 * End of an HTML tag (the closing tag node). 1063 * 1064 * <p>This node represents the closing part of an HTML element and contains the 1065 * closing delimiter, optional slash, and the tag name.</p> 1066 * 1067 * <p><b>Example:</b></p> 1068 * <pre>{@code * <a href="https://example.com">link</a>}</pre> 1069 * 1070 * <b>Tree:</b> 1071 * <pre>{@code 1072 * |--LEADING_ASTERISK -> * 1073 * `--HTML_ELEMENT -> HTML_ELEMENT 1074 * |--HTML_TAG_START -> HTML_TAG_START 1075 * | |--TAG_OPEN -> < 1076 * | |--TAG_NAME -> a 1077 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1078 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1079 * | | |--TEXT -> (whitespace) 1080 * | | |--TAG_ATTR_NAME -> href 1081 * | | |--EQUALS -> = 1082 * | | `--ATTRIBUTE_VALUE -> "https://example.com" 1083 * | `--TAG_CLOSE -> > 1084 * |--HTML_CONTENT -> HTML_CONTENT 1085 * | `--TEXT -> link 1086 * `--HTML_TAG_END -> HTML_TAG_END 1087 * |--TAG_OPEN -> < 1088 * |--TAG_SLASH -> / 1089 * |--TAG_NAME -> a 1090 * `--TAG_CLOSE -> > 1091 * }</pre> 1092 * 1093 * @see #HTML_ELEMENT 1094 */ 1095 1096 public static final int HTML_TAG_END = JavadocCommentsLexer.HTML_TAG_END; 1097 1098 /** 1099 * Opening tag delimiter {@code < }. 1100 */ 1101 public static final int TAG_OPEN = JavadocCommentsLexer.TAG_OPEN; 1102 1103 /** 1104 * HTML tag name. 1105 */ 1106 public static final int TAG_NAME = JavadocCommentsLexer.TAG_NAME; 1107 1108 /** 1109 * Closing tag delimiter {@code > }. 1110 */ 1111 public static final int TAG_CLOSE = JavadocCommentsLexer.TAG_CLOSE; 1112 1113 /** 1114 * {@code />} Self-closing tag delimiter. 1115 * 1116 * <p>Used for void HTML elements.</p> 1117 * 1118 * <p><b>Example:</b></p> 1119 * <pre>{@code * <br />}</pre> 1120 * 1121 * <b>Tree:</b> 1122 * <pre>{@code 1123 * VOID_ELEMENT -> VOID_ELEMENT 1124 * |--TAG_OPEN -> < 1125 * |--TAG_NAME -> br 1126 * `--TAG_SLASH_CLOSE -> /> 1127 * }</pre> 1128 * 1129 * @see #HTML_ELEMENT 1130 */ 1131 public static final int TAG_SLASH_CLOSE = JavadocCommentsLexer.TAG_SLASH_CLOSE; 1132 1133 /** 1134 * Slash symbol inside a closing tag. 1135 */ 1136 public static final int TAG_SLASH = JavadocCommentsLexer.TAG_SLASH; 1137 1138 /** 1139 * Attribute name inside an HTML tag. 1140 */ 1141 public static final int TAG_ATTR_NAME = JavadocCommentsLexer.TAG_ATTR_NAME; 1142 1143 /** 1144 * Start of an HTML comment node. 1145 * 1146 * <p>This node represents a full HTML comment inside Javadoc.</p> 1147 * 1148 * <p>This node has three children:</p> 1149 * <ol> 1150 * <li>{@link #HTML_COMMENT_START}</li> 1151 * <li>{@link #HTML_COMMENT_CONTENT}</li> 1152 * <li>{@link #HTML_COMMENT_END}</li> 1153 * </ol> 1154 * 1155 * <p><b>Example:</b></p> 1156 * <pre>{@code * <!-- Hello World! -->}</pre> 1157 * 1158 * <b>Tree:</b> 1159 * <pre>{@code 1160 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1161 * |--TEXT -> /** 1162 * |--NEWLINE -> \r\n 1163 * |--LEADING_ASTERISK -> * 1164 * |--TEXT -> 1165 * |--HTML_COMMENT -> HTML_COMMENT 1166 * |--HTML_COMMENT_START -> <!-- 1167 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 1168 * | `--TEXT -> Hello World! 1169 * `--HTML_COMMENT_END -> --> 1170 * |--NEWLINE -> \r\n 1171 * |--LEADING_ASTERISK -> * 1172 * |--TEXT -> / 1173 * }</pre> 1174 * 1175 * @see #HTML_COMMENT 1176 */ 1177 public static final int HTML_COMMENT = JavadocCommentsLexer.HTML_COMMENT; 1178 1179 /** 1180 * Opening part of an HTML comment. 1181 */ 1182 public static final int HTML_COMMENT_START = JavadocCommentsLexer.HTML_COMMENT_START; 1183 1184 /** 1185 * Closing part of an HTML comment. 1186 * 1187 * <p>This node represents the closing delimiter of an HTML comment in 1188 * Javadoc (for example {@code -->}).</p> 1189 * 1190 * <p><b>Example:</b></p> 1191 * <pre>{@code * <!-- hidden comment -->}</pre> 1192 * 1193 * <b>Tree:</b> 1194 * <pre>{@code 1195 * |--LEADING_ASTERISK -> * 1196 * |--TEXT -> 1197 * |--HTML_COMMENT -> HTML_COMMENT 1198 * | |--HTML_COMMENT_START -> <!-- 1199 * | |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 1200 * | | `--TEXT -> hidden comment 1201 * | `--HTML_COMMENT_END -> --> 1202 * }</pre> 1203 * 1204 * @see #HTML_COMMENT 1205 */ 1206 1207 public static final int HTML_COMMENT_END = JavadocCommentsLexer.HTML_COMMENT_END; 1208 1209 /** 1210 * Content inside an HTML comment. 1211 */ 1212 public static final int HTML_COMMENT_CONTENT = JavadocCommentsLexer.HTML_COMMENT_CONTENT; 1213 1214 /** Empty private constructor of the current class. */ 1215 private JavadocCommentsTokenTypes() { 1216 } 1217}