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.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 * @noinspection JavadocDeclaration ,EmptyClass 031 * @noinspectionreason JavadocDeclaration - Javadoc is intentional 032 * @noinspectionreason EmptyClass - false positive from Language Injection in snippet block 033 */ 034@SuppressWarnings({"InvalidInlineTag", "UnrecognisedJavadocTag"}) 035public final class JavadocCommentsTokenTypes { 036 037 /** 038 * Root node of any Javadoc comment. 039 * 040 * <p><b>Tree for example:</b></p> 041 * <pre>{@code 042 * JAVADOC_CONTENT -> JAVADOC_CONTENT 043 * |--LEADING_ASTERISK -> * 044 * |--NEWLINE -> \n 045 * |--LEADING_ASTERISK -> * 046 * |--NEWLINE -> \n 047 * |--LEADING_ASTERISK -> * 048 * `--NEWLINE -> \n 049 * }</pre> 050 */ 051 public static final int JAVADOC_CONTENT = JavadocCommentsLexer.JAVADOC; 052 053 /** 054 * Leading asterisk used to format Javadoc lines. 055 * 056 * <p><b>Example:</b></p> 057 * <pre>{@code 058 * /** 059 * * This is a Javadoc line. 060 * * / 061 * }</pre> 062 * 063 * <p><b>Tree:</b></p> 064 * <pre>{@code 065 * --BLOCK_COMMENT_BEGIN -> /** 066 * |--COMMENT_CONTENT -> *\r\n * This is a Javadoc line.\r\n 067 * | `--JAVADOC_CONTENT -> JAVADOC_CONTENT 068 * | |--NEWLINE -> \r\n 069 * | |--LEADING_ASTERISK -> * 070 * | |--TEXT -> This is a Javadoc line. 071 * | |--NEWLINE -> \r\n 072 * | `--TEXT -> 073 * ` --BLOCK_COMMENT_END -> * 074 * }</pre> 075 */ 076 public static final int LEADING_ASTERISK = JavadocCommentsLexer.LEADING_ASTERISK; 077 078 /** 079 * Newline character in a Javadoc comment. 080 * 081 * <p><b>Example:</b></p> 082 * <pre>{@code 083 * /** 084 * * This is a Javadoc line. 085 * * / 086 * }</pre> 087 * 088 * <p><b>Tree:</b></p> 089 * <pre>{@code 090 * --BLOCK_COMMENT_BEGIN -> /** 091 * |--COMMENT_CONTENT -> *\r\n * This is a Javadoc line.\r\n 092 * | `--JAVADOC_CONTENT -> JAVADOC_CONTENT 093 * | |--NEWLINE -> \r\n 094 * | |--LEADING_ASTERISK -> * 095 * | |--TEXT -> This is a Javadoc line. 096 * | |--NEWLINE -> \r\n 097 * | `--TEXT -> 098 * ` --BLOCK_COMMENT_END -> * 099 * }</pre> 100 */ 101 102 public static final int NEWLINE = JavadocCommentsLexer.NEWLINE; 103 104 /** 105 * Plain text content within a Javadoc comment. 106 * 107 * <p>This node represents any plain text that appears in a Javadoc comment, 108 * including spaces and punctuation.</p> 109 * 110 * <p><b>Example:</b></p> 111 * <pre>{@code 112 * /** 113 * * This is plain text content. 114 * * / 115 * }</pre> 116 * 117 * <p><b>Tree:</b></p> 118 * <pre>{@code 119 * --BLOCK_COMMENT_BEGIN -> /** 120 * |--COMMENT_CONTENT -> *\r\n * This is plain text content.\r\n 121 * | `--JAVADOC_CONTENT -> JAVADOC_CONTENT 122 * | |--NEWLINE -> \r\n 123 * | |--LEADING_ASTERISK -> * 124 * | |--TEXT -> This is plain text content. 125 * | |--NEWLINE -> \r\n 126 * | `--TEXT -> 127 * `--BLOCK_COMMENT_END -> * / 128 * }</pre> 129 * 130 * @see #JAVADOC_CONTENT 131 */ 132 public static final int TEXT = JavadocCommentsLexer.TEXT; 133 134 // Block tags 135 136 /** 137 * General block tag (e.g. {@code @param}, {@code @return}). 138 * 139 * <p>Such Javadoc tag can have these children:</p> 140 * <ol> 141 * <li>{@link #PARAM_BLOCK_TAG}</li> 142 * <li>{@link #RETURN_BLOCK_TAG}</li> 143 * <li>{@link #THROWS_BLOCK_TAG}</li> 144 * </ol> 145 * 146 * <p><b>Example:</b></p> 147 * <pre>{@code * @param value The parameter of method.}</pre> 148 * 149 * <b>Tree:</b> 150 * <pre>{@code 151 * JAVADOC_CONTENT -> JAVADOC_CONTENT 152 * |--LEADING_ASTERISK -> * 153 * |--TEXT -> 154 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 155 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 156 * |--AT_SIGN -> @ 157 * |--TAG_NAME -> param 158 * |--TEXT -> 159 * |--PARAMETER_NAME -> value 160 * `--DESCRIPTION -> DESCRIPTION 161 * `--TEXT -> The parameter of method. 162 * }</pre> 163 * 164 * @see #PARAM_BLOCK_TAG 165 * @see #RETURN_BLOCK_TAG 166 * @see #THROWS_BLOCK_TAG 167 */ 168 public static final int JAVADOC_BLOCK_TAG = JavadocCommentsLexer.JAVADOC_BLOCK_TAG; 169 170 /** 171 * At-sign {@code @} that starts a block tag. 172 * 173 * <p><b>Example:</b></p> 174 * <pre>{@code * @author name}</pre> 175 * 176 * <b>Tree:</b> 177 * <pre>{@code 178 * |--LEADING_ASTERISK -> * 179 * |--TEXT -> 180 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 181 * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG 182 * |--AT_SIGN -> @ 183 * |--TAG_NAME -> author 184 * `--DESCRIPTION -> DESCRIPTION 185 * `--TEXT -> name 186 * }</pre> 187 * 188 * @see #JAVADOC_BLOCK_TAG 189 */ 190 public static final int AT_SIGN = JavadocCommentsLexer.AT_SIGN; 191 192 /** 193 * {@code @author} Javadoc block tag. 194 * 195 * <p>Such Javadoc tag can have one child:</p> 196 * <ol> 197 * <li>{@link #DESCRIPTION}</li> 198 * </ol> 199 * 200 * <p><b>Example:</b></p> 201 * <pre>{@code * @author name.}</pre> 202 * 203 * <b>Tree:</b> 204 * <pre>{@code 205 * JAVADOC_CONTENT -> JAVADOC_CONTENT 206 * |--LEADING_ASTERISK -> * 207 * |--TEXT -> 208 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 209 * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG 210 * |--AT_SIGN -> @ 211 * |--TAG_NAME -> author 212 * `--DESCRIPTION -> DESCRIPTION 213 * `--TEXT -> name. 214 * }</pre> 215 * 216 * @see #JAVADOC_BLOCK_TAG 217 */ 218 public static final int AUTHOR_BLOCK_TAG = JavadocCommentsLexer.AUTHOR_BLOCK_TAG; 219 220 /** 221 * {@code @deprecated} block tag. 222 * 223 * <p>Such Javadoc tag can have one child:</p> 224 * <ol> 225 * <li>{@link #DESCRIPTION}</li> 226 * </ol> 227 * 228 * <p><b>Example:</b></p> 229 * <pre>{@code * @deprecated deprecated text.}</pre> 230 * 231 * <b>Tree:</b> 232 * <pre>{@code 233 * JAVADOC_CONTENT -> JAVADOC_CONTENT 234 * |--LEADING_ASTERISK -> * 235 * |--TEXT -> 236 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 237 * `--DEPRECATED_BLOCK_TAG -> DEPRECATED_BLOCK_TAG 238 * |--AT_SIGN -> @ 239 * |--TAG_NAME -> deprecated 240 * `--DESCRIPTION -> DESCRIPTION 241 * `--TEXT -> deprecated text. 242 * }</pre> 243 * 244 * @see #JAVADOC_BLOCK_TAG 245 */ 246 public static final int DEPRECATED_BLOCK_TAG = JavadocCommentsLexer.DEPRECATED_BLOCK_TAG; 247 248 /** 249 * {@code @param} Javadoc block tag. 250 * 251 * <p>Such Javadoc tag can have two children:</p> 252 * <ol> 253 * <li>{@link #PARAMETER_NAME}</li> 254 * <li>{@link #DESCRIPTION}</li> 255 * </ol> 256 * 257 * <p><b>Example:</b></p> 258 * <pre>{@code * @param value The parameter of method.}</pre> 259 * 260 * <b>Tree:</b> 261 * <pre>{@code 262 * JAVADOC_CONTENT -> JAVADOC_CONTENT 263 * |--LEADING_ASTERISK -> * 264 * |--TEXT -> 265 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 266 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 267 * |--AT_SIGN -> @ 268 * |--TAG_NAME -> param 269 * |--TEXT -> 270 * |--PARAMETER_NAME -> value 271 * `--DESCRIPTION -> DESCRIPTION 272 * `--TEXT -> The parameter of method. 273 * }</pre> 274 * 275 * @see #JAVADOC_BLOCK_TAG 276 */ 277 public static final int PARAM_BLOCK_TAG = JavadocCommentsLexer.PARAM_BLOCK_TAG; 278 279 /** 280 * {@code @return} Javadoc block tag. 281 * 282 * <p>Such Javadoc tag can have one child:</p> 283 * <ol> 284 * <li>{@link #DESCRIPTION}</li> 285 * </ol> 286 * 287 * <p><b>Example:</b></p> 288 * <pre>{@code * @return The return of method.}</pre> 289 * 290 * <b>Tree:</b> 291 * <pre>{@code 292 * JAVADOC_CONTENT -> JAVADOC_CONTENT 293 * |--LEADING_ASTERISK -> * 294 * |--TEXT -> 295 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 296 * `--RETURN_BLOCK_TAG -> RETURN_BLOCK_TAG 297 * |--AT_SIGN -> @ 298 * |--TAG_NAME -> return 299 * `--DESCRIPTION -> DESCRIPTION 300 * `--TEXT -> The return of method. 301 * }</pre> 302 * 303 * @see #JAVADOC_BLOCK_TAG 304 */ 305 public static final int RETURN_BLOCK_TAG = JavadocCommentsLexer.RETURN_BLOCK_TAG; 306 307 /** 308 * {@code @throws} Javadoc block tag. 309 * 310 * <p>Such Javadoc tag can have two children:</p> 311 * <ol> 312 * <li>{@link #IDENTIFIER} - the exception class</li> 313 * <li>{@link #DESCRIPTION} - description</li> 314 * </ol> 315 * 316 * <p><b>Example:</b></p> 317 * <pre>{@code * @throws IOException if an I/O error occurs}</pre> 318 * 319 * <b>Tree:</b> 320 * <pre>{@code 321 * JAVADOC_CONTENT -> JAVADOC_CONTENT 322 * |--LEADING_ASTERISK -> * 323 * |--TEXT -> 324 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 325 * `--THROWS_BLOCK_TAG -> THROWS_BLOCK_TAG 326 * |--AT_SIGN -> @ 327 * |--TAG_NAME -> throws 328 * |--TEXT -> 329 * |--IDENTIFIER -> IOException 330 * `--DESCRIPTION -> DESCRIPTION 331 * `--TEXT -> if an I/O error occurs 332 * }</pre> 333 * 334 * @see #JAVADOC_BLOCK_TAG 335 */ 336 public static final int THROWS_BLOCK_TAG = JavadocCommentsLexer.THROWS_BLOCK_TAG; 337 338 /** 339 * {@code @exception} Javadoc block tag. 340 * 341 * <p>Such Javadoc tag can have two children:</p> 342 * <ol> 343 * <li>{@link #IDENTIFIER}</li> 344 * <li>{@link #DESCRIPTION}</li> 345 * </ol> 346 * 347 * <p><b>Example:</b></p> 348 * <pre>{@code * @exception FileNotFoundException when file is not found.}</pre> 349 * 350 * <b>Tree:</b> 351 * <pre>{@code 352 * JAVADOC_CONTENT -> JAVADOC_CONTENT 353 * |--LEADING_ASTERISK -> * 354 * |--TEXT -> 355 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 356 * `--EXCEPTION_BLOCK_TAG -> EXCEPTION_BLOCK_TAG 357 * |--AT_SIGN -> @ 358 * |--TAG_NAME -> exception 359 * |--TEXT -> 360 * |--IDENTIFIER -> FileNotFoundException 361 * `--DESCRIPTION -> DESCRIPTION 362 * `--TEXT -> when file is not found. 363 * }</pre> 364 * 365 * @see #JAVADOC_BLOCK_TAG 366 */ 367 public static final int EXCEPTION_BLOCK_TAG = JavadocCommentsLexer.EXCEPTION_BLOCK_TAG; 368 369 /** 370 * {@code @since} Javadoc block tag. 371 * 372 * <p>Such Javadoc tag can have one child:</p> 373 * <ol> 374 * <li>{@link #DESCRIPTION}</li> 375 * </ol> 376 * 377 * <p><b>Example:</b></p> 378 * <pre>{@code * @since 1.0}</pre> 379 * 380 * <b>Tree:</b> 381 * <pre>{@code 382 * JAVADOC_CONTENT -> JAVADOC_CONTENT 383 * |--LEADING_ASTERISK -> * 384 * |--TEXT -> 385 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 386 * `--SINCE_BLOCK_TAG -> SINCE_BLOCK_TAG 387 * |--AT_SIGN -> @ 388 * |--TAG_NAME -> since 389 * `--DESCRIPTION -> DESCRIPTION 390 * `--TEXT -> 1.0 391 * }</pre> 392 * 393 * @see #JAVADOC_BLOCK_TAG 394 */ 395 public static final int SINCE_BLOCK_TAG = JavadocCommentsLexer.SINCE_BLOCK_TAG; 396 397 /** 398 * {@code @version} Javadoc block tag. 399 * 400 * <p>This tag has only one argument — {@link #TEXT}:</p> 401 * 402 * <p><b>Example:</b></p> 403 * <pre>{@code * @version value}</pre> 404 * 405 * <b>Tree:</b> 406 * <pre>{@code 407 * JAVADOC_CONTENT -> JAVADOC_CONTENT 408 * |--LEADING_ASTERISK -> * 409 * |--TEXT -> 410 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 411 * `--VERSION_BLOCK_TAG -> VERSION_BLOCK_TAG 412 * |--AT_SIGN -> @ 413 * |--TAG_NAME -> version 414 * `--DESCRIPTION -> DESCRIPTION 415 * `--TEXT -> value 416 * }</pre> 417 * 418 * @see #JAVADOC_BLOCK_TAG 419 */ 420 public static final int VERSION_BLOCK_TAG = JavadocCommentsLexer.VERSION_BLOCK_TAG; 421 422 /** 423 * {@code @see} Javadoc block tag. 424 * 425 * <p>Such Javadoc tag can have three children:</p> 426 * <ol> 427 * <li>{@link #REFERENCE}</li> 428 * <li>{@link #DESCRIPTION}</li> 429 * <li>{@link #HTML_ELEMENT}</li> 430 * </ol> 431 * 432 * <p><b>Example:</b></p> 433 * <pre>{@code * @see SomeClass#Field}</pre> 434 * 435 * <b>Tree:</b> 436 * <pre>{@code 437 * JAVADOC_CONTENT -> JAVADOC_CONTENT 438 * |--LEADING_ASTERISK -> * 439 * |--TEXT -> 440 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 441 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 442 * |--AT_SIGN -> @ 443 * |--TAG_NAME -> see 444 * |--TEXT -> 445 * `--REFERENCE -> REFERENCE 446 * |--IDENTIFIER -> SomeClass 447 * |--HASH -> # 448 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE 449 * `--IDENTIFIER -> Field 450 * }</pre> 451 * 452 * @see #JAVADOC_BLOCK_TAG 453 */ 454 public static final int SEE_BLOCK_TAG = JavadocCommentsLexer.SEE_BLOCK_TAG; 455 456 /** 457 * {@code @hidden} Javadoc block tag. 458 * 459 * <p>Such Javadoc tag can have one child:</p> 460 * <ol> 461 * <li>{@link #DESCRIPTION} – optional description text</li> 462 * </ol> 463 * 464 * <p><b>Example:</b></p> 465 * <pre>{@code * @hidden value}</pre> 466 * 467 * <b>Tree:</b> 468 * <pre>{@code 469 * JAVADOC_CONTENT -> JAVADOC_CONTENT 470 * |--LEADING_ASTERISK -> * 471 * |--TEXT -> 472 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 473 * `--HIDDEN_BLOCK_TAG -> HIDDEN_BLOCK_TAG 474 * |--AT_SIGN -> @ 475 * |--TAG_NAME -> hidden 476 * `--DESCRIPTION -> DESCRIPTION 477 * `--TEXT -> value 478 * }</pre> 479 * 480 * @see #JAVADOC_BLOCK_TAG 481 */ 482 public static final int HIDDEN_BLOCK_TAG = JavadocCommentsLexer.HIDDEN_BLOCK_TAG; 483 484 /** 485 * {@code @uses} Javadoc block tag. 486 * 487 * <p>Such Javadoc tag can have one child:</p> 488 * <ol> 489 * <li>{@link #IDENTIFIER} – the referenced service type</li> 490 * </ol> 491 * 492 * <p><b>Example:</b></p> 493 * <pre>{@code * @uses com.example.app.MyService}</pre> 494 * 495 * <b>Tree:</b> 496 * <pre>{@code 497 * JAVADOC_CONTENT -> JAVADOC_CONTENT 498 * |--LEADING_ASTERISK -> * 499 * |--TEXT -> 500 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 501 * `--USES_BLOCK_TAG -> USES_BLOCK_TAG 502 * |--AT_SIGN -> @ 503 * |--TAG_NAME -> uses 504 * |--TEXT -> 505 * `--IDENTIFIER -> com.example.app.MyService 506 * }</pre> 507 * 508 * @see #JAVADOC_BLOCK_TAG 509 */ 510 public static final int USES_BLOCK_TAG = JavadocCommentsLexer.USES_BLOCK_TAG; 511 512 /** 513 * {@code @provides} block tag. 514 * 515 * <p>Such Javadoc tag can have two children:</p> 516 * <ol> 517 * <li>{@link #IDENTIFIER}</li> 518 * <li>{@link #DESCRIPTION}</li> 519 * </ol> 520 * 521 * <p><b>Example:</b></p> 522 * <pre>{@code * @provides com.example.MyService with com.example.MyServiceImpl}</pre> 523 * 524 * <b>Tree:</b> 525 * <pre>{@code 526 * JAVADOC_CONTENT -> JAVADOC_CONTENT 527 * |--LEADING_ASTERISK -> * 528 * |--TEXT -> 529 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 530 * `--PROVIDES_BLOCK_TAG -> PROVIDES_BLOCK_TAG 531 * |--AT_SIGN -> @ 532 * |--TAG_NAME -> provides 533 * |--TEXT -> 534 * |--IDENTIFIER -> com.example.MyService 535 * `--DESCRIPTION -> DESCRIPTION 536 * `--TEXT -> with com.example.MyServiceImpl 537 * }</pre> 538 * 539 * @see #JAVADOC_BLOCK_TAG 540 */ 541 public static final int PROVIDES_BLOCK_TAG = JavadocCommentsLexer.PROVIDES_BLOCK_TAG; 542 543 /** 544 * {@code @serial} block tag. 545 * 546 * <p>Such Javadoc tag can have one child:</p> 547 * <ol> 548 * <li>{@link #DESCRIPTION} – optional description text</li> 549 * </ol> 550 * 551 * <p><b>Example:</b></p> 552 * <pre>{@code * @serial include}</pre> 553 * 554 * <b>Tree:</b> 555 * <pre>{@code 556 * JAVADOC_CONTENT -> JAVADOC_CONTENT 557 * |--LEADING_ASTERISK -> * 558 * |--TEXT -> 559 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 560 * `--SERIAL_BLOCK_TAG -> SERIAL_BLOCK_TAG 561 * |--AT_SIGN -> @ 562 * |--TAG_NAME -> serial 563 * `--DESCRIPTION -> DESCRIPTION 564 * `--TEXT -> include 565 * }</pre> 566 * 567 * @see #JAVADOC_BLOCK_TAG 568 */ 569 public static final int SERIAL_BLOCK_TAG = JavadocCommentsLexer.SERIAL_BLOCK_TAG; 570 571 /** 572 * {@code @serialData} block tag. 573 * 574 * <p>Such Javadoc tag can have one child:</p> 575 * <ol> 576 * <li>{@link #DESCRIPTION} – optional description text</li> 577 * </ol> 578 * 579 * <p><b>Example:</b></p> 580 * <pre>{@code * @serialData data description value}</pre> 581 * 582 * <b>Tree:</b> 583 * <pre>{@code 584 * JAVADOC_CONTENT -> JAVADOC_CONTENT 585 * |--LEADING_ASTERISK -> * 586 * |--TEXT -> 587 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 588 * `--SERIAL_DATA_BLOCK_TAG -> SERIAL_DATA_BLOCK_TAG 589 * |--AT_SIGN -> @ 590 * |--TAG_NAME -> serialData 591 * `--DESCRIPTION -> DESCRIPTION 592 * `--TEXT -> data description value 593 * }</pre> 594 * 595 * @see #JAVADOC_BLOCK_TAG 596 */ 597 public static final int SERIAL_DATA_BLOCK_TAG = JavadocCommentsLexer.SERIAL_DATA_BLOCK_TAG; 598 599 /** 600 * {@code @serialField} Javadoc block tag. 601 * 602 * <p>Such Javadoc tag can have three children:</p> 603 * <ol> 604 * <li>{@link #IDENTIFIER} – field name</li> 605 * <li>{@link #FIELD_TYPE} – field type</li> 606 * <li>{@link #DESCRIPTION} – field description</li> 607 * </ol> 608 * 609 * <p><b>Example:</b></p> 610 * <pre>{@code * @serialField name String The person's full name.}</pre> 611 * 612 * <b>Tree:</b> 613 * <pre>{@code 614 * JAVADOC_CONTENT -> JAVADOC_CONTENT 615 * |--LEADING_ASTERISK -> * 616 * |--TEXT -> 617 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 618 * `--SERIAL_FIELD_BLOCK_TAG -> SERIAL_FIELD_BLOCK_TAG 619 * |--AT_SIGN -> @ 620 * |--TAG_NAME -> serialField 621 * |--TEXT -> 622 * |--IDENTIFIER -> name 623 * |--TEXT -> 624 * |--FIELD_TYPE -> String 625 * `--DESCRIPTION -> DESCRIPTION 626 * `--TEXT -> The person's full name. 627 * }</pre> 628 * 629 * @see #JAVADOC_BLOCK_TAG 630 */ 631 public static final int SERIAL_FIELD_BLOCK_TAG = JavadocCommentsLexer.SERIAL_FIELD_BLOCK_TAG; 632 633 /** 634 * {@code @customBlock} Javadoc block tag. 635 * 636 * <p>This type represents any block tag that is not explicitly recognized by Checkstyle, 637 * such as a project-specific or malformed tag.</p> 638 * 639 * <p><b>Example:</b></p> 640 * <pre>{@code * @mycustomtag This is a custom block tag.}</pre> 641 * 642 * <b>Tree:</b> 643 * <pre>{@code 644 * JAVADOC_CONTENT -> JAVADOC_CONTENT 645 * |--LEADING_ASTERISK -> * 646 * |--TEXT -> 647 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 648 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 649 * |--AT_SIGN -> @ 650 * |--TAG_NAME -> mycustomtag 651 * `--DESCRIPTION -> DESCRIPTION 652 * `--TEXT -> This is a custom block tag. 653 * }</pre> 654 * 655 * @see #JAVADOC_BLOCK_TAG 656 */ 657 public static final int CUSTOM_BLOCK_TAG = JavadocCommentsLexer.CUSTOM_BLOCK_TAG; 658 659 // Inline tags 660 661 /** 662 * General inline tag (e.g. {@code @link}). 663 * 664 * <p>Such Javadoc tag can have these children:</p> 665 * <ol> 666 * <li>{@link #CODE_INLINE_TAG}</li> 667 * <li>{@link #LINK_INLINE_TAG}</li> 668 * <li>{@link #VALUE_INLINE_TAG}</li> 669 * </ol> 670 * 671 * <p><b>Example:</b></p> 672 * <pre>{@code 673 * /** 674 * * {@code code} 675 * * / 676 * }</pre> 677 * 678 * <b>Tree:</b> 679 * <pre>{@code 680 * JAVADOC_CONTENT -> JAVADOC_CONTENT 681 * |--TEXT -> /** 682 * |--NEWLINE -> \n 683 * |--LEADING_ASTERISK -> * 684 * |--TEXT -> 685 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 686 * | `--CODE_INLINE_TAG -> CODE_INLINE_TAG 687 * | |--JAVADOC_INLINE_TAG_START -> { @ 688 * | |--TAG_NAME -> code 689 * | |--TEXT -> code 690 * | `--JAVADOC_INLINE_TAG_END -> } 691 * |--NEWLINE -> \n 692 * |--LEADING_ASTERISK -> * 693 * |--TEXT -> / 694 * |--NEWLINE -> \n 695 * |--TEXT -> public class Test {} 696 * `--NEWLINE -> \n 697 * }</pre> 698 * 699 * @see #JAVADOC_INLINE_TAG 700 */ 701 public static final int JAVADOC_INLINE_TAG = JavadocCommentsLexer.JAVADOC_INLINE_TAG; 702 703 /** 704 * Start of an inline tag <code>{</code>. 705 * 706 * <p>This node represents the start of a Javadoc inline tag like 707 * {@code @code} or {@code @link}.</p> 708 * 709 * <p><b>Example:</b></p> 710 * <pre>{@code 711 * /** 712 * * {@code code} 713 * * / 714 * }</pre> 715 * 716 * <b>Tree:</b> 717 * <pre>{@code 718 * JAVADOC_CONTENT -> JAVADOC_CONTENT 719 * |--TEXT -> /** 720 * |--NEWLINE -> \n 721 * |--LEADING_ASTERISK -> * 722 * |--TEXT -> 723 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 724 * | `--CODE_INLINE_TAG -> CODE_INLINE_TAG 725 * | |--JAVADOC_INLINE_TAG_START -> { @ 726 * | |--TAG_NAME -> code 727 * | |--TEXT -> code 728 * | `--JAVADOC_INLINE_TAG_END -> } 729 * |--NEWLINE -> \n 730 * |--LEADING_ASTERISK -> * 731 * |--TEXT -> / 732 * |--NEWLINE -> \n 733 * |--TEXT -> public class Test {} 734 * `--NEWLINE -> \n 735 * }</pre> 736 * 737 * @see #JAVADOC_INLINE_TAG 738 */ 739 public static final int JAVADOC_INLINE_TAG_START = 740 JavadocCommentsLexer.JAVADOC_INLINE_TAG_START; 741 742 /** 743 * End of an inline tag <code>}</code>. 744 * 745 * <p>This node represents the closing brace of a Javadoc inline tag like 746 * {@code @code} or {@code @link}.</p> 747 * 748 * <p><b>Example:</b></p> 749 * <pre>{@code 750 * /** 751 * * {@code code} 752 * * / 753 * }</pre> 754 * 755 * <b>Tree:</b> 756 * <pre>{@code 757 * JAVADOC_CONTENT -> JAVADOC_CONTENT 758 * |--TEXT -> /** 759 * |--NEWLINE -> \n 760 * |--LEADING_ASTERISK -> * 761 * |--TEXT -> 762 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 763 * | `--CODE_INLINE_TAG -> CODE_INLINE_TAG 764 * | |--JAVADOC_INLINE_TAG_START -> { @ 765 * | |--TAG_NAME -> code 766 * | |--TEXT -> code 767 * | `--JAVADOC_INLINE_TAG_END -> } 768 * |--NEWLINE -> \n 769 * |--LEADING_ASTERISK -> * 770 * |--TEXT -> / 771 * |--NEWLINE -> \n 772 * |--TEXT -> public class Test {} 773 * `--NEWLINE -> \n 774 * }</pre> 775 * 776 * @see #JAVADOC_INLINE_TAG 777 * @see #JAVADOC_INLINE_TAG_START 778 */ 779 public static final int JAVADOC_INLINE_TAG_END = JavadocCommentsLexer.JAVADOC_INLINE_TAG_END; 780 781 /** 782 * {@code {@code}} Javadoc inline tag. 783 * 784 * <p>Such Javadoc tag can have no children:</p> 785 * 786 * <p><b>Example:</b></p> 787 * <pre>{@code * {@code println("Hello");}}</pre> 788 * 789 * <b>Tree:</b> 790 * <pre>{@code 791 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 792 * |--CODE_INLINE_TAG -> CODE_INLINE_TAG 793 * |--JAVADOC_INLINE_TAG_START -> { @ 794 * |--TAG_NAME -> code 795 * |--TEXT -> println("Hello"); 796 * `--JAVADOC_INLINE_TAG_END -> } 797 * }</pre> 798 * 799 * @see #JAVADOC_INLINE_TAG 800 */ 801 public static final int CODE_INLINE_TAG = JavadocCommentsLexer.CODE_INLINE_TAG; 802 803 /** 804 * {@code {@link}} Javadoc inline tag. 805 * 806 * <p>Such Javadoc tag can have two children:</p> 807 * <ol> 808 * <li>{@link #REFERENCE}</li> 809 * <li>{@link #DESCRIPTION}</li> 810 * </ol> 811 * 812 * <p><b>Example:</b></p> 813 * <pre>{@code * {@link Math#max(int, int) label}}</pre> 814 * 815 * <b>Tree:</b> 816 * <pre>{@code 817 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 818 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 819 * |--JAVADOC_INLINE_TAG_START -> { @ 820 * |--TAG_NAME -> link 821 * |--TEXT -> 822 * |--REFERENCE -> REFERENCE 823 * | |--IDENTIFIER -> Math 824 * | |--HASH -> # 825 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 826 * | |--IDENTIFIER -> max 827 * | |--LPAREN -> ( 828 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 829 * | | |--PARAMETER_TYPE -> int 830 * | | |--COMMA -> , 831 * | | |--TEXT -> 832 * | | `--PARAMETER_TYPE -> int 833 * | `--RPAREN -> ) 834 * |--DESCRIPTION -> DESCRIPTION 835 * | `--TEXT -> label 836 * `--JAVADOC_INLINE_TAG_END -> } 837 * }</pre> 838 * 839 * @see #JAVADOC_INLINE_TAG 840 */ 841 public static final int LINK_INLINE_TAG = JavadocCommentsLexer.LINK_INLINE_TAG; 842 843 /** 844 * {@code {@linkplain}} Javadoc inline tag. 845 * 846 * <p>Such Javadoc tag can have two children:</p> 847 * <ol> 848 * <li>{@link #REFERENCE}</li> 849 * <li>{@link #DESCRIPTION}</li> 850 * </ol> 851 * 852 * <p><b>Example:</b></p> 853 * <pre>{@code * {@linkplain String#indexOf(int, int) label}}</pre> 854 * 855 * <b>Tree:</b> 856 * <pre>{@code 857 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 858 * `--LINKPLAIN_INLINE_TAG -> LINKPLAIN_INLINE_TAG 859 * |--JAVADOC_INLINE_TAG_START -> { @ 860 * |--TAG_NAME -> linkplain 861 * |--TEXT -> 862 * |--REFERENCE -> REFERENCE 863 * | |--IDENTIFIER -> String 864 * | |--HASH -> # 865 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 866 * | |--IDENTIFIER -> indexOf 867 * | |--LPAREN -> ( 868 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 869 * | | |--PARAMETER_TYPE -> int 870 * | | |--COMMA -> , 871 * | | |--TEXT -> 872 * | | `--PARAMETER_TYPE -> int 873 * | `--RPAREN -> ) 874 * |--DESCRIPTION -> DESCRIPTION 875 * | `--TEXT -> label 876 * `--JAVADOC_INLINE_TAG_END -> } 877 * }</pre> 878 * 879 * @see #JAVADOC_INLINE_TAG 880 */ 881 public static final int LINKPLAIN_INLINE_TAG = JavadocCommentsLexer.LINKPLAIN_INLINE_TAG; 882 883 /** 884 * {@code {@value}} Javadoc inline tag. 885 * 886 * <p>Such Javadoc tag can have one child:</p> 887 * <ol> 888 * <li>{@link #REFERENCE}</li> 889 * </ol> 890 * 891 * <p><b>Example:</b></p> 892 * <pre>{@code * {@value Integer#MAX_VALUE}}</pre> 893 * 894 * <b>Tree:</b> 895 * <pre>{@code 896 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 897 * `--VALUE_INLINE_TAG -> VALUE_INLINE_TAG 898 * |--JAVADOC_INLINE_TAG_START -> { @ 899 * |--TAG_NAME -> value 900 * |--TEXT -> 901 * |--REFERENCE -> REFERENCE 902 * | |--IDENTIFIER -> Integer 903 * | |--HASH -> # 904 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 905 * | `--IDENTIFIER -> MAX_VALUE 906 * |--TEXT -> 907 * `--JAVADOC_INLINE_TAG_END -> } 908 * }</pre> 909 * 910 * @see #JAVADOC_INLINE_TAG 911 */ 912 public static final int VALUE_INLINE_TAG = JavadocCommentsLexer.VALUE_INLINE_TAG; 913 914 /** 915 * Inline {@code {@summary ...}} tag inside Javadoc. 916 * 917 * <p>This node represents an inline {@code {@summary ...}} tag used to provide a 918 * short summary description within a Javadoc sentence.</p> 919 * 920 * <p><b>Example:</b></p> 921 * <pre>{@code * Example showing {@summary This is a short summary.}}</pre> 922 * 923 * <b>Tree:</b> 924 * <pre>{@code 925 * |--LEADING_ASTERISK -> * 926 * |--TEXT -> Example showing 927 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 928 * `--SUMMARY_INLINE_TAG -> SUMMARY_INLINE_TAG 929 * |--JAVADOC_INLINE_TAG_START -> { @ 930 * |--TAG_NAME -> summary 931 * |--DESCRIPTION -> DESCRIPTION 932 * | `--TEXT -> This is a short summary. 933 * `--JAVADOC_INLINE_TAG_END -> } 934 * }</pre> 935 * 936 * @see #JAVADOC_INLINE_TAG 937 */ 938 939 public static final int SUMMARY_INLINE_TAG = JavadocCommentsLexer.SUMMARY_INLINE_TAG; 940 941 /** 942 * {@code {@inheritDoc}} inline tag. 943 * 944 * <p>This node models the inline {@code {@inheritDoc}} tag that instructs Javadoc 945 * to inherit documentation from the corresponding element in a parent class or interface.</p> 946 * 947 * <p><b>Example:</b></p> 948 * <pre>{@code * {@inheritDoc}}</pre> 949 * 950 * <b>Tree:</b> 951 * <pre>{@code 952 * |--LEADING_ASTERISK -> * 953 * |--TEXT -> 954 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 955 * `--INHERIT_DOC_INLINE_TAG -> INHERIT_DOC_INLINE_TAG 956 * |--JAVADOC_INLINE_TAG_START -> { @ 957 * |--TAG_NAME -> inheritDoc 958 * `--JAVADOC_INLINE_TAG_END -> } 959 * }</pre> 960 * 961 * @see #JAVADOC_INLINE_TAG 962 */ 963 public static final int INHERIT_DOC_INLINE_TAG = JavadocCommentsLexer.INHERIT_DOC_INLINE_TAG; 964 965 /** 966 * {@code {@systemProperty}} inline tag. 967 * 968 * <p>Such Javadoc tag is used to reference a system property.</p> 969 * 970 * <p><b>Example:</b></p> 971 * <pre>{@code * This method uses {@systemProperty user.home} system property.}</pre> 972 * 973 * <b>Tree:</b> 974 * <pre>{@code 975 * |--LEADING_ASTERISK -> * 976 * |--TEXT -> This method uses 977 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 978 * | `--SYSTEM_PROPERTY_INLINE_TAG -> SYSTEM_PROPERTY_INLINE_TAG 979 * | |--JAVADOC_INLINE_TAG_START -> { @ 980 * | |--TAG_NAME -> systemProperty 981 * | |--TEXT -> 982 * | |--IDENTIFIER -> user.home 983 * | `--JAVADOC_INLINE_TAG_END -> } 984 * |--TEXT -> system property. 985 * }</pre> 986 * 987 * @see #JAVADOC_INLINE_TAG 988 */ 989 public static final int SYSTEM_PROPERTY_INLINE_TAG = 990 JavadocCommentsLexer.SYSTEM_PROPERTY_INLINE_TAG; 991 992 /** 993 * {@code {@literal}} inline tag. 994 * 995 * <p><b>Example:</b></p> 996 * <pre>{@code * {@literal @Override}}</pre> 997 * 998 * <b>Tree:</b> 999 * <pre>{@code 1000 * |--LEADING_ASTERISK -> * 1001 * |--TEXT -> 1002 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1003 * `--LITERAL_INLINE_TAG -> LITERAL_INLINE_TAG 1004 * |--JAVADOC_INLINE_TAG_START -> { @ 1005 * |--TAG_NAME -> literal 1006 * |--TEXT -> @Override 1007 * `--JAVADOC_INLINE_TAG_END -> } 1008 * }</pre> 1009 * 1010 * @see #JAVADOC_INLINE_TAG 1011 */ 1012 public static final int LITERAL_INLINE_TAG = JavadocCommentsLexer.LITERAL_INLINE_TAG; 1013 1014 /** 1015 * Inline {@code return} tag inside Javadoc. 1016 * 1017 * <p>This node represents an inline {@code {@return ...}} tag used to 1018 * describe the returned value directly within a Javadoc sentence.</p> 1019 * 1020 * <p><b>Example:</b></p> 1021 * <pre>{@code Example showing result {@return The computed value.}}</pre> 1022 * 1023 * <b>Tree:</b> 1024 * <pre>{@code 1025 * |--LEADING_ASTERISK -> * 1026 * |--TEXT -> Example showing result 1027 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1028 * `--RETURN_INLINE_TAG -> RETURN_INLINE_TAG 1029 * |--JAVADOC_INLINE_TAG_START -> { @ 1030 * |--TAG_NAME -> return 1031 * |--DESCRIPTION -> DESCRIPTION 1032 * | `--TEXT -> The computed value. 1033 * `--JAVADOC_INLINE_TAG_END -> } 1034 * }</pre> 1035 * 1036 * @see #JAVADOC_INLINE_TAG 1037 */ 1038 1039 public static final int RETURN_INLINE_TAG = JavadocCommentsLexer.RETURN_INLINE_TAG; 1040 1041 /** 1042 * {@code {@index}} inline tag. 1043 * 1044 * <p>This node represents an inline {@code {@index ...}} tag used to mark an 1045 * index term inside a Javadoc sentence.</p> 1046 * 1047 * <p><b>Example:</b></p> 1048 * <pre>{@code * Example showing {@index keyword description of the index term}.}</pre> 1049 * 1050 * <b>Tree:</b> 1051 * <pre>{@code 1052 * |--LEADING_ASTERISK -> * 1053 * |--TEXT -> Example showing 1054 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1055 * `--INDEX_INLINE_TAG -> INDEX_INLINE_TAG 1056 * |--JAVADOC_INLINE_TAG_START -> { @ 1057 * |--TAG_NAME -> index 1058 * |--TEXT -> 1059 * |--INDEX_TERM -> keyword 1060 * |--DESCRIPTION -> DESCRIPTION 1061 * | `--TEXT -> description of the index term 1062 * `--JAVADOC_INLINE_TAG_END -> } 1063 * |--TEXT -> . 1064 * }</pre> 1065 * 1066 * @see #JAVADOC_INLINE_TAG 1067 */ 1068 1069 public static final int INDEX_INLINE_TAG = JavadocCommentsLexer.INDEX_INLINE_TAG; 1070 1071 /** 1072 * {@code @snippet} inline tag. 1073 * 1074 * <p>This node represents an inline { @code { @snippet :}} tag used to embed 1075 * code snippets directly inside a Javadoc sentence.</p> 1076 * 1077 * <p><b>Example:</b></p> 1078 * <pre>{ @code * Example showing { @snippet :java 1079 * System.out.println("hello"); 1080 * }}</pre> 1081 * 1082 * <b>Tree:</b> 1083 * <pre>{@code 1084 * |--LEADING_ASTERISK -> * 1085 * |--TEXT -> Example showing 1086 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1087 * `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 1088 * |--JAVADOC_INLINE_TAG_START -> { @ 1089 * |--COLON -> : 1090 * |--SNIPPET_BODY -> SNIPPET_BODY 1091 * | |--TEXT -> java 1092 * | |--NEWLINE -> \n 1093 * | |--LEADING_ASTERISK -> * 1094 * | |--TEXT -> System.out.println("hello"); 1095 * | |--NEWLINE -> \n 1096 * | |--LEADING_ASTERISK -> * 1097 * | `--TEXT -> 1098 * `--JAVADOC_INLINE_TAG_END -> } 1099 * }</pre> 1100 * 1101 * @see #JAVADOC_INLINE_TAG 1102 */ 1103 public static final int SNIPPET_INLINE_TAG = JavadocCommentsLexer.SNIPPET_INLINE_TAG; 1104 1105 /** 1106 * {@code @custom} inline tag. 1107 * 1108 * <p><b>Example:</b></p> 1109 * <pre>{@code * Example showing {@custom This is a Custom Inline Tag}.}</pre> 1110 * 1111 * <p><b>Tree:</b></p> 1112 * <pre>{@code 1113 * |--LEADING_ASTERISK -> * 1114 * |--TEXT -> Example showing 1115 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1116 * | `--CUSTOM_INLINE_TAG -> CUSTOM_INLINE_TAG 1117 * | |--JAVADOC_INLINE_TAG_START -> { @ 1118 * | |--TAG_NAME -> custom 1119 * | |--DESCRIPTION -> DESCRIPTION 1120 * | | `--TEXT -> This is a Custom Inline Tag 1121 * | `--JAVADOC_INLINE_TAG_END -> } 1122 * |--TEXT -> . 1123 * }</pre> 1124 * 1125 * @see #JAVADOC_INLINE_TAG 1126 */ 1127 public static final int CUSTOM_INLINE_TAG = JavadocCommentsLexer.CUSTOM_INLINE_TAG; 1128 1129 // Components 1130 1131 /** 1132 * Identifier token. 1133 * 1134 * <p><b>Example:</b></p> 1135 * <pre>{@code * @throws Exception if error.}</pre> 1136 * 1137 * <p><b>Tree:</b></p> 1138 * <pre>{@code 1139 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1140 * |--LEADING_ASTERISK -> * 1141 * |--TEXT -> 1142 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1143 * `--THROWS_BLOCK_TAG -> THROWS_BLOCK_TAG 1144 * |--AT_SIGN -> @ 1145 * |--TAG_NAME -> throws 1146 * |--TEXT -> 1147 * |--IDENTIFIER -> Exception 1148 * `--DESCRIPTION -> DESCRIPTION 1149 * `--TEXT -> if error. 1150 * }</pre> 1151 */ 1152 public static final int IDENTIFIER = JavadocCommentsLexer.IDENTIFIER; 1153 1154 /** 1155 * Hash symbol {@code #} used in references within Javadoc. 1156 * 1157 * <p><b>Example:</b></p> 1158 * <pre>{@code * @see MyClass#myMethod()}</pre> 1159 * 1160 * <b>Tree:</b> 1161 * <pre>{@code 1162 * |--LEADING_ASTERISK -> * 1163 * |--TEXT -> 1164 * |--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1165 * | `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1166 * | |--AT_SIGN -> @ 1167 * | |--TAG_NAME -> see 1168 * | |--TEXT -> 1169 * | `--REFERENCE -> REFERENCE 1170 * | |--IDENTIFIER -> MyClass 1171 * | |--HASH -> # 1172 * | |--IDENTIFIER -> myMethod 1173 * | |--LPAREN -> ( 1174 * | `--RPAREN -> ) 1175 * }</pre> 1176 * 1177 * @see #REFERENCE 1178 */ 1179 public static final int HASH = JavadocCommentsLexer.HASH; 1180 1181 /** 1182 * Left parenthesis {@code (} used in references within Javadoc. 1183 * 1184 * <p><b>Example:</b></p> 1185 * <pre>{@code 1186 * * {@link String#length()} 1187 * }</pre> 1188 * 1189 * <b>Tree:</b> 1190 * <pre>{@code 1191 * |--LEADING_ASTERISK -> * 1192 * |--TEXT -> 1193 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1194 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1195 * |--JAVADOC_INLINE_TAG_START -> {@ 1196 * |--TAG_NAME -> link 1197 * |--TEXT -> 1198 * |--REFERENCE -> REFERENCE 1199 * |--IDENTIFIER -> String 1200 * |--HASH -> # 1201 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1202 * |--IDENTIFIER -> length 1203 * |--LPAREN -> ( 1204 * `--RPAREN -> ) 1205 * `--JAVADOC_INLINE_TAG_END -> } 1206 * }</pre> 1207 * 1208 * @see #REFERENCE 1209 */ 1210 public static final int LPAREN = JavadocCommentsLexer.LPAREN; 1211 1212 /** 1213 * Right parenthesis {@code (} used in references within Javadoc. 1214 * 1215 * <p><b>Example:</b></p> 1216 * <pre>{@code 1217 * * {@link String#length()} 1218 * }</pre> 1219 * 1220 * <b>Tree:</b> 1221 * <pre>{@code 1222 * |--LEADING_ASTERISK -> * 1223 * |--TEXT -> 1224 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1225 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1226 * |--JAVADOC_INLINE_TAG_START -> {@ 1227 * |--TAG_NAME -> link 1228 * |--TEXT -> 1229 * |--REFERENCE -> REFERENCE 1230 * |--IDENTIFIER -> String 1231 * |--HASH -> # 1232 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1233 * |--IDENTIFIER -> length 1234 * |--LPAREN -> ( 1235 * `--RPAREN -> ) 1236 * `--JAVADOC_INLINE_TAG_END -> } 1237 * }</pre> 1238 * 1239 * @see #REFERENCE 1240 */ 1241 public static final int RPAREN = JavadocCommentsLexer.RPAREN; 1242 1243 /** 1244 * Comma symbol {@code , }. 1245 * 1246 * <p><b>Example:</b></p> 1247 * <pre>{@code * @see #method(int, int)}</pre> 1248 * 1249 * <p><b>Tree:</b></p> 1250 * <pre>{@code 1251 * |--LEADING_ASTERISK -> * 1252 * |--TEXT -> 1253 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1254 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1255 * |--AT_SIGN -> @ 1256 * |--TAG_NAME -> see 1257 * |--TEXT -> 1258 * |--REFERENCE -> REFERENCE 1259 * | |--HASH -> # 1260 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1261 * | |--IDENTIFIER -> method 1262 * | |--LPAREN -> ( 1263 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1264 * | | |--PARAMETER_TYPE -> int 1265 * | | |--COMMA -> , 1266 * | | |--TEXT -> 1267 * | | `--PARAMETER_TYPE -> int 1268 * | `--RPAREN -> ) 1269 * }</pre> 1270 */ 1271 public static final int COMMA = JavadocCommentsLexer.COMMA; 1272 1273 /** 1274 * Slash symbol {@code /} used in module or package references within Javadoc. 1275 * 1276 * <p><b>Example:</b></p> 1277 * <pre>{@code 1278 * {@link String}; 1279 * }</pre> 1280 * 1281 * <b>Tree:</b> 1282 * <pre>{@code 1283 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1284 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1285 * |--JAVADOC_INLINE_TAG_START -> {@ 1286 * |--TAG_NAME -> link 1287 * |--TEXT -> 1288 * |--REFERENCE -> REFERENCE 1289 * | |--IDENTIFIER -> java.base 1290 * | |--SLASH -> / 1291 * | `--IDENTIFIER -> java.lang.String 1292 * `--JAVADOC_INLINE_TAG_END -> } 1293 * }</pre> 1294 * 1295 * @see #REFERENCE 1296 */ 1297 public static final int SLASH = JavadocCommentsLexer.SLASH; 1298 1299 /** 1300 * Question mark symbol {@code ?} used in generic type wildcards. 1301 * 1302 * <p>This token appears in references that use wildcard type arguments, 1303 * such as {@code ? extends Type} or {@code ? super Type}.</p> 1304 * 1305 * <p><b>Example:</b></p> 1306 * <pre>{@code 1307 * {@link java.util.List<? extends Number>}; 1308 * }</pre> 1309 * 1310 * <b>Tree:</b> 1311 * <pre>{@code 1312 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1313 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1314 * |--JAVADOC_INLINE_TAG_START -> {@ 1315 * |--TAG_NAME -> link 1316 * |--TEXT -> 1317 * |--REFERENCE -> REFERENCE 1318 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1319 * | |--LT -> < 1320 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1321 * | | |--QUESTION -> ? 1322 * | | |--TEXT -> 1323 * | | |--EXTENDS -> extends 1324 * | | |--TEXT -> 1325 * | | `--IDENTIFIER -> Number 1326 * | `--GT -> > 1327 * `--JAVADOC_INLINE_TAG_END -> } 1328 * }</pre> 1329 * 1330 * @see #TYPE_ARGUMENT 1331 */ 1332 public static final int QUESTION = JavadocCommentsLexer.QUESTION; 1333 1334 /** 1335 * Less-than symbol {@code < }. 1336 * 1337 * <p><b>Example:</b></p> 1338 * <pre>{@code * @see List<String>}</pre> 1339 * 1340 * <b>Tree:</b> 1341 * <pre>{@code 1342 * |--LEADING_ASTERISK -> * 1343 * |--TEXT -> 1344 * |--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1345 * | `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1346 * | |--AT_SIGN -> @ 1347 * | |--TAG_NAME -> see 1348 * | |--TEXT -> 1349 * | `--REFERENCE -> REFERENCE 1350 * | |--IDENTIFIER -> List 1351 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1352 * | |--LT -> < 1353 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1354 * | | `--IDENTIFIER -> String 1355 * | `--GT -> > 1356 * |--NEWLINE -> \n 1357 * `--TEXT -> 1358 * }</pre> 1359 */ 1360 public static final int LT = JavadocCommentsLexer.LT; 1361 1362 /** 1363 * Greater-than symbol {@code > }. 1364 * 1365 * <p><b>Example:</b></p> 1366 * <pre>{@code * @see List<String>}</pre> 1367 * 1368 * <b>Tree:</b> 1369 * <pre>{@code 1370 * |--LEADING_ASTERISK -> * 1371 * |--TEXT -> 1372 * |--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1373 * | `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1374 * | |--AT_SIGN -> @ 1375 * | |--TAG_NAME -> see 1376 * | |--TEXT -> 1377 * | `--REFERENCE -> REFERENCE 1378 * | |--IDENTIFIER -> List 1379 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1380 * | |--LT -> < 1381 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1382 * | | `--IDENTIFIER -> String 1383 * | `--GT -> > 1384 * |--NEWLINE -> \n 1385 * `--Text -> 1386 * }</pre> 1387 */ 1388 1389 public static final int GT = JavadocCommentsLexer.GT; 1390 1391 /** 1392 * {@code extends} keyword inside type arguments of a Javadoc inline tag. 1393 * 1394 * <p>This node represents the {@code extends} bound used inside a 1395 * parameterized type within an inline Javadoc tag.</p> 1396 * 1397 * <p><b>Example:</b></p> 1398 * <pre>{@code 1399 * * {@link java.util.List<? extends Number> list of any subtype of Number} 1400 * }</pre> 1401 * 1402 * <b>Tree:</b> 1403 * <pre>{@code 1404 * |--LEADING_ASTERISK -> * 1405 * |--TEXT -> 1406 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1407 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1408 * |--JAVADOC_INLINE_TAG_START -> { @ 1409 * |--TAG_NAME -> link 1410 * |--TEXT -> 1411 * |--REFERENCE -> REFERENCE 1412 * | |--IDENTIFIER -> java.util.List 1413 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1414 * | |--LT -> < 1415 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1416 * | | |--QUESTION -> ? 1417 * | | |--TEXT -> 1418 * | | |--EXTENDS -> extends 1419 * | | |--TEXT -> 1420 * | | `--IDENTIFIER -> Number 1421 * | `--GT -> > 1422 * |--DESCRIPTION -> DESCRIPTION 1423 * | `--TEXT -> list of any subtype of Number 1424 * `--JAVADOC_INLINE_TAG_END -> } 1425 * }</pre> 1426 * 1427 * @see #JAVADOC_INLINE_TAG 1428 */ 1429 public static final int EXTENDS = JavadocCommentsLexer.EXTENDS; 1430 1431 /** 1432 * {@code SUPER} represents the {@code super} keyword inside a generic 1433 * wildcard bound (e.g., {@code ? super Number}). 1434 * 1435 * <p><b>Example:</b> {@code {@link java.util.List <? super Integer> list} 1436 * of any supertype of Integer}</p> 1437 * 1438 * <p><b>Tree:</b></p> 1439 * <pre>{@code 1440 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1441 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1442 * |--JAVADOC_INLINE_TAG_START -> { @ 1443 * |--TAG_NAME -> link 1444 * |--TEXT -> 1445 * |--REFERENCE -> REFERENCE 1446 * | |--IDENTIFIER -> java.util.List 1447 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1448 * | |--LT -> < 1449 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1450 * | | |--QUESTION -> ? 1451 * | | |--TEXT -> 1452 * | | |--SUPER -> super 1453 * | | |--TEXT -> 1454 * | | `--IDENTIFIER -> Integer 1455 * | `--GT -> > 1456 * |--DESCRIPTION -> DESCRIPTION 1457 * | `--TEXT -> list of any supertype of Integer 1458 * `--JAVADOC_INLINE_TAG_END -> } 1459 * }</pre> 1460 * 1461 * @see #PARAMETER_TYPE 1462 */ 1463 public static final int SUPER = JavadocCommentsLexer.SUPER; 1464 1465 /** 1466 * {@code PARAMETER_TYPE} Parameter type reference. 1467 * 1468 * <p>Represents a type used in a method parameter.</p> 1469 * 1470 * <p><b>Example:</b></p> 1471 * <pre>{@code {@link java.util.List#add(Object)}} </pre> 1472 * 1473 * <b>Tree:</b> 1474 * <pre>{@code 1475 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1476 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1477 * |--JAVADOC_INLINE_TAG_START -> {@ 1478 * |--TAG_NAME -> link 1479 * |--REFERENCE -> REFERENCE 1480 * | |--IDENTIFIER -> List 1481 * | |--HASH -> # 1482 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1483 * | |--IDENTIFIER -> add 1484 * | |--LPAREN -> ( 1485 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1486 * | | `--PARAMETER_TYPE -> Object 1487 * | `--RPAREN -> ) 1488 * `--JAVADOC_INLINE_TAG_END -> } 1489 * }</pre> 1490 * 1491 * @see #REFERENCE 1492 */ 1493 public static final int PARAMETER_TYPE = JavadocCommentsLexer.PARAMETER_TYPE; 1494 1495 /** 1496 * {@code REFERENCE} General reference within Javadoc. 1497 * 1498 * <p>Represents the target of an inline reference tag such as 1499 * {@code {@link String#length()}}.</p> 1500 * 1501 * <p><b>Example:</b></p> 1502 * <pre>{@code 1503 * {@link String#length()} 1504 * }</pre> 1505 * 1506 * <b>Tree:</b> 1507 * <pre>{@code 1508 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1509 * |--LINK_INLINE_TAG -> LINK_INLINE_TAG 1510 * | |--JAVADOC_INLINE_TAG_START -> {@ 1511 * | |--TAG_NAME -> link 1512 * | |--REFERENCE -> String#length() 1513 * `--JAVADOC_INLINE_TAG_END -> } 1514 * }</pre> 1515 * 1516 * @see #JAVADOC_INLINE_TAG 1517 */ 1518 public static final int REFERENCE = JavadocCommentsLexer.REFERENCE; 1519 1520 /** 1521 * {@code MEMBER_REFERENCE} Member reference (method or field). 1522 * 1523 * <p>Represents a field or method in a type reference.</p> 1524 * 1525 * <p><b>Example:</b></p> 1526 * <pre>{@code 1527 * {@link String#length()} 1528 * }</pre> 1529 * 1530 * <p><b>Tree:</b></p> 1531 * <pre>{@code 1532 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1533 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1534 * |--JAVADOC_INLINE_TAG_START -> {@ 1535 * |--TAG_NAME -> link 1536 * |--TEXT -> 1537 * |--REFERENCE -> REFERENCE 1538 * | |--IDENTIFIER -> String 1539 * | |--HASH -> # 1540 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1541 * | |--IDENTIFIER -> length 1542 * | |--LPAREN -> ( 1543 * | `--RPAREN -> ) 1544 * `--JAVADOC_INLINE_TAG_END -> } 1545 * }</pre> 1546 * 1547 * @see #REFERENCE 1548 */ 1549 public static final int MEMBER_REFERENCE = JavadocCommentsLexer.MEMBER_REFERENCE; 1550 1551 /** 1552 * {@code PARAMETER_TYPE_LIST} represents the list of parameter types inside a 1553 * member reference within a Javadoc inline {@code @link} tag. 1554 * 1555 * <p><b>Example:</b></p> 1556 * <pre>{@code 1557 * {@link Math#max(int, int)} 1558 * }</pre> 1559 * 1560 * <p><b>Tree:</b></p> 1561 * <pre>{@code 1562 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1563 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1564 * |--JAVADOC_INLINE_TAG_START -> {\@ 1565 * |--TAG_NAME -> link 1566 * |--TEXT -> 1567 * |--REFERENCE -> REFERENCE 1568 * | |--IDENTIFIER -> Math 1569 * | |--HASH -> # 1570 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1571 * | |--IDENTIFIER -> max 1572 * | |--LPAREN -> ( 1573 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1574 * | | |--PARAMETER_TYPE -> int 1575 * | | |--COMMA -> , 1576 * | | |--TEXT -> 1577 * | | `--PARAMETER_TYPE -> int 1578 * | `--RPAREN -> ) 1579 * `--JAVADOC_INLINE_TAG_END -> } 1580 * }</pre> 1581 * 1582 * @see #PARAMETER_TYPE 1583 */ 1584 public static final int PARAMETER_TYPE_LIST = JavadocCommentsLexer.PARAMETER_TYPE_LIST; 1585 1586 /** 1587 * {@code TYPE_ARGUMENTS} Type arguments in generics. 1588 * 1589 * <p>Represents the type arguments inside a generic type reference.</p> 1590 * 1591 * <p><b>Example:</b></p> 1592 * <pre>{@code {@link java.util.List<String>}}</pre> 1593 * 1594 * <p><b>Tree:</b></p> 1595 * <pre>{@code 1596 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1597 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1598 * |--JAVADOC_INLINE_TAG_START -> {@ 1599 * |--TAG_NAME -> link 1600 * |--TEXT -> 1601 * |--REFERENCE -> REFERENCE 1602 * | |--IDENTIFIER -> java.util.List 1603 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1604 * | |--LT -> < 1605 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1606 * | | `--IDENTIFIER -> String 1607 * | `--GT -> > 1608 * `--JAVADOC_INLINE_TAG_END -> } 1609 * }</pre> 1610 * 1611 * @see #TYPE_ARGUMENT 1612 */ 1613 public static final int TYPE_ARGUMENTS = JavadocCommentsLexer.TYPE_ARGUMENTS; 1614 1615 /** 1616 * Single type argument in generics. 1617 * 1618 * <p>This node represents one individual type inside a generic type 1619 * argument list.</p> 1620 * 1621 * <p><b>Example:</b></p> 1622 * <pre>{@code 1623 * {@link java.util.List<String>} 1624 * }</pre> 1625 * 1626 * <p><b>Tree:</b></p> 1627 * <pre>{@code 1628 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1629 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1630 * |--JAVADOC_INLINE_TAG_START -> {@ 1631 * |--TAG_NAME -> link 1632 * |--TEXT -> 1633 * |--REFERENCE -> REFERENCE 1634 * |--IDENTIFIER -> java.util.List 1635 * `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1636 * |--LT -> < 1637 * |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1638 * | `--IDENTIFIER -> String 1639 * `--GT -> > 1640 * `--JAVADOC_INLINE_TAG_END -> } 1641 * }</pre> 1642 * 1643 * @see #TYPE_ARGUMENTS 1644 */ 1645 public static final int TYPE_ARGUMENT = JavadocCommentsLexer.TYPE_ARGUMENT; 1646 1647 /** 1648 * Description part of a Javadoc tag. 1649 * 1650 * <p><b>Example:</b></p> 1651 * <pre>{@code * @param value The parameter description goes here.}</pre> 1652 * 1653 * <p><b>Tree:</b></p> 1654 * <pre>{@code 1655 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 1656 * |--AT_SIGN -> @ 1657 * |--TAG_NAME -> param 1658 * |--TEXT -> 1659 * |--PARAMETER_NAME -> value 1660 * `--DESCRIPTION -> DESCRIPTION 1661 * `--TEXT -> The parameter description goes here. 1662 * }</pre> 1663 */ 1664 public static final int DESCRIPTION = JavadocCommentsLexer.DESCRIPTION; 1665 1666 /** 1667 * Format specifier inside a {@code {@value}} inline tag. 1668 * The {@value} tag is used to display the value of a constant directly 1669 * within the Javadoc documentation. In newer Java versions (20+), there 1670 * is ability include a format string inside the tag. 1671 * 1672 * <p>In this example, the format specifier {@code 0x%04x} is used to format the integer 1673 * {@code Modifier#MANDATED} as a hexadecimal value, padded with zeros to a width of four characters.</p> 1674 * <pre>{@code 1675 * {@value %04x Modifier#MANDATED} 1676 * }</pre> 1677 * 1678 * <p><b>Tree:</b></p> 1679 * <pre>{@code 1680 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1681 * `--VALUE_INLINE_TAG -> VALUE_INLINE_TAG 1682 * |--JAVADOC_INLINE_TAG_START -> {@ 1683 * |--TAG_NAME -> value 1684 * |--TEXT -> 1685 * |--FORMAT_SPECIFIER -> %04x 1686 * |--TEXT -> 1687 * |--REFERENCE -> REFERENCE 1688 * | |--IDENTIFIER -> Modifier 1689 * | |--HASH -> # 1690 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1691 * | `--IDENTIFIER -> MANDATED 1692 * `--JAVADOC_INLINE_TAG_END -> } 1693 * }</pre> 1694 * 1695 * @see #VALUE_INLINE_TAG 1696 */ 1697 public static final int FORMAT_SPECIFIER = JavadocCommentsLexer.FORMAT_SPECIFIER; 1698 1699 /** 1700 * Attribute name in a {@code @snippet} tag. 1701 * 1702 * <p> 1703 * <b>Note:</b> In the current Checkstyle AST, all snippet attributes (such as 1704 * {@code lang=java}) appear as plain text under the {@code DESCRIPTION} node. 1705 * There is <b>no</b> {@code SNIPPET_ATTR_NAME} node in the AST tree. 1706 * All attribute content is represented as {@code TEXT}.</p> 1707 * 1708 * <p> 1709 * <b>Example:</b> 1710 * </p> 1711 * <pre>{@code * @snippet lang=java}</pre> 1712 * 1713 * <p> 1714 * <b>Tree:</b> 1715 * </p> 1716 * <pre>{@code 1717 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1718 * |--LEADING_ASTERISK -> * 1719 * |--TEXT -> 1720 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1721 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1722 * |--AT_SIGN -> @ 1723 * |--TAG_NAME -> snippet 1724 * `--DESCRIPTION -> DESCRIPTION 1725 * `--TEXT -> lang=java 1726 * }</pre> 1727 * 1728 * @see #SNIPPET_ATTRIBUTE 1729 */ 1730 public static final int SNIPPET_ATTR_NAME = JavadocCommentsLexer.SNIPPET_ATTR_NAME; 1731 1732 /** 1733 * Equals sign {@code =}. 1734 * 1735 * <p>Used within snippet attributes to assign values.</p> 1736 * 1737 * <p><b>Example:</b></p> 1738 * <pre>{@code 1739 * { @snippet lang="java" : 1740 * int x = 1; 1741 * } 1742 * }</pre> 1743 * 1744 * <p><b>Tree:</b></p> 1745 * <pre>{@code 1746 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1747 * `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 1748 * |--JAVADOC_INLINE_TAG_START -> {@ 1749 * |--SNIPPET_ATTRIBUTES -> SNIPPET_ATTRIBUTES 1750 * | `--SNIPPET_ATTRIBUTE -> SNIPPET_ATTRIBUTE 1751 * | |--TEXT -> 1752 * | |--SNIPPET_ATTR_NAME -> lang 1753 * | |--EQUALS -> = 1754 * | `--ATTRIBUTE_VALUE -> "java" 1755 * |--COLON -> : 1756 * |--SNIPPET_BODY -> SNIPPET_BODY 1757 * | |--NEWLINE -> \n 1758 * | |--TEXT -> int x = 1; 1759 * | |--NEWLINE -> \r\n 1760 * `--JAVADOC_INLINE_TAG_END -> } 1761 * }</pre> 1762 * 1763 * @see #SNIPPET_ATTRIBUTE 1764 * @see #SNIPPET_ATTRIBUTES 1765 */ 1766 public static final int EQUALS = JavadocCommentsLexer.EQUALS; 1767 1768 /** 1769 * {@code ATTRIBUTE_VALUE} Value assigned to an attribute. 1770 * 1771 * <p><b>Example:</b></p> 1772 * <pre>{@code <a href="example">text</a>}</pre> 1773 * 1774 * <p><b>Tree:</b></p> 1775 * <pre>{@code 1776 * HTML_ELEMENT -> HTML_ELEMENT 1777 * |--HTML_TAG_START -> HTML_TAG_START 1778 * | |--TAG_OPEN -> < 1779 * | |--TAG_NAME -> a 1780 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1781 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1782 * | | |--TEXT -> 1783 * | | |--TAG_ATTR_NAME -> href 1784 * | | |--EQUALS -> = 1785 * | | `--ATTRIBUTE_VALUE -> "example" 1786 * | `--TAG_CLOSE -> > 1787 * |--HTML_CONTENT -> HTML_CONTENT 1788 * | `--TEXT -> text 1789 * `--HTML_TAG_END -> HTML_TAG_END 1790 * |--TAG_OPEN -> < 1791 * |--TAG_SLASH -> / 1792 * |--TAG_NAME -> a 1793 * `--TAG_CLOSE -> > 1794 * }</pre> 1795 * 1796 * @see #HTML_ATTRIBUTE 1797 * @see #TAG_ATTR_NAME 1798 */ 1799 public static final int ATTRIBUTE_VALUE = JavadocCommentsLexer.ATTRIBUTE_VALUE; 1800 1801 /** 1802 * Colon symbol {@code : }. 1803 * 1804 * <p><b>Example:</b></p> 1805 * <pre>{@code * {@snippet :config}}</pre> 1806 * 1807 * <p><b>Tree:</b></p> 1808 * <pre>{@code 1809 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1810 * |--TEXT -> /** 1811 * |--NEWLINE -> \n 1812 * |--LEADING_ASTERISK -> * 1813 * |--TEXT -> 1814 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1815 * | `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 1816 * | |--JAVADOC_INLINE_TAG_START -> {@ 1817 * | |--COLON -> : 1818 * | |--SNIPPET_BODY -> SNIPPET_BODY 1819 * | | `--TEXT -> config 1820 * | `--JAVADOC_INLINE_TAG_END -> } 1821 * |--NEWLINE -> \n 1822 * |--LEADING_ASTERISK -> * 1823 * |--TEXT -> / 1824 * |--NEWLINE -> \n 1825 * `--TEXT -> class Test {} 1826 * }</pre> 1827 * 1828 * @see #SNIPPET_INLINE_TAG 1829 */ 1830 public static final int COLON = JavadocCommentsLexer.COLON; 1831 1832 /** 1833 * Term used in {@code {@index}} tag. 1834 * 1835 * <p>This node represents the term inside an inline {@code {@index ...}} tag in Javadoc.</p> 1836 * 1837 * <p><b>Example:</b></p> 1838 * <pre>{@code * Example showing {@index keyword description of the index term}.}</pre> 1839 * 1840 * <b>Tree:</b> 1841 * <pre>{@code 1842 * |--LEADING_ASTERISK -> * 1843 * |--TEXT -> Example showing 1844 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1845 * `--INDEX_INLINE_TAG -> INDEX_INLINE_TAG 1846 * |--JAVADOC_INLINE_TAG_START -> { @ 1847 * |--TAG_NAME -> index 1848 * |--TEXT -> 1849 * |--INDEX_TERM -> keyword 1850 * |--DESCRIPTION -> DESCRIPTION 1851 * | `--TEXT -> description of the index term 1852 * `--JAVADOC_INLINE_TAG_END -> } 1853 * |--TEXT -> . 1854 * }</pre> 1855 * 1856 * @see #JAVADOC_INLINE_TAG 1857 */ 1858 public static final int INDEX_TERM = JavadocCommentsLexer.INDEX_TERM; 1859 1860 /** 1861 * Single attribute in a {@code @snippet} tag. 1862 * 1863 * <p> 1864 * Represents a single attribute (e.g., {@code lang=java}) 1865 * in a {@code @snippet} tag.</p> 1866 * 1867 * <p><b>Note:</b> In the current Checkstyle AST, all snippet 1868 * attributes appear as plain text under the {@code DESCRIPTION} node, 1869 * not as a separate {@code SNIPPET_ATTRIBUTE} node.</p> 1870 * 1871 * <p><b>Example:</b></p> 1872 * <pre>{@code * @snippet lang=java}</pre> 1873 * 1874 * <p><b>Tree:</b></p> 1875 * <pre>{@code 1876 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1877 * |--LEADING_ASTERISK -> * 1878 * |--TEXT -> 1879 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1880 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1881 * |--AT_SIGN -> @ 1882 * |--TAG_NAME -> snippet 1883 * `--DESCRIPTION -> DESCRIPTION 1884 * `--TEXT -> lang=java 1885 * }</pre> 1886 */ 1887 public static final int SNIPPET_ATTRIBUTE = JavadocCommentsLexer.SNIPPET_ATTRIBUTE; 1888 1889 /** 1890 * Collection of attributes in a {@code @snippet} tag. 1891 * 1892 * <p> 1893 * Represents all attributes (e.g., {@code lang=java region=main}) in a {@code @snippet} tag. 1894 * </p> 1895 * 1896 * <p><b>Note:</b> In the current Checkstyle AST, all snippet attributes appear as 1897 * plain text under the {@code DESCRIPTION} node, not as a separate 1898 * {@code SNIPPET_ATTRIBUTES} node.</p> 1899 * 1900 * <p><b>Example:</b></p> 1901 * <pre>{@code * @snippet lang=java region=main}</pre> 1902 * 1903 * <p><b>Tree:</b></p> 1904 * <pre>{@code 1905 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1906 * |--LEADING_ASTERISK -> * 1907 * |--TEXT -> 1908 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1909 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1910 * |--AT_SIGN -> @ 1911 * |--TAG_NAME -> snippet 1912 * `--DESCRIPTION -> DESCRIPTION 1913 * `--TEXT -> lang=java region=main 1914 * }</pre> 1915 */ 1916 public static final int SNIPPET_ATTRIBUTES = JavadocCommentsLexer.SNIPPET_ATTRIBUTES; 1917 1918 /** 1919 * Body content of a {@code @snippet} tag. 1920 * 1921 * <p> 1922 * Represents the code or text content inside a {@code @snippet} tag in Javadoc. 1923 * </p> 1924 * 1925 * <b>Example:</b> 1926 * <pre>{@code * @snippet lang=java * System.out.println("hello");}</pre> 1927 * 1928 * <b>Tree:</b> 1929 * <pre>{@code 1930 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1931 * |--LEADING_ASTERISK -> * 1932 * |--TEXT -> 1933 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1934 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1935 * |--AT_SIGN -> @ 1936 * |--TAG_NAME -> snippet 1937 * `--DESCRIPTION -> DESCRIPTION 1938 * |--TEXT -> lang=java 1939 * |--NEWLINE -> \n 1940 * |--LEADING_ASTERISK -> * 1941 * `--TEXT -> System.out.println("hello"); 1942 * }</pre> 1943 */ 1944 public static final int SNIPPET_BODY = JavadocCommentsLexer.SNIPPET_BODY; 1945 1946 /** 1947 * Field type reference in a Javadoc. 1948 * 1949 * <p>Example:</p> 1950 * <pre> 1951 * /** 1952 * * @serialField counter int The counter. 1953 * */ 1954 * </pre> 1955 * 1956 * <b>Tree:</b> 1957 * <pre> 1958 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1959 * |--TEXT -> /** 1960 * |--NEWLINE -> \n 1961 * |--LEADING_ASTERISK -> * 1962 * |--TEXT -> 1963 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1964 * `--SERIAL_FIELD_BLOCK_TAG -> SERIAL_FIELD_BLOCK_TAG 1965 * |--AT_SIGN -> @ 1966 * |--TAG_NAME -> serialField 1967 * |--TEXT -> 1968 * |--IDENTIFIER -> counter 1969 * |--TEXT -> 1970 * |--FIELD_TYPE -> int 1971 * `--DESCRIPTION -> DESCRIPTION 1972 * |--TEXT -> The counter. 1973 * |--NEWLINE -> \n 1974 * |--LEADING_ASTERISK -> * 1975 * `--TEXT -> / 1976 * </pre> 1977 * 1978 * @see #FIELD_TYPE 1979 */ 1980 public static final int FIELD_TYPE = JavadocCommentsLexer.FIELD_TYPE; 1981 1982 /** 1983 * Parameter name reference in a Javadoc {@code @param} block tag. 1984 * 1985 * <p><b>Example:</b></p> 1986 * <pre>{@code * @param value The parameter of method.}</pre> 1987 * 1988 * <b>Tree:</b> 1989 * <pre>{@code 1990 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1991 * |--LEADING_ASTERISK -> * 1992 * |--TEXT -> 1993 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1994 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 1995 * |--AT_SIGN -> @ 1996 * |--TAG_NAME -> param 1997 * |--TEXT -> 1998 * |--PARAMETER_NAME -> value 1999 * `--DESCRIPTION -> DESCRIPTION 2000 * `--TEXT -> The parameter of method. 2001 * }</pre> 2002 * 2003 * @see #PARAM_BLOCK_TAG 2004 */ 2005 public static final int PARAMETER_NAME = JavadocCommentsLexer.PARAMETER_NAME; 2006 2007 /** 2008 * String literal inside Javadoc. 2009 * 2010 * <p>Example in Javadoc:</p> 2011 * 2012 * <pre>{@code 2013 * {@see "foo"} 2014 * }</pre> 2015 * 2016 * <p>Tree:</p> 2017 * 2018 * <pre>{@code 2019 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 2020 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 2021 * |--AT_SIGN -> @ 2022 * |--TAG_NAME -> see 2023 * |--TEXT -> 2024 * `--STRING_LITERAL -> "foo" 2025 * }</pre> 2026 */ 2027 public static final int STRING_LITERAL = JavadocCommentsLexer.STRING_LITERAL; 2028 2029 // HTML 2030 2031 /** 2032 * General HTML element in a Javadoc comment. 2033 * 2034 * <p><b>Example:</b></p> 2035 * <pre>{@code 2036 * /** 2037 * * <p>Hello</p> 2038 * * / 2039 * }</pre> 2040 * 2041 * <b>Tree:</b> 2042 * <pre>{@code 2043 * JAVADOC_CONTENT -> JAVADOC_CONTENT 2044 * |--LEADING_ASTERISK -> * 2045 * |--TEXT -> 2046 * |--HTML_ELEMENT -> HTML_ELEMENT 2047 * | |--HTML_TAG_START -> HTML_TAG_START 2048 * | | |--TAG_OPEN -> < 2049 * | | |--TAG_NAME -> p 2050 * | | `--TAG_CLOSE -> > 2051 * | |--HTML_CONTENT -> HTML_CONTENT 2052 * | | `--TEXT -> Hello 2053 * | `--HTML_TAG_END -> HTML_TAG_END 2054 * | |--TAG_OPEN -> < 2055 * | |--TAG_SLASH -> / 2056 * | |--TAG_NAME -> p 2057 * | `--TAG_CLOSE -> > 2058 * |--NEWLINE -> \n 2059 * |--LEADING_ASTERISK -> * 2060 * |--TEXT -> / 2061 * }</pre> 2062 */ 2063 public static final int HTML_ELEMENT = JavadocCommentsLexer.HTML_ELEMENT; 2064 2065 /** 2066 * Void HTML element (self-closing). 2067 * 2068 * <p>Example in Javadoc:</p> 2069 * <pre> 2070 * <br> 2071 * </pre> 2072 * 2073 * <p>Tree:</p> 2074 * <pre> 2075 * HTML_ELEMENT -> HTML_ELEMENT 2076 * `--VOID_ELEMENT -> VOID_ELEMENT 2077 * `--HTML_TAG_START -> HTML_TAG_START 2078 * |--TAG_OPEN -> < 2079 * |--TAG_NAME -> br 2080 * `--TAG_CLOSE -> > 2081 * </pre> 2082 */ 2083 public static final int VOID_ELEMENT = JavadocCommentsLexer.VOID_ELEMENT; 2084 2085 /** 2086 * Content inside an HTML element. 2087 * 2088 * <p>This node represents the textual content between an HTML start tag and 2089 * the corresponding end tag inside a Javadoc comment.</p> 2090 * 2091 * <p><b>Example:</b></p> 2092 * <pre>{@code * <a href="https://example.com">link</a>}</pre> 2093 * 2094 * <b>Tree:</b> 2095 * <pre>{@code 2096 * |--LEADING_ASTERISK -> * 2097 * `--HTML_ELEMENT -> HTML_ELEMENT 2098 * |--HTML_TAG_START -> HTML_TAG_START 2099 * | |--TAG_OPEN -> < 2100 * | |--TAG_NAME -> a 2101 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2102 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2103 * | | |--TEXT -> (whitespace) 2104 * | | |--TAG_ATTR_NAME -> href 2105 * | | |--EQUALS -> = 2106 * | | `--ATTRIBUTE_VALUE -> "https://example.com" 2107 * | `--TAG_CLOSE -> > 2108 * |--HTML_CONTENT -> HTML_CONTENT 2109 * | `--TEXT -> link 2110 * `--HTML_TAG_END -> HTML_TAG_END 2111 * |--TAG_OPEN -> < 2112 * |--TAG_SLASH -> / 2113 * |--TAG_NAME -> a 2114 * `--TAG_CLOSE -> > 2115 * }</pre> 2116 * 2117 * @see #HTML_ELEMENT 2118 */ 2119 2120 public static final int HTML_CONTENT = JavadocCommentsLexer.HTML_CONTENT; 2121 2122 /** 2123 * {@code HTML_ATTRIBUTE} Single HTML attribute. 2124 * 2125 * <p>Represents one attribute inside an HTML tag.</p> 2126 * 2127 * <p><b>Example:</b></p> 2128 * <pre>{@code 2129 * <input type="text"> 2130 * }</pre> 2131 * 2132 * <b>Tree:</b> 2133 * <pre>{@code 2134 * HTML_ELEMENT -> HTML_ELEMENT 2135 * `--VOID_ELEMENT -> VOID_ELEMENT 2136 * `--HTML_TAG_START -> HTML_TAG_START 2137 * |--TAG_OPEN -> < 2138 * |--TAG_NAME -> input 2139 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2140 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2141 * | |--TEXT -> 2142 * | |--TAG_ATTR_NAME -> type 2143 * | |--EQUALS -> = 2144 * | `--ATTRIBUTE_VALUE -> "text" 2145 * `--TAG_CLOSE -> > 2146 * }</pre> 2147 * 2148 * @see #HTML_ATTRIBUTES 2149 */ 2150 public static final int HTML_ATTRIBUTE = JavadocCommentsLexer.HTML_ATTRIBUTE; 2151 2152 /** 2153 * {@code HTML_ATTRIBUTES} represents a collection of HTML attributes 2154 * inside an HTML tag. 2155 * 2156 * <p>Appears in Javadoc comments when documenting HTML elements that contain 2157 * multiple attributes.</p> 2158 * 2159 * <p><b>Example:</b></p> 2160 * <pre>{@code 2161 * <div lang="en" custom-attr="value"></div> 2162 * }</pre> 2163 * 2164 * <p><b>Tree:</b></p> 2165 * <pre>{@code 2166 * HTML_ELEMENT -> HTML_ELEMENT 2167 * |--HTML_TAG_START -> HTML_TAG_START 2168 * | |--TAG_OPEN -> < 2169 * | |--TAG_NAME -> div 2170 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2171 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2172 * | | | |--TEXT -> 2173 * | | | |--TAG_ATTR_NAME -> lang 2174 * | | | |--EQUALS -> = 2175 * | | | `--ATTRIBUTE_VALUE -> "en" 2176 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2177 * | | |--TEXT -> 2178 * | | |--TAG_ATTR_NAME -> custom-attr 2179 * | | |--EQUALS -> = 2180 * | | `--ATTRIBUTE_VALUE -> "value" 2181 * | `--TAG_CLOSE -> > 2182 * }</pre> 2183 * 2184 * @see #HTML_ATTRIBUTE 2185 */ 2186 public static final int HTML_ATTRIBUTES = JavadocCommentsLexer.HTML_ATTRIBUTES; 2187 2188 /** 2189 * Start of an HTML tag (the opening tag node). 2190 * 2191 * <p>This node represents the opening part of an HTML element and contains 2192 * the opening delimiter, tag name, optional attributes, and the closing 2193 * delimiter of the opening tag.</p> 2194 * 2195 * <p><b>Example:</b></p> 2196 * <pre>{@code * <a href="https://example.com">link</a>}</pre> 2197 * 2198 * <b>Tree:</b> 2199 * <pre>{@code 2200 * |--LEADING_ASTERISK -> * 2201 * `--HTML_ELEMENT -> HTML_ELEMENT 2202 * `--HTML_TAG_START -> HTML_TAG_START 2203 * |--TAG_OPEN -> < 2204 * |--TAG_NAME -> a 2205 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2206 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2207 * | |--TEXT -> 2208 * | |--TAG_ATTR_NAME -> href 2209 * | |--EQUALS -> = 2210 * | `--ATTRIBUTE_VALUE -> "https://example.com" 2211 * `--TAG_CLOSE -> > 2212 * }</pre> 2213 * 2214 * @see #HTML_ELEMENT 2215 */ 2216 2217 public static final int HTML_TAG_START = JavadocCommentsLexer.HTML_TAG_START; 2218 2219 /** 2220 * End of an HTML tag (the closing tag node). 2221 * 2222 * <p>This node represents the closing part of an HTML element and contains the 2223 * closing delimiter, optional slash, and the tag name.</p> 2224 * 2225 * <p><b>Example:</b></p> 2226 * <pre>{@code * <a href="https://example.com">link</a>}</pre> 2227 * 2228 * <b>Tree:</b> 2229 * <pre>{@code 2230 * |--LEADING_ASTERISK -> * 2231 * `--HTML_ELEMENT -> HTML_ELEMENT 2232 * |--HTML_TAG_START -> HTML_TAG_START 2233 * | |--TAG_OPEN -> < 2234 * | |--TAG_NAME -> a 2235 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2236 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2237 * | | |--TEXT -> (whitespace) 2238 * | | |--TAG_ATTR_NAME -> href 2239 * | | |--EQUALS -> = 2240 * | | `--ATTRIBUTE_VALUE -> "https://example.com" 2241 * | `--TAG_CLOSE -> > 2242 * |--HTML_CONTENT -> HTML_CONTENT 2243 * | `--TEXT -> link 2244 * `--HTML_TAG_END -> HTML_TAG_END 2245 * |--TAG_OPEN -> < 2246 * |--TAG_SLASH -> / 2247 * |--TAG_NAME -> a 2248 * `--TAG_CLOSE -> > 2249 * }</pre> 2250 * 2251 * @see #HTML_ELEMENT 2252 */ 2253 2254 public static final int HTML_TAG_END = JavadocCommentsLexer.HTML_TAG_END; 2255 2256 /** 2257 * Represents the opening {@literal "<"} symbol of an HTML start tag. 2258 * 2259 * <p><b>Example:</b></p> 2260 * <pre>{@code 2261 * <div class="container" lang="en"></div> 2262 * }</pre> 2263 * 2264 * <b>Tree:</b> 2265 * <pre>{@code 2266 * HTML_ELEMENT -> HTML_ELEMENT 2267 * |--HTML_TAG_START -> HTML_TAG_START 2268 * | |--TAG_OPEN -> < 2269 * | |--TAG_NAME -> div 2270 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2271 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2272 * | | | |--TAG_ATTR_NAME -> class 2273 * | | | |--EQUALS -> = 2274 * | | | `--ATTRIBUTE_VALUE -> "container" 2275 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2276 * | | |--TAG_ATTR_NAME -> lang 2277 * | | |--EQUALS -> = 2278 * | | `--ATTRIBUTE_VALUE -> "en" 2279 * | `--TAG_CLOSE -> > 2280 * `--HTML_TAG_END -> HTML_TAG_END 2281 * |--TAG_OPEN -> < 2282 * |--TAG_SLASH -> / 2283 * |--TAG_NAME -> div 2284 * `--TAG_CLOSE -> > 2285 * }</pre> 2286 * 2287 * @see #HTML_TAG_START 2288 */ 2289 public static final int TAG_OPEN = JavadocCommentsLexer.TAG_OPEN; 2290 2291 /** 2292 * {@code TAG_NAME} Name of an HTML element. 2293 * 2294 * <p>Appears inside an HTML tag within Javadoc comments.</p> 2295 * 2296 * <p><b>Example:</b></p> 2297 * <pre>{@code 2298 * <div class="container"> 2299 * Content 2300 * </div> 2301 * }</pre> 2302 * 2303 * <b>Tree:</b> 2304 * <pre>{@code 2305 * HTML_ELEMENT -> HTML_ELEMENT 2306 * |--HTML_TAG_START -> HTML_TAG_START 2307 * | |--TAG_OPEN -> < 2308 * | |--TAG_NAME -> div 2309 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2310 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2311 * | | |--TAG_ATTR_NAME -> class 2312 * | | |--EQUALS -> = 2313 * | | `--ATTRIBUTE_VALUE -> "container" 2314 * | `--TAG_CLOSE -> > 2315 * |--HTML_CONTENT -> HTML_CONTENT 2316 * | `--TEXT -> Content 2317 * `--HTML_TAG_END -> HTML_TAG_END 2318 * |--TAG_OPEN -> < 2319 * |--TAG_SLASH -> / 2320 * |--TAG_NAME -> div 2321 * `--TAG_CLOSE -> > 2322 * }</pre> 2323 * 2324 * <p>Here {@code TAG_NAME} corresponds to {@code "div"}.</p> 2325 */ 2326 public static final int TAG_NAME = JavadocCommentsLexer.TAG_NAME; 2327 2328 /** 2329 * {@code TAG_CLOSE} represents the closing {@literal ">"} symbol 2330 * of an HTML tag. 2331 * 2332 * <p>Appears in Javadoc comments when documenting HTML elements.</p> 2333 * 2334 * <p><b>Example:</b></p> 2335 * <pre>{@code 2336 * <p>Some text</p> 2337 * }</pre> 2338 * 2339 * <b>Tree:</b> 2340 * <pre>{@code 2341 * HTML_ELEMENT -> HTML_ELEMENT 2342 * |--HTML_TAG_START -> HTML_TAG_START 2343 * | |--TAG_OPEN -> < 2344 * | |--TAG_NAME -> p 2345 * | `--TAG_CLOSE -> > 2346 * |--HTML_CONTENT -> HTML_CONTENT 2347 * | `--TEXT -> Some text 2348 * `--HTML_TAG_END -> HTML_TAG_END 2349 * |--TAG_OPEN -> < 2350 * |--TAG_SLASH -> / 2351 * |--TAG_NAME -> p 2352 * `--TAG_CLOSE -> > 2353 * }</pre> 2354 * 2355 * @see #HTML_TAG_START 2356 */ 2357 public static final int TAG_CLOSE = JavadocCommentsLexer.TAG_CLOSE; 2358 2359 /** 2360 * {@code />} Self-closing tag delimiter. 2361 * 2362 * <p>Used for void HTML elements.</p> 2363 * 2364 * <p><b>Example:</b></p> 2365 * <pre>{@code * <br />}</pre> 2366 * 2367 * <b>Tree:</b> 2368 * <pre>{@code 2369 * VOID_ELEMENT -> VOID_ELEMENT 2370 * |--TAG_OPEN -> < 2371 * |--TAG_NAME -> br 2372 * `--TAG_SLASH_CLOSE -> /> 2373 * }</pre> 2374 * 2375 * @see #HTML_ELEMENT 2376 */ 2377 public static final int TAG_SLASH_CLOSE = JavadocCommentsLexer.TAG_SLASH_CLOSE; 2378 2379 /** 2380 * {@code TAG_SLASH} represents the slash {@literal "/"} used 2381 * inside an HTML closing tag. 2382 * 2383 * <p>Appears in Javadoc comments when closing HTML elements.</p> 2384 * 2385 * <p><b>Example:</b></p> 2386 * <pre>{@code 2387 * <p>Paragraph text</p> 2388 * }</pre> 2389 * 2390 * <b>Tree:</b> 2391 * <pre>{@code 2392 * HTML_ELEMENT -> HTML_ELEMENT 2393 * |--HTML_TAG_START -> HTML_TAG_START 2394 * | |--TAG_OPEN -> < 2395 * | |--TAG_NAME -> p 2396 * | `--TAG_CLOSE -> > 2397 * |--HTML_CONTENT -> HTML_CONTENT 2398 * | `--TEXT -> Paragraph text 2399 * `--HTML_TAG_END -> HTML_TAG_END 2400 * |--TAG_OPEN -> < 2401 * |--TAG_SLASH -> / 2402 * |--TAG_NAME -> p 2403 * `--TAG_CLOSE -> > 2404 * }</pre> 2405 * 2406 * @see #HTML_TAG_END 2407 */ 2408 public static final int TAG_SLASH = JavadocCommentsLexer.TAG_SLASH; 2409 2410 /** 2411 * {@code TAG_ATTR_NAME} represents the name of an attribute inside an 2412 * HTML element within a Javadoc comment. 2413 * 2414 * <p><b>Example:</b></p> 2415 * <pre>{@code 2416 * <img src="logo.png" alt="Site logo"> 2417 * }</pre> 2418 * 2419 * <p><b>Tree:</b></p> 2420 * <pre>{@code 2421 * HTML_ELEMENT -> HTML_ELEMENT 2422 * `--VOID_ELEMENT -> VOID_ELEMENT 2423 * `--HTML_TAG_START -> HTML_TAG_START 2424 * |--TAG_OPEN -> < 2425 * |--TAG_NAME -> img 2426 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2427 * | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2428 * | | |--TEXT -> 2429 * | | |--TAG_ATTR_NAME -> src 2430 * | | |--EQUALS -> = 2431 * | | `--ATTRIBUTE_VALUE -> "logo.png" 2432 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2433 * | |--TEXT -> 2434 * | |--TAG_ATTR_NAME -> alt 2435 * | |--EQUALS -> = 2436 * | `--ATTRIBUTE_VALUE -> "Site logo" 2437 * `--TAG_CLOSE -> > 2438 * }</pre> 2439 * 2440 * @see #HTML_ATTRIBUTES 2441 */ 2442 public static final int TAG_ATTR_NAME = JavadocCommentsLexer.TAG_ATTR_NAME; 2443 2444 /** 2445 * Start of an HTML comment node. 2446 * 2447 * <p>This node represents a full HTML comment inside Javadoc.</p> 2448 * 2449 * <p>This node has three children:</p> 2450 * <ol> 2451 * <li>{@link #HTML_COMMENT_START}</li> 2452 * <li>{@link #HTML_COMMENT_CONTENT}</li> 2453 * <li>{@link #HTML_COMMENT_END}</li> 2454 * </ol> 2455 * 2456 * <p><b>Example:</b></p> 2457 * <pre>{@code * <!-- Hello World! -->}</pre> 2458 * 2459 * <b>Tree:</b> 2460 * <pre>{@code 2461 * JAVADOC_CONTENT -> JAVADOC_CONTENT 2462 * |--TEXT -> /** 2463 * |--NEWLINE -> \r\n 2464 * |--LEADING_ASTERISK -> * 2465 * |--TEXT -> 2466 * |--HTML_COMMENT -> HTML_COMMENT 2467 * |--HTML_COMMENT_START -> <!-- 2468 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 2469 * | `--TEXT -> Hello World! 2470 * `--HTML_COMMENT_END -> --> 2471 * |--NEWLINE -> \r\n 2472 * |--LEADING_ASTERISK -> * 2473 * |--TEXT -> / 2474 * }</pre> 2475 * 2476 * @see #HTML_COMMENT 2477 */ 2478 public static final int HTML_COMMENT = JavadocCommentsLexer.HTML_COMMENT; 2479 2480 /** 2481 * {@code HTML_COMMENT_START} represents the beginning of an HTML comment, 2482 * i.e., the {@literal "<!--"} sequence inside a Javadoc comment. 2483 * 2484 * <p>HTML comments occasionally appear in Javadoc to add internal notes or 2485 * explanations without affecting the rendered output.</p> 2486 * Example: {@code <!-- Note: This method is for demonstration purposes only. -->} 2487 * 2488 * <p><b>Tree:</b></p> 2489 * <pre>{@code 2490 * HTML_COMMENT -> HTML_COMMENT 2491 * |--HTML_COMMENT_START -> <!-- 2492 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 2493 * | `--TEXT -> Note: This method is for demonstration purposes only. 2494 * `--HTML_COMMENT_END -> --> 2495 * }</pre> 2496 * 2497 * @see #HTML_COMMENT_END 2498 */ 2499 public static final int HTML_COMMENT_START = JavadocCommentsLexer.HTML_COMMENT_START; 2500 2501 /** 2502 * Closing part of an HTML comment. 2503 * 2504 * <p>This node represents the closing delimiter of an HTML comment in 2505 * Javadoc (for example {@code -->}).</p> 2506 * 2507 * <p><b>Example:</b></p> 2508 * <pre>{@code * <!-- hidden comment -->}</pre> 2509 * 2510 * <b>Tree:</b> 2511 * <pre>{@code 2512 * |--LEADING_ASTERISK -> * 2513 * |--TEXT -> 2514 * |--HTML_COMMENT -> HTML_COMMENT 2515 * | |--HTML_COMMENT_START -> <!-- 2516 * | |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 2517 * | | `--TEXT -> hidden comment 2518 * | `--HTML_COMMENT_END -> --> 2519 * }</pre> 2520 * 2521 * @see #HTML_COMMENT 2522 */ 2523 2524 public static final int HTML_COMMENT_END = JavadocCommentsLexer.HTML_COMMENT_END; 2525 2526 /** 2527 * {@code HTML_COMMENT_CONTENT} Content inside an HTML comment. 2528 * 2529 * <p>Text within an HTML comment.</p> 2530 * 2531 * <p><b>Example:</b> {@code <!-- This is a comment -->}</p> 2532 * 2533 * <p><b>Tree:</b></p> 2534 * <pre>{@code 2535 * HTML_COMMENT -> HTML_COMMENT 2536 * |--HTML_COMMENT_START -> <!-- 2537 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 2538 * | `--TEXT -> This is a comment 2539 * `--HTML_COMMENT_END -> --> 2540 * }</pre> 2541 * 2542 * @see #HTML_COMMENT 2543 */ 2544 public static final int HTML_COMMENT_CONTENT = JavadocCommentsLexer.HTML_COMMENT_CONTENT; 2545 2546 /** Empty private constructor of the current class. */ 2547 private JavadocCommentsTokenTypes() { 2548 } 2549}