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).