001///////////////////////////////////////////////////////////////////////////////////////////////
002// checkstyle: Checks Java source code and other text files for adherence to a set of rules.
003// Copyright (C) 2001-2025 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 */
031public final class JavadocCommentsTokenTypes {
032
033    /**
034     * Root node of any Javadoc comment.
035     *
036     * <p><b>Tree for example:</b></p>
037     * <pre>{@code
038     * JAVADOC_CONTENT -> JAVADOC_CONTENT
039     * |--LEADING_ASTERISK -> *
040     * |--NEWLINE -> \n
041     * |--LEADING_ASTERISK -> *
042     * |--NEWLINE -> \n
043     * |--LEADING_ASTERISK -> *
044     * `--NEWLINE -> \n
045     * }</pre>
046     */
047    public static final int JAVADOC_CONTENT = JavadocCommentsLexer.JAVADOC;
048
049    /**
050     * Leading asterisk used to format Javadoc lines.
051     */
052    public static final int LEADING_ASTERISK = JavadocCommentsLexer.LEADING_ASTERISK;
053
054    /**
055     * Newline character in a Javadoc comment.
056     */
057    public static final int NEWLINE = JavadocCommentsLexer.NEWLINE;
058
059    /**
060     * Plain text content within a Javadoc comment.
061     */
062    public static final int TEXT = JavadocCommentsLexer.TEXT;
063
064    // Block tags
065
066    /**
067     * General block tag (e.g. {@code @param}, {@code @return}).
068     */
069    public static final int JAVADOC_BLOCK_TAG = JavadocCommentsLexer.JAVADOC_BLOCK_TAG;
070
071    /**
072     * At-sign {@code @} that starts a block tag.
073     */
074    public static final int AT_SIGN = JavadocCommentsLexer.AT_SIGN;
075
076    /**
077     * {@code @author} Javadoc block tag.
078     *
079     * <p>Such Javadoc tag can have one child:</p>
080     * <ol>
081     *  <li>{@link #DESCRIPTION}</li>
082     * </ol>
083     *
084     * <p><b>Example:</b></p>
085     * <pre>{@code * @author name.}</pre>
086     * <b>Tree:</b>
087     * <pre>{@code
088     * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
089     * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG
090     *    |--AT_SIGN -> @
091     *    |--TAG_NAME -> author
092     *    `--DESCRIPTION -> DESCRIPTION
093     *        `--TEXT ->  name.
094     * }</pre>
095     *
096     * @see #JAVADOC_BLOCK_TAG
097     */
098    public static final int AUTHOR_BLOCK_TAG = JavadocCommentsLexer.AUTHOR_BLOCK_TAG;
099
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     * {@code {@summary}} inline tag.
642     */
643    public static final int SUMMARY_INLINE_TAG = JavadocCommentsLexer.SUMMARY_INLINE_TAG;
644
645    /**
646     * {@code {@inheritDoc}} inline tag.
647     */
648    public static final int INHERIT_DOC_INLINE_TAG = JavadocCommentsLexer.INHERIT_DOC_INLINE_TAG;
649
650    /**
651     * {@code {@systemProperty}} inline tag.
652     */
653    public static final int SYSTEM_PROPERTY_INLINE_TAG =
654            JavadocCommentsLexer.SYSTEM_PROPERTY_INLINE_TAG;
655
656    /**
657     * {@code {@literal}} inline tag.
658     */
659    public static final int LITERAL_INLINE_TAG = JavadocCommentsLexer.LITERAL_INLINE_TAG;
660
661    /**
662     * {@code {@return}} inline tag.
663     */
664    public static final int RETURN_INLINE_TAG = JavadocCommentsLexer.RETURN_INLINE_TAG;
665
666    /**
667     * {@code {@index}} inline tag.
668     */
669    public static final int INDEX_INLINE_TAG = JavadocCommentsLexer.INDEX_INLINE_TAG;
670
671    /**
672     * {@code @snippet} inline tag.
673     */
674    public static final int SNIPPET_INLINE_TAG = JavadocCommentsLexer.SNIPPET_INLINE_TAG;
675
676    /**
677     * Custom or unrecognized inline tag.
678     */
679    public static final int CUSTOM_INLINE_TAG = JavadocCommentsLexer.CUSTOM_INLINE_TAG;
680
681    // Components
682
683    /**
684     * Identifier token.
685     */
686    public static final int IDENTIFIER = JavadocCommentsLexer.IDENTIFIER;
687
688    /**
689     * Hash symbol {@code #} used in references.
690     */
691    public static final int HASH = JavadocCommentsLexer.HASH;
692
693    /**
694     * Left parenthesis {@code ( }.
695     */
696    public static final int LPAREN = JavadocCommentsLexer.LPAREN;
697
698    /**
699     * Right parenthesis {@code ) }.
700     */
701    public static final int RPAREN = JavadocCommentsLexer.RPAREN;
702
703    /**
704     * Comma symbol {@code , }.
705     */
706    public static final int COMMA = JavadocCommentsLexer.COMMA;
707
708    /**
709     * Slash symbol {@code / }.
710     */
711    public static final int SLASH = JavadocCommentsLexer.SLASH;
712
713    /**
714     * Question mark symbol {@code ? }.
715     */
716    public static final int QUESTION = JavadocCommentsLexer.QUESTION;
717
718    /**
719     * Less-than symbol {@code < }.
720     */
721    public static final int LT = JavadocCommentsLexer.LT;
722
723    /**
724     * Greater-than symbol {@code > }.
725     */
726    public static final int GT = JavadocCommentsLexer.GT;
727
728    /**
729     * Keyword {@code extends} in type parameters.
730     */
731    public static final int EXTENDS = JavadocCommentsLexer.EXTENDS;
732
733    /**
734     * Keyword {@code super} in type parameters.
735     */
736    public static final int SUPER = JavadocCommentsLexer.SUPER;
737
738    /**
739     * Parameter type reference.
740     */
741    public static final int PARAMETER_TYPE = JavadocCommentsLexer.PARAMETER_TYPE;
742
743    /**
744     * General reference within Javadoc.
745     */
746    public static final int REFERENCE = JavadocCommentsLexer.REFERENCE;
747
748    /**
749     * Type name reference.
750     */
751    public static final int TYPE_NAME = JavadocCommentsLexer.TYPE_NAME;
752
753    /**
754     * Member reference (e.g. method or field).
755     */
756    public static final int MEMBER_REFERENCE = JavadocCommentsLexer.MEMBER_REFERENCE;
757
758    /**
759     * List of parameter types in a reference.
760     */
761    public static final int PARAMETER_TYPE_LIST = JavadocCommentsLexer.PARAMETER_TYPE_LIST;
762
763    /**
764     * Type arguments in generics.
765     */
766    public static final int TYPE_ARGUMENTS = JavadocCommentsLexer.TYPE_ARGUMENTS;
767
768    /**
769     * Single type argument in generics.
770     */
771    public static final int TYPE_ARGUMENT = JavadocCommentsLexer.TYPE_ARGUMENT;
772
773    /**
774     * Description part of a Javadoc tag.
775     */
776    public static final int DESCRIPTION = JavadocCommentsLexer.DESCRIPTION;
777
778    /**
779     * Format specifier inside Javadoc content.
780     */
781    public static final int FORMAT_SPECIFIER = JavadocCommentsLexer.FORMAT_SPECIFIER;
782
783    /**
784     * Attribute name in a {@code @snippet}.
785     */
786    public static final int SNIPPET_ATTR_NAME = JavadocCommentsLexer.SNIPPET_ATTR_NAME;
787
788    /**
789     * Equals sign {@code = }.
790     */
791    public static final int EQUALS = JavadocCommentsLexer.EQUALS;
792
793    /**
794     * Value assigned to an attribute.
795     */
796    public static final int ATTRIBUTE_VALUE = JavadocCommentsLexer.ATTRIBUTE_VALUE;
797
798    /**
799     * Colon symbol {@code : }.
800     */
801    public static final int COLON = JavadocCommentsLexer.COLON;
802
803    /**
804     * Term used in {@code {@index}} tag.
805     */
806    public static final int INDEX_TERM = JavadocCommentsLexer.INDEX_TERM;
807
808    /**
809     * Single snippet attribute.
810     */
811    public static final int SNIPPET_ATTRIBUTE = JavadocCommentsLexer.SNIPPET_ATTRIBUTE;
812
813    /**
814     * Collection of snippet attributes.
815     */
816    public static final int SNIPPET_ATTRIBUTES = JavadocCommentsLexer.SNIPPET_ATTRIBUTES;
817
818    /**
819     * Body content of a {@code @snippet}.
820     */
821    public static final int SNIPPET_BODY = JavadocCommentsLexer.SNIPPET_BODY;
822
823    /**
824     * Field type reference.
825     */
826    public static final int FIELD_TYPE = JavadocCommentsLexer.FIELD_TYPE;
827
828    /**
829     * Parameter name reference.
830     */
831    public static final int PARAMETER_NAME = JavadocCommentsLexer.PARAMETER_NAME;
832
833    /**
834     * String literal inside Javadoc.
835     */
836    public static final int STRING_LITERAL = JavadocCommentsLexer.STRING_LITERAL;
837
838    // HTML
839
840    /**
841     * General HTML element.
842     */
843    public static final int HTML_ELEMENT = JavadocCommentsLexer.HTML_ELEMENT;
844
845    /**
846     * Void HTML element (self-closing).
847     */
848    public static final int VOID_ELEMENT = JavadocCommentsLexer.VOID_ELEMENT;
849
850    /**
851     * Content inside an HTML element.
852     */
853    public static final int HTML_CONTENT = JavadocCommentsLexer.HTML_CONTENT;
854
855    /**
856     * Single HTML attribute.
857     */
858    public static final int HTML_ATTRIBUTE = JavadocCommentsLexer.HTML_ATTRIBUTE;
859
860    /**
861     * List of HTML attributes.
862     */
863    public static final int HTML_ATTRIBUTES = JavadocCommentsLexer.HTML_ATTRIBUTES;
864
865    /**
866     * Start of an HTML tag.
867     */
868    public static final int HTML_TAG_START = JavadocCommentsLexer.HTML_TAG_START;
869
870    /**
871     * End of an HTML tag.
872     */
873    public static final int HTML_TAG_END = JavadocCommentsLexer.HTML_TAG_END;
874
875    /**
876     * Opening tag delimiter {@code < }.
877     */
878    public static final int TAG_OPEN = JavadocCommentsLexer.TAG_OPEN;
879
880    /**
881     * HTML tag name.
882     */
883    public static final int TAG_NAME = JavadocCommentsLexer.TAG_NAME;
884
885    /**
886     * Closing tag delimiter {@code > }.
887     */
888    public static final int TAG_CLOSE = JavadocCommentsLexer.TAG_CLOSE;
889
890    /**
891     * Self-closing tag delimiter {@code /> }.
892     */
893    public static final int TAG_SLASH_CLOSE = JavadocCommentsLexer.TAG_SLASH_CLOSE;
894
895    /**
896     * Slash symbol inside a closing tag.
897     */
898    public static final int TAG_SLASH = JavadocCommentsLexer.TAG_SLASH;
899
900    /**
901     * Attribute name inside an HTML tag.
902     */
903    public static final int TAG_ATTR_NAME = JavadocCommentsLexer.TAG_ATTR_NAME;
904
905    /**
906     * Full HTML comment.
907     */
908    public static final int HTML_COMMENT = JavadocCommentsLexer.HTML_COMMENT;
909
910    /**
911     * Opening part of an HTML comment.
912     */
913    public static final int HTML_COMMENT_START = JavadocCommentsLexer.HTML_COMMENT_START;
914
915    /**
916     * Closing part of an HTML comment.
917     */
918    public static final int HTML_COMMENT_END = JavadocCommentsLexer.HTML_COMMENT_END;
919
920    /**
921     * Content inside an HTML comment.
922     */
923    public static final int HTML_COMMENT_CONTENT = JavadocCommentsLexer.HTML_COMMENT_CONTENT;
924
925    /** Empty private constructor of the current class. */
926    private JavadocCommentsTokenTypes() {
927    }
928}