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