/*
 * Copyright (c) 2005, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.sun.source.tree;

Common interface for all nodes in an abstract syntax tree.
WARNING: This interface and its sub-interfaces are
subject to change as the Java programming language evolves.
These interfaces are implemented by the JDK Java compiler (javac)
and should not be implemented either directly or indirectly by
other applications.
Author:
Peter von der Ahé, Jonathan Gibbons
Since:
1.6/**
 * Common interface for all nodes in an abstract syntax tree.
 *
 * <p><b>WARNING:</b> This interface and its sub-interfaces are
 * subject to change as the Java programming language evolves.
 * These interfaces are implemented by the JDK Java compiler (javac)
 * and should not be implemented either directly or indirectly by
 * other applications.
 *
 * @author Peter von der Ah&eacute;
 * @author Jonathan Gibbons
 *
 * @since 1.6
 */
public interface Tree {

    
Enumerates all kinds of trees.
/**
     * Enumerates all kinds of trees.
     */
    public enum Kind {
        
Used for instances of AnnotatedTypeTree representing annotated types. /**
         * Used for instances of {@link AnnotatedTypeTree}
         * representing annotated types.
         */
        ANNOTATED_TYPE(AnnotatedTypeTree.class),

        
Used for instances of AnnotationTree representing declaration annotations. /**
         * Used for instances of {@link AnnotationTree}
         * representing declaration annotations.
         */
        ANNOTATION(AnnotationTree.class),

        
Used for instances of AnnotationTree representing type annotations. /**
         * Used for instances of {@link AnnotationTree}
         * representing type annotations.
         */
        TYPE_ANNOTATION(AnnotationTree.class),

        
Used for instances of ArrayAccessTree. /**
         * Used for instances of {@link ArrayAccessTree}.
         */
        ARRAY_ACCESS(ArrayAccessTree.class),

        
Used for instances of ArrayTypeTree. /**
         * Used for instances of {@link ArrayTypeTree}.
         */
        ARRAY_TYPE(ArrayTypeTree.class),

        
Used for instances of AssertTree. /**
         * Used for instances of {@link AssertTree}.
         */
        ASSERT(AssertTree.class),

        
Used for instances of AssignmentTree. /**
         * Used for instances of {@link AssignmentTree}.
         */
        ASSIGNMENT(AssignmentTree.class),

        
Used for instances of BlockTree. /**
         * Used for instances of {@link BlockTree}.
         */
        BLOCK(BlockTree.class),

        
Used for instances of BreakTree. /**
         * Used for instances of {@link BreakTree}.
         */
        BREAK(BreakTree.class),

        
Used for instances of CaseTree. /**
         * Used for instances of {@link CaseTree}.
         */
        CASE(CaseTree.class),

        
Used for instances of CatchTree. /**
         * Used for instances of {@link CatchTree}.
         */
        CATCH(CatchTree.class),

        
Used for instances of ClassTree representing classes. /**
         * Used for instances of {@link ClassTree} representing classes.
         */
        CLASS(ClassTree.class),

        
Used for instances of CompilationUnitTree. /**
         * Used for instances of {@link CompilationUnitTree}.
         */
        COMPILATION_UNIT(CompilationUnitTree.class),

        
Used for instances of ConditionalExpressionTree. /**
         * Used for instances of {@link ConditionalExpressionTree}.
         */
        CONDITIONAL_EXPRESSION(ConditionalExpressionTree.class),

        
Used for instances of ContinueTree. /**
         * Used for instances of {@link ContinueTree}.
         */
        CONTINUE(ContinueTree.class),

        
Used for instances of DoWhileLoopTree. /**
         * Used for instances of {@link DoWhileLoopTree}.
         */
        DO_WHILE_LOOP(DoWhileLoopTree.class),

        
Used for instances of EnhancedForLoopTree. /**
         * Used for instances of {@link EnhancedForLoopTree}.
         */
        ENHANCED_FOR_LOOP(EnhancedForLoopTree.class),

        
Used for instances of ExpressionStatementTree. /**
         * Used for instances of {@link ExpressionStatementTree}.
         */
        EXPRESSION_STATEMENT(ExpressionStatementTree.class),

        
Used for instances of MemberSelectTree. /**
         * Used for instances of {@link MemberSelectTree}.
         */
        MEMBER_SELECT(MemberSelectTree.class),

        
Used for instances of MemberReferenceTree. /**
         * Used for instances of {@link MemberReferenceTree}.
         */
        MEMBER_REFERENCE(MemberReferenceTree.class),

        
Used for instances of ForLoopTree. /**
         * Used for instances of {@link ForLoopTree}.
         */
        FOR_LOOP(ForLoopTree.class),

        
Used for instances of IdentifierTree. /**
         * Used for instances of {@link IdentifierTree}.
         */
        IDENTIFIER(IdentifierTree.class),

        
Used for instances of IfTree. /**
         * Used for instances of {@link IfTree}.
         */
        IF(IfTree.class),

        
Used for instances of ImportTree. /**
         * Used for instances of {@link ImportTree}.
         */
        IMPORT(ImportTree.class),

        
Used for instances of InstanceOfTree. /**
         * Used for instances of {@link InstanceOfTree}.
         */
        INSTANCE_OF(InstanceOfTree.class),

        
Used for instances of LabeledStatementTree. /**
         * Used for instances of {@link LabeledStatementTree}.
         */
        LABELED_STATEMENT(LabeledStatementTree.class),

        
Used for instances of MethodTree. /**
         * Used for instances of {@link MethodTree}.
         */
        METHOD(MethodTree.class),

        
Used for instances of MethodInvocationTree. /**
         * Used for instances of {@link MethodInvocationTree}.
         */
        METHOD_INVOCATION(MethodInvocationTree.class),

        
Used for instances of ModifiersTree. /**
         * Used for instances of {@link ModifiersTree}.
         */
        MODIFIERS(ModifiersTree.class),

        
Used for instances of NewArrayTree. /**
         * Used for instances of {@link NewArrayTree}.
         */
        NEW_ARRAY(NewArrayTree.class),

        
Used for instances of NewClassTree. /**
         * Used for instances of {@link NewClassTree}.
         */
        NEW_CLASS(NewClassTree.class),

        
Used for instances of LambdaExpressionTree. /**
         * Used for instances of {@link LambdaExpressionTree}.
         */
        LAMBDA_EXPRESSION(LambdaExpressionTree.class),

        
Used for instances of PackageTree. 
Since:
9/**
         * Used for instances of {@link PackageTree}.
         * @since 9
         */
        PACKAGE(PackageTree.class),

        
Used for instances of ParenthesizedTree. /**
         * Used for instances of {@link ParenthesizedTree}.
         */
        PARENTHESIZED(ParenthesizedTree.class),

        
{@preview Associated with pattern matching for instanceof, a preview feature of
          the Java language.
          This enum constant is associated with pattern matching for instanceof, a preview feature of the Java language. Preview features may be removed in a future release, or upgraded to permanent features of the Java language.} Used for instances of BindingPatternTree. 
Since:
14/**
         * {@preview Associated with pattern matching for instanceof, a preview feature of
         *           the Java language.
         *
         *           This enum constant is associated with <i>pattern matching for instanceof</i>, a preview
         *           feature of the Java language. Preview features
         *           may be removed in a future release, or upgraded to permanent
         *           features of the Java language.}
         *
         * Used for instances of {@link BindingPatternTree}.
         *
         * @since 14
         */
        BINDING_PATTERN(BindingPatternTree.class),

        
Used for instances of PrimitiveTypeTree. /**
         * Used for instances of {@link PrimitiveTypeTree}.
         */
        PRIMITIVE_TYPE(PrimitiveTypeTree.class),

        
Used for instances of ReturnTree. /**
         * Used for instances of {@link ReturnTree}.
         */
        RETURN(ReturnTree.class),

        
Used for instances of EmptyStatementTree. /**
         * Used for instances of {@link EmptyStatementTree}.
         */
        EMPTY_STATEMENT(EmptyStatementTree.class),

        
Used for instances of SwitchTree. /**
         * Used for instances of {@link SwitchTree}.
         */
        SWITCH(SwitchTree.class),

        
Used for instances of SwitchExpressionTree. 
Since:
12/**
         * Used for instances of {@link SwitchExpressionTree}.
         *
         * @since 12
         */
        SWITCH_EXPRESSION(SwitchExpressionTree.class),

        
Used for instances of SynchronizedTree. /**
         * Used for instances of {@link SynchronizedTree}.
         */
        SYNCHRONIZED(SynchronizedTree.class),

        
Used for instances of ThrowTree. /**
         * Used for instances of {@link ThrowTree}.
         */
        THROW(ThrowTree.class),

        
Used for instances of TryTree. /**
         * Used for instances of {@link TryTree}.
         */
        TRY(TryTree.class),

        
Used for instances of ParameterizedTypeTree. /**
         * Used for instances of {@link ParameterizedTypeTree}.
         */
        PARAMETERIZED_TYPE(ParameterizedTypeTree.class),

        
Used for instances of UnionTypeTree. /**
         * Used for instances of {@link UnionTypeTree}.
         */
        UNION_TYPE(UnionTypeTree.class),

        
Used for instances of IntersectionTypeTree. /**
         * Used for instances of {@link IntersectionTypeTree}.
         */
        INTERSECTION_TYPE(IntersectionTypeTree.class),

        
Used for instances of TypeCastTree. /**
         * Used for instances of {@link TypeCastTree}.
         */
        TYPE_CAST(TypeCastTree.class),

        
Used for instances of TypeParameterTree. /**
         * Used for instances of {@link TypeParameterTree}.
         */
        TYPE_PARAMETER(TypeParameterTree.class),

        
Used for instances of VariableTree. /**
         * Used for instances of {@link VariableTree}.
         */
        VARIABLE(VariableTree.class),

        
Used for instances of WhileLoopTree. /**
         * Used for instances of {@link WhileLoopTree}.
         */
        WHILE_LOOP(WhileLoopTree.class),

        
Used for instances of UnaryTree representing postfix increment operator ++. /**
         * Used for instances of {@link UnaryTree} representing postfix
         * increment operator {@code ++}.
         */
        POSTFIX_INCREMENT(UnaryTree.class),

        
Used for instances of UnaryTree representing postfix decrement operator --. /**
         * Used for instances of {@link UnaryTree} representing postfix
         * decrement operator {@code --}.
         */
        POSTFIX_DECREMENT(UnaryTree.class),

        
Used for instances of UnaryTree representing prefix increment operator ++. /**
         * Used for instances of {@link UnaryTree} representing prefix
         * increment operator {@code ++}.
         */
        PREFIX_INCREMENT(UnaryTree.class),

        
Used for instances of UnaryTree representing prefix decrement operator --. /**
         * Used for instances of {@link UnaryTree} representing prefix
         * decrement operator {@code --}.
         */
        PREFIX_DECREMENT(UnaryTree.class),

        
Used for instances of UnaryTree representing unary plus operator +. /**
         * Used for instances of {@link UnaryTree} representing unary plus
         * operator {@code +}.
         */
        UNARY_PLUS(UnaryTree.class),

        
Used for instances of UnaryTree representing unary minus operator -. /**
         * Used for instances of {@link UnaryTree} representing unary minus
         * operator {@code -}.
         */
        UNARY_MINUS(UnaryTree.class),

        
Used for instances of UnaryTree representing bitwise complement operator ~. /**
         * Used for instances of {@link UnaryTree} representing bitwise
         * complement operator {@code ~}.
         */
        BITWISE_COMPLEMENT(UnaryTree.class),

        
Used for instances of UnaryTree representing logical complement operator !. /**
         * Used for instances of {@link UnaryTree} representing logical
         * complement operator {@code !}.
         */
        LOGICAL_COMPLEMENT(UnaryTree.class),

        
Used for instances of BinaryTree representing multiplication *. /**
         * Used for instances of {@link BinaryTree} representing
         * multiplication {@code *}.
         */
        MULTIPLY(BinaryTree.class),

        
Used for instances of BinaryTree representing division /. /**
         * Used for instances of {@link BinaryTree} representing
         * division {@code /}.
         */
        DIVIDE(BinaryTree.class),

        
Used for instances of BinaryTree representing remainder %. /**
         * Used for instances of {@link BinaryTree} representing
         * remainder {@code %}.
         */
        REMAINDER(BinaryTree.class),

        
Used for instances of BinaryTree representing addition or string concatenation +. /**
         * Used for instances of {@link BinaryTree} representing
         * addition or string concatenation {@code +}.
         */
        PLUS(BinaryTree.class),

        
Used for instances of BinaryTree representing subtraction -. /**
         * Used for instances of {@link BinaryTree} representing
         * subtraction {@code -}.
         */
        MINUS(BinaryTree.class),

        
Used for instances of BinaryTree representing left shift <<. /**
         * Used for instances of {@link BinaryTree} representing
         * left shift {@code <<}.
         */
        LEFT_SHIFT(BinaryTree.class),

        
Used for instances of BinaryTree representing right shift >>. /**
         * Used for instances of {@link BinaryTree} representing
         * right shift {@code >>}.
         */
        RIGHT_SHIFT(BinaryTree.class),

        
Used for instances of BinaryTree representing unsigned right shift >>>. /**
         * Used for instances of {@link BinaryTree} representing
         * unsigned right shift {@code >>>}.
         */
        UNSIGNED_RIGHT_SHIFT(BinaryTree.class),

        
Used for instances of BinaryTree representing less-than <. /**
         * Used for instances of {@link BinaryTree} representing
         * less-than {@code <}.
         */
        LESS_THAN(BinaryTree.class),

        
Used for instances of BinaryTree representing greater-than >. /**
         * Used for instances of {@link BinaryTree} representing
         * greater-than {@code >}.
         */
        GREATER_THAN(BinaryTree.class),

        
Used for instances of BinaryTree representing less-than-equal <=. /**
         * Used for instances of {@link BinaryTree} representing
         * less-than-equal {@code <=}.
         */
        LESS_THAN_EQUAL(BinaryTree.class),

        
Used for instances of BinaryTree representing greater-than-equal >=. /**
         * Used for instances of {@link BinaryTree} representing
         * greater-than-equal {@code >=}.
         */
        GREATER_THAN_EQUAL(BinaryTree.class),

        
Used for instances of BinaryTree representing equal-to ==. /**
         * Used for instances of {@link BinaryTree} representing
         * equal-to {@code ==}.
         */
        EQUAL_TO(BinaryTree.class),

        
Used for instances of BinaryTree representing not-equal-to !=. /**
         * Used for instances of {@link BinaryTree} representing
         * not-equal-to {@code !=}.
         */
        NOT_EQUAL_TO(BinaryTree.class),

        
Used for instances of BinaryTree representing bitwise and logical "and" &. /**
         * Used for instances of {@link BinaryTree} representing
         * bitwise and logical "and" {@code &}.
         */
        AND(BinaryTree.class),

        
Used for instances of BinaryTree representing bitwise and logical "xor" ^. /**
         * Used for instances of {@link BinaryTree} representing
         * bitwise and logical "xor" {@code ^}.
         */
        XOR(BinaryTree.class),

        
Used for instances of BinaryTree representing bitwise and logical "or" |. /**
         * Used for instances of {@link BinaryTree} representing
         * bitwise and logical "or" {@code |}.
         */
        OR(BinaryTree.class),

        
Used for instances of BinaryTree representing conditional-and &&. /**
         * Used for instances of {@link BinaryTree} representing
         * conditional-and {@code &&}.
         */
        CONDITIONAL_AND(BinaryTree.class),

        
Used for instances of BinaryTree representing conditional-or ||. /**
         * Used for instances of {@link BinaryTree} representing
         * conditional-or {@code ||}.
         */
        CONDITIONAL_OR(BinaryTree.class),

        
Used for instances of CompoundAssignmentTree representing multiplication assignment *=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * multiplication assignment {@code *=}.
         */
        MULTIPLY_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing division assignment /=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * division assignment {@code /=}.
         */
        DIVIDE_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing remainder assignment %=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * remainder assignment {@code %=}.
         */
        REMAINDER_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing addition or string concatenation assignment +=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * addition or string concatenation assignment {@code +=}.
         */
        PLUS_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing subtraction assignment -=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * subtraction assignment {@code -=}.
         */
        MINUS_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing left shift assignment <<=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * left shift assignment {@code <<=}.
         */
        LEFT_SHIFT_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing right shift assignment >>=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * right shift assignment {@code >>=}.
         */
        RIGHT_SHIFT_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing unsigned right shift assignment >>>=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * unsigned right shift assignment {@code >>>=}.
         */
        UNSIGNED_RIGHT_SHIFT_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing bitwise and logical "and" assignment &=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * bitwise and logical "and" assignment {@code &=}.
         */
        AND_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing bitwise and logical "xor" assignment ^=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * bitwise and logical "xor" assignment {@code ^=}.
         */
        XOR_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of CompoundAssignmentTree representing bitwise and logical "or" assignment |=. /**
         * Used for instances of {@link CompoundAssignmentTree} representing
         * bitwise and logical "or" assignment {@code |=}.
         */
        OR_ASSIGNMENT(CompoundAssignmentTree.class),

        
Used for instances of LiteralTree representing an integral literal expression of type int. /**
         * Used for instances of {@link LiteralTree} representing
         * an integral literal expression of type {@code int}.
         */
        INT_LITERAL(LiteralTree.class),

        
Used for instances of LiteralTree representing an integral literal expression of type long. /**
         * Used for instances of {@link LiteralTree} representing
         * an integral literal expression of type {@code long}.
         */
        LONG_LITERAL(LiteralTree.class),

        
Used for instances of LiteralTree representing a floating-point literal expression of type float. /**
         * Used for instances of {@link LiteralTree} representing
         * a floating-point literal expression of type {@code float}.
         */
        FLOAT_LITERAL(LiteralTree.class),

        
Used for instances of LiteralTree representing a floating-point literal expression of type double. /**
         * Used for instances of {@link LiteralTree} representing
         * a floating-point literal expression of type {@code double}.
         */
        DOUBLE_LITERAL(LiteralTree.class),

        
Used for instances of LiteralTree representing a boolean literal expression of type boolean. /**
         * Used for instances of {@link LiteralTree} representing
         * a boolean literal expression of type {@code boolean}.
         */
        BOOLEAN_LITERAL(LiteralTree.class),

        
Used for instances of LiteralTree representing a character literal expression of type char. /**
         * Used for instances of {@link LiteralTree} representing
         * a character literal expression of type {@code char}.
         */
        CHAR_LITERAL(LiteralTree.class),

        
Used for instances of LiteralTree representing a string literal expression of type String. /**
         * Used for instances of {@link LiteralTree} representing
         * a string literal expression of type {@link String}.
         */
        STRING_LITERAL(LiteralTree.class),

        
Used for instances of LiteralTree representing the use of null. /**
         * Used for instances of {@link LiteralTree} representing
         * the use of {@code null}.
         */
        NULL_LITERAL(LiteralTree.class),

        
Used for instances of WildcardTree representing an unbounded wildcard type argument. /**
         * Used for instances of {@link WildcardTree} representing
         * an unbounded wildcard type argument.
         */
        UNBOUNDED_WILDCARD(WildcardTree.class),

        
Used for instances of WildcardTree representing an extends bounded wildcard type argument. /**
         * Used for instances of {@link WildcardTree} representing
         * an extends bounded wildcard type argument.
         */
        EXTENDS_WILDCARD(WildcardTree.class),

        
Used for instances of WildcardTree representing a super bounded wildcard type argument. /**
         * Used for instances of {@link WildcardTree} representing
         * a super bounded wildcard type argument.
         */
        SUPER_WILDCARD(WildcardTree.class),

        
Used for instances of ErroneousTree. /**
         * Used for instances of {@link ErroneousTree}.
         */
        ERRONEOUS(ErroneousTree.class),

        
Used for instances of ClassTree representing interfaces. /**
         * Used for instances of {@link ClassTree} representing interfaces.
         */
        INTERFACE(ClassTree.class),

        
Used for instances of ClassTree representing enums. /**
         * Used for instances of {@link ClassTree} representing enums.
         */
        ENUM(ClassTree.class),

        
Used for instances of ClassTree representing annotation types. /**
         * Used for instances of {@link ClassTree} representing annotation types.
         */
        ANNOTATION_TYPE(ClassTree.class),

        
Used for instances of ModuleTree representing module declarations. /**
         * Used for instances of {@link ModuleTree} representing module declarations.
         */
        MODULE(ModuleTree.class),

        
Used for instances of ExportsTree representing exports directives in a module declaration. /**
         * Used for instances of {@link ExportsTree} representing
         * exports directives in a module declaration.
         */
        EXPORTS(ExportsTree.class),

        
Used for instances of ExportsTree representing opens directives in a module declaration. /**
         * Used for instances of {@link ExportsTree} representing
         * opens directives in a module declaration.
         */
        OPENS(OpensTree.class),

        
Used for instances of ProvidesTree representing provides directives in a module declaration. /**
         * Used for instances of {@link ProvidesTree} representing
         * provides directives in a module declaration.
         */
        PROVIDES(ProvidesTree.class),

        
{@preview Associated with records, a preview feature of the Java language.
          This enum constant is associated with records, a preview feature of the Java language. Preview features may be removed in a future release, or upgraded to permanent features of the Java language.} Used for instances of ClassTree representing records. 
Since:
14/**
         * {@preview Associated with records, a preview feature of the Java language.
         *
         *           This enum constant is associated with <i>records</i>, a preview
         *           feature of the Java language. Preview features
         *           may be removed in a future release, or upgraded to permanent
         *           features of the Java language.}
         *
         * Used for instances of {@link ClassTree} representing records.
         *
         * @since 14
         */
        @jdk.internal.PreviewFeature(feature=jdk.internal.PreviewFeature.Feature.RECORDS,
                                     essentialAPI=false)
        RECORD(ClassTree.class),

        
Used for instances of RequiresTree representing requires directives in a module declaration. /**
         * Used for instances of {@link RequiresTree} representing
         * requires directives in a module declaration.
         */
        REQUIRES(RequiresTree.class),

        
Used for instances of UsesTree representing uses directives in a module declaration. /**
         * Used for instances of {@link UsesTree} representing
         * uses directives in a module declaration.
         */
        USES(UsesTree.class),

        
An implementation-reserved node. This is the not the node
you are looking for.
/**
         * An implementation-reserved node. This is the not the node
         * you are looking for.
         */
        OTHER(null),

        
Used for instances of YieldTree. 
Since:
13/**
         * Used for instances of {@link YieldTree}.
         *
         * @since 13
         */
        YIELD(YieldTree.class);


        Kind(Class<? extends Tree> intf) {
            associatedInterface = intf;
        }

        
Returns the associated interface type that uses this kind.
Returns:
the associated interface/**
         * Returns the associated interface type that uses this kind.
         * @return the associated interface
         */
        public Class<? extends Tree> asInterface() {
            return associatedInterface;
        }

        private final Class<? extends Tree> associatedInterface;
    }

    
Returns the kind of this tree.
Returns:
the kind of this tree./**
     * Returns the kind of this tree.
     *
     * @return the kind of this tree.
     */
    Kind getKind();

    
Accept method used to implement the visitor pattern.  The
visitor pattern is used to implement operations on trees.
Params:
visitor – the visitor to be called
data – a value to be passed to the visitor
Type parameters:
<R> – result type of this operation.
<D> – type of additional data.
Returns:
the result returned from calling the visitor/**
     * Accept method used to implement the visitor pattern.  The
     * visitor pattern is used to implement operations on trees.
     *
     * @param <R> result type of this operation.
     * @param <D> type of additional data.
     * @param visitor the visitor to be called
     * @param data a value to be passed to the visitor
     * @return the result returned from calling the visitor
     */
    <R,D> R accept(TreeVisitor<R,D> visitor, D data);
}