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