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