1 /*

     2  * Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.tools.javac.tree;

    27 

    28 import javax.tools.Diagnostic;

    29 

    30 import com.sun.source.doctree.*;

    31 import com.sun.tools.javac.parser.Tokens.Comment;

    32 import com.sun.tools.javac.util.Assert;

    33 import com.sun.tools.javac.util.DefinedBy;

    34 import com.sun.tools.javac.util.DefinedBy.Api;

    35 import com.sun.tools.javac.util.DiagnosticSource;

    36 import com.sun.tools.javac.util.JCDiagnostic;

    37 import com.sun.tools.javac.util.JCDiagnostic.SimpleDiagnosticPosition;

    38 import com.sun.tools.javac.util.Position;

    39 

    40 import java.io.IOException;

    41 import java.io.StringWriter;

    42 import java.util.List;

    43 

    44 import javax.lang.model.element.Name;

    45 import javax.tools.JavaFileObject;

    46 

    47 /**

    48  * <p><b>This is NOT part of any supported API.

    49  * If you write code that depends on this, you do so at your own risk.

    50  * This code and its internal interfaces are subject to change or

    51  * deletion without notice.</b>

    52  */

    53 public abstract class DCTree implements DocTree {

    54 

    55     /**

    56      * The position in the comment string.

    57      * Use {@link #getSourcePosition getSourcePosition} to convert

    58      * it to a position in the source file.

    59      *

    60      * TODO: why not simply translate all these values into

    61      * source file positions? Is it useful to have string-offset

    62      * positions as well?

    63      */

    64     public int pos;

    65 

    66     public long getSourcePosition(DCDocComment dc) {

    67         return dc.comment.getSourcePos(pos);

    68     }

    69 

    70     public JCDiagnostic.DiagnosticPosition pos(DCDocComment dc) {

    71         return new SimpleDiagnosticPosition(dc.comment.getSourcePos(pos));

    72     }

    73 

    74     /** Convert a tree to a pretty-printed string. */

    75     @Override

    76     public String toString() {

    77         StringWriter s = new StringWriter();

    78         try {

    79             new DocPretty(s).print(this);

    80         }

    81         catch (IOException e) {

    82             // should never happen, because StringWriter is defined

    83             // never to throw any IOExceptions

    84             throw new AssertionError(e);

    85         }

    86         return s.toString();

    87     }

    88 

    89     public static abstract class DCEndPosTree<T extends DCEndPosTree<T>> extends DCTree {

    90 

    91         private int endPos = Position.NOPOS;

    92 

    93         public int getEndPos(DCDocComment dc) {

    94             return dc.comment.getSourcePos(endPos);

    95         }

    96 

    97         @SuppressWarnings("unchecked")

    98         public T setEndPos(int endPos) {

    99             this.endPos = endPos;

   100             return (T) this;

   101         }

   102 

   103     }

   104 

   105     public static class DCDocComment extends DCTree implements DocCommentTree {

   106         public final Comment comment; // required for the implicit source pos table

   107 

   108         public final List<DCTree> fullBody;

   109         public final List<DCTree> firstSentence;

   110         public final List<DCTree> body;

   111         public final List<DCTree> tags;

   112 

   113         public DCDocComment(Comment comment,

   114                             List<DCTree> fullBody,

   115                             List<DCTree> firstSentence,

   116                             List<DCTree> body,

   117                             List<DCTree> tags) {

   118             this.comment = comment;

   119             this.firstSentence = firstSentence;

   120             this.fullBody = fullBody;

   121             this.body = body;

   122             this.tags = tags;

   123         }

   124 

   125         @Override @DefinedBy(Api.COMPILER_TREE)

   126         public Kind getKind() {

   127             return Kind.DOC_COMMENT;

   128         }

   129 

   130         @Override @DefinedBy(Api.COMPILER_TREE)

   131         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   132             return v.visitDocComment(this, d);

   133         }

   134 

   135         @Override @DefinedBy(Api.COMPILER_TREE)

   136         public List<? extends DocTree> getFirstSentence() {

   137             return firstSentence;

   138         }

   139 

   140         @Override @DefinedBy(Api.COMPILER_TREE)

   141         public List<? extends DocTree> getFullBody() {

   142             return fullBody;

   143         }

   144 

   145         @Override @DefinedBy(Api.COMPILER_TREE)

   146         public List<? extends DocTree> getBody() {

   147             return body;

   148         }

   149 

   150         @Override @DefinedBy(Api.COMPILER_TREE)

   151         public List<? extends DocTree> getBlockTags() {

   152             return tags;

   153         }

   154 

   155     }

   156 

   157     public static abstract class DCBlockTag extends DCTree implements BlockTagTree {

   158         @Override @DefinedBy(Api.COMPILER_TREE)

   159         public String getTagName() {

   160             return getKind().tagName;

   161         }

   162     }

   163 

   164     public static abstract class DCInlineTag extends DCEndPosTree<DCInlineTag> implements InlineTagTree {

   165         @Override @DefinedBy(Api.COMPILER_TREE)

   166         public String getTagName() {

   167             return getKind().tagName;

   168         }

   169     }

   170 

   171     public static class DCAttribute extends DCTree implements AttributeTree {

   172         public final Name name;

   173         public final ValueKind vkind;

   174         public final List<DCTree> value;

   175 

   176         DCAttribute(Name name, ValueKind vkind, List<DCTree> value) {

   177             Assert.check((vkind == ValueKind.EMPTY) ? (value == null) : (value != null));

   178             this.name = name;

   179             this.vkind = vkind;

   180             this.value = value;

   181         }

   182 

   183         @Override @DefinedBy(Api.COMPILER_TREE)

   184         public Kind getKind() {

   185             return Kind.ATTRIBUTE;

   186         }

   187 

   188         @Override @DefinedBy(Api.COMPILER_TREE)

   189         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   190             return v.visitAttribute(this, d);

   191         }

   192 

   193         @Override @DefinedBy(Api.COMPILER_TREE)

   194         public Name getName() {

   195             return name;

   196         }

   197 

   198         @Override @DefinedBy(Api.COMPILER_TREE)

   199         public ValueKind getValueKind() {

   200             return vkind;

   201         }

   202 

   203         @Override @DefinedBy(Api.COMPILER_TREE)

   204         public List<DCTree> getValue() {

   205             return value;

   206         }

   207     }

   208 

   209     public static class DCAuthor extends DCBlockTag implements AuthorTree {

   210         public final List<DCTree> name;

   211 

   212         DCAuthor(List<DCTree> name) {

   213             this.name = name;

   214         }

   215 

   216         @Override @DefinedBy(Api.COMPILER_TREE)

   217         public Kind getKind() {

   218             return Kind.AUTHOR;

   219         }

   220 

   221         @Override @DefinedBy(Api.COMPILER_TREE)

   222         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   223             return v.visitAuthor(this, d);

   224         }

   225 

   226         @Override @DefinedBy(Api.COMPILER_TREE)

   227         public List<? extends DocTree> getName() {

   228             return name;

   229         }

   230     }

   231 

   232     public static class DCComment extends DCTree implements CommentTree {

   233         public final String body;

   234 

   235         DCComment(String body) {

   236             this.body = body;

   237         }

   238 

   239         @Override @DefinedBy(Api.COMPILER_TREE)

   240         public Kind getKind() {

   241             return Kind.COMMENT;

   242         }

   243 

   244         @Override @DefinedBy(Api.COMPILER_TREE)

   245         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   246             return v.visitComment(this, d);

   247         }

   248 

   249         @Override @DefinedBy(Api.COMPILER_TREE)

   250         public String getBody() {

   251             return body;

   252         }

   253     }

   254 

   255     public static class DCDeprecated extends DCBlockTag implements DeprecatedTree {

   256         public final List<DCTree> body;

   257 

   258         DCDeprecated(List<DCTree> body) {

   259             this.body = body;

   260         }

   261 

   262         @Override @DefinedBy(Api.COMPILER_TREE)

   263         public Kind getKind() {

   264             return Kind.DEPRECATED;

   265         }

   266 

   267         @Override @DefinedBy(Api.COMPILER_TREE)

   268         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   269             return v.visitDeprecated(this, d);

   270         }

   271 

   272         @Override @DefinedBy(Api.COMPILER_TREE)

   273         public List<? extends DocTree> getBody() {

   274             return body;

   275         }

   276     }

   277 

   278     public static class DCDocRoot extends DCInlineTag implements DocRootTree {

   279 

   280         @Override @DefinedBy(Api.COMPILER_TREE)

   281         public Kind getKind() {

   282             return Kind.DOC_ROOT;

   283         }

   284 

   285         @Override @DefinedBy(Api.COMPILER_TREE)

   286         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   287             return v.visitDocRoot(this, d);

   288         }

   289     }

   290 

   291     public static class DCEndElement extends DCTree implements EndElementTree {

   292         public final Name name;

   293 

   294         DCEndElement(Name name) {

   295             this.name = name;

   296         }

   297 

   298         @Override @DefinedBy(Api.COMPILER_TREE)

   299         public Kind getKind() {

   300             return Kind.END_ELEMENT;

   301         }

   302 

   303         @Override @DefinedBy(Api.COMPILER_TREE)

   304         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   305             return v.visitEndElement(this, d);

   306         }

   307 

   308         @Override @DefinedBy(Api.COMPILER_TREE)

   309         public Name getName() {

   310             return name;

   311         }

   312     }

   313 

   314     public static class DCEntity extends DCTree implements EntityTree {

   315         public final Name name;

   316 

   317         DCEntity(Name name) {

   318             this.name = name;

   319         }

   320 

   321         @Override @DefinedBy(Api.COMPILER_TREE)

   322         public Kind getKind() {

   323             return Kind.ENTITY;

   324         }

   325 

   326         @Override @DefinedBy(Api.COMPILER_TREE)

   327         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   328             return v.visitEntity(this, d);

   329         }

   330 

   331         @Override @DefinedBy(Api.COMPILER_TREE)

   332         public Name getName() {

   333             return name;

   334         }

   335     }

   336 

   337     public static class DCErroneous extends DCTree implements ErroneousTree, JCDiagnostic.DiagnosticPosition {

   338         public final String body;

   339         public final JCDiagnostic diag;

   340 

   341         DCErroneous(String body, JCDiagnostic.Factory diags, DiagnosticSource diagSource, String code, Object... args) {

   342             this.body = body;

   343             this.diag = diags.error(null, diagSource, this, code, args);

   344         }

   345 

   346         DCErroneous(String body, JCDiagnostic diag) {

   347             this.body = body;

   348             this.diag = diag;

   349         }

   350 

   351         @Override @DefinedBy(Api.COMPILER_TREE)

   352         public Kind getKind() {

   353             return Kind.ERRONEOUS;

   354         }

   355 

   356         @Override @DefinedBy(Api.COMPILER_TREE)

   357         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   358             return v.visitErroneous(this, d);

   359         }

   360 

   361         @Override @DefinedBy(Api.COMPILER_TREE)

   362         public String getBody() {

   363             return body;

   364         }

   365 

   366         @Override @DefinedBy(Api.COMPILER_TREE)

   367         public Diagnostic<JavaFileObject> getDiagnostic() {

   368             return diag;

   369         }

   370 

   371         @Override

   372         public JCTree getTree() {

   373             return null;

   374         }

   375 

   376         @Override

   377         public int getStartPosition() {

   378             return pos;

   379         }

   380 

   381         @Override

   382         public int getPreferredPosition() {

   383             return pos + body.length() - 1;

   384         }

   385 

   386         @Override

   387         public int getEndPosition(EndPosTable endPosTable) {

   388             return pos + body.length();

   389         }

   390 

   391     }

   392 

   393     public static class DCHidden extends DCBlockTag implements HiddenTree {

   394         public final List<DCTree> body;

   395 

   396         DCHidden(List<DCTree> body) {

   397             this.body = body;

   398         }

   399 

   400         @Override @DefinedBy(Api.COMPILER_TREE)

   401         public Kind getKind() {

   402             return Kind.HIDDEN;

   403         }

   404 

   405         @Override @DefinedBy(Api.COMPILER_TREE)

   406         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   407             return v.visitHidden(this, d);

   408         }

   409 

   410         @Override @DefinedBy(Api.COMPILER_TREE)

   411         public List<? extends DocTree> getBody() {

   412             return body;

   413         }

   414     }

   415 

   416     public static class DCIdentifier extends DCTree implements IdentifierTree {

   417         public final Name name;

   418 

   419         DCIdentifier(Name name) {

   420             this.name = name;

   421         }

   422 

   423         @Override @DefinedBy(Api.COMPILER_TREE)

   424         public Kind getKind() {

   425             return Kind.IDENTIFIER;

   426         }

   427 

   428         @Override @DefinedBy(Api.COMPILER_TREE)

   429         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   430             return v.visitIdentifier(this, d);

   431         }

   432 

   433         @Override @DefinedBy(Api.COMPILER_TREE)

   434         public Name getName() {

   435             return name;

   436         }

   437     }

   438 

   439     public static class DCIndex extends DCInlineTag implements IndexTree {

   440         public final DCTree term;

   441         public final List<DCTree> description;

   442 

   443         DCIndex(DCTree term, List<DCTree> description) {

   444             this.term = term;

   445             this.description = description;

   446         }

   447 

   448         @Override @DefinedBy(Api.COMPILER_TREE)

   449         public Kind getKind() {

   450             return Kind.INDEX;

   451         }

   452 

   453         @Override @DefinedBy(Api.COMPILER_TREE)

   454         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   455             return v.visitIndex(this, d);

   456         }

   457 

   458         @Override @DefinedBy(Api.COMPILER_TREE)

   459         public DocTree getSearchTerm() {

   460             return term;

   461         }

   462 

   463         @Override @DefinedBy(Api.COMPILER_TREE)

   464         public java.util.List<? extends DocTree> getDescription() {

   465             return description;

   466         }

   467     }

   468 

   469     public static class DCInheritDoc extends DCInlineTag implements InheritDocTree {

   470         @Override @DefinedBy(Api.COMPILER_TREE)

   471         public Kind getKind() {

   472             return Kind.INHERIT_DOC;

   473         }

   474 

   475         @Override @DefinedBy(Api.COMPILER_TREE)

   476         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   477             return v.visitInheritDoc(this, d);

   478         }

   479     }

   480 

   481     public static class DCLink extends DCInlineTag implements LinkTree {

   482         public final Kind kind;

   483         public final DCReference ref;

   484         public final List<DCTree> label;

   485 

   486         DCLink(Kind kind, DCReference ref, List<DCTree> label) {

   487             Assert.check(kind == Kind.LINK || kind == Kind.LINK_PLAIN);

   488             this.kind = kind;

   489             this.ref = ref;

   490             this.label = label;

   491         }

   492 

   493         @Override @DefinedBy(Api.COMPILER_TREE)

   494         public Kind getKind() {

   495             return kind;

   496         }

   497 

   498         @Override @DefinedBy(Api.COMPILER_TREE)

   499         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   500             return v.visitLink(this, d);

   501         }

   502 

   503         @Override @DefinedBy(Api.COMPILER_TREE)

   504         public ReferenceTree getReference() {

   505             return ref;

   506         }

   507 

   508         @Override @DefinedBy(Api.COMPILER_TREE)

   509         public List<? extends DocTree> getLabel() {

   510             return label;

   511         }

   512     }

   513 

   514     public static class DCLiteral extends DCInlineTag implements LiteralTree {

   515         public final Kind kind;

   516         public final DCText body;

   517 

   518         DCLiteral(Kind kind, DCText body) {

   519             Assert.check(kind == Kind.CODE || kind == Kind.LITERAL);

   520             this.kind = kind;

   521             this.body = body;

   522         }

   523 

   524         @Override @DefinedBy(Api.COMPILER_TREE)

   525         public Kind getKind() {

   526             return kind;

   527         }

   528 

   529         @Override @DefinedBy(Api.COMPILER_TREE)

   530         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   531             return v.visitLiteral(this, d);

   532         }

   533 

   534         @Override @DefinedBy(Api.COMPILER_TREE)

   535         public DCText getBody() {

   536             return body;

   537         }

   538     }

   539 

   540     public static class DCParam extends DCBlockTag implements ParamTree {

   541         public final boolean isTypeParameter;

   542         public final DCIdentifier name;

   543         public final List<DCTree> description;

   544 

   545         DCParam(boolean isTypeParameter, DCIdentifier name, List<DCTree> description) {

   546             this.isTypeParameter = isTypeParameter;

   547             this.name = name;

   548             this.description = description;

   549         }

   550 

   551         @Override @DefinedBy(Api.COMPILER_TREE)

   552         public Kind getKind() {

   553             return Kind.PARAM;

   554         }

   555 

   556         @Override @DefinedBy(Api.COMPILER_TREE)

   557         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   558             return v.visitParam(this, d);

   559         }

   560 

   561         @Override @DefinedBy(Api.COMPILER_TREE)

   562         public boolean isTypeParameter() {

   563             return isTypeParameter;

   564         }

   565 

   566         @Override @DefinedBy(Api.COMPILER_TREE)

   567         public IdentifierTree getName() {

   568             return name;

   569         }

   570 

   571         @Override @DefinedBy(Api.COMPILER_TREE)

   572         public List<? extends DocTree> getDescription() {

   573             return description;

   574         }

   575     }

   576 

   577     public static class DCProvides extends DCBlockTag implements ProvidesTree {

   578         public final DCReference serviceType;

   579         public final List<DCTree> description;

   580 

   581         DCProvides(DCReference serviceType, List<DCTree> description) {

   582             this.serviceType = serviceType;

   583             this.description = description;

   584         }

   585 

   586         @Override @DefinedBy(Api.COMPILER_TREE)

   587         public Kind getKind() {

   588             return Kind.PROVIDES;

   589         }

   590 

   591         @Override @DefinedBy(Api.COMPILER_TREE)

   592         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   593             return v.visitProvides(this, d);

   594         }

   595 

   596         @Override @DefinedBy(Api.COMPILER_TREE)

   597         public ReferenceTree getServiceType() {

   598             return serviceType;

   599         }

   600 

   601         @Override @DefinedBy(Api.COMPILER_TREE)

   602         public List<? extends DocTree> getDescription() {

   603             return description;

   604         }

   605     }

   606 

   607     public static class DCReference extends DCEndPosTree<DCReference> implements ReferenceTree {

   608         public final String signature;

   609 

   610         // The following are not directly exposed through ReferenceTree

   611         // use DocTrees.getElement(DocTreePath)

   612         public final JCTree qualifierExpression;

   613         public final Name memberName;

   614         public final List<JCTree> paramTypes;

   615 

   616 

   617         DCReference(String signature, JCTree qualExpr, Name member, List<JCTree> paramTypes) {

   618             this.signature = signature;

   619             qualifierExpression = qualExpr;

   620             memberName = member;

   621             this.paramTypes = paramTypes;

   622         }

   623 

   624         @Override @DefinedBy(Api.COMPILER_TREE)

   625         public Kind getKind() {

   626             return Kind.REFERENCE;

   627         }

   628 

   629         @Override @DefinedBy(Api.COMPILER_TREE)

   630         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   631             return v.visitReference(this, d);

   632         }

   633 

   634         @Override @DefinedBy(Api.COMPILER_TREE)

   635         public String getSignature() {

   636             return signature;

   637         }

   638     }

   639 

   640     public static class DCReturn extends DCBlockTag implements ReturnTree {

   641         public final List<DCTree> description;

   642 

   643         DCReturn(List<DCTree> description) {

   644             this.description = description;

   645         }

   646 

   647         @Override @DefinedBy(Api.COMPILER_TREE)

   648         public Kind getKind() {

   649             return Kind.RETURN;

   650         }

   651 

   652         @Override @DefinedBy(Api.COMPILER_TREE)

   653         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   654             return v.visitReturn(this, d);

   655         }

   656 

   657         @Override @DefinedBy(Api.COMPILER_TREE)

   658         public List<? extends DocTree> getDescription() {

   659             return description;

   660         }

   661     }

   662 

   663     public static class DCSee extends DCBlockTag implements SeeTree {

   664         public final List<DCTree> reference;

   665 

   666         DCSee(List<DCTree> reference) {

   667             this.reference = reference;

   668         }

   669 

   670         @Override @DefinedBy(Api.COMPILER_TREE)

   671         public Kind getKind() {

   672             return Kind.SEE;

   673         }

   674 

   675         @Override @DefinedBy(Api.COMPILER_TREE)

   676         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   677             return v.visitSee(this, d);

   678         }

   679 

   680         @Override @DefinedBy(Api.COMPILER_TREE)

   681         public List<? extends DocTree> getReference() {

   682             return reference;

   683         }

   684     }

   685 

   686     public static class DCSerial extends DCBlockTag implements SerialTree {

   687         public final List<DCTree> description;

   688 

   689         DCSerial(List<DCTree> description) {

   690             this.description = description;

   691         }

   692 

   693         @Override @DefinedBy(Api.COMPILER_TREE)

   694         public Kind getKind() {

   695             return Kind.SERIAL;

   696         }

   697 

   698         @Override @DefinedBy(Api.COMPILER_TREE)

   699         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   700             return v.visitSerial(this, d);

   701         }

   702 

   703         @Override @DefinedBy(Api.COMPILER_TREE)

   704         public List<? extends DocTree> getDescription() {

   705             return description;

   706         }

   707     }

   708 

   709     public static class DCSerialData extends DCBlockTag implements SerialDataTree {

   710         public final List<DCTree> description;

   711 

   712         DCSerialData(List<DCTree> description) {

   713             this.description = description;

   714         }

   715 

   716         @Override @DefinedBy(Api.COMPILER_TREE)

   717         public Kind getKind() {

   718             return Kind.SERIAL_DATA;

   719         }

   720 

   721         @Override @DefinedBy(Api.COMPILER_TREE)

   722         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   723             return v.visitSerialData(this, d);

   724         }

   725 

   726         @Override @DefinedBy(Api.COMPILER_TREE)

   727         public List<? extends DocTree> getDescription() {

   728             return description;

   729         }

   730     }

   731 

   732     public static class DCSerialField extends DCBlockTag implements SerialFieldTree {

   733         public final DCIdentifier name;

   734         public final DCReference type;

   735         public final List<DCTree> description;

   736 

   737         DCSerialField(DCIdentifier name, DCReference type, List<DCTree> description) {

   738             this.description = description;

   739             this.name = name;

   740             this.type = type;

   741         }

   742 

   743         @Override @DefinedBy(Api.COMPILER_TREE)

   744         public Kind getKind() {

   745             return Kind.SERIAL_FIELD;

   746         }

   747 

   748         @Override @DefinedBy(Api.COMPILER_TREE)

   749         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   750             return v.visitSerialField(this, d);

   751         }

   752 

   753         @Override @DefinedBy(Api.COMPILER_TREE)

   754         public List<? extends DocTree> getDescription() {

   755             return description;

   756         }

   757 

   758         @Override @DefinedBy(Api.COMPILER_TREE)

   759         public IdentifierTree getName() {

   760             return name;

   761         }

   762 

   763         @Override @DefinedBy(Api.COMPILER_TREE)

   764         public ReferenceTree getType() {

   765             return type;

   766         }

   767     }

   768 

   769     public static class DCSince extends DCBlockTag implements SinceTree {

   770         public final List<DCTree> body;

   771 

   772         DCSince(List<DCTree> body) {

   773             this.body = body;

   774         }

   775 

   776         @Override @DefinedBy(Api.COMPILER_TREE)

   777         public Kind getKind() {

   778             return Kind.SINCE;

   779         }

   780 

   781         @Override @DefinedBy(Api.COMPILER_TREE)

   782         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   783             return v.visitSince(this, d);

   784         }

   785 

   786         @Override @DefinedBy(Api.COMPILER_TREE)

   787         public List<? extends DocTree> getBody() {

   788             return body;

   789         }

   790     }

   791 

   792     public static class DCStartElement extends DCEndPosTree<DCStartElement> implements StartElementTree {

   793         public final Name name;

   794         public final List<DCTree> attrs;

   795         public final boolean selfClosing;

   796 

   797         DCStartElement(Name name, List<DCTree> attrs, boolean selfClosing) {

   798             this.name = name;

   799             this.attrs = attrs;

   800             this.selfClosing = selfClosing;

   801         }

   802 

   803         @Override @DefinedBy(Api.COMPILER_TREE)

   804         public Kind getKind() {

   805             return Kind.START_ELEMENT;

   806         }

   807 

   808         @Override @DefinedBy(Api.COMPILER_TREE)

   809         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   810             return v.visitStartElement(this, d);

   811         }

   812 

   813         @Override @DefinedBy(Api.COMPILER_TREE)

   814         public Name getName() {

   815             return name;

   816         }

   817 

   818         @Override @DefinedBy(Api.COMPILER_TREE)

   819         public List<? extends DocTree> getAttributes() {

   820             return attrs;

   821         }

   822 

   823         @Override @DefinedBy(Api.COMPILER_TREE)

   824         public boolean isSelfClosing() {

   825             return selfClosing;

   826         }

   827     }

   828 

   829     public static class DCSummary extends DCInlineTag implements SummaryTree {

   830         public final List<DCTree> summary;

   831 

   832         DCSummary(List<DCTree> summary) {

   833             this.summary = summary;

   834         }

   835 

   836         @Override @DefinedBy(Api.COMPILER_TREE)

   837         public Kind getKind() {

   838             return Kind.SUMMARY;

   839         }

   840 

   841         @Override @DefinedBy(Api.COMPILER_TREE)

   842         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   843             return v.visitSummary(this, d);

   844         }

   845 

   846         @Override @DefinedBy(Api.COMPILER_TREE)

   847         public List<? extends DocTree> getSummary() {

   848             return summary;

   849         }

   850     }

   851 

   852     public static class DCText extends DCTree implements TextTree {

   853         public final String text;

   854 

   855         DCText(String text) {

   856             this.text = text;

   857         }

   858 

   859         @Override @DefinedBy(Api.COMPILER_TREE)

   860         public Kind getKind() {

   861             return Kind.TEXT;

   862         }

   863 

   864         @Override @DefinedBy(Api.COMPILER_TREE)

   865         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   866             return v.visitText(this, d);

   867         }

   868 

   869         @Override @DefinedBy(Api.COMPILER_TREE)

   870         public String getBody() {

   871             return text;

   872         }

   873     }

   874 

   875     public static class DCThrows extends DCBlockTag implements ThrowsTree {

   876         public final Kind kind;

   877         public final DCReference name;

   878         public final List<DCTree> description;

   879 

   880         DCThrows(Kind kind, DCReference name, List<DCTree> description) {

   881             Assert.check(kind == Kind.EXCEPTION || kind == Kind.THROWS);

   882             this.kind = kind;

   883             this.name = name;

   884             this.description = description;

   885         }

   886 

   887         @Override @DefinedBy(Api.COMPILER_TREE)

   888         public Kind getKind() {

   889             return kind;

   890         }

   891 

   892         @Override @DefinedBy(Api.COMPILER_TREE)

   893         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   894             return v.visitThrows(this, d);

   895         }

   896 

   897         @Override @DefinedBy(Api.COMPILER_TREE)

   898         public ReferenceTree getExceptionName() {

   899             return name;

   900         }

   901 

   902         @Override @DefinedBy(Api.COMPILER_TREE)

   903         public List<? extends DocTree> getDescription() {

   904             return description;

   905         }

   906     }

   907 

   908     public static class DCUnknownBlockTag extends DCBlockTag implements UnknownBlockTagTree {

   909         public final Name name;

   910         public final List<DCTree> content;

   911 

   912         DCUnknownBlockTag(Name name, List<DCTree> content) {

   913             this.name = name;

   914             this.content = content;

   915         }

   916 

   917         @Override @DefinedBy(Api.COMPILER_TREE)

   918         public Kind getKind() {

   919             return Kind.UNKNOWN_BLOCK_TAG;

   920         }

   921 

   922         @Override @DefinedBy(Api.COMPILER_TREE)

   923         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   924             return v.visitUnknownBlockTag(this, d);

   925         }

   926 

   927         @Override @DefinedBy(Api.COMPILER_TREE)

   928         public String getTagName() {

   929             return name.toString();

   930         }

   931 

   932         @Override @DefinedBy(Api.COMPILER_TREE)

   933         public List<? extends DocTree> getContent() {

   934             return content;

   935         }

   936     }

   937 

   938     public static class DCUnknownInlineTag extends DCInlineTag implements UnknownInlineTagTree {

   939         public final Name name;

   940         public final List<DCTree> content;

   941 

   942         DCUnknownInlineTag(Name name, List<DCTree> content) {

   943             this.name = name;

   944             this.content = content;

   945         }

   946 

   947         @Override @DefinedBy(Api.COMPILER_TREE)

   948         public Kind getKind() {

   949             return Kind.UNKNOWN_INLINE_TAG;

   950         }

   951 

   952         @Override @DefinedBy(Api.COMPILER_TREE)

   953         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   954             return v.visitUnknownInlineTag(this, d);

   955         }

   956 

   957         @Override @DefinedBy(Api.COMPILER_TREE)

   958         public String getTagName() {

   959             return name.toString();

   960         }

   961 

   962         @Override @DefinedBy(Api.COMPILER_TREE)

   963         public List<? extends DocTree> getContent() {

   964             return content;

   965         }

   966     }

   967 

   968     public static class DCUses extends DCBlockTag implements UsesTree {

   969         public final DCReference serviceType;

   970         public final List<DCTree> description;

   971 

   972         DCUses(DCReference serviceType, List<DCTree> description) {

   973             this.serviceType = serviceType;

   974             this.description = description;

   975         }

   976 

   977         @Override @DefinedBy(Api.COMPILER_TREE)

   978         public Kind getKind() {

   979             return Kind.USES;

   980         }

   981 

   982         @Override @DefinedBy(Api.COMPILER_TREE)

   983         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

   984             return v.visitUses(this, d);

   985         }

   986 

   987         @Override @DefinedBy(Api.COMPILER_TREE)

   988         public ReferenceTree getServiceType() {

   989             return serviceType;

   990         }

   991 

   992         @Override @DefinedBy(Api.COMPILER_TREE)

   993         public List<? extends DocTree> getDescription() {

   994             return description;

   995         }

   996     }

   997 

   998     public static class DCValue extends DCInlineTag implements ValueTree {

   999         public final DCReference ref;

  1000 

  1001         DCValue(DCReference ref) {

  1002             this.ref = ref;

  1003         }

  1004 

  1005         @Override @DefinedBy(Api.COMPILER_TREE)

  1006         public Kind getKind() {

  1007             return Kind.VALUE;

  1008         }

  1009 

  1010         @Override @DefinedBy(Api.COMPILER_TREE)

  1011         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

  1012             return v.visitValue(this, d);

  1013         }

  1014 

  1015         @Override @DefinedBy(Api.COMPILER_TREE)

  1016         public ReferenceTree getReference() {

  1017             return ref;

  1018         }

  1019     }

  1020 

  1021     public static class DCVersion extends DCBlockTag implements VersionTree {

  1022         public final List<DCTree> body;

  1023 

  1024         DCVersion(List<DCTree> body) {

  1025             this.body = body;

  1026         }

  1027 

  1028         @Override @DefinedBy(Api.COMPILER_TREE)

  1029         public Kind getKind() {

  1030             return Kind.VERSION;

  1031         }

  1032 

  1033         @Override @DefinedBy(Api.COMPILER_TREE)

  1034         public <R, D> R accept(DocTreeVisitor<R, D> v, D d) {

  1035             return v.visitVersion(this, d);

  1036         }

  1037 

  1038         @Override @DefinedBy(Api.COMPILER_TREE)

  1039         public List<? extends DocTree> getBody() {

  1040             return body;

  1041         }

  1042     }

  1043 

  1044 }