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