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, JavadocLinkAsPlainText 031 * @noinspectionreason JavadocDeclaration - Javadoc is intentional 032 * @noinspectionreason EmptyClass - false positive from Language Injection in snippet block 033 * @noinspectionreason JavadocLinkAsPlainText - false positive in snippet block 034 */ 035@SuppressWarnings({"InvalidInlineTag", "UnrecognisedJavadocTag"}) 036public final class JavadocCommentsTokenTypes { 037 038 /** 039 * Root node of any Javadoc comment. 040 * 041 * <p><b>Tree for example:</b></p> 042 * {@snippet lang="text" : 043 * JAVADOC_CONTENT -> JAVADOC_CONTENT 044 * |--LEADING_ASTERISK -> * 045 * |--NEWLINE -> \n 046 * |--LEADING_ASTERISK -> * 047 * |--NEWLINE -> \n 048 * |--LEADING_ASTERISK -> * 049 * `--NEWLINE -> \n 050 * } 051 */ 052 public static final int JAVADOC_CONTENT = JavadocCommentsLexer.JAVADOC; 053 054 /** 055 * Leading asterisk used to format Javadoc lines. 056 * 057 * <p><b>Example:</b></p> 058 * <pre>{@code 059 * /** 060 * * This is a Javadoc line. 061 * * / 062 * }</pre> 063 * 064 * <p><b>Tree:</b></p> 065 * {@snippet lang="text" : 066 * --BLOCK_COMMENT_BEGIN -> /** 067 * |--COMMENT_CONTENT -> *\r\n * This is a Javadoc line.\r\n 068 * | `--JAVADOC_CONTENT -> JAVADOC_CONTENT 069 * | |--NEWLINE -> \r\n 070 * | |--LEADING_ASTERISK -> * 071 * | |--TEXT -> This is a Javadoc line. 072 * | |--NEWLINE -> \r\n 073 * | `--TEXT -> 074 * ` --BLOCK_COMMENT_END -> * 075 * } 076 */ 077 public static final int LEADING_ASTERISK = JavadocCommentsLexer.LEADING_ASTERISK; 078 079 /** 080 * Multiple leading asterisks used to format Javadoc lines. 081 * 082 * <p><b>Example:</b></p> 083 * <pre>{@code 084 * /*** 085 * **** This is a Javadoc line. 086 * * / 087 * }</pre> 088 * 089 * <p><b>Tree:</b></p> 090 * {@snippet lang="text" : 091 * --BLOCK_COMMENT_BEGIN -> /* 092 * |--COMMENT_CONTENT -> **\r\n **** This is a Javadoc line.\r\n 093 * | `--JAVADOC_CONTENT -> JAVADOC_CONTENT 094 * | |--LEADING_ASTERISK -> * 095 * | |--NEWLINE -> \r\n 096 * | |--LEADING_ASTERISKS -> **** 097 * | |--TEXT -> This is a Javadoc line. 098 * | |--NEWLINE -> \r\n 099 * | `--TEXT -> 100 * ` --BLOCK_COMMENT_END -> * 101 * } 102 */ 103 public static final int LEADING_ASTERISKS = JavadocCommentsLexer.LEADING_ASTERISKS; 104 105 /** 106 * Newline character in a Javadoc comment. 107 * 108 * <p><b>Example:</b></p> 109 * <pre>{@code 110 * /** 111 * * This is a Javadoc line. 112 * * / 113 * }</pre> 114 * 115 * <p><b>Tree:</b></p> 116 * {@snippet lang="text" : 117 * --BLOCK_COMMENT_BEGIN -> /** 118 * |--COMMENT_CONTENT -> *\r\n * This is a Javadoc line.\r\n 119 * | `--JAVADOC_CONTENT -> JAVADOC_CONTENT 120 * | |--NEWLINE -> \r\n 121 * | |--LEADING_ASTERISK -> * 122 * | |--TEXT -> This is a Javadoc line. 123 * | |--NEWLINE -> \r\n 124 * | `--TEXT -> 125 * ` --BLOCK_COMMENT_END -> * 126 * } 127 */ 128 129 public static final int NEWLINE = JavadocCommentsLexer.NEWLINE; 130 131 /** 132 * Plain text content within a Javadoc comment. 133 * 134 * <p>This node represents any plain text that appears in a Javadoc comment, 135 * including spaces and punctuation.</p> 136 * 137 * <p><b>Example:</b></p> 138 * <pre>{@code 139 * /** 140 * * This is plain text content. 141 * * / 142 * }</pre> 143 * 144 * <p><b>Tree:</b></p> 145 * {@snippet lang="text" : 146 * --BLOCK_COMMENT_BEGIN -> /** 147 * |--COMMENT_CONTENT -> *\r\n * This is plain text content.\r\n 148 * | `--JAVADOC_CONTENT -> JAVADOC_CONTENT 149 * | |--NEWLINE -> \r\n 150 * | |--LEADING_ASTERISK -> * 151 * | |--TEXT -> This is plain text content. 152 * | |--NEWLINE -> \r\n 153 * | `--TEXT -> 154 * `--BLOCK_COMMENT_END -> * / 155 * } 156 * 157 * @see #JAVADOC_CONTENT 158 */ 159 public static final int TEXT = JavadocCommentsLexer.TEXT; 160 161 // Block tags 162 163 /** 164 * General block tag (e.g. {@code @param}, {@code @return}). 165 * 166 * <p>Such Javadoc tag can have these children:</p> 167 * <ol> 168 * <li>{@link #PARAM_BLOCK_TAG}</li> 169 * <li>{@link #RETURN_BLOCK_TAG}</li> 170 * <li>{@link #THROWS_BLOCK_TAG}</li> 171 * </ol> 172 * 173 * <p><b>Example:</b>{@code * @param value The parameter of method.}</p> 174 * 175 * <b>Tree:</b> 176 * {@snippet lang="text" : 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 * } 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>{@code * @author name}</p> 200 * 201 * <b>Tree:</b> 202 * {@snippet lang="text" : 203 * |--LEADING_ASTERISK -> * 204 * |--TEXT -> 205 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 206 * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG 207 * |--AT_SIGN -> @ 208 * |--TAG_NAME -> author 209 * `--DESCRIPTION -> DESCRIPTION 210 * `--TEXT -> name 211 * } 212 * 213 * @see #JAVADOC_BLOCK_TAG 214 */ 215 public static final int AT_SIGN = JavadocCommentsLexer.AT_SIGN; 216 217 /** 218 * {@code @author} Javadoc block tag. 219 * 220 * <p>Such Javadoc tag can have one child:</p> 221 * <ol> 222 * <li>{@link #DESCRIPTION}</li> 223 * </ol> 224 * 225 * <p><b>Example:</b>{@code * @author name.}</p> 226 * 227 * <b>Tree:</b> 228 * {@snippet lang="text" : 229 * JAVADOC_CONTENT -> JAVADOC_CONTENT 230 * |--LEADING_ASTERISK -> * 231 * |--TEXT -> 232 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 233 * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG 234 * |--AT_SIGN -> @ 235 * |--TAG_NAME -> author 236 * `--DESCRIPTION -> DESCRIPTION 237 * `--TEXT -> name. 238 * } 239 * 240 * @see #JAVADOC_BLOCK_TAG 241 */ 242 public static final int AUTHOR_BLOCK_TAG = JavadocCommentsLexer.AUTHOR_BLOCK_TAG; 243 244 /** 245 * {@code @deprecated} block tag. 246 * 247 * <p>Such Javadoc tag can have one child:</p> 248 * <ol> 249 * <li>{@link #DESCRIPTION}</li> 250 * </ol> 251 * 252 * <p><b>Example:</b>{@code * @deprecated deprecated text.}</p> 253 * 254 * <b>Tree:</b> 255 * {@snippet lang="text" : 256 * JAVADOC_CONTENT -> JAVADOC_CONTENT 257 * |--LEADING_ASTERISK -> * 258 * |--TEXT -> 259 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 260 * `--DEPRECATED_BLOCK_TAG -> DEPRECATED_BLOCK_TAG 261 * |--AT_SIGN -> @ 262 * |--TAG_NAME -> deprecated 263 * `--DESCRIPTION -> DESCRIPTION 264 * `--TEXT -> deprecated text. 265 * } 266 * 267 * @see #JAVADOC_BLOCK_TAG 268 */ 269 public static final int DEPRECATED_BLOCK_TAG = JavadocCommentsLexer.DEPRECATED_BLOCK_TAG; 270 271 /** 272 * {@code @param} Javadoc block tag. 273 * 274 * <p>Such Javadoc tag can have two children:</p> 275 * <ol> 276 * <li>{@link #PARAMETER_NAME}</li> 277 * <li>{@link #DESCRIPTION}</li> 278 * </ol> 279 * 280 * <p><b>Example:</b>{@code * @param value The parameter of method.}</p> 281 * 282 * <b>Tree:</b> 283 * {@snippet lang="text" : 284 * JAVADOC_CONTENT -> JAVADOC_CONTENT 285 * |--LEADING_ASTERISK -> * 286 * |--TEXT -> 287 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 288 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 289 * |--AT_SIGN -> @ 290 * |--TAG_NAME -> param 291 * |--TEXT -> 292 * |--PARAMETER_NAME -> value 293 * `--DESCRIPTION -> DESCRIPTION 294 * `--TEXT -> The parameter of method. 295 * } 296 * 297 * @see #JAVADOC_BLOCK_TAG 298 */ 299 public static final int PARAM_BLOCK_TAG = JavadocCommentsLexer.PARAM_BLOCK_TAG; 300 301 /** 302 * {@code @return} Javadoc block tag. 303 * 304 * <p>Such Javadoc tag can have one child:</p> 305 * <ol> 306 * <li>{@link #DESCRIPTION}</li> 307 * </ol> 308 * 309 * <p><b>Example:</b>{@code * @return The return of method.}</p> 310 * 311 * <b>Tree:</b> 312 * {@snippet lang="text" : 313 * JAVADOC_CONTENT -> JAVADOC_CONTENT 314 * |--LEADING_ASTERISK -> * 315 * |--TEXT -> 316 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 317 * `--RETURN_BLOCK_TAG -> RETURN_BLOCK_TAG 318 * |--AT_SIGN -> @ 319 * |--TAG_NAME -> return 320 * `--DESCRIPTION -> DESCRIPTION 321 * `--TEXT -> The return of method. 322 * } 323 * 324 * @see #JAVADOC_BLOCK_TAG 325 */ 326 public static final int RETURN_BLOCK_TAG = JavadocCommentsLexer.RETURN_BLOCK_TAG; 327 328 /** 329 * {@code @throws} Javadoc block tag. 330 * 331 * <p>Such Javadoc tag can have two children:</p> 332 * <ol> 333 * <li>{@link #IDENTIFIER} - the exception class</li> 334 * <li>{@link #DESCRIPTION} - description</li> 335 * </ol> 336 * 337 * <p><b>Example:</b>{@code * @throws IOException if an I/O error occurs}</p> 338 * 339 * <b>Tree:</b> 340 * {@snippet lang="text" : 341 * JAVADOC_CONTENT -> JAVADOC_CONTENT 342 * |--LEADING_ASTERISK -> * 343 * |--TEXT -> 344 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 345 * `--THROWS_BLOCK_TAG -> THROWS_BLOCK_TAG 346 * |--AT_SIGN -> @ 347 * |--TAG_NAME -> throws 348 * |--TEXT -> 349 * |--IDENTIFIER -> IOException 350 * `--DESCRIPTION -> DESCRIPTION 351 * `--TEXT -> if an I/O error occurs 352 * } 353 * 354 * @see #JAVADOC_BLOCK_TAG 355 */ 356 public static final int THROWS_BLOCK_TAG = JavadocCommentsLexer.THROWS_BLOCK_TAG; 357 358 /** 359 * {@code @exception} Javadoc block tag. 360 * 361 * <p>Such Javadoc tag can have two children:</p> 362 * <ol> 363 * <li>{@link #IDENTIFIER}</li> 364 * <li>{@link #DESCRIPTION}</li> 365 * </ol> 366 * 367 * <p><b>Example:</b>{@code * @exception FileNotFoundException when file is not found.}</p> 368 * 369 * <b>Tree:</b> 370 * {@snippet lang="text" : 371 * JAVADOC_CONTENT -> JAVADOC_CONTENT 372 * |--LEADING_ASTERISK -> * 373 * |--TEXT -> 374 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 375 * `--EXCEPTION_BLOCK_TAG -> EXCEPTION_BLOCK_TAG 376 * |--AT_SIGN -> @ 377 * |--TAG_NAME -> exception 378 * |--TEXT -> 379 * |--IDENTIFIER -> FileNotFoundException 380 * `--DESCRIPTION -> DESCRIPTION 381 * `--TEXT -> when file is not found. 382 * } 383 * 384 * @see #JAVADOC_BLOCK_TAG 385 */ 386 public static final int EXCEPTION_BLOCK_TAG = JavadocCommentsLexer.EXCEPTION_BLOCK_TAG; 387 388 /** 389 * {@code @since} Javadoc block tag. 390 * 391 * <p>Such Javadoc tag can have one child:</p> 392 * <ol> 393 * <li>{@link #DESCRIPTION}</li> 394 * </ol> 395 * 396 * <p><b>Example: </b>{@code * @since 1.0}</p> 397 * 398 * <b>Tree:</b> 399 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 1084 * * Example showing {@snippet :java 1085 * System.out.println("hello"); 1086 * } 1087 * } 1088 * 1089 * <b>Tree:</b> 1090 * {@snippet lang="text" : 1091 * |--LEADING_ASTERISK -> * 1092 * |--TEXT -> Example showing 1093 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1094 * `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 1095 * |--JAVADOC_INLINE_TAG_START -> { @ 1096 * |--COLON -> : 1097 * |--SNIPPET_BODY -> SNIPPET_BODY 1098 * | |--TEXT -> java 1099 * | |--NEWLINE -> \n 1100 * | |--LEADING_ASTERISK -> * 1101 * | |--TEXT -> System.out.println("hello"); 1102 * | |--NEWLINE -> \n 1103 * | |--LEADING_ASTERISK -> * 1104 * | `--TEXT -> 1105 * `--JAVADOC_INLINE_TAG_END -> } 1106 * } 1107 * 1108 * @see #JAVADOC_INLINE_TAG 1109 */ 1110 public static final int SNIPPET_INLINE_TAG = JavadocCommentsLexer.SNIPPET_INLINE_TAG; 1111 1112 /** 1113 * {@code @custom} inline tag. 1114 * 1115 * <p><b>Example:</b>{@code * Example showing {@custom This is a Custom Inline Tag}.}</p> 1116 * 1117 * <p><b>Tree:</b></p> 1118 * {@snippet lang="text" : 1119 * |--LEADING_ASTERISK -> * 1120 * |--TEXT -> Example showing 1121 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1122 * | `--CUSTOM_INLINE_TAG -> CUSTOM_INLINE_TAG 1123 * | |--JAVADOC_INLINE_TAG_START -> { @ 1124 * | |--TAG_NAME -> custom 1125 * | |--DESCRIPTION -> DESCRIPTION 1126 * | | `--TEXT -> This is a Custom Inline Tag 1127 * | `--JAVADOC_INLINE_TAG_END -> } 1128 * |--TEXT -> . 1129 * } 1130 * 1131 * @see #JAVADOC_INLINE_TAG 1132 */ 1133 public static final int CUSTOM_INLINE_TAG = JavadocCommentsLexer.CUSTOM_INLINE_TAG; 1134 1135 // Components 1136 1137 /** 1138 * Identifier token. 1139 * 1140 * <p><b>Example:</b>{@code * @throws Exception if error.}</p> 1141 * 1142 * <p><b>Tree:</b></p> 1143 * {@snippet lang="text" : 1144 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1145 * |--LEADING_ASTERISK -> * 1146 * |--TEXT -> 1147 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1148 * `--THROWS_BLOCK_TAG -> THROWS_BLOCK_TAG 1149 * |--AT_SIGN -> @ 1150 * |--TAG_NAME -> throws 1151 * |--TEXT -> 1152 * |--IDENTIFIER -> Exception 1153 * `--DESCRIPTION -> DESCRIPTION 1154 * `--TEXT -> if error. 1155 * } 1156 */ 1157 public static final int IDENTIFIER = JavadocCommentsLexer.IDENTIFIER; 1158 1159 /** 1160 * Hash symbol {@code #} used in references within Javadoc. 1161 * 1162 * <p><b>Example:</b>{@code * @see MyClass#myMethod()}</p> 1163 * 1164 * <b>Tree:</b> 1165 * {@snippet lang="text" : 1166 * |--LEADING_ASTERISK -> * 1167 * |--TEXT -> 1168 * |--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1169 * | `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1170 * | |--AT_SIGN -> @ 1171 * | |--TAG_NAME -> see 1172 * | |--TEXT -> 1173 * | `--REFERENCE -> REFERENCE 1174 * | |--IDENTIFIER -> MyClass 1175 * | |--HASH -> # 1176 * | |--IDENTIFIER -> myMethod 1177 * | |--LPAREN -> ( 1178 * | `--RPAREN -> ) 1179 * } 1180 * 1181 * @see #REFERENCE 1182 */ 1183 public static final int HASH = JavadocCommentsLexer.HASH; 1184 1185 /** 1186 * Left parenthesis {@code (} used in references within Javadoc. 1187 * 1188 * <p><b>Example:</b></p> 1189 * <pre>{@code 1190 * * {@link String#length()} 1191 * }</pre> 1192 * 1193 * <b>Tree:</b> 1194 * {@snippet lang="text" : 1195 * |--LEADING_ASTERISK -> * 1196 * |--TEXT -> 1197 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1198 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1199 * |--JAVADOC_INLINE_TAG_START -> {@ 1200 * |--TAG_NAME -> link 1201 * |--TEXT -> 1202 * |--REFERENCE -> REFERENCE 1203 * |--IDENTIFIER -> String 1204 * |--HASH -> # 1205 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1206 * |--IDENTIFIER -> length 1207 * |--LPAREN -> ( 1208 * `--RPAREN -> ) 1209 * `--JAVADOC_INLINE_TAG_END -> } 1210 * } 1211 * 1212 * @see #REFERENCE 1213 */ 1214 public static final int LPAREN = JavadocCommentsLexer.LPAREN; 1215 1216 /** 1217 * Right parenthesis {@code (} used in references within Javadoc. 1218 * 1219 * <p><b>Example:</b></p> 1220 * <pre>{@code 1221 * * {@link String#length()} 1222 * }</pre> 1223 * 1224 * <b>Tree:</b> 1225 * {@snippet lang="text" : 1226 * |--LEADING_ASTERISK -> * 1227 * |--TEXT -> 1228 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1229 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1230 * |--JAVADOC_INLINE_TAG_START -> {@ 1231 * |--TAG_NAME -> link 1232 * |--TEXT -> 1233 * |--REFERENCE -> REFERENCE 1234 * |--IDENTIFIER -> String 1235 * |--HASH -> # 1236 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1237 * |--IDENTIFIER -> length 1238 * |--LPAREN -> ( 1239 * `--RPAREN -> ) 1240 * `--JAVADOC_INLINE_TAG_END -> } 1241 * } 1242 * 1243 * @see #REFERENCE 1244 */ 1245 public static final int RPAREN = JavadocCommentsLexer.RPAREN; 1246 1247 /** 1248 * Comma symbol {@code , }. 1249 * 1250 * <p><b>Example:</b>{@code * @see #method(int, int)}</p> 1251 * 1252 * <p><b>Tree:</b></p> 1253 * {@snippet lang="text" : 1254 * |--LEADING_ASTERISK -> * 1255 * |--TEXT -> 1256 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1257 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1258 * |--AT_SIGN -> @ 1259 * |--TAG_NAME -> see 1260 * |--TEXT -> 1261 * |--REFERENCE -> REFERENCE 1262 * | |--HASH -> # 1263 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1264 * | |--IDENTIFIER -> method 1265 * | |--LPAREN -> ( 1266 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1267 * | | |--PARAMETER_TYPE -> int 1268 * | | |--COMMA -> , 1269 * | | |--TEXT -> 1270 * | | `--PARAMETER_TYPE -> int 1271 * | `--RPAREN -> ) 1272 * } 1273 */ 1274 public static final int COMMA = JavadocCommentsLexer.COMMA; 1275 1276 /** 1277 * Slash symbol {@code /} used in module or package references within Javadoc. 1278 * 1279 * <p><b>Example:</b></p> 1280 * {@snippet lang="text" : 1281 * {@link String}; 1282 * } 1283 * 1284 * <b>Tree:</b> 1285 * {@snippet lang="text" : 1286 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1287 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1288 * |--JAVADOC_INLINE_TAG_START -> {@ 1289 * |--TAG_NAME -> link 1290 * |--TEXT -> 1291 * |--REFERENCE -> REFERENCE 1292 * | |--IDENTIFIER -> java.base 1293 * | |--SLASH -> / 1294 * | `--IDENTIFIER -> java.lang.String 1295 * `--JAVADOC_INLINE_TAG_END -> } 1296 * } 1297 * 1298 * @see #REFERENCE 1299 */ 1300 public static final int SLASH = JavadocCommentsLexer.SLASH; 1301 1302 /** 1303 * Question mark symbol {@code ?} used in generic type wildcards. 1304 * 1305 * <p>This token appears in references that use wildcard type arguments, 1306 * such as {@code ? extends Type} or {@code ? super Type}.</p> 1307 * 1308 * <p><b>Example:</b></p> 1309 * {@snippet lang="text" : 1310 * {@link java.util.List<? extends Number>}; 1311 * } 1312 * 1313 * <b>Tree:</b> 1314 * {@snippet lang="text" : 1315 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1316 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1317 * |--JAVADOC_INLINE_TAG_START -> {@ 1318 * |--TAG_NAME -> link 1319 * |--TEXT -> 1320 * |--REFERENCE -> REFERENCE 1321 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1322 * | |--LT -> < 1323 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1324 * | | |--QUESTION -> ? 1325 * | | |--TEXT -> 1326 * | | |--EXTENDS -> extends 1327 * | | |--TEXT -> 1328 * | | `--IDENTIFIER -> Number 1329 * | `--GT -> > 1330 * `--JAVADOC_INLINE_TAG_END -> } 1331 * } 1332 * 1333 * @see #TYPE_ARGUMENT 1334 */ 1335 public static final int QUESTION = JavadocCommentsLexer.QUESTION; 1336 1337 /** 1338 * Less-than symbol {@code < }. 1339 * 1340 * <p><b>Example:</b>{@code * @see List<String>}</p> 1341 * 1342 * <b>Tree:</b> 1343 * {@snippet lang="text" : 1344 * |--LEADING_ASTERISK -> * 1345 * |--TEXT -> 1346 * |--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1347 * | `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1348 * | |--AT_SIGN -> @ 1349 * | |--TAG_NAME -> see 1350 * | |--TEXT -> 1351 * | `--REFERENCE -> REFERENCE 1352 * | |--IDENTIFIER -> List 1353 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1354 * | |--LT -> < 1355 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1356 * | | `--IDENTIFIER -> String 1357 * | `--GT -> > 1358 * |--NEWLINE -> \n 1359 * `--TEXT -> 1360 * } 1361 */ 1362 public static final int LT = JavadocCommentsLexer.LT; 1363 1364 /** 1365 * Greater-than symbol {@code > }. 1366 * 1367 * <p><b>Example:</b>{@code * @see List<String>}</p> 1368 * 1369 * <b>Tree:</b> 1370 * {@snippet lang="text" : 1371 * |--LEADING_ASTERISK -> * 1372 * |--TEXT -> 1373 * |--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1374 * | `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1375 * | |--AT_SIGN -> @ 1376 * | |--TAG_NAME -> see 1377 * | |--TEXT -> 1378 * | `--REFERENCE -> REFERENCE 1379 * | |--IDENTIFIER -> List 1380 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1381 * | |--LT -> < 1382 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1383 * | | `--IDENTIFIER -> String 1384 * | `--GT -> > 1385 * |--NEWLINE -> \n 1386 * `--Text -> 1387 * } 1388 */ 1389 1390 public static final int GT = JavadocCommentsLexer.GT; 1391 1392 /** 1393 * {@code extends} keyword inside type arguments of a Javadoc inline tag. 1394 * 1395 * <p>This node represents the {@code extends} bound used inside a 1396 * parameterized type within an inline Javadoc tag.</p> 1397 * 1398 * <p><b>Example:</b></p> 1399 * <pre>{@code 1400 * * {@link java.util.List<? extends Number> list of any subtype of Number} 1401 * }</pre> 1402 * 1403 * <b>Tree:</b> 1404 * {@snippet lang="text" : 1405 * |--LEADING_ASTERISK -> * 1406 * |--TEXT -> 1407 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1408 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1409 * |--JAVADOC_INLINE_TAG_START -> { @ 1410 * |--TAG_NAME -> link 1411 * |--TEXT -> 1412 * |--REFERENCE -> REFERENCE 1413 * | |--IDENTIFIER -> java.util.List 1414 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1415 * | |--LT -> < 1416 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1417 * | | |--QUESTION -> ? 1418 * | | |--TEXT -> 1419 * | | |--EXTENDS -> extends 1420 * | | |--TEXT -> 1421 * | | `--IDENTIFIER -> Number 1422 * | `--GT -> > 1423 * |--DESCRIPTION -> DESCRIPTION 1424 * | `--TEXT -> list of any subtype of Number 1425 * `--JAVADOC_INLINE_TAG_END -> } 1426 * } 1427 * 1428 * @see #JAVADOC_INLINE_TAG 1429 */ 1430 public static final int EXTENDS = JavadocCommentsLexer.EXTENDS; 1431 1432 /** 1433 * {@code SUPER} represents the {@code super} keyword inside a generic 1434 * wildcard bound (e.g., {@code ? super Number}). 1435 * 1436 * <p><b>Example:</b> {@code {@link java.util.List <? super Integer> list} 1437 * of any supertype of Integer}</p> 1438 * 1439 * <p><b>Tree:</b></p> 1440 * {@snippet lang="text" : 1441 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1442 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1443 * |--JAVADOC_INLINE_TAG_START -> { @ 1444 * |--TAG_NAME -> link 1445 * |--TEXT -> 1446 * |--REFERENCE -> REFERENCE 1447 * | |--IDENTIFIER -> java.util.List 1448 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1449 * | |--LT -> < 1450 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1451 * | | |--QUESTION -> ? 1452 * | | |--TEXT -> 1453 * | | |--SUPER -> super 1454 * | | |--TEXT -> 1455 * | | `--IDENTIFIER -> Integer 1456 * | `--GT -> > 1457 * |--DESCRIPTION -> DESCRIPTION 1458 * | `--TEXT -> list of any supertype of Integer 1459 * `--JAVADOC_INLINE_TAG_END -> } 1460 * } 1461 * 1462 * @see #PARAMETER_TYPE 1463 */ 1464 public static final int SUPER = JavadocCommentsLexer.SUPER; 1465 1466 /** 1467 * {@code PARAMETER_TYPE} Parameter type reference. 1468 * 1469 * <p>Represents a type used in a method parameter.</p> 1470 * 1471 * <p><b>Example:</b>{@code {@link java.util.List#add(Object)}}</p> 1472 * 1473 * <b>Tree:</b> 1474 * {@snippet lang="text" : 1475 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1476 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1477 * |--JAVADOC_INLINE_TAG_START -> {@ 1478 * |--TAG_NAME -> link 1479 * |--REFERENCE -> REFERENCE 1480 * | |--IDENTIFIER -> List 1481 * | |--HASH -> # 1482 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1483 * | |--IDENTIFIER -> add 1484 * | |--LPAREN -> ( 1485 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1486 * | | `--PARAMETER_TYPE -> Object 1487 * | `--RPAREN -> ) 1488 * `--JAVADOC_INLINE_TAG_END -> } 1489 * } 1490 * 1491 * @see #REFERENCE 1492 */ 1493 public static final int PARAMETER_TYPE = JavadocCommentsLexer.PARAMETER_TYPE; 1494 1495 /** 1496 * {@code REFERENCE} General reference within Javadoc. 1497 * 1498 * <p>Represents the target of an inline reference tag such as 1499 * {@code {@link String#length()}}.</p> 1500 * 1501 * <p><b>Example:</b></p> 1502 * {@snippet lang="text" : 1503 * {@link String#length()} 1504 * } 1505 * 1506 * <b>Tree:</b> 1507 * {@snippet lang="text" : 1508 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1509 * |--LINK_INLINE_TAG -> LINK_INLINE_TAG 1510 * | |--JAVADOC_INLINE_TAG_START -> {@ 1511 * | |--TAG_NAME -> link 1512 * | |--REFERENCE -> String#length() 1513 * `--JAVADOC_INLINE_TAG_END -> } 1514 * } 1515 * 1516 * @see #JAVADOC_INLINE_TAG 1517 */ 1518 public static final int REFERENCE = JavadocCommentsLexer.REFERENCE; 1519 1520 /** 1521 * {@code MEMBER_REFERENCE} Member reference (method or field). 1522 * 1523 * <p>Represents a field or method in a type reference.</p> 1524 * 1525 * <p><b>Example:</b></p> 1526 * {@snippet lang="text" : 1527 * {@link String#length()} 1528 * } 1529 * 1530 * <p><b>Tree:</b></p> 1531 * {@snippet lang="text" : 1532 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1533 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1534 * |--JAVADOC_INLINE_TAG_START -> {@ 1535 * |--TAG_NAME -> link 1536 * |--TEXT -> 1537 * |--REFERENCE -> REFERENCE 1538 * | |--IDENTIFIER -> String 1539 * | |--HASH -> # 1540 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1541 * | |--IDENTIFIER -> length 1542 * | |--LPAREN -> ( 1543 * | `--RPAREN -> ) 1544 * `--JAVADOC_INLINE_TAG_END -> } 1545 * } 1546 * 1547 * @see #REFERENCE 1548 */ 1549 public static final int MEMBER_REFERENCE = JavadocCommentsLexer.MEMBER_REFERENCE; 1550 1551 /** 1552 * {@code PARAMETER_TYPE_LIST} represents the list of parameter types inside a 1553 * member reference within a Javadoc inline {@code @link} tag. 1554 * 1555 * <p><b>Example:</b></p> 1556 * {@snippet lang="text" : 1557 * {@link Math#max(int, int)} 1558 * } 1559 * 1560 * <p><b>Tree:</b></p> 1561 * {@snippet lang="text" : 1562 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1563 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1564 * |--JAVADOC_INLINE_TAG_START -> {\@ 1565 * |--TAG_NAME -> link 1566 * |--TEXT -> 1567 * |--REFERENCE -> REFERENCE 1568 * | |--IDENTIFIER -> Math 1569 * | |--HASH -> # 1570 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1571 * | |--IDENTIFIER -> max 1572 * | |--LPAREN -> ( 1573 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1574 * | | |--PARAMETER_TYPE -> int 1575 * | | |--COMMA -> , 1576 * | | |--TEXT -> 1577 * | | `--PARAMETER_TYPE -> int 1578 * | `--RPAREN -> ) 1579 * `--JAVADOC_INLINE_TAG_END -> } 1580 * } 1581 * 1582 * @see #PARAMETER_TYPE 1583 */ 1584 public static final int PARAMETER_TYPE_LIST = JavadocCommentsLexer.PARAMETER_TYPE_LIST; 1585 1586 /** 1587 * {@code TYPE_ARGUMENTS} Type arguments in generics. 1588 * 1589 * <p>Represents the type arguments inside a generic type reference.</p> 1590 * 1591 * <p><b>Example:</b>{@code {@link java.util.List<String>}}</p> 1592 * 1593 * <p><b>Tree:</b></p> 1594 * {@snippet lang="text" : 1595 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1596 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1597 * |--JAVADOC_INLINE_TAG_START -> {@ 1598 * |--TAG_NAME -> link 1599 * |--TEXT -> 1600 * |--REFERENCE -> REFERENCE 1601 * | |--IDENTIFIER -> java.util.List 1602 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1603 * | |--LT -> < 1604 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1605 * | | `--IDENTIFIER -> String 1606 * | `--GT -> > 1607 * `--JAVADOC_INLINE_TAG_END -> } 1608 * } 1609 * 1610 * @see #TYPE_ARGUMENT 1611 */ 1612 public static final int TYPE_ARGUMENTS = JavadocCommentsLexer.TYPE_ARGUMENTS; 1613 1614 /** 1615 * Single type argument in generics. 1616 * 1617 * <p>This node represents one individual type inside a generic type 1618 * argument list.</p> 1619 * 1620 * <p><b>Example:</b></p> 1621 * {@snippet lang="text" : 1622 * {@link java.util.List<String>} 1623 * } 1624 * 1625 * <p><b>Tree:</b></p> 1626 * {@snippet lang="text" : 1627 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1628 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1629 * |--JAVADOC_INLINE_TAG_START -> {@ 1630 * |--TAG_NAME -> link 1631 * |--TEXT -> 1632 * |--REFERENCE -> REFERENCE 1633 * |--IDENTIFIER -> java.util.List 1634 * `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1635 * |--LT -> < 1636 * |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1637 * | `--IDENTIFIER -> String 1638 * `--GT -> > 1639 * `--JAVADOC_INLINE_TAG_END -> } 1640 * } 1641 * 1642 * @see #TYPE_ARGUMENTS 1643 */ 1644 public static final int TYPE_ARGUMENT = JavadocCommentsLexer.TYPE_ARGUMENT; 1645 1646 /** 1647 * Description part of a Javadoc tag. 1648 * 1649 * <p><b>Example:</b>{@code * @param value The parameter description goes here.}</p> 1650 * 1651 * <p><b>Tree:</b></p> 1652 * {@snippet lang="text" : 1653 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 1654 * |--AT_SIGN -> @ 1655 * |--TAG_NAME -> param 1656 * |--TEXT -> 1657 * |--PARAMETER_NAME -> value 1658 * `--DESCRIPTION -> DESCRIPTION 1659 * `--TEXT -> The parameter description goes here. 1660 * } 1661 */ 1662 public static final int DESCRIPTION = JavadocCommentsLexer.DESCRIPTION; 1663 1664 /** 1665 * Format specifier inside a {@code {@value}} inline tag. 1666 * The {@value} tag is used to display the value of a constant directly 1667 * within the Javadoc documentation. In newer Java versions (20+), there 1668 * is ability include a format string inside the tag. 1669 * 1670 * <p>In this example, the format specifier {@code 0x%04x} is used to format the integer 1671 * {@code Modifier#PUBLIC} as a hexadecimal value, padded with zeros to a width of four 1672 * characters.</p> 1673 * {@snippet lang="text" : 1674 * {@value %04x java.lang.reflect.Modifier#PUBLIC} 1675 * } 1676 * 1677 * <p><b>Tree:</b></p> 1678 * {@snippet lang="text" : 1679 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1680 * `--VALUE_INLINE_TAG -> VALUE_INLINE_TAG 1681 * |--JAVADOC_INLINE_TAG_START -> {@ 1682 * |--TAG_NAME -> value 1683 * |--TEXT -> 1684 * |--FORMAT_SPECIFIER -> %04x 1685 * |--TEXT -> 1686 * |--REFERENCE -> REFERENCE 1687 * | |--IDENTIFIER -> java.lang.reflect.Modifier 1688 * | |--HASH -> # 1689 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1690 * | `--IDENTIFIER -> PUBLIC 1691 * `--JAVADOC_INLINE_TAG_END -> } 1692 * } 1693 * 1694 * @see #VALUE_INLINE_TAG 1695 */ 1696 public static final int FORMAT_SPECIFIER = JavadocCommentsLexer.FORMAT_SPECIFIER; 1697 1698 /** 1699 * Attribute name in a {@code @snippet} tag. 1700 * 1701 * <p> 1702 * <b>Note:</b> In the current Checkstyle AST, all snippet attributes (such as 1703 * {@code lang=java}) appear as plain text under the {@code DESCRIPTION} node. 1704 * There is <b>no</b> {@code SNIPPET_ATTR_NAME} node in the AST tree. 1705 * All attribute content is represented as {@code TEXT}.</p> 1706 * 1707 * <p> 1708 * <b>Example:</b> 1709 * {@code * @snippet lang=java} 1710 * </p> 1711 * 1712 * <p> 1713 * <b>Tree:</b> 1714 * </p> 1715 * {@snippet lang="text" : 1716 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1717 * |--LEADING_ASTERISK -> * 1718 * |--TEXT -> 1719 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1720 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1721 * |--AT_SIGN -> @ 1722 * |--TAG_NAME -> snippet 1723 * `--DESCRIPTION -> DESCRIPTION 1724 * `--TEXT -> lang=java 1725 * } 1726 * 1727 * @see #SNIPPET_ATTRIBUTE 1728 */ 1729 public static final int SNIPPET_ATTR_NAME = JavadocCommentsLexer.SNIPPET_ATTR_NAME; 1730 1731 /** 1732 * Equals sign {@code =}. 1733 * 1734 * <p>Used within snippet attributes to assign values.</p> 1735 * 1736 * <p><b>Example:</b></p> 1737 * {@snippet lang="text" : 1738 * { @snippet lang="java" : 1739 * int x = 1; 1740 * } 1741 * } 1742 * 1743 * <p><b>Tree:</b></p> 1744 * {@snippet lang="text" : 1745 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1746 * `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 1747 * |--JAVADOC_INLINE_TAG_START -> {@ 1748 * |--SNIPPET_ATTRIBUTES -> SNIPPET_ATTRIBUTES 1749 * | `--SNIPPET_ATTRIBUTE -> SNIPPET_ATTRIBUTE 1750 * | |--TEXT -> 1751 * | |--SNIPPET_ATTR_NAME -> lang 1752 * | |--EQUALS -> = 1753 * | `--ATTRIBUTE_VALUE -> "java" 1754 * |--COLON -> : 1755 * |--SNIPPET_BODY -> SNIPPET_BODY 1756 * | |--NEWLINE -> \n 1757 * | |--TEXT -> int x = 1; 1758 * | |--NEWLINE -> \r\n 1759 * `--JAVADOC_INLINE_TAG_END -> } 1760 * } 1761 * 1762 * @see #SNIPPET_ATTRIBUTE 1763 * @see #SNIPPET_ATTRIBUTES 1764 */ 1765 public static final int EQUALS = JavadocCommentsLexer.EQUALS; 1766 1767 /** 1768 * {@code ATTRIBUTE_VALUE} Value assigned to an attribute. 1769 * 1770 * <p><b>Example:</b>{@code <a href="example">text</a>}</p> 1771 * 1772 * <p><b>Tree:</b></p> 1773 * {@snippet lang="text" : 1774 * HTML_ELEMENT -> HTML_ELEMENT 1775 * |--HTML_TAG_START -> HTML_TAG_START 1776 * | |--TAG_OPEN -> < 1777 * | |--TAG_NAME -> a 1778 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1779 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1780 * | | |--TEXT -> 1781 * | | |--TAG_ATTR_NAME -> href 1782 * | | |--EQUALS -> = 1783 * | | `--ATTRIBUTE_VALUE -> "example" 1784 * | `--TAG_CLOSE -> > 1785 * |--HTML_CONTENT -> HTML_CONTENT 1786 * | `--TEXT -> text 1787 * `--HTML_TAG_END -> HTML_TAG_END 1788 * |--TAG_OPEN -> < 1789 * |--TAG_SLASH -> / 1790 * |--TAG_NAME -> a 1791 * `--TAG_CLOSE -> > 1792 * } 1793 * 1794 * @see #HTML_ATTRIBUTE 1795 * @see #TAG_ATTR_NAME 1796 */ 1797 public static final int ATTRIBUTE_VALUE = JavadocCommentsLexer.ATTRIBUTE_VALUE; 1798 1799 /** 1800 * Colon symbol {@code : }. 1801 * 1802 * <p><b>Example:</b>{@code * {@snippet :config}}</p> 1803 * 1804 * <p><b>Tree:</b></p> 1805 * {@snippet lang="text" : 1806 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1807 * |--TEXT -> /** 1808 * |--NEWLINE -> \n 1809 * |--LEADING_ASTERISK -> * 1810 * |--TEXT -> 1811 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1812 * | `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 1813 * | |--JAVADOC_INLINE_TAG_START -> {@ 1814 * | |--COLON -> : 1815 * | |--SNIPPET_BODY -> SNIPPET_BODY 1816 * | | `--TEXT -> config 1817 * | `--JAVADOC_INLINE_TAG_END -> } 1818 * |--NEWLINE -> \n 1819 * |--LEADING_ASTERISK -> * 1820 * |--TEXT -> / 1821 * |--NEWLINE -> \n 1822 * `--TEXT -> class Test {} 1823 * } 1824 * 1825 * @see #SNIPPET_INLINE_TAG 1826 */ 1827 public static final int COLON = JavadocCommentsLexer.COLON; 1828 1829 /** 1830 * Term used in {@code {@index}} tag. 1831 * 1832 * <p>This node represents the term inside an inline {@code {@index ...}} tag in Javadoc.</p> 1833 * 1834 * <p> 1835 * <b>Example:</b> 1836 * {@code * Example showing {@index keyword description of the index term}.} 1837 * </p> 1838 * 1839 * <b>Tree:</b> 1840 * {@snippet lang="text" : 1841 * |--LEADING_ASTERISK -> * 1842 * |--TEXT -> Example showing 1843 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1844 * `--INDEX_INLINE_TAG -> INDEX_INLINE_TAG 1845 * |--JAVADOC_INLINE_TAG_START -> { @ 1846 * |--TAG_NAME -> index 1847 * |--TEXT -> 1848 * |--INDEX_TERM -> keyword 1849 * |--DESCRIPTION -> DESCRIPTION 1850 * | `--TEXT -> description of the index term 1851 * `--JAVADOC_INLINE_TAG_END -> } 1852 * |--TEXT -> . 1853 * } 1854 * 1855 * @see #JAVADOC_INLINE_TAG 1856 */ 1857 public static final int INDEX_TERM = JavadocCommentsLexer.INDEX_TERM; 1858 1859 /** 1860 * Single attribute in a {@code @snippet} tag. 1861 * 1862 * <p> 1863 * Represents a single attribute (e.g., {@code lang=java}) 1864 * in a {@code @snippet} tag.</p> 1865 * 1866 * <p><b>Note:</b> In the current Checkstyle AST, all snippet 1867 * attributes appear as plain text under the {@code DESCRIPTION} node, 1868 * not as a separate {@code SNIPPET_ATTRIBUTE} node.</p> 1869 * 1870 * <p><b>Example:</b>{@code * @snippet lang=java}</p> 1871 * 1872 * <p><b>Tree:</b></p> 1873 * {@snippet lang="text" : 1874 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1875 * |--LEADING_ASTERISK -> * 1876 * |--TEXT -> 1877 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1878 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1879 * |--AT_SIGN -> @ 1880 * |--TAG_NAME -> snippet 1881 * `--DESCRIPTION -> DESCRIPTION 1882 * `--TEXT -> lang=java 1883 * } 1884 */ 1885 public static final int SNIPPET_ATTRIBUTE = JavadocCommentsLexer.SNIPPET_ATTRIBUTE; 1886 1887 /** 1888 * Collection of attributes in a {@code @snippet} tag. 1889 * 1890 * <p> 1891 * Represents all attributes (e.g., {@code lang=java region=main}) in a {@code @snippet} tag. 1892 * </p> 1893 * 1894 * <p><b>Note:</b> In the current Checkstyle AST, all snippet attributes appear as 1895 * plain text under the {@code DESCRIPTION} node, not as a separate 1896 * {@code SNIPPET_ATTRIBUTES} node.</p> 1897 * 1898 * <p><b>Example:</b>{@code * @snippet lang=java region=main}</p> 1899 * 1900 * <p><b>Tree:</b></p> 1901 * {@snippet lang="text" : 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 region=main 1911 * } 1912 */ 1913 public static final int SNIPPET_ATTRIBUTES = JavadocCommentsLexer.SNIPPET_ATTRIBUTES; 1914 1915 /** 1916 * Body content of a {@code @snippet} tag. 1917 * 1918 * <p> 1919 * Represents the code or text content inside a {@code @snippet} tag in Javadoc. 1920 * </p> 1921 * 1922 * <b>Example:</b> 1923 * 1924 * <p>{@code * @snippet lang=java * System.out.println("hello");}</p> 1925 * 1926 * <b>Tree:</b> 1927 * {@snippet lang="text" : 1928 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1929 * |--LEADING_ASTERISK -> * 1930 * |--TEXT -> 1931 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1932 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1933 * |--AT_SIGN -> @ 1934 * |--TAG_NAME -> snippet 1935 * `--DESCRIPTION -> DESCRIPTION 1936 * |--TEXT -> lang=java 1937 * |--NEWLINE -> \n 1938 * |--LEADING_ASTERISK -> * 1939 * `--TEXT -> System.out.println("hello"); 1940 * } 1941 */ 1942 public static final int SNIPPET_BODY = JavadocCommentsLexer.SNIPPET_BODY; 1943 1944 /** 1945 * Field type reference in a Javadoc. 1946 * 1947 * <p>Example:</p> 1948 * <pre> 1949 * /** 1950 * * @serialField counter int The counter. 1951 * */ 1952 * </pre> 1953 * 1954 * <b>Tree:</b> 1955 * {@snippet lang="text" : 1956 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1957 * |--TEXT -> /** 1958 * |--NEWLINE -> \n 1959 * |--LEADING_ASTERISK -> * 1960 * |--TEXT -> 1961 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1962 * `--SERIAL_FIELD_BLOCK_TAG -> SERIAL_FIELD_BLOCK_TAG 1963 * |--AT_SIGN -> @ 1964 * |--TAG_NAME -> serialField 1965 * |--TEXT -> 1966 * |--IDENTIFIER -> counter 1967 * |--TEXT -> 1968 * |--FIELD_TYPE -> int 1969 * `--DESCRIPTION -> DESCRIPTION 1970 * |--TEXT -> The counter. 1971 * |--NEWLINE -> \n 1972 * |--LEADING_ASTERISK -> * 1973 * `--TEXT -> / 1974 * } 1975 * 1976 * @see #FIELD_TYPE 1977 */ 1978 public static final int FIELD_TYPE = JavadocCommentsLexer.FIELD_TYPE; 1979 1980 /** 1981 * Parameter name reference in a Javadoc {@code @param} block tag. 1982 * 1983 * <p><b>Example:</b>{@code * @param value The parameter of method.}</p> 1984 * 1985 * <b>Tree:</b> 1986 * {@snippet lang="text" : 1987 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1988 * |--LEADING_ASTERISK -> * 1989 * |--TEXT -> 1990 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1991 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 1992 * |--AT_SIGN -> @ 1993 * |--TAG_NAME -> param 1994 * |--TEXT -> 1995 * |--PARAMETER_NAME -> value 1996 * `--DESCRIPTION -> DESCRIPTION 1997 * `--TEXT -> The parameter of method. 1998 * } 1999 * 2000 * @see #PARAM_BLOCK_TAG 2001 */ 2002 public static final int PARAMETER_NAME = JavadocCommentsLexer.PARAMETER_NAME; 2003 2004 /** 2005 * String literal inside Javadoc. 2006 * 2007 * <p>Example in Javadoc:</p> 2008 * 2009 * {@snippet lang="text" : 2010 * {@see "foo"} 2011 * } 2012 * 2013 * <p>Tree:</p> 2014 * 2015 * {@snippet lang="text" : 2016 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 2017 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 2018 * |--AT_SIGN -> @ 2019 * |--TAG_NAME -> see 2020 * |--TEXT -> 2021 * `--STRING_LITERAL -> "foo" 2022 * } 2023 */ 2024 public static final int STRING_LITERAL = JavadocCommentsLexer.STRING_LITERAL; 2025 2026 // HTML 2027 2028 /** 2029 * General HTML element in a Javadoc comment. 2030 * 2031 * <p><b>Example:</b></p> 2032 * <pre>{@code 2033 * /** 2034 * * <p>Hello</p> 2035 * * / 2036 * }</pre> 2037 * 2038 * <b>Tree:</b> 2039 * {@snippet lang="text" : 2040 * JAVADOC_CONTENT -> JAVADOC_CONTENT 2041 * |--LEADING_ASTERISK -> * 2042 * |--TEXT -> 2043 * |--HTML_ELEMENT -> HTML_ELEMENT 2044 * | |--HTML_TAG_START -> HTML_TAG_START 2045 * | | |--TAG_OPEN -> < 2046 * | | |--TAG_NAME -> p 2047 * | | `--TAG_CLOSE -> > 2048 * | |--HTML_CONTENT -> HTML_CONTENT 2049 * | | `--TEXT -> Hello 2050 * | `--HTML_TAG_END -> HTML_TAG_END 2051 * | |--TAG_OPEN -> < 2052 * | |--TAG_SLASH -> / 2053 * | |--TAG_NAME -> p 2054 * | `--TAG_CLOSE -> > 2055 * |--NEWLINE -> \n 2056 * |--LEADING_ASTERISK -> * 2057 * |--TEXT -> / 2058 * } 2059 */ 2060 public static final int HTML_ELEMENT = JavadocCommentsLexer.HTML_ELEMENT; 2061 2062 /** 2063 * Void HTML element (self-closing). 2064 * 2065 * <p>Example in Javadoc: {@code <br>}</p> 2066 * 2067 * <p>Tree:</p> 2068 * {@snippet lang="text" : 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 * } 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 * {@snippet lang="text" : 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 * } 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>{@code <input type="text">}</p> 2121 * 2122 * <b>Tree:</b> 2123 * {@snippet lang="text" : 2124 * HTML_ELEMENT -> HTML_ELEMENT 2125 * `--VOID_ELEMENT -> VOID_ELEMENT 2126 * `--HTML_TAG_START -> HTML_TAG_START 2127 * |--TAG_OPEN -> < 2128 * |--TAG_NAME -> input 2129 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2130 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2131 * | |--TEXT -> 2132 * | |--TAG_ATTR_NAME -> type 2133 * | |--EQUALS -> = 2134 * | `--ATTRIBUTE_VALUE -> "text" 2135 * `--TAG_CLOSE -> > 2136 * } 2137 * 2138 * @see #HTML_ATTRIBUTES 2139 */ 2140 public static final int HTML_ATTRIBUTE = JavadocCommentsLexer.HTML_ATTRIBUTE; 2141 2142 /** 2143 * {@code HTML_ATTRIBUTES} represents a collection of HTML attributes inside an HTML tag. 2144 * 2145 * <p>Appears in Javadoc comments when documenting HTML elements that contain 2146 * multiple attributes.</p> 2147 * 2148 * <p><b>Example:</b>{@code <div lang="en" custom-attr="value"></div>}</p> 2149 * 2150 * <p><b>Tree:</b></p> 2151 * {@snippet lang="text" : 2152 * HTML_ELEMENT -> HTML_ELEMENT 2153 * |--HTML_TAG_START -> HTML_TAG_START 2154 * | |--TAG_OPEN -> < 2155 * | |--TAG_NAME -> div 2156 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2157 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2158 * | | | |--TEXT -> 2159 * | | | |--TAG_ATTR_NAME -> lang 2160 * | | | |--EQUALS -> = 2161 * | | | `--ATTRIBUTE_VALUE -> "en" 2162 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2163 * | | |--TEXT -> 2164 * | | |--TAG_ATTR_NAME -> custom-attr 2165 * | | |--EQUALS -> = 2166 * | | `--ATTRIBUTE_VALUE -> "value" 2167 * | `--TAG_CLOSE -> > 2168 * } 2169 * 2170 * @see #HTML_ATTRIBUTE 2171 */ 2172 public static final int HTML_ATTRIBUTES = JavadocCommentsLexer.HTML_ATTRIBUTES; 2173 2174 /** 2175 * Start of an HTML tag (the opening tag node). 2176 * 2177 * <p>This node represents the opening part of an HTML element and contains 2178 * the opening delimiter, tag name, optional attributes, and the closing 2179 * delimiter of the opening tag.</p> 2180 * 2181 * <p><b>Example:</b>{@code * <a href="https://example.com">link</a>}</p> 2182 * 2183 * <b>Tree:</b> 2184 * {@snippet lang="text" : 2185 * |--LEADING_ASTERISK -> * 2186 * `--HTML_ELEMENT -> HTML_ELEMENT 2187 * `--HTML_TAG_START -> HTML_TAG_START 2188 * |--TAG_OPEN -> < 2189 * |--TAG_NAME -> a 2190 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2191 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2192 * | |--TEXT -> 2193 * | |--TAG_ATTR_NAME -> href 2194 * | |--EQUALS -> = 2195 * | `--ATTRIBUTE_VALUE -> "https://example.com" 2196 * `--TAG_CLOSE -> > 2197 * } 2198 * 2199 * @see #HTML_ELEMENT 2200 */ 2201 2202 public static final int HTML_TAG_START = JavadocCommentsLexer.HTML_TAG_START; 2203 2204 /** 2205 * End of an HTML tag (the closing tag node). 2206 * 2207 * <p>This node represents the closing part of an HTML element and contains the 2208 * closing delimiter, optional slash, and the tag name.</p> 2209 * 2210 * <p><b>Example:</b>{@code * <a href="https://example.com">link</a>}</p> 2211 * 2212 * <b>Tree:</b> 2213 * {@snippet lang="text" : 2214 * |--LEADING_ASTERISK -> * 2215 * `--HTML_ELEMENT -> HTML_ELEMENT 2216 * |--HTML_TAG_START -> HTML_TAG_START 2217 * | |--TAG_OPEN -> < 2218 * | |--TAG_NAME -> a 2219 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2220 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2221 * | | |--TEXT -> (whitespace) 2222 * | | |--TAG_ATTR_NAME -> href 2223 * | | |--EQUALS -> = 2224 * | | `--ATTRIBUTE_VALUE -> "https://example.com" 2225 * | `--TAG_CLOSE -> > 2226 * |--HTML_CONTENT -> HTML_CONTENT 2227 * | `--TEXT -> link 2228 * `--HTML_TAG_END -> HTML_TAG_END 2229 * |--TAG_OPEN -> < 2230 * |--TAG_SLASH -> / 2231 * |--TAG_NAME -> a 2232 * `--TAG_CLOSE -> > 2233 * } 2234 * 2235 * @see #HTML_ELEMENT 2236 */ 2237 2238 public static final int HTML_TAG_END = JavadocCommentsLexer.HTML_TAG_END; 2239 2240 /** 2241 * Represents the opening {@literal "<"} symbol of an HTML start tag. 2242 * 2243 * <p><b>Example:</b>{@code <div class="container" lang="en"></div>}</p> 2244 * 2245 * <b>Tree:</b> 2246 * {@snippet lang="text" : 2247 * HTML_ELEMENT -> HTML_ELEMENT 2248 * |--HTML_TAG_START -> HTML_TAG_START 2249 * | |--TAG_OPEN -> < 2250 * | |--TAG_NAME -> div 2251 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2252 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2253 * | | | |--TAG_ATTR_NAME -> class 2254 * | | | |--EQUALS -> = 2255 * | | | `--ATTRIBUTE_VALUE -> "container" 2256 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2257 * | | |--TAG_ATTR_NAME -> lang 2258 * | | |--EQUALS -> = 2259 * | | `--ATTRIBUTE_VALUE -> "en" 2260 * | `--TAG_CLOSE -> > 2261 * `--HTML_TAG_END -> HTML_TAG_END 2262 * |--TAG_OPEN -> < 2263 * |--TAG_SLASH -> / 2264 * |--TAG_NAME -> div 2265 * `--TAG_CLOSE -> > 2266 * } 2267 * 2268 * @see #HTML_TAG_START 2269 */ 2270 public static final int TAG_OPEN = JavadocCommentsLexer.TAG_OPEN; 2271 2272 /** 2273 * {@code TAG_NAME} Name of an HTML element. 2274 * 2275 * <p>Appears inside an HTML tag within Javadoc comments.</p> 2276 * 2277 * <p><b>Example: </b>{@code <div class="container">Content</div>}</p> 2278 * 2279 * <b>Tree:</b> 2280 * {@snippet lang="text" : 2281 * HTML_ELEMENT -> HTML_ELEMENT 2282 * |--HTML_TAG_START -> HTML_TAG_START 2283 * | |--TAG_OPEN -> < 2284 * | |--TAG_NAME -> div 2285 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2286 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2287 * | | |--TAG_ATTR_NAME -> class 2288 * | | |--EQUALS -> = 2289 * | | `--ATTRIBUTE_VALUE -> "container" 2290 * | `--TAG_CLOSE -> > 2291 * |--HTML_CONTENT -> HTML_CONTENT 2292 * | `--TEXT -> Content 2293 * `--HTML_TAG_END -> HTML_TAG_END 2294 * |--TAG_OPEN -> < 2295 * |--TAG_SLASH -> / 2296 * |--TAG_NAME -> div 2297 * `--TAG_CLOSE -> > 2298 * } 2299 * 2300 * <p>Here {@code TAG_NAME} corresponds to {@code "div"}.</p> 2301 */ 2302 public static final int TAG_NAME = JavadocCommentsLexer.TAG_NAME; 2303 2304 /** 2305 * {@code TAG_CLOSE} represents the closing {@literal ">"} symbol of an HTML tag. 2306 * 2307 * <p>Appears in Javadoc comments when documenting HTML elements.</p> 2308 * 2309 * <p><b>Example:</b>{@code <p>Some text</p>}</p> 2310 * 2311 * <b>Tree:</b> 2312 * {@snippet lang="text" : 2313 * HTML_ELEMENT -> HTML_ELEMENT 2314 * |--HTML_TAG_START -> HTML_TAG_START 2315 * | |--TAG_OPEN -> < 2316 * | |--TAG_NAME -> p 2317 * | `--TAG_CLOSE -> > 2318 * |--HTML_CONTENT -> HTML_CONTENT 2319 * | `--TEXT -> Some text 2320 * `--HTML_TAG_END -> HTML_TAG_END 2321 * |--TAG_OPEN -> < 2322 * |--TAG_SLASH -> / 2323 * |--TAG_NAME -> p 2324 * `--TAG_CLOSE -> > 2325 * } 2326 * 2327 * @see #HTML_TAG_START 2328 */ 2329 public static final int TAG_CLOSE = JavadocCommentsLexer.TAG_CLOSE; 2330 2331 /** 2332 * {@code />} Self-closing tag delimiter. 2333 * 2334 * <p>Used for void HTML elements.</p> 2335 * 2336 * <p><b>Example:</b>{@code * <br />}</p> 2337 * 2338 * <b>Tree:</b> 2339 * {@snippet lang="text" : 2340 * VOID_ELEMENT -> VOID_ELEMENT 2341 * |--TAG_OPEN -> < 2342 * |--TAG_NAME -> br 2343 * `--TAG_SLASH_CLOSE -> /> 2344 * } 2345 * 2346 * @see #HTML_ELEMENT 2347 */ 2348 public static final int TAG_SLASH_CLOSE = JavadocCommentsLexer.TAG_SLASH_CLOSE; 2349 2350 /** 2351 * {@code TAG_SLASH} represents the slash {@literal "/"} used inside an HTML closing tag. 2352 * 2353 * <p>Appears in Javadoc comments when closing HTML elements.</p> 2354 * 2355 * <p><b>Example: </b>{@code <p>Paragraph text</p>}</p> 2356 * 2357 * <b>Tree:</b> 2358 * {@snippet lang="text" : 2359 * HTML_ELEMENT -> HTML_ELEMENT 2360 * |--HTML_TAG_START -> HTML_TAG_START 2361 * | |--TAG_OPEN -> < 2362 * | |--TAG_NAME -> p 2363 * | `--TAG_CLOSE -> > 2364 * |--HTML_CONTENT -> HTML_CONTENT 2365 * | `--TEXT -> Paragraph text 2366 * `--HTML_TAG_END -> HTML_TAG_END 2367 * |--TAG_OPEN -> < 2368 * |--TAG_SLASH -> / 2369 * |--TAG_NAME -> p 2370 * `--TAG_CLOSE -> > 2371 * } 2372 * 2373 * @see #HTML_TAG_END 2374 */ 2375 public static final int TAG_SLASH = JavadocCommentsLexer.TAG_SLASH; 2376 2377 /** 2378 * {@code TAG_ATTR_NAME} represents the name of an attribute inside an 2379 * HTML element within a Javadoc comment. 2380 * 2381 * <p><b>Example: </b>{@code <img src="logo.png" alt="Site logo">}</p> 2382 * 2383 * <p><b>Tree:</b></p> 2384 * {@snippet lang="text" : 2385 * HTML_ELEMENT -> HTML_ELEMENT 2386 * `--VOID_ELEMENT -> VOID_ELEMENT 2387 * `--HTML_TAG_START -> HTML_TAG_START 2388 * |--TAG_OPEN -> < 2389 * |--TAG_NAME -> img 2390 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2391 * | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2392 * | | |--TEXT -> 2393 * | | |--TAG_ATTR_NAME -> src 2394 * | | |--EQUALS -> = 2395 * | | `--ATTRIBUTE_VALUE -> "logo.png" 2396 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2397 * | |--TEXT -> 2398 * | |--TAG_ATTR_NAME -> alt 2399 * | |--EQUALS -> = 2400 * | `--ATTRIBUTE_VALUE -> "Site logo" 2401 * `--TAG_CLOSE -> > 2402 * } 2403 * 2404 * @see #HTML_ATTRIBUTES 2405 */ 2406 public static final int TAG_ATTR_NAME = JavadocCommentsLexer.TAG_ATTR_NAME; 2407 2408 /** 2409 * Start of an HTML comment node. 2410 * 2411 * <p>This node represents a full HTML comment inside Javadoc.</p> 2412 * 2413 * <p>This node has three children:</p> 2414 * <ol> 2415 * <li>{@link #HTML_COMMENT_START}</li> 2416 * <li>{@link #HTML_COMMENT_CONTENT}</li> 2417 * <li>{@link #HTML_COMMENT_END}</li> 2418 * </ol> 2419 * 2420 * <p><b>Example:</b>{@code * <!-- Hello World! -->}</p> 2421 * 2422 * <b>Tree:</b> 2423 * {@snippet lang="text ": 2424 * JAVADOC_CONTENT -> JAVADOC_CONTENT 2425 * |--TEXT -> /** 2426 * |--NEWLINE -> \r\n 2427 * |--LEADING_ASTERISK -> * 2428 * |--TEXT -> 2429 * |--HTML_COMMENT -> HTML_COMMENT 2430 * |--HTML_COMMENT_START -> <!-- 2431 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 2432 * | `--TEXT -> Hello World! 2433 * `--HTML_COMMENT_END -> --> 2434 * |--NEWLINE -> \r\n 2435 * |--LEADING_ASTERISK -> * 2436 * |--TEXT -> / 2437 * } 2438 * 2439 * @see #HTML_COMMENT 2440 */ 2441 public static final int HTML_COMMENT = JavadocCommentsLexer.HTML_COMMENT; 2442 2443 /** 2444 * {@code HTML_COMMENT_START} represents the beginning of an HTML comment, 2445 * i.e., the {@literal "<!--"} sequence inside a Javadoc comment. 2446 * 2447 * <p>HTML comments occasionally appear in Javadoc to add internal notes or 2448 * explanations without affecting the rendered output.</p> 2449 * Example: {@code <!-- Note: This method is for demonstration purposes only. -->} 2450 * 2451 * <p><b>Tree:</b></p> 2452 * {@snippet lang="text ": 2453 * HTML_COMMENT -> HTML_COMMENT 2454 * |--HTML_COMMENT_START -> <!-- 2455 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 2456 * | `--TEXT -> Note: This method is for demonstration purposes only. 2457 * `--HTML_COMMENT_END -> --> 2458 * } 2459 * 2460 * @see #HTML_COMMENT_END 2461 */ 2462 public static final int HTML_COMMENT_START = JavadocCommentsLexer.HTML_COMMENT_START; 2463 2464 /** 2465 * Closing part of an HTML comment. 2466 * 2467 * <p>This node represents the closing delimiter of an HTML comment in 2468 * Javadoc (for example {@code -->}).</p> 2469 * 2470 * <p><b>Example:</b>{@code * <!-- hidden comment -->}</p> 2471 * 2472 * <b>Tree:</b> 2473 * {@snippet lang="text ": 2474 * |--LEADING_ASTERISK -> * 2475 * |--TEXT -> 2476 * |--HTML_COMMENT -> HTML_COMMENT 2477 * | |--HTML_COMMENT_START -> <!-- 2478 * | |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 2479 * | | `--TEXT -> hidden comment 2480 * | `--HTML_COMMENT_END -> --> 2481 * } 2482 * 2483 * @see #HTML_COMMENT 2484 */ 2485 2486 public static final int HTML_COMMENT_END = JavadocCommentsLexer.HTML_COMMENT_END; 2487 2488 /** 2489 * {@code HTML_COMMENT_CONTENT} Content inside an HTML comment. 2490 * 2491 * <p>Text within an HTML comment.</p> 2492 * 2493 * <p><b>Example:</b> {@code <!-- This is a comment -->}</p> 2494 * 2495 * <p><b>Tree:</b></p> 2496 * {@snippet lang="text ": 2497 * HTML_COMMENT -> HTML_COMMENT 2498 * |--HTML_COMMENT_START -> <!-- 2499 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 2500 * | `--TEXT -> This is a comment 2501 * `--HTML_COMMENT_END -> --> 2502 * } 2503 * 2504 * @see #HTML_COMMENT 2505 */ 2506 public static final int HTML_COMMENT_CONTENT = JavadocCommentsLexer.HTML_COMMENT_CONTENT; 2507 2508 /** Empty private constructor of the current class. */ 2509 private JavadocCommentsTokenTypes() { 2510 } 2511 2512}