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 * <pre>{ @code * Example showing { @snippet :java 1084 * System.out.println("hello"); 1085 * }}</pre> 1086 * 1087 * <b>Tree:</b> 1088 * {@snippet lang="text" : 1089 * |--LEADING_ASTERISK -> * 1090 * |--TEXT -> Example showing 1091 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1092 * `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 1093 * |--JAVADOC_INLINE_TAG_START -> { @ 1094 * |--COLON -> : 1095 * |--SNIPPET_BODY -> SNIPPET_BODY 1096 * | |--TEXT -> java 1097 * | |--NEWLINE -> \n 1098 * | |--LEADING_ASTERISK -> * 1099 * | |--TEXT -> System.out.println("hello"); 1100 * | |--NEWLINE -> \n 1101 * | |--LEADING_ASTERISK -> * 1102 * | `--TEXT -> 1103 * `--JAVADOC_INLINE_TAG_END -> } 1104 * } 1105 * 1106 * @see #JAVADOC_INLINE_TAG 1107 */ 1108 public static final int SNIPPET_INLINE_TAG = JavadocCommentsLexer.SNIPPET_INLINE_TAG; 1109 1110 /** 1111 * {@code @custom} inline tag. 1112 * 1113 * <p><b>Example:</b>{@code * Example showing {@custom This is a Custom Inline Tag}.}</p> 1114 * 1115 * <p><b>Tree:</b></p> 1116 * {@snippet lang="text" : 1117 * |--LEADING_ASTERISK -> * 1118 * |--TEXT -> Example showing 1119 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1120 * | `--CUSTOM_INLINE_TAG -> CUSTOM_INLINE_TAG 1121 * | |--JAVADOC_INLINE_TAG_START -> { @ 1122 * | |--TAG_NAME -> custom 1123 * | |--DESCRIPTION -> DESCRIPTION 1124 * | | `--TEXT -> This is a Custom Inline Tag 1125 * | `--JAVADOC_INLINE_TAG_END -> } 1126 * |--TEXT -> . 1127 * } 1128 * 1129 * @see #JAVADOC_INLINE_TAG 1130 */ 1131 public static final int CUSTOM_INLINE_TAG = JavadocCommentsLexer.CUSTOM_INLINE_TAG; 1132 1133 // Components 1134 1135 /** 1136 * Identifier token. 1137 * 1138 * <p><b>Example:</b>{@code * @throws Exception if error.}</p> 1139 * 1140 * <p><b>Tree:</b></p> 1141 * {@snippet lang="text" : 1142 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1143 * |--LEADING_ASTERISK -> * 1144 * |--TEXT -> 1145 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1146 * `--THROWS_BLOCK_TAG -> THROWS_BLOCK_TAG 1147 * |--AT_SIGN -> @ 1148 * |--TAG_NAME -> throws 1149 * |--TEXT -> 1150 * |--IDENTIFIER -> Exception 1151 * `--DESCRIPTION -> DESCRIPTION 1152 * `--TEXT -> if error. 1153 * } 1154 */ 1155 public static final int IDENTIFIER = JavadocCommentsLexer.IDENTIFIER; 1156 1157 /** 1158 * Hash symbol {@code #} used in references within Javadoc. 1159 * 1160 * <p><b>Example:</b>{@code * @see MyClass#myMethod()}</p> 1161 * 1162 * <b>Tree:</b> 1163 * {@snippet lang="text" : 1164 * |--LEADING_ASTERISK -> * 1165 * |--TEXT -> 1166 * |--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1167 * | `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1168 * | |--AT_SIGN -> @ 1169 * | |--TAG_NAME -> see 1170 * | |--TEXT -> 1171 * | `--REFERENCE -> REFERENCE 1172 * | |--IDENTIFIER -> MyClass 1173 * | |--HASH -> # 1174 * | |--IDENTIFIER -> myMethod 1175 * | |--LPAREN -> ( 1176 * | `--RPAREN -> ) 1177 * } 1178 * 1179 * @see #REFERENCE 1180 */ 1181 public static final int HASH = JavadocCommentsLexer.HASH; 1182 1183 /** 1184 * Left parenthesis {@code (} used in references within Javadoc. 1185 * 1186 * <p><b>Example:</b></p> 1187 * <pre>{@code 1188 * * {@link String#length()} 1189 * }</pre> 1190 * 1191 * <b>Tree:</b> 1192 * {@snippet lang="text" : 1193 * |--LEADING_ASTERISK -> * 1194 * |--TEXT -> 1195 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1196 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1197 * |--JAVADOC_INLINE_TAG_START -> {@ 1198 * |--TAG_NAME -> link 1199 * |--TEXT -> 1200 * |--REFERENCE -> REFERENCE 1201 * |--IDENTIFIER -> String 1202 * |--HASH -> # 1203 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1204 * |--IDENTIFIER -> length 1205 * |--LPAREN -> ( 1206 * `--RPAREN -> ) 1207 * `--JAVADOC_INLINE_TAG_END -> } 1208 * } 1209 * 1210 * @see #REFERENCE 1211 */ 1212 public static final int LPAREN = JavadocCommentsLexer.LPAREN; 1213 1214 /** 1215 * Right parenthesis {@code (} used in references within Javadoc. 1216 * 1217 * <p><b>Example:</b></p> 1218 * <pre>{@code 1219 * * {@link String#length()} 1220 * }</pre> 1221 * 1222 * <b>Tree:</b> 1223 * {@snippet lang="text" : 1224 * |--LEADING_ASTERISK -> * 1225 * |--TEXT -> 1226 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1227 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1228 * |--JAVADOC_INLINE_TAG_START -> {@ 1229 * |--TAG_NAME -> link 1230 * |--TEXT -> 1231 * |--REFERENCE -> REFERENCE 1232 * |--IDENTIFIER -> String 1233 * |--HASH -> # 1234 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1235 * |--IDENTIFIER -> length 1236 * |--LPAREN -> ( 1237 * `--RPAREN -> ) 1238 * `--JAVADOC_INLINE_TAG_END -> } 1239 * } 1240 * 1241 * @see #REFERENCE 1242 */ 1243 public static final int RPAREN = JavadocCommentsLexer.RPAREN; 1244 1245 /** 1246 * Comma symbol {@code , }. 1247 * 1248 * <p><b>Example:</b>{@code * @see #method(int, int)}</p> 1249 * 1250 * <p><b>Tree:</b></p> 1251 * {@snippet lang="text" : 1252 * |--LEADING_ASTERISK -> * 1253 * |--TEXT -> 1254 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1255 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1256 * |--AT_SIGN -> @ 1257 * |--TAG_NAME -> see 1258 * |--TEXT -> 1259 * |--REFERENCE -> REFERENCE 1260 * | |--HASH -> # 1261 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1262 * | |--IDENTIFIER -> method 1263 * | |--LPAREN -> ( 1264 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1265 * | | |--PARAMETER_TYPE -> int 1266 * | | |--COMMA -> , 1267 * | | |--TEXT -> 1268 * | | `--PARAMETER_TYPE -> int 1269 * | `--RPAREN -> ) 1270 * } 1271 */ 1272 public static final int COMMA = JavadocCommentsLexer.COMMA; 1273 1274 /** 1275 * Slash symbol {@code /} used in module or package references within Javadoc. 1276 * 1277 * <p><b>Example:</b></p> 1278 * {@snippet lang="text" : 1279 * {@link String}; 1280 * } 1281 * 1282 * <b>Tree:</b> 1283 * {@snippet lang="text" : 1284 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1285 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1286 * |--JAVADOC_INLINE_TAG_START -> {@ 1287 * |--TAG_NAME -> link 1288 * |--TEXT -> 1289 * |--REFERENCE -> REFERENCE 1290 * | |--IDENTIFIER -> java.base 1291 * | |--SLASH -> / 1292 * | `--IDENTIFIER -> java.lang.String 1293 * `--JAVADOC_INLINE_TAG_END -> } 1294 * } 1295 * 1296 * @see #REFERENCE 1297 */ 1298 public static final int SLASH = JavadocCommentsLexer.SLASH; 1299 1300 /** 1301 * Question mark symbol {@code ?} used in generic type wildcards. 1302 * 1303 * <p>This token appears in references that use wildcard type arguments, 1304 * such as {@code ? extends Type} or {@code ? super Type}.</p> 1305 * 1306 * <p><b>Example:</b></p> 1307 * {@snippet lang="text" : 1308 * {@link java.util.List<? extends Number>}; 1309 * } 1310 * 1311 * <b>Tree:</b> 1312 * {@snippet lang="text" : 1313 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1314 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1315 * |--JAVADOC_INLINE_TAG_START -> {@ 1316 * |--TAG_NAME -> link 1317 * |--TEXT -> 1318 * |--REFERENCE -> REFERENCE 1319 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1320 * | |--LT -> < 1321 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1322 * | | |--QUESTION -> ? 1323 * | | |--TEXT -> 1324 * | | |--EXTENDS -> extends 1325 * | | |--TEXT -> 1326 * | | `--IDENTIFIER -> Number 1327 * | `--GT -> > 1328 * `--JAVADOC_INLINE_TAG_END -> } 1329 * } 1330 * 1331 * @see #TYPE_ARGUMENT 1332 */ 1333 public static final int QUESTION = JavadocCommentsLexer.QUESTION; 1334 1335 /** 1336 * Less-than symbol {@code < }. 1337 * 1338 * <p><b>Example:</b>{@code * @see List<String>}</p> 1339 * 1340 * <b>Tree:</b> 1341 * {@snippet lang="text" : 1342 * |--LEADING_ASTERISK -> * 1343 * |--TEXT -> 1344 * |--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1345 * | `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1346 * | |--AT_SIGN -> @ 1347 * | |--TAG_NAME -> see 1348 * | |--TEXT -> 1349 * | `--REFERENCE -> REFERENCE 1350 * | |--IDENTIFIER -> List 1351 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1352 * | |--LT -> < 1353 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1354 * | | `--IDENTIFIER -> String 1355 * | `--GT -> > 1356 * |--NEWLINE -> \n 1357 * `--TEXT -> 1358 * } 1359 */ 1360 public static final int LT = JavadocCommentsLexer.LT; 1361 1362 /** 1363 * Greater-than symbol {@code > }. 1364 * 1365 * <p><b>Example:</b>{@code * @see List<String>}</p> 1366 * 1367 * <b>Tree:</b> 1368 * {@snippet lang="text" : 1369 * |--LEADING_ASTERISK -> * 1370 * |--TEXT -> 1371 * |--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1372 * | `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 1373 * | |--AT_SIGN -> @ 1374 * | |--TAG_NAME -> see 1375 * | |--TEXT -> 1376 * | `--REFERENCE -> REFERENCE 1377 * | |--IDENTIFIER -> List 1378 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1379 * | |--LT -> < 1380 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1381 * | | `--IDENTIFIER -> String 1382 * | `--GT -> > 1383 * |--NEWLINE -> \n 1384 * `--Text -> 1385 * } 1386 */ 1387 1388 public static final int GT = JavadocCommentsLexer.GT; 1389 1390 /** 1391 * {@code extends} keyword inside type arguments of a Javadoc inline tag. 1392 * 1393 * <p>This node represents the {@code extends} bound used inside a 1394 * parameterized type within an inline Javadoc tag.</p> 1395 * 1396 * <p><b>Example:</b></p> 1397 * <pre>{@code 1398 * * {@link java.util.List<? extends Number> list of any subtype of Number} 1399 * }</pre> 1400 * 1401 * <b>Tree:</b> 1402 * {@snippet lang="text" : 1403 * |--LEADING_ASTERISK -> * 1404 * |--TEXT -> 1405 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1406 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1407 * |--JAVADOC_INLINE_TAG_START -> { @ 1408 * |--TAG_NAME -> link 1409 * |--TEXT -> 1410 * |--REFERENCE -> REFERENCE 1411 * | |--IDENTIFIER -> java.util.List 1412 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1413 * | |--LT -> < 1414 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1415 * | | |--QUESTION -> ? 1416 * | | |--TEXT -> 1417 * | | |--EXTENDS -> extends 1418 * | | |--TEXT -> 1419 * | | `--IDENTIFIER -> Number 1420 * | `--GT -> > 1421 * |--DESCRIPTION -> DESCRIPTION 1422 * | `--TEXT -> list of any subtype of Number 1423 * `--JAVADOC_INLINE_TAG_END -> } 1424 * } 1425 * 1426 * @see #JAVADOC_INLINE_TAG 1427 */ 1428 public static final int EXTENDS = JavadocCommentsLexer.EXTENDS; 1429 1430 /** 1431 * {@code SUPER} represents the {@code super} keyword inside a generic 1432 * wildcard bound (e.g., {@code ? super Number}). 1433 * 1434 * <p><b>Example:</b> {@code {@link java.util.List <? super Integer> list} 1435 * of any supertype of Integer}</p> 1436 * 1437 * <p><b>Tree:</b></p> 1438 * {@snippet lang="text" : 1439 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1440 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1441 * |--JAVADOC_INLINE_TAG_START -> { @ 1442 * |--TAG_NAME -> link 1443 * |--TEXT -> 1444 * |--REFERENCE -> REFERENCE 1445 * | |--IDENTIFIER -> java.util.List 1446 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1447 * | |--LT -> < 1448 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1449 * | | |--QUESTION -> ? 1450 * | | |--TEXT -> 1451 * | | |--SUPER -> super 1452 * | | |--TEXT -> 1453 * | | `--IDENTIFIER -> Integer 1454 * | `--GT -> > 1455 * |--DESCRIPTION -> DESCRIPTION 1456 * | `--TEXT -> list of any supertype of Integer 1457 * `--JAVADOC_INLINE_TAG_END -> } 1458 * } 1459 * 1460 * @see #PARAMETER_TYPE 1461 */ 1462 public static final int SUPER = JavadocCommentsLexer.SUPER; 1463 1464 /** 1465 * {@code PARAMETER_TYPE} Parameter type reference. 1466 * 1467 * <p>Represents a type used in a method parameter.</p> 1468 * 1469 * <p><b>Example:</b>{@code {@link java.util.List#add(Object)}}</p> 1470 * 1471 * <b>Tree:</b> 1472 * {@snippet lang="text" : 1473 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1474 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1475 * |--JAVADOC_INLINE_TAG_START -> {@ 1476 * |--TAG_NAME -> link 1477 * |--REFERENCE -> REFERENCE 1478 * | |--IDENTIFIER -> List 1479 * | |--HASH -> # 1480 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1481 * | |--IDENTIFIER -> add 1482 * | |--LPAREN -> ( 1483 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1484 * | | `--PARAMETER_TYPE -> Object 1485 * | `--RPAREN -> ) 1486 * `--JAVADOC_INLINE_TAG_END -> } 1487 * } 1488 * 1489 * @see #REFERENCE 1490 */ 1491 public static final int PARAMETER_TYPE = JavadocCommentsLexer.PARAMETER_TYPE; 1492 1493 /** 1494 * {@code REFERENCE} General reference within Javadoc. 1495 * 1496 * <p>Represents the target of an inline reference tag such as 1497 * {@code {@link String#length()}}.</p> 1498 * 1499 * <p><b>Example:</b></p> 1500 * {@snippet lang="text" : 1501 * {@link String#length()} 1502 * } 1503 * 1504 * <b>Tree:</b> 1505 * {@snippet lang="text" : 1506 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1507 * |--LINK_INLINE_TAG -> LINK_INLINE_TAG 1508 * | |--JAVADOC_INLINE_TAG_START -> {@ 1509 * | |--TAG_NAME -> link 1510 * | |--REFERENCE -> String#length() 1511 * `--JAVADOC_INLINE_TAG_END -> } 1512 * } 1513 * 1514 * @see #JAVADOC_INLINE_TAG 1515 */ 1516 public static final int REFERENCE = JavadocCommentsLexer.REFERENCE; 1517 1518 /** 1519 * {@code MEMBER_REFERENCE} Member reference (method or field). 1520 * 1521 * <p>Represents a field or method in a type reference.</p> 1522 * 1523 * <p><b>Example:</b></p> 1524 * {@snippet lang="text" : 1525 * {@link String#length()} 1526 * } 1527 * 1528 * <p><b>Tree:</b></p> 1529 * {@snippet lang="text" : 1530 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1531 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1532 * |--JAVADOC_INLINE_TAG_START -> {@ 1533 * |--TAG_NAME -> link 1534 * |--TEXT -> 1535 * |--REFERENCE -> REFERENCE 1536 * | |--IDENTIFIER -> String 1537 * | |--HASH -> # 1538 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1539 * | |--IDENTIFIER -> length 1540 * | |--LPAREN -> ( 1541 * | `--RPAREN -> ) 1542 * `--JAVADOC_INLINE_TAG_END -> } 1543 * } 1544 * 1545 * @see #REFERENCE 1546 */ 1547 public static final int MEMBER_REFERENCE = JavadocCommentsLexer.MEMBER_REFERENCE; 1548 1549 /** 1550 * {@code PARAMETER_TYPE_LIST} represents the list of parameter types inside a 1551 * member reference within a Javadoc inline {@code @link} tag. 1552 * 1553 * <p><b>Example:</b></p> 1554 * {@snippet lang="text" : 1555 * {@link Math#max(int, int)} 1556 * } 1557 * 1558 * <p><b>Tree:</b></p> 1559 * {@snippet lang="text" : 1560 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1561 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1562 * |--JAVADOC_INLINE_TAG_START -> {\@ 1563 * |--TAG_NAME -> link 1564 * |--TEXT -> 1565 * |--REFERENCE -> REFERENCE 1566 * | |--IDENTIFIER -> Math 1567 * | |--HASH -> # 1568 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1569 * | |--IDENTIFIER -> max 1570 * | |--LPAREN -> ( 1571 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1572 * | | |--PARAMETER_TYPE -> int 1573 * | | |--COMMA -> , 1574 * | | |--TEXT -> 1575 * | | `--PARAMETER_TYPE -> int 1576 * | `--RPAREN -> ) 1577 * `--JAVADOC_INLINE_TAG_END -> } 1578 * } 1579 * 1580 * @see #PARAMETER_TYPE 1581 */ 1582 public static final int PARAMETER_TYPE_LIST = JavadocCommentsLexer.PARAMETER_TYPE_LIST; 1583 1584 /** 1585 * {@code TYPE_ARGUMENTS} Type arguments in generics. 1586 * 1587 * <p>Represents the type arguments inside a generic type reference.</p> 1588 * 1589 * <p><b>Example:</b>{@code {@link java.util.List<String>}}</p> 1590 * 1591 * <p><b>Tree:</b></p> 1592 * {@snippet lang="text" : 1593 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1594 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1595 * |--JAVADOC_INLINE_TAG_START -> {@ 1596 * |--TAG_NAME -> link 1597 * |--TEXT -> 1598 * |--REFERENCE -> REFERENCE 1599 * | |--IDENTIFIER -> java.util.List 1600 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1601 * | |--LT -> < 1602 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1603 * | | `--IDENTIFIER -> String 1604 * | `--GT -> > 1605 * `--JAVADOC_INLINE_TAG_END -> } 1606 * } 1607 * 1608 * @see #TYPE_ARGUMENT 1609 */ 1610 public static final int TYPE_ARGUMENTS = JavadocCommentsLexer.TYPE_ARGUMENTS; 1611 1612 /** 1613 * Single type argument in generics. 1614 * 1615 * <p>This node represents one individual type inside a generic type 1616 * argument list.</p> 1617 * 1618 * <p><b>Example:</b></p> 1619 * {@snippet lang="text" : 1620 * {@link java.util.List<String>} 1621 * } 1622 * 1623 * <p><b>Tree:</b></p> 1624 * {@snippet lang="text" : 1625 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1626 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1627 * |--JAVADOC_INLINE_TAG_START -> {@ 1628 * |--TAG_NAME -> link 1629 * |--TEXT -> 1630 * |--REFERENCE -> REFERENCE 1631 * |--IDENTIFIER -> java.util.List 1632 * `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1633 * |--LT -> < 1634 * |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1635 * | `--IDENTIFIER -> String 1636 * `--GT -> > 1637 * `--JAVADOC_INLINE_TAG_END -> } 1638 * } 1639 * 1640 * @see #TYPE_ARGUMENTS 1641 */ 1642 public static final int TYPE_ARGUMENT = JavadocCommentsLexer.TYPE_ARGUMENT; 1643 1644 /** 1645 * Description part of a Javadoc tag. 1646 * 1647 * <p><b>Example:</b>{@code * @param value The parameter description goes here.}</p> 1648 * 1649 * <p><b>Tree:</b></p> 1650 * {@snippet lang="text" : 1651 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 1652 * |--AT_SIGN -> @ 1653 * |--TAG_NAME -> param 1654 * |--TEXT -> 1655 * |--PARAMETER_NAME -> value 1656 * `--DESCRIPTION -> DESCRIPTION 1657 * `--TEXT -> The parameter description goes here. 1658 * } 1659 */ 1660 public static final int DESCRIPTION = JavadocCommentsLexer.DESCRIPTION; 1661 1662 /** 1663 * Format specifier inside a {@code {@value}} inline tag. 1664 * The {@value} tag is used to display the value of a constant directly 1665 * within the Javadoc documentation. In newer Java versions (20+), there 1666 * is ability include a format string inside the tag. 1667 * 1668 * <p>In this example, the format specifier {@code 0x%04x} is used to format the integer 1669 * {@code Modifier#PUBLIC} as a hexadecimal value, padded with zeros to a width of four characters.</p> 1670 * {@snippet lang="text" : 1671 * {@value %04x java.lang.reflect.Modifier#PUBLIC} 1672 * } 1673 * 1674 * <p><b>Tree:</b></p> 1675 * {@snippet lang="text" : 1676 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1677 * `--VALUE_INLINE_TAG -> VALUE_INLINE_TAG 1678 * |--JAVADOC_INLINE_TAG_START -> {@ 1679 * |--TAG_NAME -> value 1680 * |--TEXT -> 1681 * |--FORMAT_SPECIFIER -> %04x 1682 * |--TEXT -> 1683 * |--REFERENCE -> REFERENCE 1684 * | |--IDENTIFIER -> java.lang.reflect.Modifier 1685 * | |--HASH -> # 1686 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1687 * | `--IDENTIFIER -> PUBLIC 1688 * `--JAVADOC_INLINE_TAG_END -> } 1689 * } 1690 * 1691 * @see #VALUE_INLINE_TAG 1692 */ 1693 public static final int FORMAT_SPECIFIER = JavadocCommentsLexer.FORMAT_SPECIFIER; 1694 1695 /** 1696 * Attribute name in a {@code @snippet} tag. 1697 * 1698 * <p> 1699 * <b>Note:</b> In the current Checkstyle AST, all snippet attributes (such as 1700 * {@code lang=java}) appear as plain text under the {@code DESCRIPTION} node. 1701 * There is <b>no</b> {@code SNIPPET_ATTR_NAME} node in the AST tree. 1702 * All attribute content is represented as {@code TEXT}.</p> 1703 * 1704 * <p> 1705 * <b>Example:</b> 1706 * {@code * @snippet lang=java} 1707 * </p> 1708 * 1709 * <p> 1710 * <b>Tree:</b> 1711 * </p> 1712 * {@snippet lang="text" : 1713 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1714 * |--LEADING_ASTERISK -> * 1715 * |--TEXT -> 1716 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1717 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1718 * |--AT_SIGN -> @ 1719 * |--TAG_NAME -> snippet 1720 * `--DESCRIPTION -> DESCRIPTION 1721 * `--TEXT -> lang=java 1722 * } 1723 * 1724 * @see #SNIPPET_ATTRIBUTE 1725 */ 1726 public static final int SNIPPET_ATTR_NAME = JavadocCommentsLexer.SNIPPET_ATTR_NAME; 1727 1728 /** 1729 * Equals sign {@code =}. 1730 * 1731 * <p>Used within snippet attributes to assign values.</p> 1732 * 1733 * <p><b>Example:</b></p> 1734 * {@snippet lang="text" : 1735 * { @snippet lang="java" : 1736 * int x = 1; 1737 * } 1738 * } 1739 * 1740 * <p><b>Tree:</b></p> 1741 * {@snippet lang="text" : 1742 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1743 * `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 1744 * |--JAVADOC_INLINE_TAG_START -> {@ 1745 * |--SNIPPET_ATTRIBUTES -> SNIPPET_ATTRIBUTES 1746 * | `--SNIPPET_ATTRIBUTE -> SNIPPET_ATTRIBUTE 1747 * | |--TEXT -> 1748 * | |--SNIPPET_ATTR_NAME -> lang 1749 * | |--EQUALS -> = 1750 * | `--ATTRIBUTE_VALUE -> "java" 1751 * |--COLON -> : 1752 * |--SNIPPET_BODY -> SNIPPET_BODY 1753 * | |--NEWLINE -> \n 1754 * | |--TEXT -> int x = 1; 1755 * | |--NEWLINE -> \r\n 1756 * `--JAVADOC_INLINE_TAG_END -> } 1757 * } 1758 * 1759 * @see #SNIPPET_ATTRIBUTE 1760 * @see #SNIPPET_ATTRIBUTES 1761 */ 1762 public static final int EQUALS = JavadocCommentsLexer.EQUALS; 1763 1764 /** 1765 * {@code ATTRIBUTE_VALUE} Value assigned to an attribute. 1766 * 1767 * <p><b>Example:</b>{@code <a href="example">text</a>}</p> 1768 * 1769 * <p><b>Tree:</b></p> 1770 * {@snippet lang="text" : 1771 * HTML_ELEMENT -> HTML_ELEMENT 1772 * |--HTML_TAG_START -> HTML_TAG_START 1773 * | |--TAG_OPEN -> < 1774 * | |--TAG_NAME -> a 1775 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1776 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1777 * | | |--TEXT -> 1778 * | | |--TAG_ATTR_NAME -> href 1779 * | | |--EQUALS -> = 1780 * | | `--ATTRIBUTE_VALUE -> "example" 1781 * | `--TAG_CLOSE -> > 1782 * |--HTML_CONTENT -> HTML_CONTENT 1783 * | `--TEXT -> text 1784 * `--HTML_TAG_END -> HTML_TAG_END 1785 * |--TAG_OPEN -> < 1786 * |--TAG_SLASH -> / 1787 * |--TAG_NAME -> a 1788 * `--TAG_CLOSE -> > 1789 * } 1790 * 1791 * @see #HTML_ATTRIBUTE 1792 * @see #TAG_ATTR_NAME 1793 */ 1794 public static final int ATTRIBUTE_VALUE = JavadocCommentsLexer.ATTRIBUTE_VALUE; 1795 1796 /** 1797 * Colon symbol {@code : }. 1798 * 1799 * <p><b>Example:</b>{@code * {@snippet :config}}</p> 1800 * 1801 * <p><b>Tree:</b></p> 1802 * {@snippet lang="text" : 1803 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1804 * |--TEXT -> /** 1805 * |--NEWLINE -> \n 1806 * |--LEADING_ASTERISK -> * 1807 * |--TEXT -> 1808 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1809 * | `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG 1810 * | |--JAVADOC_INLINE_TAG_START -> {@ 1811 * | |--COLON -> : 1812 * | |--SNIPPET_BODY -> SNIPPET_BODY 1813 * | | `--TEXT -> config 1814 * | `--JAVADOC_INLINE_TAG_END -> } 1815 * |--NEWLINE -> \n 1816 * |--LEADING_ASTERISK -> * 1817 * |--TEXT -> / 1818 * |--NEWLINE -> \n 1819 * `--TEXT -> class Test {} 1820 * } 1821 * 1822 * @see #SNIPPET_INLINE_TAG 1823 */ 1824 public static final int COLON = JavadocCommentsLexer.COLON; 1825 1826 /** 1827 * Term used in {@code {@index}} tag. 1828 * 1829 * <p>This node represents the term inside an inline {@code {@index ...}} tag in Javadoc.</p> 1830 * 1831 * <p> 1832 * <b>Example:</b> 1833 * {@code * Example showing {@index keyword description of the index term}.} 1834 * </p> 1835 * 1836 * <b>Tree:</b> 1837 * {@snippet lang="text" : 1838 * |--LEADING_ASTERISK -> * 1839 * |--TEXT -> Example showing 1840 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1841 * `--INDEX_INLINE_TAG -> INDEX_INLINE_TAG 1842 * |--JAVADOC_INLINE_TAG_START -> { @ 1843 * |--TAG_NAME -> index 1844 * |--TEXT -> 1845 * |--INDEX_TERM -> keyword 1846 * |--DESCRIPTION -> DESCRIPTION 1847 * | `--TEXT -> description of the index term 1848 * `--JAVADOC_INLINE_TAG_END -> } 1849 * |--TEXT -> . 1850 * } 1851 * 1852 * @see #JAVADOC_INLINE_TAG 1853 */ 1854 public static final int INDEX_TERM = JavadocCommentsLexer.INDEX_TERM; 1855 1856 /** 1857 * Single attribute in a {@code @snippet} tag. 1858 * 1859 * <p> 1860 * Represents a single attribute (e.g., {@code lang=java}) 1861 * in a {@code @snippet} tag.</p> 1862 * 1863 * <p><b>Note:</b> In the current Checkstyle AST, all snippet 1864 * attributes appear as plain text under the {@code DESCRIPTION} node, 1865 * not as a separate {@code SNIPPET_ATTRIBUTE} node.</p> 1866 * 1867 * <p><b>Example:</b>{@code * @snippet lang=java}</p> 1868 * 1869 * <p><b>Tree:</b></p> 1870 * {@snippet lang="text" : 1871 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1872 * |--LEADING_ASTERISK -> * 1873 * |--TEXT -> 1874 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1875 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1876 * |--AT_SIGN -> @ 1877 * |--TAG_NAME -> snippet 1878 * `--DESCRIPTION -> DESCRIPTION 1879 * `--TEXT -> lang=java 1880 * } 1881 */ 1882 public static final int SNIPPET_ATTRIBUTE = JavadocCommentsLexer.SNIPPET_ATTRIBUTE; 1883 1884 /** 1885 * Collection of attributes in a {@code @snippet} tag. 1886 * 1887 * <p> 1888 * Represents all attributes (e.g., {@code lang=java region=main}) in a {@code @snippet} tag. 1889 * </p> 1890 * 1891 * <p><b>Note:</b> In the current Checkstyle AST, all snippet attributes appear as 1892 * plain text under the {@code DESCRIPTION} node, not as a separate 1893 * {@code SNIPPET_ATTRIBUTES} node.</p> 1894 * 1895 * <p><b>Example:</b>{@code * @snippet lang=java region=main}</p> 1896 * 1897 * <p><b>Tree:</b></p> 1898 * {@snippet lang="text" : 1899 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1900 * |--LEADING_ASTERISK -> * 1901 * |--TEXT -> 1902 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1903 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1904 * |--AT_SIGN -> @ 1905 * |--TAG_NAME -> snippet 1906 * `--DESCRIPTION -> DESCRIPTION 1907 * `--TEXT -> lang=java region=main 1908 * } 1909 */ 1910 public static final int SNIPPET_ATTRIBUTES = JavadocCommentsLexer.SNIPPET_ATTRIBUTES; 1911 1912 /** 1913 * Body content of a {@code @snippet} tag. 1914 * 1915 * <p> 1916 * Represents the code or text content inside a {@code @snippet} tag in Javadoc. 1917 * </p> 1918 * 1919 * <b>Example:</b> 1920 * 1921 * <p>{@code * @snippet lang=java * System.out.println("hello");}</p> 1922 * 1923 * <b>Tree:</b> 1924 * {@snippet lang="text" : 1925 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1926 * |--LEADING_ASTERISK -> * 1927 * |--TEXT -> 1928 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1929 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 1930 * |--AT_SIGN -> @ 1931 * |--TAG_NAME -> snippet 1932 * `--DESCRIPTION -> DESCRIPTION 1933 * |--TEXT -> lang=java 1934 * |--NEWLINE -> \n 1935 * |--LEADING_ASTERISK -> * 1936 * `--TEXT -> System.out.println("hello"); 1937 * } 1938 */ 1939 public static final int SNIPPET_BODY = JavadocCommentsLexer.SNIPPET_BODY; 1940 1941 /** 1942 * Field type reference in a Javadoc. 1943 * 1944 * <p>Example:</p> 1945 * <pre> 1946 * /** 1947 * * @serialField counter int The counter. 1948 * */ 1949 * </pre> 1950 * 1951 * <b>Tree:</b> 1952 * {@snippet lang="text" : 1953 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1954 * |--TEXT -> /** 1955 * |--NEWLINE -> \n 1956 * |--LEADING_ASTERISK -> * 1957 * |--TEXT -> 1958 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1959 * `--SERIAL_FIELD_BLOCK_TAG -> SERIAL_FIELD_BLOCK_TAG 1960 * |--AT_SIGN -> @ 1961 * |--TAG_NAME -> serialField 1962 * |--TEXT -> 1963 * |--IDENTIFIER -> counter 1964 * |--TEXT -> 1965 * |--FIELD_TYPE -> int 1966 * `--DESCRIPTION -> DESCRIPTION 1967 * |--TEXT -> The counter. 1968 * |--NEWLINE -> \n 1969 * |--LEADING_ASTERISK -> * 1970 * `--TEXT -> / 1971 * } 1972 * 1973 * @see #FIELD_TYPE 1974 */ 1975 public static final int FIELD_TYPE = JavadocCommentsLexer.FIELD_TYPE; 1976 1977 /** 1978 * Parameter name reference in a Javadoc {@code @param} block tag. 1979 * 1980 * <p><b>Example:</b>{@code * @param value The parameter of method.}</p> 1981 * 1982 * <b>Tree:</b> 1983 * {@snippet lang="text" : 1984 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1985 * |--LEADING_ASTERISK -> * 1986 * |--TEXT -> 1987 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 1988 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 1989 * |--AT_SIGN -> @ 1990 * |--TAG_NAME -> param 1991 * |--TEXT -> 1992 * |--PARAMETER_NAME -> value 1993 * `--DESCRIPTION -> DESCRIPTION 1994 * `--TEXT -> The parameter of method. 1995 * } 1996 * 1997 * @see #PARAM_BLOCK_TAG 1998 */ 1999 public static final int PARAMETER_NAME = JavadocCommentsLexer.PARAMETER_NAME; 2000 2001 /** 2002 * String literal inside Javadoc. 2003 * 2004 * <p>Example in Javadoc:</p> 2005 * 2006 * {@snippet lang="text" : 2007 * {@see "foo"} 2008 * } 2009 * 2010 * <p>Tree:</p> 2011 * 2012 * {@snippet lang="text" : 2013 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 2014 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 2015 * |--AT_SIGN -> @ 2016 * |--TAG_NAME -> see 2017 * |--TEXT -> 2018 * `--STRING_LITERAL -> "foo" 2019 * } 2020 */ 2021 public static final int STRING_LITERAL = JavadocCommentsLexer.STRING_LITERAL; 2022 2023 // HTML 2024 2025 /** 2026 * General HTML element in a Javadoc comment. 2027 * 2028 * <p><b>Example:</b></p> 2029 * <pre>{@code 2030 * /** 2031 * * <p>Hello</p> 2032 * * / 2033 * }</pre> 2034 * 2035 * <b>Tree:</b> 2036 * {@snippet lang="text" : 2037 * JAVADOC_CONTENT -> JAVADOC_CONTENT 2038 * |--LEADING_ASTERISK -> * 2039 * |--TEXT -> 2040 * |--HTML_ELEMENT -> HTML_ELEMENT 2041 * | |--HTML_TAG_START -> HTML_TAG_START 2042 * | | |--TAG_OPEN -> < 2043 * | | |--TAG_NAME -> p 2044 * | | `--TAG_CLOSE -> > 2045 * | |--HTML_CONTENT -> HTML_CONTENT 2046 * | | `--TEXT -> Hello 2047 * | `--HTML_TAG_END -> HTML_TAG_END 2048 * | |--TAG_OPEN -> < 2049 * | |--TAG_SLASH -> / 2050 * | |--TAG_NAME -> p 2051 * | `--TAG_CLOSE -> > 2052 * |--NEWLINE -> \n 2053 * |--LEADING_ASTERISK -> * 2054 * |--TEXT -> / 2055 * } 2056 */ 2057 public static final int HTML_ELEMENT = JavadocCommentsLexer.HTML_ELEMENT; 2058 2059 /** 2060 * Void HTML element (self-closing). 2061 * 2062 * <p>Example in Javadoc: {@code <br>}</p> 2063 * 2064 * <p>Tree:</p> 2065 * {@snippet lang="text" : 2066 * HTML_ELEMENT -> HTML_ELEMENT 2067 * `--VOID_ELEMENT -> VOID_ELEMENT 2068 * `--HTML_TAG_START -> HTML_TAG_START 2069 * |--TAG_OPEN -> < 2070 * |--TAG_NAME -> br 2071 * `--TAG_CLOSE -> > 2072 * } 2073 */ 2074 public static final int VOID_ELEMENT = JavadocCommentsLexer.VOID_ELEMENT; 2075 2076 /** 2077 * Content inside an HTML element. 2078 * 2079 * <p>This node represents the textual content between an HTML start tag and 2080 * the corresponding end tag inside a Javadoc comment.</p> 2081 * 2082 * <p><b>Example:</b>{@code * <a href="https://example.com">link</a>}</p> 2083 * 2084 * <b>Tree:</b> 2085 * {@snippet lang="text" : 2086 * |--LEADING_ASTERISK -> * 2087 * `--HTML_ELEMENT -> HTML_ELEMENT 2088 * |--HTML_TAG_START -> HTML_TAG_START 2089 * | |--TAG_OPEN -> < 2090 * | |--TAG_NAME -> a 2091 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2092 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2093 * | | |--TEXT -> (whitespace) 2094 * | | |--TAG_ATTR_NAME -> href 2095 * | | |--EQUALS -> = 2096 * | | `--ATTRIBUTE_VALUE -> "https://example.com" 2097 * | `--TAG_CLOSE -> > 2098 * |--HTML_CONTENT -> HTML_CONTENT 2099 * | `--TEXT -> link 2100 * `--HTML_TAG_END -> HTML_TAG_END 2101 * |--TAG_OPEN -> < 2102 * |--TAG_SLASH -> / 2103 * |--TAG_NAME -> a 2104 * `--TAG_CLOSE -> > 2105 * } 2106 * 2107 * @see #HTML_ELEMENT 2108 */ 2109 2110 public static final int HTML_CONTENT = JavadocCommentsLexer.HTML_CONTENT; 2111 2112 /** 2113 * {@code HTML_ATTRIBUTE} Single HTML attribute. 2114 * 2115 * <p>Represents one attribute inside an HTML tag.</p> 2116 * 2117 * <p><b>Example:</b>{@code <input type="text">}</p> 2118 * 2119 * <b>Tree:</b> 2120 * {@snippet lang="text" : 2121 * HTML_ELEMENT -> HTML_ELEMENT 2122 * `--VOID_ELEMENT -> VOID_ELEMENT 2123 * `--HTML_TAG_START -> HTML_TAG_START 2124 * |--TAG_OPEN -> < 2125 * |--TAG_NAME -> input 2126 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2127 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2128 * | |--TEXT -> 2129 * | |--TAG_ATTR_NAME -> type 2130 * | |--EQUALS -> = 2131 * | `--ATTRIBUTE_VALUE -> "text" 2132 * `--TAG_CLOSE -> > 2133 * } 2134 * 2135 * @see #HTML_ATTRIBUTES 2136 */ 2137 public static final int HTML_ATTRIBUTE = JavadocCommentsLexer.HTML_ATTRIBUTE; 2138 2139 /** 2140 * {@code HTML_ATTRIBUTES} represents a collection of HTML attributes 2141 * inside an HTML tag. 2142 * 2143 * <p>Appears in Javadoc comments when documenting HTML elements that contain 2144 * multiple attributes.</p> 2145 * 2146 * <p><b>Example:</b>{@code <div lang="en" custom-attr="value"></div>}</p> 2147 * 2148 * <p><b>Tree:</b></p> 2149 * {@snippet lang="text" : 2150 * HTML_ELEMENT -> HTML_ELEMENT 2151 * |--HTML_TAG_START -> HTML_TAG_START 2152 * | |--TAG_OPEN -> < 2153 * | |--TAG_NAME -> div 2154 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2155 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2156 * | | | |--TEXT -> 2157 * | | | |--TAG_ATTR_NAME -> lang 2158 * | | | |--EQUALS -> = 2159 * | | | `--ATTRIBUTE_VALUE -> "en" 2160 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2161 * | | |--TEXT -> 2162 * | | |--TAG_ATTR_NAME -> custom-attr 2163 * | | |--EQUALS -> = 2164 * | | `--ATTRIBUTE_VALUE -> "value" 2165 * | `--TAG_CLOSE -> > 2166 * } 2167 * 2168 * @see #HTML_ATTRIBUTE 2169 */ 2170 public static final int HTML_ATTRIBUTES = JavadocCommentsLexer.HTML_ATTRIBUTES; 2171 2172 /** 2173 * Start of an HTML tag (the opening tag node). 2174 * 2175 * <p>This node represents the opening part of an HTML element and contains 2176 * the opening delimiter, tag name, optional attributes, and the closing 2177 * delimiter of the opening tag.</p> 2178 * 2179 * <p><b>Example:</b>{@code * <a href="https://example.com">link</a>}</p> 2180 * 2181 * <b>Tree:</b> 2182 * {@snippet lang="text" : 2183 * |--LEADING_ASTERISK -> * 2184 * `--HTML_ELEMENT -> HTML_ELEMENT 2185 * `--HTML_TAG_START -> HTML_TAG_START 2186 * |--TAG_OPEN -> < 2187 * |--TAG_NAME -> a 2188 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2189 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2190 * | |--TEXT -> 2191 * | |--TAG_ATTR_NAME -> href 2192 * | |--EQUALS -> = 2193 * | `--ATTRIBUTE_VALUE -> "https://example.com" 2194 * `--TAG_CLOSE -> > 2195 * } 2196 * 2197 * @see #HTML_ELEMENT 2198 */ 2199 2200 public static final int HTML_TAG_START = JavadocCommentsLexer.HTML_TAG_START; 2201 2202 /** 2203 * End of an HTML tag (the closing tag node). 2204 * 2205 * <p>This node represents the closing part of an HTML element and contains the 2206 * closing delimiter, optional slash, and the tag name.</p> 2207 * 2208 * <p><b>Example:</b>{@code * <a href="https://example.com">link</a>}</p> 2209 * 2210 * <b>Tree:</b> 2211 * {@snippet lang="text" : 2212 * |--LEADING_ASTERISK -> * 2213 * `--HTML_ELEMENT -> HTML_ELEMENT 2214 * |--HTML_TAG_START -> HTML_TAG_START 2215 * | |--TAG_OPEN -> < 2216 * | |--TAG_NAME -> a 2217 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2218 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2219 * | | |--TEXT -> (whitespace) 2220 * | | |--TAG_ATTR_NAME -> href 2221 * | | |--EQUALS -> = 2222 * | | `--ATTRIBUTE_VALUE -> "https://example.com" 2223 * | `--TAG_CLOSE -> > 2224 * |--HTML_CONTENT -> HTML_CONTENT 2225 * | `--TEXT -> link 2226 * `--HTML_TAG_END -> HTML_TAG_END 2227 * |--TAG_OPEN -> < 2228 * |--TAG_SLASH -> / 2229 * |--TAG_NAME -> a 2230 * `--TAG_CLOSE -> > 2231 * } 2232 * 2233 * @see #HTML_ELEMENT 2234 */ 2235 2236 public static final int HTML_TAG_END = JavadocCommentsLexer.HTML_TAG_END; 2237 2238 /** 2239 * Represents the opening {@literal "<"} symbol of an HTML start tag. 2240 * 2241 * <p><b>Example:</b>{@code <div class="container" lang="en"></div>}</p> 2242 * 2243 * <b>Tree:</b> 2244 * {@snippet lang="text" : 2245 * HTML_ELEMENT -> HTML_ELEMENT 2246 * |--HTML_TAG_START -> HTML_TAG_START 2247 * | |--TAG_OPEN -> < 2248 * | |--TAG_NAME -> div 2249 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2250 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2251 * | | | |--TAG_ATTR_NAME -> class 2252 * | | | |--EQUALS -> = 2253 * | | | `--ATTRIBUTE_VALUE -> "container" 2254 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2255 * | | |--TAG_ATTR_NAME -> lang 2256 * | | |--EQUALS -> = 2257 * | | `--ATTRIBUTE_VALUE -> "en" 2258 * | `--TAG_CLOSE -> > 2259 * `--HTML_TAG_END -> HTML_TAG_END 2260 * |--TAG_OPEN -> < 2261 * |--TAG_SLASH -> / 2262 * |--TAG_NAME -> div 2263 * `--TAG_CLOSE -> > 2264 * } 2265 * 2266 * @see #HTML_TAG_START 2267 */ 2268 public static final int TAG_OPEN = JavadocCommentsLexer.TAG_OPEN; 2269 2270 /** 2271 * {@code TAG_NAME} Name of an HTML element. 2272 * 2273 * <p>Appears inside an HTML tag within Javadoc comments.</p> 2274 * 2275 * <p><b>Example: </b>{@code <div class="container">Content</div>}</p> 2276 * 2277 * <b>Tree:</b> 2278 * {@snippet lang="text" : 2279 * HTML_ELEMENT -> HTML_ELEMENT 2280 * |--HTML_TAG_START -> HTML_TAG_START 2281 * | |--TAG_OPEN -> < 2282 * | |--TAG_NAME -> div 2283 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 2284 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 2285 * | | |--TAG_ATTR_NAME -> class 2286 * | | |--EQUALS -> = 2287 * | | `--ATTRIBUTE_VALUE -> "container" 2288 * | `--TAG_CLOSE -> > 2289 * |--HTML_CONTENT -> HTML_CONTENT 2290 * | `--TEXT -> Content 2291 * `--HTML_TAG_END -> HTML_TAG_END 2292 * |--TAG_OPEN -> < 2293 * |--TAG_SLASH -> / 2294 * |--TAG_NAME -> div 2295 * `--TAG_CLOSE -> > 2296 * } 2297 * 2298 * <p>Here {@code TAG_NAME} corresponds to {@code "div"}.</p> 2299 */ 2300 public static final int TAG_NAME = JavadocCommentsLexer.TAG_NAME; 2301 2302 /** 2303 * {@code TAG_CLOSE} represents the closing {@literal ">"} symbol 2304 * of an HTML tag. 2305 * 2306 * <p>Appears in Javadoc comments when documenting HTML elements.</p> 2307 * 2308 * <p><b>Example:</b>{@code <p>Some text</p>}</p> 2309 * 2310 * <b>Tree:</b> 2311 * {@snippet lang="text" : 2312 * HTML_ELEMENT -> HTML_ELEMENT 2313 * |--HTML_TAG_START -> HTML_TAG_START 2314 * | |--TAG_OPEN -> < 2315 * | |--TAG_NAME -> p 2316 * | `--TAG_CLOSE -> > 2317 * |--HTML_CONTENT -> HTML_CONTENT 2318 * | `--TEXT -> Some text 2319 * `--HTML_TAG_END -> HTML_TAG_END 2320 * |--TAG_OPEN -> < 2321 * |--TAG_SLASH -> / 2322 * |--TAG_NAME -> p 2323 * `--TAG_CLOSE -> > 2324 * } 2325 * 2326 * @see #HTML_TAG_START 2327 */ 2328 public static final int TAG_CLOSE = JavadocCommentsLexer.TAG_CLOSE; 2329 2330 /** 2331 * {@code />} Self-closing tag delimiter. 2332 * 2333 * <p>Used for void HTML elements.</p> 2334 * 2335 * <p><b>Example:</b>{@code * <br />}</p> 2336 * 2337 * <b>Tree:</b> 2338 * {@snippet lang="text" : 2339 * VOID_ELEMENT -> VOID_ELEMENT 2340 * |--TAG_OPEN -> < 2341 * |--TAG_NAME -> br 2342 * `--TAG_SLASH_CLOSE -> /> 2343 * } 2344 * 2345 * @see #HTML_ELEMENT 2346 */ 2347 public static final int TAG_SLASH_CLOSE = JavadocCommentsLexer.TAG_SLASH_CLOSE; 2348 2349 /** 2350 * {@code TAG_SLASH} represents the slash {@literal "/"} used 2351 * 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}