1 ///////////////////////////////////////////////////////////////////////////////////////////////
2 // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3 // Copyright (C) 2001-2025 the original author or authors.
4 //
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License, or (at your option) any later version.
9 //
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 ///////////////////////////////////////////////////////////////////////////////////////////////
19
20 package com.puppycrawl.tools.checkstyle.api;
21
22 import com.puppycrawl.tools.checkstyle.grammar.javadoc.JavadocCommentsLexer;
23
24 /**
25 * Contains the constants for all the tokens contained in the Abstract
26 * Syntax Tree for the javadoc grammar.
27 *
28 * @see <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html">
29 * javadoc - The Java API Documentation Generator</a>
30 */
31 public final class JavadocCommentsTokenTypes {
32
33 /**
34 * Root node of any Javadoc comment.
35 *
36 * <p><b>Tree for example:</b></p>
37 * <pre>{@code
38 * JAVADOC_CONTENT -> JAVADOC_CONTENT
39 * |--LEADING_ASTERISK -> *
40 * |--NEWLINE -> \n
41 * |--LEADING_ASTERISK -> *
42 * |--NEWLINE -> \n
43 * |--LEADING_ASTERISK -> *
44 * `--NEWLINE -> \n
45 * }</pre>
46 */
47 public static final int JAVADOC_CONTENT = JavadocCommentsLexer.JAVADOC;
48
49 /**
50 * Leading asterisk used to format Javadoc lines.
51 */
52 public static final int LEADING_ASTERISK = JavadocCommentsLexer.LEADING_ASTERISK;
53
54 /**
55 * Newline character in a Javadoc comment.
56 */
57 public static final int NEWLINE = JavadocCommentsLexer.NEWLINE;
58
59 /**
60 * Plain text content within a Javadoc comment.
61 */
62 public static final int TEXT = JavadocCommentsLexer.TEXT;
63
64 // Block tags
65
66 /**
67 * General block tag (e.g. {@code @param}, {@code @return}).
68 */
69 public static final int JAVADOC_BLOCK_TAG = JavadocCommentsLexer.JAVADOC_BLOCK_TAG;
70
71 /**
72 * At-sign {@code @} that starts a block tag.
73 */
74 public static final int AT_SIGN = JavadocCommentsLexer.AT_SIGN;
75
76 /**
77 * {@code @author} Javadoc block tag.
78 *
79 * <p>Such Javadoc tag can have one child:</p>
80 * <ol>
81 * <li>{@link #DESCRIPTION}</li>
82 * </ol>
83 *
84 * <p><b>Example:</b></p>
85 * <pre>{@code * @author name.}</pre>
86 * <b>Tree:</b>
87 * <pre>{@code
88 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
89 * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG
90 * |--AT_SIGN -> @
91 * |--TAG_NAME -> author
92 * `--DESCRIPTION -> DESCRIPTION
93 * `--TEXT -> name.
94 * }</pre>
95 *
96 * @see #JAVADOC_BLOCK_TAG
97 */
98 public static final int AUTHOR_BLOCK_TAG = JavadocCommentsLexer.AUTHOR_BLOCK_TAG;
99
100 /**
101 * {@code @deprecated} block tag.
102 *
103 * <p>Such Javadoc tag can have one child:</p>
104 * <ol>
105 * <li>{@link #DESCRIPTION}</li>
106 * </ol>
107 *
108 * <p><b>Example:</b></p>
109 * <pre>{@code * @deprecated deprecated text.}</pre>
110 *
111 * <b>Tree:</b>
112 * <pre>{@code
113 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
114 * `--DEPRECATED_BLOCK_TAG -> DEPRECATED_BLOCK_TAG
115 * |--AT_SIGN -> @
116 * |--TAG_NAME -> deprecated
117 * `--DESCRIPTION -> DESCRIPTION
118 * `--TEXT -> deprecated text.
119 * }</pre>
120 *
121 * @see #JAVADOC_BLOCK_TAG
122 */
123 public static final int DEPRECATED_BLOCK_TAG = JavadocCommentsLexer.DEPRECATED_BLOCK_TAG;
124
125 /**
126 * {@code @param} Javadoc block tag.
127 *
128 * <p>Such Javadoc tag can have two children:</p>
129 * <ol>
130 * <li>{@link #PARAMETER_NAME}</li>
131 * <li>{@link #DESCRIPTION}</li>
132 * </ol>
133 *
134 * <p><b>Example:</b></p>
135 * <pre>{@code * @param value The parameter of method.}</pre>
136 * <b>Tree:</b>
137 * <pre>{@code
138 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
139 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG
140 * |--AT_SIGN -> @
141 * |--TAG_NAME -> param
142 * |--TEXT ->
143 * |--PARAMETER_NAME -> value
144 * `--DESCRIPTION -> DESCRIPTION
145 * `--TEXT -> The parameter of method.
146 * }</pre>
147 *
148 * @see #JAVADOC_BLOCK_TAG
149 */
150 public static final int PARAM_BLOCK_TAG = JavadocCommentsLexer.PARAM_BLOCK_TAG;
151
152 /**
153 * {@code @return} Javadoc block tag.
154 *
155 * <p>Such Javadoc tag can have one child:</p>
156 * <ol>
157 * <li>{@link #DESCRIPTION}</li>
158 * </ol>
159 *
160 * <p><b>Example:</b></p>
161 * <pre>{@code * @return The return of method.}</pre>
162 * <b>Tree:</b>
163 * <pre>{@code
164 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
165 * `--RETURN_BLOCK_TAG -> RETURN_BLOCK_TAG
166 * |--AT_SIGN -> @
167 * |--TAG_NAME -> return
168 * `--DESCRIPTION -> DESCRIPTION
169 * `--TEXT -> The return of method.
170 * }</pre>
171 *
172 * @see #JAVADOC_BLOCK_TAG
173 */
174 public static final int RETURN_BLOCK_TAG = JavadocCommentsLexer.RETURN_BLOCK_TAG;
175
176 /**
177 * {@code @throws} Javadoc block tag.
178 *
179 * <p>Such Javadoc tag can have two children:</p>
180 * <ol>
181 * <li>{@link #IDENTIFIER} - the exception class</li>
182 * <li>{@link #DESCRIPTION} - description</li>
183 * </ol>
184 *
185 * <p><b>Example:</b></p>
186 * <pre>{@code * @throws IOException if an I/O error occurs}</pre>
187 * <b>Tree:</b>
188 * <pre>{@code
189 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
190 * `--THROWS_BLOCK_TAG -> THROWS_BLOCK_TAG
191 * |--AT_SIGN -> @
192 * |--TAG_NAME -> throws
193 * |--TEXT ->
194 * |--IDENTIFIER -> IOException
195 * `--DESCRIPTION -> DESCRIPTION
196 * `--TEXT -> if an I/O error occurs
197 * }</pre>
198 *
199 * @see #JAVADOC_BLOCK_TAG
200 */
201 public static final int THROWS_BLOCK_TAG = JavadocCommentsLexer.THROWS_BLOCK_TAG;
202
203 /**
204 * {@code @exception} Javadoc block tag.
205 *
206 * <p>Such Javadoc tag can have two children:</p>
207 * <ol>
208 * <li>{@link #IDENTIFIER}</li>
209 * <li>{@link #DESCRIPTION}</li>
210 * </ol>
211 *
212 * <p><b>Example:</b></p>
213 * <pre>{@code * @exception FileNotFoundException when file is not found.}</pre>
214 * <b>Tree:</b>
215 * <pre>{@code
216 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
217 * `--EXCEPTION_BLOCK_TAG -> EXCEPTION_BLOCK_TAG
218 * |--AT_SIGN -> @
219 * |--TAG_NAME -> exception
220 * |--TEXT ->
221 * |--IDENTIFIER -> FileNotFoundException
222 * `--DESCRIPTION -> DESCRIPTION
223 * `--TEXT -> when file is not found.
224 * }</pre>
225 *
226 * @see #JAVADOC_BLOCK_TAG
227 */
228 public static final int EXCEPTION_BLOCK_TAG = JavadocCommentsLexer.EXCEPTION_BLOCK_TAG;
229
230 /**
231 * {@code @since} Javadoc block tag.
232 *
233 * <p>Such Javadoc tag can have one child:</p>
234 * <ol>
235 * <li>{@link #DESCRIPTION}</li>
236 * </ol>
237 *
238 * <p><b>Example:</b></p>
239 * <pre>{@code * @since 1.0}</pre>
240 *
241 * <b>Tree:</b>
242 * <pre>{@code
243 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
244 * `--SINCE_BLOCK_TAG -> SINCE_BLOCK_TAG
245 * |--AT_SIGN -> @
246 * |--TAG_NAME -> since
247 * `--DESCRIPTION -> DESCRIPTION
248 * `--TEXT -> 1.0
249 * }</pre>
250 *
251 * @see #JAVADOC_BLOCK_TAG
252 */
253 public static final int SINCE_BLOCK_TAG = JavadocCommentsLexer.SINCE_BLOCK_TAG;
254
255 /**
256 * {@code @version} Javadoc block tag.
257 *
258 * <p>This tag has only one argument — {@link #TEXT}:</p>
259 *
260 * <p><b>Example:</b></p>
261 * <pre>{@code * @version value}</pre>
262 * <b>Tree:</b>
263 * <pre>{@code
264 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
265 * `--VERSION_BLOCK_TAG -> VERSION_BLOCK_TAG
266 * |--AT_SIGN -> @
267 * |--TAG_NAME -> version
268 * `--DESCRIPTION -> DESCRIPTION
269 * `--TEXT -> value
270 * }</pre>
271 *
272 * @see #JAVADOC_BLOCK_TAG
273 */
274 public static final int VERSION_BLOCK_TAG = JavadocCommentsLexer.VERSION_BLOCK_TAG;
275
276 /**
277 * {@code @see} Javadoc block tag.
278 *
279 * <p>Such Javadoc tag can have three children:</p>
280 * <ol>
281 * <li>{@link #REFERENCE}</li>
282 * <li>{@link #DESCRIPTION}</li>
283 * <li>{@link #HTML_ELEMENT}</li>
284 * </ol>
285 *
286 * <p><b>Example:</b></p>
287 * <pre>{@code * @see SomeClass#Field}</pre>
288 *
289 * <b>Tree:</b>
290 * <pre>{@code
291 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
292 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG
293 * |--AT_SIGN -> @
294 * |--TAG_NAME -> see
295 * |--TEXT ->
296 * `--REFERENCE -> REFERENCE
297 * |--IDENTIFIER -> SomeClass
298 * |--HASH -> #
299 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE
300 * `--IDENTIFIER -> Field
301 * }</pre>
302 *
303 * @see #JAVADOC_BLOCK_TAG
304 */
305 public static final int SEE_BLOCK_TAG = JavadocCommentsLexer.SEE_BLOCK_TAG;
306
307 /**
308 * {@code @hidden} Javadoc block tag.
309 *
310 * <p>Such Javadoc tag can have one child:</p>
311 * <ol>
312 * <li>{@link #DESCRIPTION} – optional description text</li>
313 * </ol>
314 *
315 * <p><b>Example:</b></p>
316 * <pre>{@code * @hidden value}</pre>
317 *
318 * <b>Tree:</b>
319 * <pre>{@code
320 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
321 * `--HIDDEN_BLOCK_TAG -> HIDDEN_BLOCK_TAG
322 * |--AT_SIGN -> @
323 * |--TAG_NAME -> hidden
324 * `--DESCRIPTION -> DESCRIPTION
325 * `--TEXT -> value
326 * }</pre>
327 *
328 * @see #JAVADOC_BLOCK_TAG
329 */
330 public static final int HIDDEN_BLOCK_TAG = JavadocCommentsLexer.HIDDEN_BLOCK_TAG;
331
332 /**
333 * {@code @uses} Javadoc block tag.
334 *
335 * <p>Such Javadoc tag can have one child:</p>
336 * <ol>
337 * <li>{@link #IDENTIFIER} – the referenced service type</li>
338 * </ol>
339 *
340 * <p><b>Example:</b></p>
341 * <pre>{@code * @uses com.example.app.MyService}</pre>
342 *
343 * <b>Tree:</b>
344 * <pre>{@code
345 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
346 * `--USES_BLOCK_TAG -> USES_BLOCK_TAG
347 * |--AT_SIGN -> @
348 * |--TAG_NAME -> uses
349 * |--TEXT ->
350 * `--IDENTIFIER -> com.example.app.MyService
351 * }</pre>
352 *
353 * @see #JAVADOC_BLOCK_TAG
354 */
355 public static final int USES_BLOCK_TAG = JavadocCommentsLexer.USES_BLOCK_TAG;
356
357 /**
358 * {@code @provides} block tag.
359 *
360 * <p>Such Javadoc tag can have two children:</p>
361 * <ol>
362 * <li>{@link #IDENTIFIER}</li>
363 * <li>{@link #DESCRIPTION}</li>
364 * </ol>
365 *
366 * <p><b>Example:</b></p>
367 * <pre>{@code * @provides com.example.MyService with com.example.MyServiceImpl}</pre>
368 *
369 * <b>Tree:</b>
370 * <pre>{@code
371 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
372 * `--PROVIDES_BLOCK_TAG -> PROVIDES_BLOCK_TAG
373 * |--AT_SIGN -> @
374 * |--TAG_NAME -> provides
375 * |--TEXT ->
376 * |--IDENTIFIER -> com.example.MyService
377 * `--DESCRIPTION -> DESCRIPTION
378 * `--TEXT -> with com.example.MyServiceImpl
379 * }</pre>
380 *
381 * @see #JAVADOC_BLOCK_TAG
382 */
383 public static final int PROVIDES_BLOCK_TAG = JavadocCommentsLexer.PROVIDES_BLOCK_TAG;
384
385 /**
386 * {@code @serial} block tag.
387 *
388 * <p>Such Javadoc tag can have one child:</p>
389 * <ol>
390 * <li>{@link #DESCRIPTION} – optional description text</li>
391 * </ol>
392 *
393 * <p><b>Example:</b></p>
394 * <pre>{@code * @serial include}</pre>
395 *
396 * <b>Tree:</b>
397 * <pre>{@code
398 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
399 * `--SERIAL_BLOCK_TAG -> SERIAL_BLOCK_TAG
400 * |--AT_SIGN -> @
401 * |--TAG_NAME -> serial
402 * `--DESCRIPTION -> DESCRIPTION
403 * `--TEXT -> include
404 * }</pre>
405 *
406 * @see #JAVADOC_BLOCK_TAG
407 */
408 public static final int SERIAL_BLOCK_TAG = JavadocCommentsLexer.SERIAL_BLOCK_TAG;
409
410 /**
411 * {@code @serialData} block tag.
412 *
413 * <p>Such Javadoc tag can have one child:</p>
414 * <ol>
415 * <li>{@link #DESCRIPTION} – optional description text</li>
416 * </ol>
417 *
418 * <p><b>Example:</b></p>
419 * <pre>{@code * @serialData data description value}</pre>
420 *
421 * <b>Tree:</b>
422 * <pre>{@code
423 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
424 * `--SERIAL_DATA_BLOCK_TAG -> SERIAL_DATA_BLOCK_TAG
425 * |--AT_SIGN -> @
426 * |--TAG_NAME -> serialData
427 * `--DESCRIPTION -> DESCRIPTION
428 * `--TEXT -> data description value
429 * }</pre>
430 *
431 * @see #JAVADOC_BLOCK_TAG
432 */
433 public static final int SERIAL_DATA_BLOCK_TAG = JavadocCommentsLexer.SERIAL_DATA_BLOCK_TAG;
434
435 /**
436 * {@code @serialField} Javadoc block tag.
437 *
438 * <p>Such Javadoc tag can have three children:</p>
439 * <ol>
440 * <li>{@link #IDENTIFIER} – field name</li>
441 * <li>{@link #FIELD_TYPE} – field type</li>
442 * <li>{@link #DESCRIPTION} – field description</li>
443 * </ol>
444 *
445 * <p><b>Example:</b></p>
446 * <pre>{@code * @serialField name String The person's full name.}</pre>
447 *
448 * <b>Tree:</b>
449 * <pre>{@code
450 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
451 * `--SERIAL_FIELD_BLOCK_TAG -> SERIAL_FIELD_BLOCK_TAG
452 * |--AT_SIGN -> @
453 * |--TAG_NAME -> serialField
454 * |--TEXT ->
455 * |--IDENTIFIER -> name
456 * |--TEXT ->
457 * |--FIELD_TYPE -> String
458 * `--DESCRIPTION -> DESCRIPTION
459 * `--TEXT -> The person's full name.
460 * }</pre>
461 *
462 * @see #JAVADOC_BLOCK_TAG
463 */
464 public static final int SERIAL_FIELD_BLOCK_TAG = JavadocCommentsLexer.SERIAL_FIELD_BLOCK_TAG;
465
466 /**
467 * {@code @customBlock} Javadoc block tag.
468 *
469 * <p>This type represents any block tag that is not explicitly recognized by Checkstyle,
470 * such as a project-specific or malformed tag.</p>
471 *
472 * <p><b>Example:</b></p>
473 * <pre>{@code * @mycustomtag This is a custom block tag.}</pre>
474 * <b>Tree:</b>
475 * <pre>{@code
476 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
477 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG
478 * |--AT_SIGN -> @
479 * |--TAG_NAME -> customBlock
480 * |--TEXT ->
481 * `--DESCRIPTION -> DESCRIPTION
482 * `--TEXT -> This is a custom block tag.
483 * }</pre>
484 *
485 * @see #JAVADOC_BLOCK_TAG
486 */
487 public static final int CUSTOM_BLOCK_TAG = JavadocCommentsLexer.CUSTOM_BLOCK_TAG;
488
489 // Inline tags
490
491 /**
492 * General inline tag (e.g. {@code @link}).
493 */
494 public static final int JAVADOC_INLINE_TAG = JavadocCommentsLexer.JAVADOC_INLINE_TAG;
495
496 /**
497 * Start of an inline tag <code>{</code>.
498 */
499 public static final int JAVADOC_INLINE_TAG_START =
500 JavadocCommentsLexer.JAVADOC_INLINE_TAG_START;
501
502 /**
503 * End of an inline tag <code>}</code>.
504 */
505 public static final int JAVADOC_INLINE_TAG_END = JavadocCommentsLexer.JAVADOC_INLINE_TAG_END;
506
507 /**
508 * {@code {@code}} Javadoc inline tag.
509 *
510 * <p>Such Javadoc tag can have no children:</p>
511 *
512 * <p><b>Example:</b></p>
513 * <pre>{@code * {@code println("Hello");}}</pre>
514 *
515 * <b>Tree:</b>
516 * <pre>{@code
517 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
518 * |--CODE_INLINE_TAG -> CODE_INLINE_TAG
519 * |--JAVADOC_INLINE_TAG_START -> { @
520 * |--TAG_NAME -> code
521 * |--TEXT -> println("Hello");
522 * `--JAVADOC_INLINE_TAG_END -> }
523 * }</pre>
524 *
525 * @see #JAVADOC_INLINE_TAG
526 */
527 public static final int CODE_INLINE_TAG = JavadocCommentsLexer.CODE_INLINE_TAG;
528
529 /**
530 * {@code {@link}} Javadoc inline tag.
531 *
532 * <p>Such Javadoc tag can have two children:</p>
533 * <ol>
534 * <li>{@link #REFERENCE}</li>
535 * <li>{@link #DESCRIPTION}</li>
536 * </ol>
537 *
538 * <p><b>Example:</b></p>
539 * <pre>{@code * {@link Math#max(int, int) label}}</pre>
540 *
541 * <b>Tree:</b>
542 * <pre>{@code
543 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
544 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG
545 * |--JAVADOC_INLINE_TAG_START -> { @
546 * |--TAG_NAME -> link
547 * |--TEXT ->
548 * |--REFERENCE -> REFERENCE
549 * | |--IDENTIFIER -> Math
550 * | |--HASH -> #
551 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE
552 * | |--IDENTIFIER -> max
553 * | |--LPAREN -> (
554 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST
555 * | | |--PARAMETER_TYPE -> int
556 * | | |--COMMA -> ,
557 * | | |--TEXT ->
558 * | | `--PARAMETER_TYPE -> int
559 * | `--RPAREN -> )
560 * |--DESCRIPTION -> DESCRIPTION
561 * | `--TEXT -> label
562 * `--JAVADOC_INLINE_TAG_END -> }
563 * }</pre>
564 *
565 * @see #JAVADOC_INLINE_TAG
566 */
567 public static final int LINK_INLINE_TAG = JavadocCommentsLexer.LINK_INLINE_TAG;
568
569 /**
570 * {@code {@linkplain}} Javadoc inline tag.
571 *
572 * <p>Such Javadoc tag can have two children:</p>
573 * <ol>
574 * <li>{@link #REFERENCE}</li>
575 * <li>{@link #DESCRIPTION}</li>
576 * </ol>
577 *
578 * <p><b>Example:</b></p>
579 * <pre>{@code * {@linkplain String#indexOf(int, int) label}}</pre>
580 *
581 * <b>Tree:</b>
582 * <pre>{@code
583 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
584 * `--LINKPLAIN_INLINE_TAG -> LINKPLAIN_INLINE_TAG
585 * |--JAVADOC_INLINE_TAG_START -> { @
586 * |--TAG_NAME -> linkplain
587 * |--TEXT ->
588 * |--REFERENCE -> REFERENCE
589 * | |--IDENTIFIER -> String
590 * | |--HASH -> #
591 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE
592 * | |--IDENTIFIER -> indexOf
593 * | |--LPAREN -> (
594 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST
595 * | | |--PARAMETER_TYPE -> int
596 * | | |--COMMA -> ,
597 * | | |--TEXT ->
598 * | | `--PARAMETER_TYPE -> int
599 * | `--RPAREN -> )
600 * |--DESCRIPTION -> DESCRIPTION
601 * | `--TEXT -> label
602 * `--JAVADOC_INLINE_TAG_END -> }
603 * }</pre>
604 *
605 * @see #JAVADOC_INLINE_TAG
606 */
607 public static final int LINKPLAIN_INLINE_TAG = JavadocCommentsLexer.LINKPLAIN_INLINE_TAG;
608
609 /**
610 * {@code {@value}} Javadoc inline tag.
611 *
612 * <p>Such Javadoc tag can have one child:</p>
613 * <ol>
614 * <li>{@link #REFERENCE}</li>
615 * </ol>
616 *
617 * <p><b>Example:</b></p>
618 * <pre>{@code * {@value Integer#MAX_VALUE}}</pre>
619 *
620 * <b>Tree:</b>
621 * <pre>{@code
622 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
623 * `--VALUE_INLINE_TAG -> VALUE_INLINE_TAG
624 * |--JAVADOC_INLINE_TAG_START -> { @
625 * |--TAG_NAME -> value
626 * |--TEXT ->
627 * |--REFERENCE -> REFERENCE
628 * | |--IDENTIFIER -> Integer
629 * | |--HASH -> #
630 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE
631 * | `--IDENTIFIER -> MAX_VALUE
632 * |--TEXT ->
633 * `--JAVADOC_INLINE_TAG_END -> }
634 * }</pre>
635 *
636 * @see #JAVADOC_INLINE_TAG
637 */
638 public static final int VALUE_INLINE_TAG = JavadocCommentsLexer.VALUE_INLINE_TAG;
639
640 /**
641 * Inline {@code {@summary ...}} tag inside Javadoc.
642 *
643 * <p>This node represents an inline {@code {@summary ...}} tag used to provide a
644 * short summary description within a Javadoc sentence.</p>
645 *
646 * <p><b>Example:</b></p>
647 * <pre>{@code * Example showing {@summary This is a short summary.}}</pre>
648 *
649 * <b>Tree:</b>
650 * <pre>{@code
651 * |--LEADING_ASTERISK -> *
652 * |--TEXT -> Example showing
653 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
654 * `--SUMMARY_INLINE_TAG -> SUMMARY_INLINE_TAG
655 * |--JAVADOC_INLINE_TAG_START -> { @
656 * |--TAG_NAME -> summary
657 * |--DESCRIPTION -> DESCRIPTION
658 * | `--TEXT -> This is a short summary.
659 * `--JAVADOC_INLINE_TAG_END -> }
660 * }</pre>
661 *
662 * @see #JAVADOC_INLINE_TAG
663 */
664
665 public static final int SUMMARY_INLINE_TAG = JavadocCommentsLexer.SUMMARY_INLINE_TAG;
666
667 /**
668 * {@code {@inheritDoc}} inline tag.
669 */
670 public static final int INHERIT_DOC_INLINE_TAG = JavadocCommentsLexer.INHERIT_DOC_INLINE_TAG;
671
672 /**
673 * {@code {@systemProperty}} inline tag.
674 */
675 public static final int SYSTEM_PROPERTY_INLINE_TAG =
676 JavadocCommentsLexer.SYSTEM_PROPERTY_INLINE_TAG;
677
678 /**
679 * {@code {@literal}} inline tag.
680 */
681 public static final int LITERAL_INLINE_TAG = JavadocCommentsLexer.LITERAL_INLINE_TAG;
682
683 /**
684 * Inline {@code return} tag inside Javadoc.
685 *
686 * <p>This node represents an inline {@code {@return ...}} tag used to
687 * describe the returned value directly within a Javadoc sentence.</p>
688 *
689 * <p><b>Example:</b></p>
690 * <pre>{@code Example showing result {@return The computed value.}}</pre>
691 *
692 * <b>Tree:</b>
693 * <pre>{@code
694 * |--LEADING_ASTERISK -> *
695 * |--TEXT -> Example showing result
696 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
697 * `--RETURN_INLINE_TAG -> RETURN_INLINE_TAG
698 * |--JAVADOC_INLINE_TAG_START -> { @
699 * |--TAG_NAME -> return
700 * |--DESCRIPTION -> DESCRIPTION
701 * | `--TEXT -> The computed value.
702 * `--JAVADOC_INLINE_TAG_END -> }
703 * }</pre>
704 *
705 * @see #JAVADOC_INLINE_TAG
706 */
707
708 public static final int RETURN_INLINE_TAG = JavadocCommentsLexer.RETURN_INLINE_TAG;
709
710 /**
711 * {@code {@index}} inline tag.
712 *
713 * <p>This node represents an inline {@code {@index ...}} tag used to mark an
714 * index term inside a Javadoc sentence.</p>
715 *
716 * <p><b>Example:</b></p>
717 * <pre>{@code * Example showing {@index keyword description of the index term}.}</pre>
718 *
719 * <b>Tree:</b>
720 * <pre>{@code
721 * |--LEADING_ASTERISK -> *
722 * |--TEXT -> Example showing
723 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
724 * `--INDEX_INLINE_TAG -> INDEX_INLINE_TAG
725 * |--JAVADOC_INLINE_TAG_START -> { @
726 * |--TAG_NAME -> index
727 * |--TEXT ->
728 * |--INDEX_TERM -> keyword
729 * |--DESCRIPTION -> DESCRIPTION
730 * | `--TEXT -> description of the index term
731 * `--JAVADOC_INLINE_TAG_END -> }
732 * |--TEXT -> .
733 * }</pre>
734 *
735 * @see #JAVADOC_INLINE_TAG
736 */
737
738 public static final int INDEX_INLINE_TAG = JavadocCommentsLexer.INDEX_INLINE_TAG;
739
740 /**
741 * {@code @snippet} inline tag.
742 *
743 * <p>This node represents an inline { @code { @snippet :}} tag used to embed
744 * code snippets directly inside a Javadoc sentence.</p>
745 *
746 * <p><b>Example:</b></p>
747 * <pre>{ @code * Example showing { @snippet :java |
748 * System.out.println("hello");
749 * }}</pre>
750 *
751 * <b>Tree:</b>
752 * <pre>{@code
753 * |--LEADING_ASTERISK -> *
754 * |--TEXT -> Example showing
755 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
756 * `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG
757 * |--JAVADOC_INLINE_TAG_START -> { @
758 * |--COLON -> :
759 * |--SNIPPET_BODY -> SNIPPET_BODY
760 * | |--TEXT -> java |
761 * | |--NEWLINE -> \n
762 * | |--LEADING_ASTERISK -> *
763 * | |--TEXT -> System.out.println("hello");
764 * | |--NEWLINE -> \n
765 * | |--LEADING_ASTERISK -> *
766 * | `--TEXT ->
767 * `--JAVADOC_INLINE_TAG_END -> }
768 * }</pre>
769 *
770 * @see #JAVADOC_INLINE_TAG
771 */
772 public static final int SNIPPET_INLINE_TAG = JavadocCommentsLexer.SNIPPET_INLINE_TAG;
773
774 /**
775 * Custom or unrecognized inline tag.
776 */
777 public static final int CUSTOM_INLINE_TAG = JavadocCommentsLexer.CUSTOM_INLINE_TAG;
778
779 // Components
780
781 /**
782 * Identifier token.
783 */
784 public static final int IDENTIFIER = JavadocCommentsLexer.IDENTIFIER;
785
786 /**
787 * Hash symbol {@code #} used in references.
788 */
789 public static final int HASH = JavadocCommentsLexer.HASH;
790
791 /**
792 * Left parenthesis {@code ( }.
793 */
794 public static final int LPAREN = JavadocCommentsLexer.LPAREN;
795
796 /**
797 * Right parenthesis {@code ) }.
798 */
799 public static final int RPAREN = JavadocCommentsLexer.RPAREN;
800
801 /**
802 * Comma symbol {@code , }.
803 */
804 public static final int COMMA = JavadocCommentsLexer.COMMA;
805
806 /**
807 * Slash symbol {@code / }.
808 */
809 public static final int SLASH = JavadocCommentsLexer.SLASH;
810
811 /**
812 * Question mark symbol {@code ? }.
813 */
814 public static final int QUESTION = JavadocCommentsLexer.QUESTION;
815
816 /**
817 * Less-than symbol {@code < }.
818 */
819 public static final int LT = JavadocCommentsLexer.LT;
820
821 /**
822 * Greater-than symbol {@code > }.
823 */
824 public static final int GT = JavadocCommentsLexer.GT;
825
826 /**
827 * {@code extends} keyword inside type arguments of a Javadoc inline tag.
828 *
829 * <p>This node represents the {@code extends} bound used inside a
830 * parameterized type within an inline Javadoc tag.</p>
831 *
832 * <p><b>Example:</b></p>
833 * <pre>{@code
834 * * {@link java.util.List<? extends Number> list of any subtype of Number}
835 * }</pre>
836 *
837 * <b>Tree:</b>
838 * <pre>{@code
839 * |--LEADING_ASTERISK -> *
840 * |--TEXT ->
841 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
842 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG
843 * |--JAVADOC_INLINE_TAG_START -> { @
844 * |--TAG_NAME -> link
845 * |--TEXT ->
846 * |--REFERENCE -> REFERENCE
847 * | |--IDENTIFIER -> java.util.List
848 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
849 * | |--LT -> <
850 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
851 * | | |--QUESTION -> ?
852 * | | |--TEXT ->
853 * | | |--EXTENDS -> extends
854 * | | |--TEXT ->
855 * | | `--IDENTIFIER -> Number
856 * | `--GT -> >
857 * |--DESCRIPTION -> DESCRIPTION
858 * | `--TEXT -> list of any subtype of Number
859 * `--JAVADOC_INLINE_TAG_END -> }
860 * }</pre>
861 *
862 * @see #JAVADOC_INLINE_TAG
863 */
864 public static final int EXTENDS = JavadocCommentsLexer.EXTENDS;
865
866 /**
867 * Keyword {@code super} in type parameters.
868 */
869 public static final int SUPER = JavadocCommentsLexer.SUPER;
870
871 /**
872 * Parameter type reference.
873 */
874 public static final int PARAMETER_TYPE = JavadocCommentsLexer.PARAMETER_TYPE;
875
876 /**
877 * General reference within Javadoc.
878 */
879 public static final int REFERENCE = JavadocCommentsLexer.REFERENCE;
880
881 /**
882 * Type name reference.
883 */
884 public static final int TYPE_NAME = JavadocCommentsLexer.TYPE_NAME;
885
886 /**
887 * Member reference (e.g. method or field).
888 */
889 public static final int MEMBER_REFERENCE = JavadocCommentsLexer.MEMBER_REFERENCE;
890
891 /**
892 * List of parameter types in a reference.
893 */
894 public static final int PARAMETER_TYPE_LIST = JavadocCommentsLexer.PARAMETER_TYPE_LIST;
895
896 /**
897 * Type arguments in generics.
898 */
899 public static final int TYPE_ARGUMENTS = JavadocCommentsLexer.TYPE_ARGUMENTS;
900
901 /**
902 * Single type argument in generics.
903 */
904 public static final int TYPE_ARGUMENT = JavadocCommentsLexer.TYPE_ARGUMENT;
905
906 /**
907 * Description part of a Javadoc tag.
908 */
909 public static final int DESCRIPTION = JavadocCommentsLexer.DESCRIPTION;
910
911 /**
912 * Format specifier inside Javadoc content.
913 */
914 public static final int FORMAT_SPECIFIER = JavadocCommentsLexer.FORMAT_SPECIFIER;
915
916 /**
917 * Attribute name in a {@code @snippet}.
918 */
919 public static final int SNIPPET_ATTR_NAME = JavadocCommentsLexer.SNIPPET_ATTR_NAME;
920
921 /**
922 * Equals sign {@code = }.
923 */
924 public static final int EQUALS = JavadocCommentsLexer.EQUALS;
925
926 /**
927 * Value assigned to an attribute.
928 */
929 public static final int ATTRIBUTE_VALUE = JavadocCommentsLexer.ATTRIBUTE_VALUE;
930
931 /**
932 * Colon symbol {@code : }.
933 */
934 public static final int COLON = JavadocCommentsLexer.COLON;
935
936 /**
937 * Term used in {@code {@index}} tag.
938 */
939 public static final int INDEX_TERM = JavadocCommentsLexer.INDEX_TERM;
940
941 /**
942 * Single snippet attribute.
943 */
944 public static final int SNIPPET_ATTRIBUTE = JavadocCommentsLexer.SNIPPET_ATTRIBUTE;
945
946 /**
947 * Collection of snippet attributes.
948 */
949 public static final int SNIPPET_ATTRIBUTES = JavadocCommentsLexer.SNIPPET_ATTRIBUTES;
950
951 /**
952 * Body content of a {@code @snippet}.
953 */
954 public static final int SNIPPET_BODY = JavadocCommentsLexer.SNIPPET_BODY;
955
956 /**
957 * Field type reference.
958 */
959 public static final int FIELD_TYPE = JavadocCommentsLexer.FIELD_TYPE;
960
961 /**
962 * Parameter name reference.
963 */
964 public static final int PARAMETER_NAME = JavadocCommentsLexer.PARAMETER_NAME;
965
966 /**
967 * String literal inside Javadoc.
968 */
969 public static final int STRING_LITERAL = JavadocCommentsLexer.STRING_LITERAL;
970
971 // HTML
972
973 /**
974 * General HTML element.
975 */
976 public static final int HTML_ELEMENT = JavadocCommentsLexer.HTML_ELEMENT;
977
978 /**
979 * Void HTML element (self-closing).
980 */
981 public static final int VOID_ELEMENT = JavadocCommentsLexer.VOID_ELEMENT;
982
983 /**
984 * Content inside an HTML element.
985 *
986 * <p>This node represents the textual content between an HTML start tag and
987 * the corresponding end tag inside a Javadoc comment.</p>
988 *
989 * <p><b>Example:</b></p>
990 * <pre>{@code * <a href="https://example.com">link</a>}</pre>
991 *
992 * <b>Tree:</b>
993 * <pre>{@code
994 * |--LEADING_ASTERISK -> *
995 * `--HTML_ELEMENT -> HTML_ELEMENT
996 * |--HTML_TAG_START -> HTML_TAG_START
997 * | |--TAG_OPEN -> <
998 * | |--TAG_NAME -> a
999 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1000 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1001 * | | |--TEXT -> (whitespace)
1002 * | | |--TAG_ATTR_NAME -> href
1003 * | | |--EQUALS -> =
1004 * | | `--ATTRIBUTE_VALUE -> "https://example.com"
1005 * | `--TAG_CLOSE -> >
1006 * |--HTML_CONTENT -> HTML_CONTENT
1007 * | `--TEXT -> link
1008 * `--HTML_TAG_END -> HTML_TAG_END
1009 * |--TAG_OPEN -> <
1010 * |--TAG_SLASH -> /
1011 * |--TAG_NAME -> a
1012 * `--TAG_CLOSE -> >
1013 * }</pre>
1014 *
1015 * @see #HTML_ELEMENT
1016 */
1017
1018 public static final int HTML_CONTENT = JavadocCommentsLexer.HTML_CONTENT;
1019
1020 /**
1021 * Single HTML attribute.
1022 */
1023 public static final int HTML_ATTRIBUTE = JavadocCommentsLexer.HTML_ATTRIBUTE;
1024
1025 /**
1026 * List of HTML attributes.
1027 */
1028 public static final int HTML_ATTRIBUTES = JavadocCommentsLexer.HTML_ATTRIBUTES;
1029
1030 /**
1031 * Start of an HTML tag (the opening tag node).
1032 *
1033 * <p>This node represents the opening part of an HTML element and contains
1034 * the opening delimiter, tag name, optional attributes, and the closing
1035 * delimiter of the opening tag.</p>
1036 *
1037 * <p><b>Example:</b></p>
1038 * <pre>{@code * <a href="https://example.com">link</a>}</pre>
1039 *
1040 * <b>Tree:</b>
1041 * <pre>{@code
1042 * |--LEADING_ASTERISK -> *
1043 * `--HTML_ELEMENT -> HTML_ELEMENT
1044 * `--HTML_TAG_START -> HTML_TAG_START
1045 * |--TAG_OPEN -> <
1046 * |--TAG_NAME -> a
1047 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1048 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1049 * | |--TEXT ->
1050 * | |--TAG_ATTR_NAME -> href
1051 * | |--EQUALS -> =
1052 * | `--ATTRIBUTE_VALUE -> "https://example.com"
1053 * `--TAG_CLOSE -> >
1054 * }</pre>
1055 *
1056 * @see #HTML_ELEMENT
1057 */
1058
1059 public static final int HTML_TAG_START = JavadocCommentsLexer.HTML_TAG_START;
1060
1061 /**
1062 * End of an HTML tag (the closing tag node).
1063 *
1064 * <p>This node represents the closing part of an HTML element and contains the
1065 * closing delimiter, optional slash, and the tag name.</p>
1066 *
1067 * <p><b>Example:</b></p>
1068 * <pre>{@code * <a href="https://example.com">link</a>}</pre>
1069 *
1070 * <b>Tree:</b>
1071 * <pre>{@code
1072 * |--LEADING_ASTERISK -> *
1073 * `--HTML_ELEMENT -> HTML_ELEMENT
1074 * |--HTML_TAG_START -> HTML_TAG_START
1075 * | |--TAG_OPEN -> <
1076 * | |--TAG_NAME -> a
1077 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1078 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1079 * | | |--TEXT -> (whitespace)
1080 * | | |--TAG_ATTR_NAME -> href
1081 * | | |--EQUALS -> =
1082 * | | `--ATTRIBUTE_VALUE -> "https://example.com"
1083 * | `--TAG_CLOSE -> >
1084 * |--HTML_CONTENT -> HTML_CONTENT
1085 * | `--TEXT -> link
1086 * `--HTML_TAG_END -> HTML_TAG_END
1087 * |--TAG_OPEN -> <
1088 * |--TAG_SLASH -> /
1089 * |--TAG_NAME -> a
1090 * `--TAG_CLOSE -> >
1091 * }</pre>
1092 *
1093 * @see #HTML_ELEMENT
1094 */
1095
1096 public static final int HTML_TAG_END = JavadocCommentsLexer.HTML_TAG_END;
1097
1098 /**
1099 * Opening tag delimiter {@code < }.
1100 */
1101 public static final int TAG_OPEN = JavadocCommentsLexer.TAG_OPEN;
1102
1103 /**
1104 * HTML tag name.
1105 */
1106 public static final int TAG_NAME = JavadocCommentsLexer.TAG_NAME;
1107
1108 /**
1109 * Closing tag delimiter {@code > }.
1110 */
1111 public static final int TAG_CLOSE = JavadocCommentsLexer.TAG_CLOSE;
1112
1113 /**
1114 * {@code />} Self-closing tag delimiter.
1115 *
1116 * <p>Used for void HTML elements.</p>
1117 *
1118 * <p><b>Example:</b></p>
1119 * <pre>{@code * <br />}</pre>
1120 *
1121 * <b>Tree:</b>
1122 * <pre>{@code
1123 * VOID_ELEMENT -> VOID_ELEMENT
1124 * |--TAG_OPEN -> <
1125 * |--TAG_NAME -> br
1126 * `--TAG_SLASH_CLOSE -> />
1127 * }</pre>
1128 *
1129 * @see #HTML_ELEMENT
1130 */
1131 public static final int TAG_SLASH_CLOSE = JavadocCommentsLexer.TAG_SLASH_CLOSE;
1132
1133 /**
1134 * Slash symbol inside a closing tag.
1135 */
1136 public static final int TAG_SLASH = JavadocCommentsLexer.TAG_SLASH;
1137
1138 /**
1139 * Attribute name inside an HTML tag.
1140 */
1141 public static final int TAG_ATTR_NAME = JavadocCommentsLexer.TAG_ATTR_NAME;
1142
1143 /**
1144 * Start of an HTML comment node.
1145 *
1146 * <p>This node represents a full HTML comment inside Javadoc.</p>
1147 *
1148 * <p>This node has three children:</p>
1149 * <ol>
1150 * <li>{@link #HTML_COMMENT_START}</li>
1151 * <li>{@link #HTML_COMMENT_CONTENT}</li>
1152 * <li>{@link #HTML_COMMENT_END}</li>
1153 * </ol>
1154 *
1155 * <p><b>Example:</b></p>
1156 * <pre>{@code * <!-- Hello World! -->}</pre>
1157 *
1158 * <b>Tree:</b>
1159 * <pre>{@code
1160 * JAVADOC_CONTENT -> JAVADOC_CONTENT
1161 * |--TEXT -> /**
1162 * |--NEWLINE -> \r\n
1163 * |--LEADING_ASTERISK -> *
1164 * |--TEXT ->
1165 * |--HTML_COMMENT -> HTML_COMMENT
1166 * |--HTML_COMMENT_START -> <!--
1167 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT
1168 * | `--TEXT -> Hello World!
1169 * `--HTML_COMMENT_END -> -->
1170 * |--NEWLINE -> \r\n
1171 * |--LEADING_ASTERISK -> *
1172 * |--TEXT -> /
1173 * }</pre>
1174 *
1175 * @see #HTML_COMMENT
1176 */
1177 public static final int HTML_COMMENT = JavadocCommentsLexer.HTML_COMMENT;
1178
1179 /**
1180 * Opening part of an HTML comment.
1181 */
1182 public static final int HTML_COMMENT_START = JavadocCommentsLexer.HTML_COMMENT_START;
1183
1184 /**
1185 * Closing part of an HTML comment.
1186 *
1187 * <p>This node represents the closing delimiter of an HTML comment in
1188 * Javadoc (for example {@code -->}).</p>
1189 *
1190 * <p><b>Example:</b></p>
1191 * <pre>{@code * <!-- hidden comment -->}</pre>
1192 *
1193 * <b>Tree:</b>
1194 * <pre>{@code
1195 * |--LEADING_ASTERISK -> *
1196 * |--TEXT ->
1197 * |--HTML_COMMENT -> HTML_COMMENT
1198 * | |--HTML_COMMENT_START -> <!--
1199 * | |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT
1200 * | | `--TEXT -> hidden comment
1201 * | `--HTML_COMMENT_END -> -->
1202 * }</pre>
1203 *
1204 * @see #HTML_COMMENT
1205 */
1206
1207 public static final int HTML_COMMENT_END = JavadocCommentsLexer.HTML_COMMENT_END;
1208
1209 /**
1210 * Content inside an HTML comment.
1211 */
1212 public static final int HTML_COMMENT_CONTENT = JavadocCommentsLexer.HTML_COMMENT_CONTENT;
1213
1214 /** Empty private constructor of the current class. */
1215 private JavadocCommentsTokenTypes() {
1216 }
1217 }