Represents a construct that can be annotated.

A construct is either an javax.lang.model.element.element or a javax.lang.model.type.type.  Annotations on an element
are on a declaration, whereas annotations on a type are on
a specific use of a type name.

The terms directly present, present,
indirectly present, and associated  are used
throughout this interface to describe precisely which annotations
are returned by the methods defined herein.

In the definitions below, an annotation A has an
annotation type AT. If AT is a repeatable annotation
type, the type of the containing annotation is ATC.

Annotation A is directly present on a construct
C if either:



A is explicitly or implicitly declared as applying to
the source code representation of C.

Typically, if exactly one annotation of type AT appears in
the source code of representation of C, then A is
explicitly declared as applying to C.

If there are multiple annotations of type AT present on
C, then if AT is repeatable annotation type, an
annotation of type ATC is implicitly declared on C.

 A representation of A appears in the executable output
for C, such as the RuntimeVisibleAnnotations or
RuntimeVisibleParameterAnnotations attributes of a class
file.



An annotation A is present on a
construct C if either:


A is directly present on C.

No annotation of type AT is directly present on
C, and C is a class and AT is inheritable
and A is present on the superclass of C.



An annotation A is indirectly present on a construct
C if both:



AT is a repeatable annotation type with a containing
annotation type ATC.

An annotation of type ATC is directly present on
C and A is an annotation included in the result of
calling the value method of the directly present annotation
of type ATC.



An annotation A is associated with a construct
C if either:



 A is directly or indirectly present on C.

 No annotation of type AT is directly or indirectly
present on C, and C is a class, and AT is
inheritable, and A is associated with the superclass of
C.

Represents an annotation.  An annotation associates a value with
each element of an annotation type.

 Annotations should be compared using the equals
method.  There is no guarantee that any particular annotation will
always be represented by the same object.

Represents a value of an annotation type element.
A value is of one of the following types:
 a wrapper class (such as Integer) for a primitive type
     String
     TypeMirror
     VariableElement (representing an enum constant)
     AnnotationMirror
     List<? extends AnnotationValue>
             (representing the elements, in declared order, if the value is an array)

A visitor of the values of annotation type elements, using a
variant of the visitor design pattern.  Unlike a standard visitor
which dispatches based on the concrete type of a member of a type
hierarchy, this visitor dispatches based on the type of data
stored; there are no distinct subclasses for storing, for example,
boolean values versus int values.  Classes
implementing this interface are used to operate on a value when the
type of that value is unknown at compile time.  When a visitor is
passed to a value's accept method,
the visitXYZ method applicable to that value is
invoked.

 Classes implementing this interface may or may not throw a
NullPointerException if the additional parameter p
is null; see documentation of the implementing class for
details.

 WARNING: It is possible that methods will be added to
this interface to accommodate new, currently unknown, language
structures added to future versions of the Java™ programming
language.  Therefore, visitor classes directly implementing this
interface may be source incompatible with future versions of the
platform.  To avoid this source incompatibility, visitor
implementations are encouraged to instead extend the appropriate
abstract visitor class that implements this interface.  However, an
API should generally use this visitor interface as the type for
parameters, return type, etc. rather than one of the abstract
classes.

Note that methods to accommodate new language constructs could
be added in a source compatible way if they were added as
default methods.  However, default methods are only
available on Java SE 8 and higher releases and the javax.lang.model.* packages bundled in Java SE 8 are required to
also be runnable on Java SE 7.  Therefore, default methods
cannot be used when extending javax.lang.model.*
to cover Java SE 8 language features.  However, default methods may
be used in subsequent revisions of the javax.lang.model.*
packages that are only required to run on Java SE 8 and higher
platform versions.

Represents a program element such as a package, class, or method.
Each element represents a static, language-level construct
(and not, for example, a runtime construct of the virtual machine).

 Elements should be compared using the equals(Object)
method.  There is no guarantee that any particular element will
always be represented by the same object.

 To implement operations based on the class of an Element object, either use a javax.lang.model.element.visitor or
use the result of the getKind() method.  Using instanceof is not necessarily a reliable idiom for
determining the effective class of an object in this modeling
hierarchy since an implementation may choose to have a single object
implement multiple Element subinterfaces.

A visitor of program elements, in the style of the visitor design
pattern.  Classes implementing this interface are used to operate
on an element when the kind of element is unknown at compile time.
When a visitor is passed to an element's accept method, the visitXYZ method most applicable
to that element is invoked.

 Classes implementing this interface may or may not throw a
NullPointerException if the additional parameter p
is null; see documentation of the implementing class for
details.

 WARNING: It is possible that methods will be added to
this interface to accommodate new, currently unknown, language
structures added to future versions of the Java™ programming
language.  Therefore, visitor classes directly implementing this
interface may be source incompatible with future versions of the
platform.  To avoid this source incompatibility, visitor
implementations are encouraged to instead extend the appropriate
abstract visitor class that implements this interface.  However, an
API should generally use this visitor interface as the type for
parameters, return type, etc. rather than one of the abstract
classes.

Note that methods to accommodate new language constructs could
be added in a source compatible way if they were added as
default methods.  However, default methods are only
available on Java SE 8 and higher releases and the javax.lang.model.* packages bundled in Java SE 8 are required to
also be runnable on Java SE 7.  Therefore, default methods
cannot be used when extending javax.lang.model.*
to cover Java SE 8 language features.  However, default methods may
be used in subsequent revisions of the javax.lang.model.*
packages that are only required to run on Java SE 8 and higher
platform versions.

Represents a method, constructor, or initializer (static or
instance) of a class or interface, including annotation type
elements.

An immutable sequence of characters.  When created by the same
implementation, objects implementing this interface must obey the
general equals contract when compared
with each other.  Therefore, Name objects from the same
implementation are usable in collections while Names from
different implementations may not work properly in collections.

An empty Name has a length of zero.

In the context of javax.annotation.processing.annotation
processing, the guarantees for "the same" implementation must
include contexts where the API mediated side effects of javax.annotation.processing.processors could be visible
to each other, including successive annotation processing
javax.annotation.processing.rounds.

Represents a package program element.  Provides access to information
about the package and its members.

A mixin interface for an element that has type parameters.

A mixin interface for an element that has a qualified name.

Represents a class or interface program element.  Provides access
to information about the type and its members.  Note that an enum
type is a kind of class and an annotation type is a kind of
interface.


While a TypeElement represents a class or interface
element, a DeclaredType represents a class
or interface type, the latter being a use
(or invocation) of the former.
The distinction is most apparent with generic types,
for which a single element can define a whole
family of types.  For example, the element
java.util.Set corresponds to the parameterized types
java.util.Set<String> and java.util.Set<Number>
(and many others), and to the raw type java.util.Set.

 Each method of this interface that returns a list of elements
will return them in the order that is natural for the underlying
source of program information.  For example, if the underlying
source of information is Java source code, then the elements will be
returned in source code order.

Represents a formal type parameter of a generic class, interface, method,
or constructor element.
A type parameter declares a TypeVariable.

Indicates that an unknown kind of annotation value was encountered.
This can occur if the language evolves and new kinds of annotation
values can be stored in an annotation.  May be thrown by an
javax.lang.model.element.annotation value visitor to
indicate that the visitor was created for a prior version of the
language.

Indicates that an unknown kind of element was encountered.  This
can occur if the language evolves and new kinds of elements are
added to the Element hierarchy.  May be thrown by an
javax.lang.model.element.element visitor to indicate that the
visitor was created for a prior version of the language.

Represents a field, enum constant, method or constructor
parameter, local variable, resource variable, or exception
parameter.

Represents an array type.
A multidimensional array type is represented as an array type
whose component type is also an array type.

Represents a declared type, either a class type or an interface type.
This includes parameterized types such as java.util.Set<String>
as well as raw types.

 While a TypeElement represents a class or interface
element, a DeclaredType represents a class
or interface type, the latter being a use
(or invocation) of the former.
See TypeElement for more on this distinction.

 The supertypes (both class and interface types) of a declared
type may be found using the Types.directSupertypes(TypeMirror) method.  This returns the
supertypes with any type arguments substituted in.

Represents a class or interface type that cannot be properly modeled.
This may be the result of a processing error,
such as a missing class file or erroneous source code.
Most queries for
information derived from such a type (such as its members or its
supertype) will not, in general, return meaningful results.

Represents the type of an executable.  An executable
is a method, constructor, or initializer.

 The executable is
represented as when viewed as a method (or constructor or
initializer) of some reference type.
If that reference type is parameterized, then its actual
type arguments are substituted into any types returned by the methods of
this interface.

Represents an intersection type.

An intersection type can be either implicitly or explicitly
declared in a program. For example, the bound of the type parameter
<T extends Number & Runnable> is an (implicit) intersection
type.  As of RELEASE_8, this is represented by an IntersectionType with
Number and Runnable as its bounds.

Thrown when an application attempts to access the Class object
corresponding to a TypeMirror.

Thrown when an application attempts to access a sequence of Class objects each corresponding to a TypeMirror.

A pseudo-type used where no actual type is appropriate.
The kinds of NoType are:

VOID - corresponds to the keyword void.
PACKAGE - the pseudo-type of a package element.
NONE - used in other cases
  where no actual type is appropriate; for example, the superclass
  of java.lang.Object.

Represents the null type.
This is the type of the expression null,

Represents a primitive type.  These include
boolean, byte, short, int,
long, char, float, and double.

Represents a reference type.
These include class and interface types, array types, type variables,
and the null type.

Represents a type in the Java programming language.
Types include primitive types, declared types (class and interface types),
array types, type variables, and the null type.
Also represented are wildcard type arguments,
the signature and return types of executables,
and pseudo-types corresponding to packages and to the keyword void.

 Types should be compared using the utility methods in Types.  There is no guarantee that any particular type will always
be represented by the same object.

 To implement operations based on the class of an TypeMirror object, either use a javax.lang.model.type.visitor
or use the result of the getKind() method.  Using instanceof is not necessarily a reliable idiom for
determining the effective class of an object in this modeling
hierarchy since an implementation may choose to have a single
object implement multiple TypeMirror subinterfaces.

Represents a type variable.
A type variable may be explicitly declared by a
javax.lang.model.element.type parameter of a
type, method, or constructor.
A type variable may also be declared implicitly, as by
the capture conversion of a wildcard type argument
(see chapter 5 of
The Java™ Language Specification).

A visitor of types, in the style of the
visitor design pattern.  Classes implementing this
interface are used to operate on a type when the kind of
type is unknown at compile time.  When a visitor is passed to a
type's accept method, the visitXYZ
method most applicable to that type is invoked.

 Classes implementing this interface may or may not throw a
NullPointerException if the additional parameter p
is null; see documentation of the implementing class for
details.

 WARNING: It is possible that methods will be added to
this interface to accommodate new, currently unknown, language
structures added to future versions of the Java™ programming
language.  Therefore, visitor classes directly implementing this
interface may be source incompatible with future versions of the
platform.  To avoid this source incompatibility, visitor
implementations are encouraged to instead extend the appropriate
abstract visitor class that implements this interface.  However, an
API should generally use this visitor interface as the type for
parameters, return type, etc. rather than one of the abstract
classes.

Note that methods to accommodate new language constructs could
be added in a source compatible way if they were added as
default methods.  However, default methods are only
available on Java SE 8 and higher releases and the javax.lang.model.* packages bundled in Java SE 8 are required to
also be runnable on Java SE 7.  Therefore, default methods
cannot be used when extending javax.lang.model.*
to cover Java SE 8 language features.  However, default methods may
be used in subsequent revisions of the javax.lang.model.*
packages that are only required to run on Java SE 8 and higher
platform versions.

Represents a union type.

As of the RELEASE_7 source version, union types can appear as the type
of a multi-catch exception parameter.

Indicates that an unknown kind of type was encountered.  This can
occur if the language evolves and new kinds of types are added to
the TypeMirror hierarchy.  May be thrown by a javax.lang.model.type.type visitor to indicate that the visitor was created
for a prior version of the language.

Represents a wildcard type argument.
Examples include:

  ?
  ? extends Number
  ? super T

 A wildcard may have its upper bound explicitly set by an
extends clause, its lower bound explicitly set by a
super clause, or neither (but not both).

Superclass of exceptions which indicate that an unknown kind of
entity was encountered.  This situation can occur if the language
evolves and new kinds of constructs are introduced.  Subclasses of
this exception may be thrown by visitors to indicate that the
visitor was created for a prior version of the language.

A common superclass for those exceptions allows a single catch
block to have code handling them uniformly.

A skeletal visitor for annotation values with default behavior
appropriate for the RELEASE_6
source version.

 WARNING: The AnnotationValueVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract annotation
value visitor class will also be introduced to correspond to the
new language level; this visitor will have different default
behavior for the visit method in question.  When the new visitor is
introduced, all or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A skeletal visitor for annotation values with default behavior
appropriate for the RELEASE_7
source version.

 WARNING: The AnnotationValueVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract annotation
value visitor class will also be introduced to correspond to the
new language level; this visitor will have different default
behavior for the visit method in question.  When the new visitor is
introduced, all or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A skeletal visitor for annotation values with default behavior
appropriate for the RELEASE_8
source version.

 WARNING: The AnnotationValueVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract annotation
value visitor class will also be introduced to correspond to the
new language level; this visitor will have different default
behavior for the visit method in question.  When the new visitor is
introduced, all or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A skeletal visitor of program elements with default behavior
appropriate for the RELEASE_6
source version.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract element visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A skeletal visitor of program elements with default behavior
appropriate for the RELEASE_7
source version.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract element visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A skeletal visitor of program elements with default behavior
appropriate for the RELEASE_8
source version.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract element visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A skeletal visitor of types with default behavior appropriate for
the RELEASE_6
source version.

 WARNING: The TypeVisitor interface implemented
by this class may have methods added to it in the future to
accommodate new, currently unknown, language structures added to
future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract type visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A skeletal visitor of types with default behavior appropriate for
the RELEASE_7
source version.

 WARNING: The TypeVisitor interface implemented
by this class may have methods added to it in the future to
accommodate new, currently unknown, language structures added to
future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract type visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A skeletal visitor of types with default behavior appropriate for
the RELEASE_8
source version.

 WARNING: The TypeVisitor interface implemented
by this class may have methods added to it in the future to
accommodate new, currently unknown, language structures added to
future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract type visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

import static javax.lang.model.util.ElementFilter.*;
...
     List<VariableElement> fs = fieldsIn(someClass.getEnclosedElements());

Filters for selecting just the elements of interest from a
collection of elements.  The returned sets and lists are new
collections and do use the argument as a backing store.  The
methods in this class do not make any attempts to guard against
concurrent modifications of the arguments.  The returned sets and
lists are mutable but unsafe for concurrent access.  A returned set
has the same iteration order as the argument set to a method.

If iterables and sets containing null are passed as
arguments to methods in this class, a NullPointerException
will be thrown.

Note that a static import statement can make the text of
calls to the methods in this class more concise; for example:



    import static javax.lang.model.util.ElementFilter.*;
    ...
         List<VariableElement> fs = fieldsIn(someClass.getEnclosedElements());

A visitor of program elements based on their javax.lang.model.element.kind with default behavior appropriate for the RELEASE_6 source version.  For javax.lang.model.element.elements XYZ that may have more than one
kind, the visitXYZ methods in this class delegate
to the visitXYZKind method corresponding to the
first argument's kind.  The visitXYZKind methods
call defaultAction, passing their arguments
to defaultAction's corresponding parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it or the
ElementKind enum used in this case may have
constants added to it in the future to accommodate new, currently
unknown, language structures added to future versions of the
Java™ programming language.  Therefore, methods whose names
begin with "visit" may be added to this class in the
future; to avoid incompatibilities, classes which extend this class
should not declare any instance methods with names beginning with
"visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract element kind
visitor class will also be introduced to correspond to the new
language level; this visitor will have different default behavior
for the visit method in question.  When the new visitor is
introduced, all or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A visitor of program elements based on their javax.lang.model.element.kind with default behavior appropriate for the RELEASE_7 source version.  For javax.lang.model.element.elements XYZ that may have more than one
kind, the visitXYZ methods in this class delegate
to the visitXYZKind method corresponding to the
first argument's kind.  The visitXYZKind methods
call defaultAction, passing their arguments
to defaultAction's corresponding parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it or the
ElementKind enum used in this case may have
constants added to it in the future to accommodate new, currently
unknown, language structures added to future versions of the
Java™ programming language.  Therefore, methods whose names
begin with "visit" may be added to this class in the
future; to avoid incompatibilities, classes which extend this class
should not declare any instance methods with names beginning with
"visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract element kind
visitor class will also be introduced to correspond to the new
language level; this visitor will have different default behavior
for the visit method in question.  When the new visitor is
introduced, all or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A visitor of program elements based on their javax.lang.model.element.kind with default behavior appropriate for the RELEASE_8 source version.  For javax.lang.model.element.elements XYZ that may have more than one
kind, the visitXYZ methods in this class delegate
to the visitXYZKind method corresponding to the
first argument's kind.  The visitXYZKind methods
call defaultAction, passing their arguments
to defaultAction's corresponding parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it or the
ElementKind enum used in this case may have
constants added to it in the future to accommodate new, currently
unknown, language structures added to future versions of the
Java™ programming language.  Therefore, methods whose names
begin with "visit" may be added to this class in the
future; to avoid incompatibilities, classes which extend this class
should not declare any instance methods with names beginning with
"visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new abstract element kind
visitor class will also be introduced to correspond to the new
language level; this visitor will have different default behavior
for the visit method in question.  When the new visitor is
introduced, all or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

Utility methods for operating on program elements.

Compatibility Note: Methods may be added to this interface
in future releases of the platform.

A scanning visitor of program elements with default behavior
appropriate for the RELEASE_6
source version.  The visitXYZ methods in this
class scan their component elements by calling scan on
their enclosed elements,
parameters, etc., as
indicated in the individual method specifications.  A subclass can
control the order elements are visited by overriding the
visitXYZ methods.  Note that clients of a scanner
may get the desired behavior be invoking v.scan(e, p) rather
than v.visit(e, p) on the root objects of interest.

When a subclass overrides a visitXYZ method, the
new method can cause the enclosed elements to be scanned in the
default way by calling super.visitXYZ.  In this
fashion, the concrete visitor can control the ordering of traversal
over the component elements with respect to the additional
processing; for example, consistently calling
super.visitXYZ at the start of the overridden
methods will yield a preorder traversal, etc.  If the component
elements should be traversed in some other order, instead of
calling super.visitXYZ, an overriding visit method
should call scan with the elements in the desired order.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new element scanner visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

A scanning visitor of program elements with default behavior
appropriate for the RELEASE_7
source version.  The visitXYZ methods in this
class scan their component elements by calling scan on
their enclosed elements,
parameters, etc., as
indicated in the individual method specifications.  A subclass can
control the order elements are visited by overriding the
visitXYZ methods.  Note that clients of a scanner
may get the desired behavior be invoking v.scan(e, p) rather
than v.visit(e, p) on the root objects of interest.

When a subclass overrides a visitXYZ method, the
new method can cause the enclosed elements to be scanned in the
default way by calling super.visitXYZ.  In this
fashion, the concrete visitor can control the ordering of traversal
over the component elements with respect to the additional
processing; for example, consistently calling
super.visitXYZ at the start of the overridden
methods will yield a preorder traversal, etc.  If the component
elements should be traversed in some other order, instead of
calling super.visitXYZ, an overriding visit method
should call scan with the elements in the desired order.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new element scanner visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

A scanning visitor of program elements with default behavior
appropriate for the RELEASE_8
source version.  The visitXYZ methods in this
class scan their component elements by calling scan on
their enclosed elements,
parameters, etc., as
indicated in the individual method specifications.  A subclass can
control the order elements are visited by overriding the
visitXYZ methods.  Note that clients of a scanner
may get the desired behavior be invoking v.scan(e, p) rather
than v.visit(e, p) on the root objects of interest.

When a subclass overrides a visitXYZ method, the
new method can cause the enclosed elements to be scanned in the
default way by calling super.visitXYZ.  In this
fashion, the concrete visitor can control the ordering of traversal
over the component elements with respect to the additional
processing; for example, consistently calling
super.visitXYZ at the start of the overridden
methods will yield a preorder traversal, etc.  If the component
elements should be traversed in some other order, instead of
calling super.visitXYZ, an overriding visit method
should call scan with the elements in the desired order.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new element scanner visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

A simple visitor for annotation values with default behavior
appropriate for the RELEASE_6
source version.  Visit methods call defaultAction(java.lang.Object, P) passing their arguments to defaultAction's
corresponding parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The AnnotationValueVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new simple annotation
value visitor class will also be introduced to correspond to the
new language level; this visitor will have different default
behavior for the visit method in question.  When the new visitor is
introduced, all or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A simple visitor for annotation values with default behavior
appropriate for the RELEASE_7
source version.  Visit methods call defaultAction passing their arguments to defaultAction's
corresponding parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The AnnotationValueVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new simple annotation
value visitor class will also be introduced to correspond to the
new language level; this visitor will have different default
behavior for the visit method in question.  When the new visitor is
introduced, all or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A simple visitor for annotation values with default behavior
appropriate for the RELEASE_8
source version.  Visit methods call defaultAction passing their arguments to defaultAction's
corresponding parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The AnnotationValueVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new simple annotation
value visitor class will also be introduced to correspond to the
new language level; this visitor will have different default
behavior for the visit method in question.  When the new visitor is
introduced, all or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A simple visitor of program elements with default behavior
appropriate for the RELEASE_6
source version.

Visit methods corresponding to RELEASE_6 language
constructs call defaultAction, passing their
arguments to defaultAction's corresponding parameters.

For constructs introduced in RELEASE_7 and later, visitUnknown is called instead.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new simple element visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A simple visitor of program elements with default behavior
appropriate for the RELEASE_7
source version.

Visit methods corresponding to RELEASE_7 and earlier
language constructs call defaultAction,
passing their arguments to defaultAction's corresponding
parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new simple element visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A simple visitor of program elements with default behavior
appropriate for the RELEASE_8
source version.

Visit methods corresponding to RELEASE_7 and earlier
language constructs call defaultAction,
passing their arguments to defaultAction's corresponding
parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The ElementVisitor interface
implemented by this class may have methods added to it in the
future to accommodate new, currently unknown, language structures
added to future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new simple element visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A simple visitor of types with default behavior appropriate for the
RELEASE_6 source version.

Visit methods corresponding to RELEASE_6 language
constructs call defaultAction, passing their
arguments to defaultAction's corresponding parameters.

For constructs introduced in RELEASE_7 and later, visitUnknown is called instead.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The TypeVisitor interface implemented
by this class may have methods added to it in the future to
accommodate new, currently unknown, language structures added to
future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new simple type visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A simple visitor of types with default behavior appropriate for the
RELEASE_7 source version.

Visit methods corresponding to RELEASE_7 and earlier
language constructs call defaultAction,
passing their arguments to defaultAction's corresponding
parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The TypeVisitor interface implemented
by this class may have methods added to it in the future to
accommodate new, currently unknown, language structures added to
future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new simple type visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A simple visitor of types with default behavior appropriate for the
RELEASE_7 source version.

Visit methods corresponding to RELEASE_8 and earlier
language constructs call defaultAction,
passing their arguments to defaultAction's corresponding
parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The TypeVisitor interface implemented
by this class may have methods added to it in the future to
accommodate new, currently unknown, language structures added to
future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new simple type visitor
class will also be introduced to correspond to the new language
level; this visitor will have different default behavior for the
visit method in question.  When the new visitor is introduced, all
or portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A visitor of types based on their javax.lang.model.type.kind with
default behavior appropriate for the RELEASE_6 source version.  For javax.lang.model.type.types XYZ that may have more than one
kind, the visitXYZ methods in this class delegate
to the visitXYZKind method corresponding to the
first argument's kind.  The visitXYZKind methods
call defaultAction, passing their arguments
to defaultAction's corresponding parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The TypeVisitor interface implemented
by this class may have methods added to it in the future to
accommodate new, currently unknown, language structures added to
future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new type kind visitor class
will also be introduced to correspond to the new language level;
this visitor will have different default behavior for the visit
method in question.  When the new visitor is introduced, all or
portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A visitor of types based on their javax.lang.model.type.kind with
default behavior appropriate for the RELEASE_7 source version.  For javax.lang.model.type.types XYZ that may have more than one
kind, the visitXYZ methods in this class delegate
to the visitXYZKind method corresponding to the
first argument's kind.  The visitXYZKind methods
call defaultAction, passing their arguments
to defaultAction's corresponding parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The TypeVisitor interface implemented
by this class may have methods added to it in the future to
accommodate new, currently unknown, language structures added to
future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new type kind visitor class
will also be introduced to correspond to the new language level;
this visitor will have different default behavior for the visit
method in question.  When the new visitor is introduced, all or
portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

A visitor of types based on their javax.lang.model.type.kind with
default behavior appropriate for the RELEASE_8 source version.  For javax.lang.model.type.types XYZ that may have more than one
kind, the visitXYZ methods in this class delegate
to the visitXYZKind method corresponding to the
first argument's kind.  The visitXYZKind methods
call defaultAction, passing their arguments
to defaultAction's corresponding parameters.

 Methods in this class may be overridden subject to their
general contract.  Note that annotating methods in concrete
subclasses with @Override will help
ensure that methods are overridden as intended.

 WARNING: The TypeVisitor interface implemented
by this class may have methods added to it in the future to
accommodate new, currently unknown, language structures added to
future versions of the Java™ programming language.
Therefore, methods whose names begin with "visit" may be
added to this class in the future; to avoid incompatibilities,
classes which extend this class should not declare any instance
methods with names beginning with "visit".

When such a new visit method is added, the default
implementation in this class will be to call the visitUnknown method.  A new type kind visitor class
will also be introduced to correspond to the new language level;
this visitor will have different default behavior for the visit
method in question.  When the new visitor is introduced, all or
portions of this visitor may be deprecated.

Note that adding a default implementation of a new visit method
in a visitor class will occur instead of adding a default
method directly in the visitor interface since a Java SE 8
language feature cannot be used to this version of the API since
this version is required to be runnable on Java SE 7
implementations.  Future versions of the API that are only required
to run on Java SE 8 and later may take advantage of default methods
in this situation.

Utility methods for operating on types.

Compatibility Note: Methods may be added to this interface
in future releases of the platform.