jdk-sandbox: comparison langtools/src/share/sample/language/model/CoreReflectionFactory.java

equal deleted inserted replaced

-:6696a7abec02
+:69b191cb1d7e
+/*
+* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+*
+*   - Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*
+*   - Redistributions in binary form must reproduce the above copyright
+*     notice, this list of conditions and the following disclaimer in the
+*     documentation and/or other materials provided with the distribution.
+*
+*   - Neither the name of Oracle nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+import java.lang.annotation.Annotation;
+import javax.annotation.processing.SupportedSourceVersion;
+import javax.lang.model.element.*;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.type.*;
+import javax.lang.model.util.*;
+import java.lang.reflect.*;
+import java.io.Writer;
+import java.util.*;
+import static javax.lang.model.SourceVersion.RELEASE_8;
+import static java.util.Objects.*;
+/**
+* This class provides a proof-of-concept implementation of the {@code
+* javax.lang.model.*} API backed by core reflection. That is, rather
+* than having a source file or compile-time class file as the
+* originator of the information about an element or type, as done
+* during standard annotation processing, runtime core reflection
+* objects serve that purpose instead.
+*
+* With this kind of implementation, the same logic can be used for
+* both compile-time and runtime processing of annotations.
+*
+* The nested types in this class define a specialization of {@code
+* javax.lang.model.*} to provide some additional functionality and
+* type information. The original {@code javax.lang.model.*} API was
+* designed to accommodate such a specialization by using wildcards in
+* the return types of methods.
+*
+* It would be technically possible for further specializations of the
+* API implemented in this class to define alternative semantics of
+* annotation look-up. For example to allow one annotation to have the
+* effect of macro-expanding into a set of other annotations.
+*
+* Some aspects of the implementation are left as "exercises for the
+* reader" to complete if interested.
+*
+* When passed null pointers, the methods defined in this type will
+* generally throw null pointer exceptions.
+*
+* To get started, first compile this file with a command line like:
+*
+* <pre>
+* $JDK/bin/javac -parameters -Xdoclint:all/public -Xlint:all -d $OUTPUT_DIR CoreReflectionFactory.java
+* </pre>
+*
+* and then run the main method of {@code CoreReflectionFactory},
+* which will print out a representation of {@code
+* CoreReflectionFactory}. To use the printing logic defined in {@code
+* javac}, put {@code tools.jar} on the classpath as in:
+*
+* <pre>
+* $JDK/bin/java -cp $OUTPUT_DIR:$JDK_ROOT/lib/tools.jar CoreReflectionFactory
+* </pre>
+*
+* @author Joseph D. Darcy (darcy)
+* @author Joel Borggren-Franck (jfranck)
+*/
+public class CoreReflectionFactory {
+private CoreReflectionFactory() {
+throw new AssertionError("No instances of CoreReflectionFactory for you!");
+}
+/**
+* Returns a reflection type element mirroring a {@code Class} object.
+* @return a reflection type element mirroring a {@code Class} object
+* @param clazz the {@code Class} to mirror
+*/
+public static ReflectionTypeElement createMirror(Class<?> clazz) {
+return new CoreReflTypeElement(Objects.requireNonNull(clazz));
+}
+/**
+* Returns a reflection package element mirroring a {@code Package} object.
+* @return a reflection package element mirroring a {@code Package} object
+* @param pkg the {@code Package} to mirror
+*/
+public static ReflectionPackageElement createMirror(Package pkg) {
+// Treat a null pkg to mean an unnamed package.
+return new CoreReflPackageElement(pkg);
+}
+/**
+* Returns a reflection variable element mirroring a {@code Field} object.
+* @return a reflection variable element mirroring a {@code Field} object
+* @param field the {@code Field} to mirror
+*/
+public static ReflectionVariableElement createMirror(Field field) {
+return new CoreReflFieldVariableElement(Objects.requireNonNull(field));
+}
+/**
+* Returns a reflection executable element mirroring a {@code Method} object.
+* @return a reflection executable element mirroring a {@code Method} object
+* @param method the {@code Method} to mirror
+*/
+public static ReflectionExecutableElement createMirror(Method method)  {
+return new CoreReflMethodExecutableElement(Objects.requireNonNull(method));
+}
+/**
+* Returns a reflection executable element mirroring a {@code Constructor} object.
+* @return a reflection executable element mirroring a {@code Constructor} object
+* @param constructor the {@code Constructor} to mirror
+*/
+public static ReflectionExecutableElement createMirror(Constructor<?> constructor)  {
+return new CoreReflConstructorExecutableElement(Objects.requireNonNull(constructor));
+}
+/**
+* Returns a type parameter element mirroring a {@code TypeVariable} object.
+* @return a type parameter element mirroring a {@code TypeVariable} object
+* @param tv the {@code TypeVariable} to mirror
+*/
+public static TypeParameterElement createMirror(java.lang.reflect.TypeVariable<?> tv) {
+return new CoreReflTypeParameterElement(Objects.requireNonNull(tv));
+}
+/**
+* Returns a variable element mirroring a {@code Parameter} object.
+* @return a variable element mirroring a {@code Parameter} object
+* @param p the {Parameter} to mirror
+*/
+public static VariableElement createMirror(java.lang.reflect.Parameter p) {
+return new CoreReflParameterVariableElement(Objects.requireNonNull(p));
+}
+/**
+* Returns an annotation mirror mirroring an annotation object.
+* @return an annotation mirror mirroring an annotation object
+* @param annotation the annotation to mirror
+*/
+public static AnnotationMirror createMirror(Annotation annotation)  {
+return new CoreReflAnnotationMirror(Objects.requireNonNull(annotation));
+}
+/**
+* Returns a {@code Types} utility object for type objects backed by core reflection.
+* @return a {@code Types} utility object for type objects backed by core reflection
+*/
+public static Types getTypes() {
+return CoreReflTypes.instance();
+}
+/**
+* Returns an {@code Elements} utility object for type objects backed by core reflection.
+* @return an {@code Elements} utility object for type objects backed by core reflection
+*/
+public static Elements getElements() {
+return CoreReflElements.instance();
+}
+// Helper
+private static TypeMirror createTypeMirror(Class<?> c) {
+return TypeFactory.instance(Objects.requireNonNull(c));
+}
+/**
+* Main method; prints out a representation of this class.
+* @param args command-line arguments, currently ignored
+*/
+public static void main(String... args) {
+getElements().printElements(new java.io.PrintWriter(System.out),
+createMirror(CoreReflectionFactory.class));
+}
+/**
+* A specialization of {@code javax.lang.model.element.Element} that is
+* backed by core reflection.
+*/
+public static interface ReflectionElement
+extends Element, AnnotatedElement {
+/**
+* {@inheritDoc}
+*/
+@Override
+ReflectionElement getEnclosingElement();
+/**
+* {@inheritDoc}
+*/
+@Override
+List<ReflectionElement> getEnclosedElements();
+/**
+* Applies a visitor to this element.
+*
+* @param v the visitor operating on this element
+* @param p additional parameter to the visitor
+* @param <R> the return type of the visitor's methods
+* @param <P> the type of the additional parameter to the visitor's methods
+* @return a visitor-specified result
+*/
+<R,P> R accept(ReflectionElementVisitor<R,P> v, P p);
+// Functionality specific to the specialization
+/**
+* Returns the underlying core reflection source object, if applicable.
+* @return the underlying core reflection source object, if applicable
+*/
+AnnotatedElement getSource();
+// Functionality from javax.lang.model.util.Elements
+/**
+* Returns the package of an element. The package of a package
+* is itself.
+* @return the package of an element
+*/
+ReflectionPackageElement getPackage();
+}
+/**
+* A logical specialization of {@code
+* javax.lang.model.element.ElementVisitor} being backed by core
+* reflection.
+*
+* @param <R> the return type of this visitor's methods.
+* @param <P> the type of the additional parameter to this visitor's
+*            methods.
+*/
+public static interface ReflectionElementVisitor<R, P> {
+/**
+* Visits an element.
+* @param e  the element to visit
+* @param p  a visitor-specified parameter
+* @return a visitor-specified result
+*/
+R visit(ReflectionElement e, P p);
+/**
+* A convenience method equivalent to {@code v.visit(e, null)}.
+* @param e  the element to visit
+* @return a visitor-specified result
+*/
+R visit(ReflectionElement e);
+/**
+* Visits a package element.
+* @param e  the element to visit
+* @param p  a visitor-specified parameter
+* @return a visitor-specified result
+*/
+R visitPackage(ReflectionPackageElement e, P p);
+/**
+* Visits a type element.
+* @param e  the element to visit
+* @param p  a visitor-specified parameter
+* @return a visitor-specified result
+*/
+R visitType(ReflectionTypeElement e, P p);
+/**
+* Visits a variable element.
+* @param e  the element to visit
+* @param p  a visitor-specified parameter
+* @return a visitor-specified result
+*/
+R visitVariable(ReflectionVariableElement e, P p);
+/**
+* Visits an executable element.
+* @param e  the element to visit
+* @param p  a visitor-specified parameter
+* @return a visitor-specified result
+*/
+R visitExecutable(ReflectionExecutableElement e, P p);
+/**
+* Visits a type parameter element.
+* @param e  the element to visit
+* @param p  a visitor-specified parameter
+* @return a visitor-specified result
+*/
+R visitTypeParameter(ReflectionTypeParameterElement e, P p);
+/**
+* Visits an unknown kind of element.
+* This can occur if the language evolves and new kinds
+* of elements are added to the {@code Element} hierarchy.
+*
+* @param e  the element to visit
+* @param p  a visitor-specified parameter
+* @return a visitor-specified result
+* @throws UnknownElementException
+* a visitor implementation may optionally throw this exception
+*/
+R visitUnknown(ReflectionElement e, P p);
+}
+/**
+* A specialization of {@code javax.lang.model.element.ExecutableElement} that is
+* backed by core reflection.
+*/
+public static interface ReflectionExecutableElement
+extends ReflectionElement, ExecutableElement, ReflectionParameterizable {
+/**
+* {@inheritDoc}
+*/
+@Override
+List<ReflectionTypeParameterElement> getTypeParameters();
+/**
+* {@inheritDoc}
+*/
+@Override
+List<ReflectionVariableElement> getParameters();
+// Functionality specific to the specialization
+/**
+* Returns all parameters, including synthetic ones.
+* @return all parameters, including synthetic ones
+*/
+List<ReflectionVariableElement> getAllParameters();
+/**
+* {@inheritDoc}
+*/
+@Override
+Executable getSource();
+/**
+* Returns true if this executable is a synthetic construct; returns false otherwise.
+* @return true if this executable is a synthetic construct; returns false otherwise
+*/
+boolean isSynthetic();
+/**
+* Returns true if this executable is a bridge method; returns false otherwise.
+* @return true if this executable is a bridge method; returns false otherwise
+*/
+boolean isBridge();
+}
+/**
+* A specialization of {@code javax.lang.model.element.PackageElement} being
+* backed by core reflection.
+*/
+public static interface ReflectionPackageElement
+extends ReflectionElement, PackageElement {
+// Functionality specific to the specialization
+/**
+* {@inheritDoc}
+*/
+@Override
+Package getSource();
+}
+/**
+* A specialization of {@code javax.lang.model.element.TypeElement} that is
+* backed by core reflection.
+*/
+public static interface ReflectionTypeElement
+extends ReflectionElement, TypeElement, ReflectionParameterizable {
+/**
+* {@inheritDoc}
+*/
+@Override
+List<ReflectionTypeParameterElement> getTypeParameters();
+/**
+* {@inheritDoc}
+*/
+@Override
+List<ReflectionElement> getEnclosedElements();
+// Methods specific to the specialization, but functionality
+// also present in javax.lang.model.util.Elements.
+/**
+* Returns all members of a type element, whether inherited or
+* declared directly. For a class the result also includes its
+* constructors, but not local or anonymous classes.
+* @return all members of the type
+*/
+List<ReflectionElement> getAllMembers();
+/**
+* Returns the binary name of a type element.
+* @return the binary name of a type element
+*/
+Name getBinaryName();
+// Functionality specific to the specialization
+/**
+* {@inheritDoc}
+*/
+@Override
+Class<?> getSource();
+}
+/**
+* A specialization of {@code javax.lang.model.element.TypeParameterElement} being
+* backed by core reflection.
+*/
+public static interface ReflectionTypeParameterElement
+extends ReflectionElement, TypeParameterElement {
+/**
+* {@inheritDoc}
+*/
+@Override
+ReflectionElement getGenericElement();
+// Functionality specific to the specialization
+// Conceptually should have an override for getSource
+// returning GenericDeclaration, but GenericDeclaration
+// doesn't currently implement AnnotatedElement.
+//         /**
+//          * {@inheritDoc}
+//          */
+//         @Override
+//         java.lang.reflect.GenericDeclaration getSource();
+}
+/**
+* A specialization of {@code javax.lang.model.element.VariableElement} that is
+* backed by core reflection.
+*/
+public static interface ReflectionVariableElement
+extends ReflectionElement, VariableElement {
+// Functionality specific to the specialization
+/**
+* Returns true if this variable is a synthetic construct; returns false otherwise.
+* @return true if this variable is a synthetic construct; returns false otherwise
+*/
+boolean isSynthetic();
+/**
+* Returns true if this variable is implicitly declared in source code; returns false otherwise.
+* @return true if this variable is implicitly declared in source code; returns false otherwise
+*/
+boolean isImplicit();
+// The VariableElement concept covers fields, variables, and
+// method and constructor parameters. Therefore, this
+// interface cannot define a more precise override of
+// getSource since those three concept have different core
+// reflection types with no supertype more precise than
+// AnnotatedElement.
+}
+/**
+* A specialization of {@code javax.lang.model.element.Parameterizable} being
+* backed by core reflection.
+*/
+public static interface ReflectionParameterizable
+extends ReflectionElement, Parameterizable {
+@Override
+List<ReflectionTypeParameterElement> getTypeParameters();
+}
+/**
+* Base class for concrete visitors of elements backed by core reflection.
+*/
+public static abstract class AbstractReflectionElementVisitor8<R, P>
+extends AbstractElementVisitor8<R, P>
+implements ReflectionElementVisitor<R, P> {
+protected AbstractReflectionElementVisitor8() {
+super();
+}
+}
+/**
+* Base class for simple visitors of elements that are backed by core reflection.
+*/
+@SupportedSourceVersion(value=RELEASE_8)
+public static abstract class SimpleReflectionElementVisitor8<R, P>
+extends SimpleElementVisitor8<R, P>
+implements ReflectionElementVisitor<R, P> {
+protected SimpleReflectionElementVisitor8(){
+super();
+}
+protected SimpleReflectionElementVisitor8(R defaultValue) {
+super(defaultValue);
+}
+// Create manual "bridge methods" for now.
+@Override
+public final R visitPackage(PackageElement e, P p) {
+return visitPackage((ReflectionPackageElement) e , p);
+}
+@Override
+public final R visitType(TypeElement e, P p) {
+return visitType((ReflectionTypeElement) e , p);
+}
+@Override
+public final R visitVariable(VariableElement e, P p) {
+return visitVariable((ReflectionVariableElement) e , p);
+}
+@Override
+public final R visitExecutable(ExecutableElement e, P p) {
+return visitExecutable((ReflectionExecutableElement) e , p);
+}
+@Override
+public final R visitTypeParameter(TypeParameterElement e, P p) {
+return visitTypeParameter((ReflectionTypeParameterElement) e , p);
+}
+}
+/**
+* {@inheritDoc}
+*/
+public static interface ReflectionElements  extends Elements {
+/**
+* Returns the innermost enclosing {@link ReflectionTypeElement}
+* of the {@link ReflectionElement} or {@code null} if the
+* supplied ReflectionElement is toplevel or represents a
+* Package.
+*
+* @param e the {@link ReflectionElement} whose innermost
+* enclosing {@link ReflectionTypeElement} is sought
+* @return the innermost enclosing {@link
+* ReflectionTypeElement} or @{code null} if the parameter
+* {@code e} is a toplevel element or a package
+*/
+ReflectionTypeElement getEnclosingTypeElement(ReflectionElement e);
+/**
+* {@inheritDoc}
+*/
+@Override
+List<? extends ReflectionElement> getAllMembers(TypeElement type);
+/**
+* {@inheritDoc}
+*/
+@Override
+ReflectionPackageElement getPackageElement(CharSequence name);
+/**
+* {@inheritDoc}
+*/
+@Override
+ReflectionPackageElement getPackageOf(Element type);
+/**
+* {@inheritDoc}
+*/
+@Override
+ReflectionTypeElement getTypeElement(CharSequence name);
+}
+// ------------------------- Implementation classes ------------------------
+// Exercise for the reader: review the CoreReflElement class
+// hierarchy below with an eye toward exposing it as an extensible
+// API that could be subclassed to provide customized behavior,
+// such as alternate annotation lookup semantics.
+private static abstract class CoreReflElement
+implements ReflectionElement, AnnotatedElement {
+public abstract AnnotatedElement getSource();
+protected CoreReflElement() {
+super();
+}
+// ReflectionElement methods
+@Override
+public ReflectionPackageElement getPackage() {
+throw new UnsupportedOperationException();
+}
+@Override
+public TypeMirror asType() {
+throw new UnsupportedOperationException(getClass().toString());
+}
+@Override
+public List<? extends AnnotationMirror> getAnnotationMirrors() {
+Annotation[] annotations = getSource().getDeclaredAnnotations();
+int len = annotations.length;
+if (len > 0) {
+List<AnnotationMirror> res = new ArrayList<>(len);
+for (Annotation a : annotations) {
+res.add(createMirror(a));
+}
+return Collections.unmodifiableList(res);
+} else {
+return Collections.emptyList();
+}
+}
+@Override
+public Set<Modifier> getModifiers() {
+return ModifierUtil.instance(0, false);
+}
+@Override
+public abstract Name getSimpleName();
+@Override
+public abstract ReflectionElement getEnclosingElement();
+@Override
+public abstract List<ReflectionElement> getEnclosedElements();
+//AnnotatedElement methods
+@Override
+public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
+return getSource().getAnnotation(annotationClass);
+}
+@Override
+public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
+return getSource().getAnnotationsByType(annotationClass);
+}
+@Override
+public Annotation[] getAnnotations() {
+return getSource().getAnnotations();
+}
+@Override
+public <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
+return getSource().getDeclaredAnnotation(annotationClass);
+}
+@Override
+public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
+return getSource().getDeclaredAnnotationsByType(annotationClass);
+}
+@Override
+public Annotation[] getDeclaredAnnotations() {
+return getSource().getDeclaredAnnotations();
+}
+// java.lang.Object methods
+@Override
+public boolean equals(Object obj) {
+if (obj instanceof CoreReflElement) {
+CoreReflElement other = (CoreReflElement)obj;
+return Objects.equals(other.getSource(), this.getSource());
+}
+return false;
+}
+@Override
+public int hashCode() {
+return Objects.hashCode(getSource());
+}
+@Override
+public String toString() {
+return getKind().toString() + " " + getSimpleName().toString();
+}
+}
+// Type
+private static class CoreReflTypeElement extends CoreReflElement
+implements ReflectionTypeElement {
+private final Class<?> source;
+protected CoreReflTypeElement(Class<?> source) {
+Objects.requireNonNull(source);
+if (source.isPrimitive() ||
+source.isArray()) {
+throw new IllegalArgumentException("Cannot create a ReflectionTypeElement based on class: " + source);
+}
+this.source = source;
+}
+@Override
+public TypeMirror asType() {
+return createTypeMirror(source);
+}
+@Override
+public Class<?> getSource() {
+return source;
+}
+@Override
+public boolean equals(Object o) {
+if (o instanceof CoreReflTypeElement) {
+return source.equals(((CoreReflTypeElement)o).getSource());
+} else {
+return false;
+}
+}
+@Override
+public <R,P> R accept(ElementVisitor<R,P> v, P p) {
+return v.visitType(this, p);
+}
+@Override
+public <R,P> R accept(ReflectionElementVisitor<R,P> v, P p) {
+return v.visitType(this, p);
+}
+@Override
+public Set<Modifier> getModifiers() {
+return ModifierUtil.instance(source.getModifiers() &
+(source.isInterface() ?
+java.lang.reflect.Modifier.interfaceModifiers() :
+java.lang.reflect.Modifier.classModifiers()),
+false);
+}
+@Override
+public List<ReflectionElement> getEnclosedElements() {
+List<ReflectionElement> enclosedElements = new ArrayList<>();
+for (Class<?> declaredClass : source.getDeclaredClasses()) {
+enclosedElements.add(createMirror(declaredClass));
+}
+// Add elements in the conventional ordering: fields, then
+// constructors, then methods.
+for (Field f : source.getDeclaredFields()) {
+enclosedElements.add(createMirror(f));
+}
+for (Constructor<?> c : source.getDeclaredConstructors()) {
+enclosedElements.add(createMirror(c));
+}
+for (Method m : source.getDeclaredMethods()) {
+enclosedElements.add(createMirror(m));
+}
+return (enclosedElements.isEmpty() ?
+Collections.emptyList():
+Collections.unmodifiableList(enclosedElements));
+}
+// Review for default method handling.
+@Override
+public List<ReflectionElement> getAllMembers() {
+List<ReflectionElement> allMembers = new ArrayList<>();
+// If I only had a MultiMap ...
+List<ReflectionElement> fields = new ArrayList<>();
+List<ReflectionExecutableElement> methods = new ArrayList<>();
+List<ReflectionElement> classes = new ArrayList<>();
+// Add all fields for this class
+for (Field f : source.getDeclaredFields()) {
+fields.add(createMirror(f));
+}
+// Add all methods for this class
+for (Method m : source.getDeclaredMethods()) {
+methods.add(createMirror(m));
+}
+// Add all classes for this class, except anonymous/local as per Elements.getAllMembers doc
+for (Class<?> c : source.getDeclaredClasses()) {
+if (c.isLocalClass() || c.isAnonymousClass())
+continue;
+classes.add(createMirror(c));
+}
+Class<?> cls = source;
+if (cls.isInterface()) {
+cls = null;
+}
+do {
+// Walk up superclasses adding non-private elements.
+// If source is an interface, just add Object's
+// elements.
+if (cls == null) {
+cls = java.lang.Object.class;
+} else {
+cls = cls.getSuperclass();
+}
+addMembers(cls, fields, methods, classes);
+} while (cls != java.lang.Object.class);
+// add members on (super)interface(s)
+Set<Class<?>> seenInterfaces = new HashSet<>();
+Queue<Class<?>> interfaces = new LinkedList<>();
+if (source.isInterface()) {
+seenInterfaces.add(source);
+interfaces.add(source);
+} else {
+Class<?>[] ifaces = source.getInterfaces();
+for (Class<?> iface : ifaces) {
+seenInterfaces.add(iface);
+interfaces.add(iface);
+}
+}
+while (interfaces.peek() != null) {
+Class<?> head = interfaces.remove();
+addMembers(head, fields, methods, classes);
+Class<?>[] ifaces = head.getInterfaces();
+for (Class<?> iface : ifaces) {
+if (!seenInterfaces.contains(iface)) {
+seenInterfaces.add(iface);
+interfaces.add(iface);
+}
+}
+}
+// Add constructors
+for (Constructor<?> c : source.getDeclaredConstructors()) {
+allMembers.add(createMirror(c));
+}
+// Add all unique methods
+allMembers.addAll(methods);
+// Add all unique fields
+allMembers.addAll(fields);
+// Add all unique classes
+allMembers.addAll(classes);
+return Collections.unmodifiableList(allMembers);
+}
+private void addMembers(Class<?> cls,
+List<ReflectionElement> fields,
+List<ReflectionExecutableElement> methods,
+List<ReflectionElement> classes) {
+Elements elements = getElements();
+for (Field f : cls.getDeclaredFields()) {
+if (java.lang.reflect.Modifier.isPrivate(f.getModifiers())) { continue; }
+ReflectionElement tmp = createMirror(f);
+boolean add = true;
+for (ReflectionElement e : fields) {
+if (elements.hides(e, tmp)) {
+add = false;
+break;
+}
+}
+if (add) {
+fields.add(tmp);
+}
+}
+for (Method m : cls.getDeclaredMethods()) {
+if (java.lang.reflect.Modifier.isPrivate(m.getModifiers()))
+continue;
+ReflectionExecutableElement tmp = createMirror(m);
+boolean add = true;
+for (ReflectionExecutableElement e : methods) {
+if (elements.hides(e, tmp)) {
+add = false;
+break;
+} else if (elements.overrides(e, tmp, this)) {
+add = false;
+break;
+}
+}
+if (add) {
+methods.add(tmp);
+}
+}
+for (Class<?> c : cls.getDeclaredClasses()) {
+if (java.lang.reflect.Modifier.isPrivate(c.getModifiers()) ||
+c.isLocalClass() ||
+c.isAnonymousClass())
+continue;
+ReflectionElement tmp = createMirror(c);
+boolean add = true;
+for (ReflectionElement e : classes) {
+if (elements.hides(e, tmp)) {
+add = false;
+break;
+}
+}
+if (add) {
+classes.add(tmp);
+}
+}
+}
+@Override
+public ElementKind getKind() {
+if (source.isInterface()) {
+if (source.isAnnotation())
+return ElementKind.ANNOTATION_TYPE;
+else
+return ElementKind.INTERFACE;
+} else if (source.isEnum()) {
+return ElementKind.ENUM;
+} else
+return ElementKind.CLASS;
+}
+@Override
+public NestingKind getNestingKind() {
+if (source.isAnonymousClass())
+return NestingKind.ANONYMOUS;
+else if (source.isLocalClass())
+return NestingKind.LOCAL;
+else if (source.isMemberClass())
+return NestingKind.MEMBER;
+else return
+NestingKind.TOP_LEVEL;
+}
+@Override
+public Name getQualifiedName() {
+String name = source.getCanonicalName(); // TODO, this should be a FQN for
+// the current element
+if (name == null)
+name = "";
+return StringName.instance(name);
+}
+@Override
+public Name getSimpleName() {
+return StringName.instance(source.getSimpleName());
+}
+@Override
+public TypeMirror getSuperclass() {
+if (source.equals(java.lang.Object.class)) {
+return NoType.getNoneInstance();
+} else {
+return createTypeMirror(source.getSuperclass());
+}
+}
+@Override
+public List<? extends TypeMirror> getInterfaces() {
+Class[] interfaces = source.getInterfaces();
+int len = interfaces.length;
+List<TypeMirror> res = new ArrayList<>(len);
+if (len > 0) {
+for (Class<?> c : interfaces) {
+res.add(createTypeMirror(c));
+}
+} else {
+return Collections.emptyList();
+}
+return Collections.unmodifiableList(res);
+}
+@Override
+public List<ReflectionTypeParameterElement> getTypeParameters() {
+return createTypeParameterList(source);
+}
+@Override
+public ReflectionElement getEnclosingElement() {
+// Returns the package of a top-level type and returns the
+// immediately lexically enclosing element for a nested type.
+switch(getNestingKind()) {
+case TOP_LEVEL:
+return createMirror(source.getPackage());
+case MEMBER:
+return createMirror(source.getEnclosingClass());
+default:
+if (source.getEnclosingConstructor() != null) {
+return createMirror(source.getEnclosingConstructor());
+} else if (source.getEnclosingMethod() != null) {
+return createMirror(source.getEnclosingMethod());
+} else {
+return createMirror(source.getEnclosingClass());
+}
+}
+}
+@Override
+public Name getBinaryName() {
+return StringName.instance(getSource().getName());
+}
+}
+private static abstract class CoreReflExecutableElement extends CoreReflElement
+implements ReflectionExecutableElement {
+protected Executable source = null;
+protected final List<CoreReflParameterVariableElement> parameters;
+protected CoreReflExecutableElement(Executable source,
+List<CoreReflParameterVariableElement> parameters) {
+this.source = Objects.requireNonNull(source);
+this.parameters = Objects.requireNonNull(parameters);
+}
+@Override
+public <R,P> R accept(ElementVisitor<R,P> v, P p) {
+return v.visitExecutable(this, p);
+}
+@Override
+public <R,P> R accept(ReflectionElementVisitor<R,P> v, P p) {
+return v.visitExecutable(this, p);
+}
+@Override
+public abstract ExecutableType asType();
+// Only Types and Packages enclose elements; see Element.getEnclosedElements()
+@Override
+public List<ReflectionElement> getEnclosedElements() {
+return Collections.emptyList();
+}
+@Override
+public List<ReflectionVariableElement> getParameters() {
+List<ReflectionVariableElement> tmp = new ArrayList<>();
+for (ReflectionVariableElement parameter : parameters) {
+if (!parameter.isSynthetic())
+tmp.add(parameter);
+}
+return tmp;
+}
+@Override
+public List<ReflectionVariableElement> getAllParameters() {
+// Could "fix" this if the return type included wildcards
+@SuppressWarnings("unchecked")
+List<ReflectionVariableElement> tmp = (List<ReflectionVariableElement>)(List)parameters;
+return tmp;
+}
+@Override
+public List<? extends TypeMirror> getThrownTypes() {
+Class<?>[] thrown = source.getExceptionTypes();
+int len = thrown.length;
+List<TypeMirror> res = new ArrayList<>(len);
+if (len > 0) {
+for (Class<?> c : thrown) {
+res.add(createTypeMirror(c));
+}
+} else {
+return Collections.emptyList();
+}
+return Collections.unmodifiableList(res);
+}
+@Override
+public boolean isVarArgs() {
+return source.isVarArgs();
+}
+@Override
+public boolean isSynthetic() {
+return source.isSynthetic();
+}
+@Override
+public boolean isBridge() {
+return false;
+}
+@Override
+public List<ReflectionTypeParameterElement> getTypeParameters() {
+return createTypeParameterList(source);
+}
+public abstract AnnotationValue getDefaultValue();
+@Override
+public TypeMirror getReceiverType() {
+// New in JDK 8
+throw new UnsupportedOperationException(this.toString());
+}
+}
+private static class CoreReflConstructorExecutableElement
+extends CoreReflExecutableElement {
+protected CoreReflConstructorExecutableElement(Constructor<?> source) {
+super(Objects.requireNonNull(source),
+createParameterList(source));
+}
+@Override
+public  Constructor<?> getSource() {
+return (Constructor<?>)source;
+}
+@Override
+public TypeMirror getReturnType() {
+return NoType.getVoidInstance();
+}
+@Override
+public ExecutableType asType() {
+throw new UnsupportedOperationException(getClass().toString());
+}
+@Override
+public boolean equals(Object o) {
+if (o instanceof CoreReflConstructorExecutableElement) {
+return source.equals(((CoreReflConstructorExecutableElement)o).getSource());
+} else {
+return false;
+}
+}
+@Override
+public ElementKind getKind() {
+return ElementKind.CONSTRUCTOR;
+}
+@Override
+public Set<Modifier> getModifiers() {
+return ModifierUtil.instance(source.getModifiers() &
+java.lang.reflect.Modifier.constructorModifiers(), false);
+}
+@Override
+public ReflectionElement getEnclosingElement() {
+return createMirror(source.getDeclaringClass());
+}
+@Override
+public Name getSimpleName() {
+return StringName.instance("<init>");
+}
+@Override
+public AnnotationValue getDefaultValue() {
+// a constructor is never an annotation element
+return null;
+}
+@Override
+public boolean isDefault() {
+return false; // A constructor cannot be a default method
+}
+}
+private static class CoreReflMethodExecutableElement
+extends CoreReflExecutableElement {
+protected CoreReflMethodExecutableElement(Method source) {
+super(Objects.requireNonNull(source),
+createParameterList(source));
+this.source = source;
+}
+@Override
+public Method getSource() {
+return (Method)source;
+}
+@Override
+public TypeMirror getReturnType() {
+return TypeFactory.instance(getSource().getReturnType());
+}
+@Override
+public boolean equals(Object o) {
+if (o instanceof CoreReflMethodExecutableElement) {
+return source.equals( ((CoreReflMethodExecutableElement)o).getSource());
+} else {
+return false;
+}
+}
+@Override
+public ElementKind getKind() {
+return ElementKind.METHOD;
+}
+@Override
+public Set<Modifier> getModifiers() {
+return ModifierUtil.instance(source.getModifiers() &
+java.lang.reflect.Modifier.methodModifiers(),
+isDefault());
+}
+@Override
+public ReflectionElement getEnclosingElement() {
+return createMirror(source.getDeclaringClass());
+}
+@Override
+public Name getSimpleName() {
+return StringName.instance(source.getName());
+}
+@Override
+public AnnotationValue getDefaultValue() {
+Object value = getSource().getDefaultValue();
+if (null == value) {
+return null;
+} else {
+return new CoreReflAnnotationValue(value);
+}
+}
+@Override
+public boolean isDefault() {
+return getSource().isDefault();
+}
+@Override
+public boolean isBridge() {
+return getSource().isBridge();
+}
+@Override
+public ExecutableType asType() {
+return TypeFactory.instance(getSource());
+}
+}
+private static List<CoreReflParameterVariableElement> createParameterList(Executable source) {
+Parameter[] parameters = source.getParameters();
+int length = parameters.length;
+if (length == 0)
+return Collections.emptyList();
+else {
+List<CoreReflParameterVariableElement> tmp = new ArrayList<>(length);
+for (Parameter parameter : parameters) {
+tmp.add(new CoreReflParameterVariableElement(parameter));
+}
+return Collections.unmodifiableList(tmp);
+}
+}
+private static List<ReflectionTypeParameterElement> createTypeParameterList(GenericDeclaration source) {
+java.lang.reflect.TypeVariable<?>[] typeParams = source.getTypeParameters();
+int length = typeParams.length;
+if (length == 0)
+return Collections.emptyList();
+else {
+List<ReflectionTypeParameterElement> tmp = new ArrayList<>(length);
+for (java.lang.reflect.TypeVariable<?> typeVar : typeParams)
+tmp.add(new CoreReflTypeParameterElement(typeVar));
+return Collections.unmodifiableList(tmp);
+}
+}
+private static class CoreReflTypeParameterElement
+extends CoreReflElement
+implements ReflectionTypeParameterElement {
+private final GenericDeclaration source;
+private final java.lang.reflect.TypeVariable<?> sourceTypeVar;
+protected CoreReflTypeParameterElement(java.lang.reflect.TypeVariable<?> sourceTypeVar) {
+this.sourceTypeVar = Objects.requireNonNull(sourceTypeVar);
+this.source = Objects.requireNonNull(sourceTypeVar.getGenericDeclaration());
+}
+@Override
+public AnnotatedElement getSource() {
+return (AnnotatedElement)source;
+}
+protected java.lang.reflect.TypeVariable<?> getSourceTypeVar() {
+return sourceTypeVar;
+}
+@Override
+public boolean equals(Object o) {
+if (o instanceof CoreReflTypeParameterElement) {
+return sourceTypeVar.equals(((CoreReflTypeParameterElement)o).sourceTypeVar);
+} else {
+return false;
+}
+}
+@Override
+public <R,P> R accept(ElementVisitor<R,P> v, P p) {
+return v.visitTypeParameter(this, p);
+}
+@Override
+public <R,P> R accept(ReflectionElementVisitor<R,P> v, P p) {
+return v.visitTypeParameter(this, p);
+}
+@Override
+public List<ReflectionElement> getEnclosedElements() {
+return Collections.emptyList();
+}
+@Override
+public ReflectionElement getEnclosingElement() {
+if (source instanceof Class)
+return createMirror((Class<?>)source);
+else if (source instanceof Method)
+return createMirror((Method)source);
+else if (source instanceof Constructor)
+return createMirror((Constructor<?>)source);
+else
+throw new AssertionError("Unexpected enclosing element: " + source);
+}
+@Override
+public ElementKind getKind() {
+return ElementKind.TYPE_PARAMETER;
+}
+@Override
+public Name getSimpleName() {
+return StringName.instance(sourceTypeVar.getName());
+}
+// TypeParameterElement methods
+@Override
+public ReflectionElement getGenericElement() {
+return getEnclosingElement(); // As per the doc,
+// getEnclosingElement and
+// getGenericElement return
+// the same information.
+}
+@Override
+public List<? extends TypeMirror> getBounds() {
+Type[] types = getSourceTypeVar().getBounds();
+int len = types.length;
+if (len > 0) {
+List<TypeMirror> res = new ArrayList<>(len);
+for (Type t : types) {
+res.add(TypeFactory.instance(t));
+}
+return Collections.unmodifiableList(res);
+} else {
+return Collections.emptyList();
+}
+}
+}
+private abstract static class CoreReflVariableElement extends CoreReflElement
+implements ReflectionVariableElement {
+protected CoreReflVariableElement() {}
+// Element visitor
+@Override
+public <R,P> R accept(ElementVisitor<R,P>v, P p) {
+return v.visitVariable(this, p);
+}
+// ReflectElement visitor
+@Override
+public <R,P> R accept(ReflectionElementVisitor<R,P> v, P p) {
+return v.visitVariable(this, p);
+}
+@Override
+public List<ReflectionElement> getEnclosedElements() {
+return Collections.emptyList();
+}
+@Override
+public ReflectionElement getEnclosingElement() {
+return null;
+}
+@Override
+public boolean isSynthetic() {
+return false;
+}
+@Override
+public boolean isImplicit() {
+return false;
+}
+}
+private static class CoreReflFieldVariableElement extends CoreReflVariableElement {
+private final Field source;
+protected CoreReflFieldVariableElement(Field source) {
+this.source = Objects.requireNonNull(source);
+}
+@Override
+public Field getSource() {
+return source;
+}
+@Override
+public TypeMirror asType() {
+return createTypeMirror(getSource().getType());
+}
+@Override
+public ElementKind getKind() {
+if (source.isEnumConstant())
+return ElementKind.ENUM_CONSTANT;
+else
+return ElementKind.FIELD;
+}
+@Override
+public Set<Modifier> getModifiers() {
+return ModifierUtil.instance(source.getModifiers() &
+java.lang.reflect.Modifier.fieldModifiers(), false);
+}
+@Override
+public Name getSimpleName() {
+return StringName.instance(source.getName());
+}
+@Override
+public ReflectionElement getEnclosingElement() {
+return createMirror(source.getDeclaringClass());
+}
+@Override
+public boolean equals(Object o) {
+if (o instanceof CoreReflFieldVariableElement) {
+return Objects.equals(source,
+((CoreReflFieldVariableElement)o).getSource());
+} else {
+return false;
+}
+}
+@Override
+public Object getConstantValue() {
+Field target = source;
+// The api says only Strings and primitives may be compile time constants.
+// Ensure field is that, and final.
+//
+// Also, we don't have an instance so restrict to static Fields
+//
+if (!(source.getType().equals(java.lang.String.class)
+|| source.getType().isPrimitive())) {
+return null;
+}
+final int modifiers = target.getModifiers();
+if (!( java.lang.reflect.Modifier.isFinal(modifiers) &&
+java.lang.reflect.Modifier.isStatic(modifiers))) {
+return null;
+}
+try {
+return target.get(null);
+} catch (IllegalAccessException e) {
+try {
+target.setAccessible(true);
+return target.get(null);
+} catch (IllegalAccessException i) {
+throw new SecurityException(i);
+}
+}
+}
+}
+private static class CoreReflParameterVariableElement
+extends CoreReflVariableElement {
+private final Parameter source;
+protected CoreReflParameterVariableElement(Parameter source) {
+this.source = Objects.requireNonNull(source);
+}
+@Override
+public Parameter getSource() {
+return source;
+}
+@Override
+public Set<Modifier> getModifiers() {
+return ModifierUtil.instance(source.getModifiers() &
+java.lang.reflect.Modifier.parameterModifiers(), false);
+}
+@Override
+public TypeMirror asType() {
+// TODO : switch to parameterized type
+return createTypeMirror(source.getType());
+}
+@Override
+public ElementKind getKind() {
+return ElementKind.PARAMETER;
+}
+@Override
+public Name getSimpleName() {
+return StringName.instance(source.getName());
+}
+@Override
+public ReflectionElement getEnclosingElement() {
+Executable enclosing = source.getDeclaringExecutable();
+if (enclosing instanceof Method)
+return createMirror((Method)enclosing);
+else if (enclosing instanceof Constructor)
+return createMirror((Constructor<?>)enclosing);
+else
+throw new AssertionError("Bad enclosing value.");
+}
+@Override
+public boolean equals(Object o) {
+if (o instanceof CoreReflParameterVariableElement) {
+return source.equals(((CoreReflParameterVariableElement) o).getSource());
+} else
+return false;
+}
+// VariableElement methods
+@Override
+public Object getConstantValue() {
+return null;
+}
+@Override
+public boolean isSynthetic() {
+return source.isSynthetic();
+}
+@Override
+public boolean isImplicit() {
+return source.isImplicit();
+}
+}
+private static class CoreReflPackageElement extends CoreReflElement
+implements ReflectionPackageElement {
+private final Package source;
+protected CoreReflPackageElement(Package source) {
+this.source = source;
+}
+@Override
+public Package getSource() {
+return source;
+}
+@Override
+public <R,P> R accept(ElementVisitor<R,P> v, P p) {
+return v.visitPackage(this, p);
+}
+@Override
+public <R,P> R accept(ReflectionElementVisitor<R,P> v, P p) {
+return v.visitPackage(this, p);
+}
+@Override
+public boolean equals(Object o) {
+if (o instanceof CoreReflPackageElement) {
+return Objects.equals(source,
+((CoreReflPackageElement)o).getSource());
+} else {
+return false;
+}
+}
+@Override
+public ElementKind getKind() {
+return ElementKind.PACKAGE;
+}
+@Override
+public ReflectionElement getEnclosingElement() {
+return null;
+}
+@Override
+public List<ReflectionElement> getEnclosedElements() {
+throw new UnsupportedOperationException();
+}
+@Override
+public Name getQualifiedName() {
+return StringName.instance((source != null) ?
+source.getName() :
+"" );
+}
+@Override
+public Name getSimpleName() {
+String n = ((source != null) ?
+source.getName() :
+"");
+int index = n.lastIndexOf('.');
+if (index > 0) {
+return StringName.instance(n.substring(index + 1, n.length()));
+} else {
+return StringName.instance(n);
+}
+}
+@Override
+public boolean isUnnamed() {
+if (source != null) {
+String name = source.getName();
+return(name == null || name.isEmpty());
+} else
+return true;
+}
+}
+private static class CoreReflAnnotationMirror
+implements javax.lang.model.element.AnnotationMirror {
+private final Annotation annotation;
+protected CoreReflAnnotationMirror(Annotation annotation) {
+this.annotation = Objects.requireNonNull(annotation);
+}
+@Override
+public DeclaredType getAnnotationType() {
+return (DeclaredType)TypeFactory.instance(annotation.annotationType());
+}
+@Override
+public Map<? extends ReflectionExecutableElement, ? extends AnnotationValue> getElementValues() {
+// This differs from the javac implementation in that it returns default values
+Method[] elems = annotation.annotationType().getDeclaredMethods();
+int len = elems.length;
+if (len > 0) {
+Map<ReflectionExecutableElement, AnnotationValue> res = new HashMap<>();
+for (Method m : elems) {
+AnnotationValue v;
+try {
+v = new CoreReflAnnotationValue(m.invoke(annotation));
+} catch (IllegalAccessException e) {
+try {
+m.setAccessible(true);
+v = new CoreReflAnnotationValue(m.invoke(annotation));
+} catch (IllegalAccessException i) {
+throw new SecurityException(i);
+} catch (InvocationTargetException ee) {
+throw new RuntimeException(ee);
+}
+} catch (InvocationTargetException ee) {
+throw new RuntimeException(ee);
+}
+ReflectionExecutableElement e = createMirror(m);
+res.put(e, v);
+}
+return Collections.unmodifiableMap(res);
+} else {
+return Collections.emptyMap();
+}
+}
+@Override
+public boolean equals(Object other) {
+if (other instanceof CoreReflAnnotationMirror) {
+return annotation.equals(((CoreReflAnnotationMirror)other).annotation);
+} else {
+return false;
+}
+}
+@Override
+public int hashCode() {
+return Objects.hashCode(annotation);
+}
+@Override
+public String toString() {
+return annotation.toString();
+}
+}
+private static class CoreReflAnnotationValue
+implements javax.lang.model.element.AnnotationValue {
+private Object value = null;
+protected CoreReflAnnotationValue(Object value) {
+// Is this constraint really necessary?
+Objects.requireNonNull(value);
+this.value = value;
+}
+@Override
+public Object getValue() {
+return value;
+}
+@Override
+public String toString() {
+return value.toString();
+}
+@Override
+public <R,P> R accept(AnnotationValueVisitor<R,P> v, P p) {
+return v.visit(this, p);
+}
+}
+// Helper utility classes
+private static class StringName implements Name {
+private String name;
+private StringName(String name) {
+this.name = Objects.requireNonNull(name);
+}
+public static StringName instance(String name) {
+return new StringName(name);
+}
+@Override
+public int length() {
+return name.length();
+}
+@Override
+public char charAt(int index) {
+return name.charAt(index);
+}
+@Override
+public CharSequence subSequence(int start, int end) {
+return name.subSequence(start, end);
+}
+@Override
+public String toString() {
+return name;
+}
+@Override
+public boolean equals(Object other) {
+if (other instanceof StringName) {
+return name.equals(((StringName) other).name);
+} else {
+return false;
+}
+}
+@Override
+public int hashCode() {
+return name.hashCode();
+}
+@Override
+public boolean contentEquals(CharSequence cs) {
+return name.contentEquals(cs);
+}
+}
+/*
+* Given an {@code int} value of modifiers, return a proper immutable set
+* of {@code Modifier}s as a result.
+*/
+private static class ModifierUtil {
+private ModifierUtil() {
+throw new AssertionError("No instances for you.");
+}
+// Exercise for the reader: explore if caching of sets of
+// Modifiers would be helpful.
+public static Set<Modifier> instance(int modifiers, boolean isDefault) {
+Set<Modifier> modSet = EnumSet.noneOf(Modifier.class);
+if (java.lang.reflect.Modifier.isAbstract(modifiers))
+modSet.add(Modifier.ABSTRACT);
+if (java.lang.reflect.Modifier.isFinal(modifiers))
+modSet.add(Modifier.FINAL);
+if (java.lang.reflect.Modifier.isNative(modifiers))
+modSet.add(Modifier.NATIVE);
+if (java.lang.reflect.Modifier.isPrivate(modifiers))
+modSet.add(Modifier.PRIVATE);
+if (java.lang.reflect.Modifier.isProtected(modifiers))
+modSet.add(Modifier.PROTECTED);
+if (java.lang.reflect.Modifier.isPublic(modifiers))
+modSet.add(Modifier.PUBLIC);
+if (java.lang.reflect.Modifier.isStatic(modifiers))
+modSet.add(Modifier.STATIC);
+if (java.lang.reflect.Modifier.isStrict(modifiers))
+modSet.add(Modifier.STRICTFP);
+if (java.lang.reflect.Modifier.isSynchronized(modifiers))
+modSet.add(Modifier.SYNCHRONIZED);
+if (java.lang.reflect.Modifier.isTransient(modifiers))
+modSet.add(Modifier.TRANSIENT);
+if (java.lang.reflect.Modifier.isVolatile(modifiers))
+modSet.add(Modifier.VOLATILE);
+if (isDefault)
+modSet.add(Modifier.DEFAULT);
+return Collections.unmodifiableSet(modSet);
+}
+}
+private abstract static class AbstractTypeMirror implements TypeMirror {
+private final TypeKind kind;
+protected AbstractTypeMirror(TypeKind kind) {
+this.kind = Objects.requireNonNull(kind);
+}
+@Override
+public TypeKind getKind() {
+return kind;
+}
+@Override
+public <R,P> R accept(TypeVisitor<R,P> v, P p) {
+return v.visit(this, p);
+}
+//Types methods
+abstract List<? extends TypeMirror> directSuperTypes();
+TypeMirror capture() {
+// Exercise for the reader: make this abstract and implement in subtypes
+throw new UnsupportedOperationException();
+}
+TypeMirror erasure() {
+// Exercise for the reader: make this abstract and implement in subtypes
+throw new UnsupportedOperationException();
+}
+// Exercise for the reader: implement the AnnotatedConstruct methods
+@Override
+public List<? extends AnnotationMirror> getAnnotationMirrors() {
+throw new UnsupportedOperationException();
+}
+@Override
+public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
+throw new UnsupportedOperationException();
+}
+@Override
+public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
+throw new UnsupportedOperationException();
+}
+}
+private static class CoreReflArrayType extends AbstractTypeMirror
+implements javax.lang.model.type.ArrayType,
+Reifiable {
+private Class<?> source = null;
+private Class<?> component = null;
+private TypeMirror eagerComponent = null;
+protected CoreReflArrayType(Class<?> source) {
+super(TypeKind.ARRAY);
+this.source = source;
+this.component = source.getComponentType();
+this.eagerComponent = TypeFactory.instance(component);
+}
+public TypeMirror getComponentType() {
+return eagerComponent;
+}
+@Override
+public Class<?> getSource() {
+return source;
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+final TypeMirror componentType = getComponentType();
+final TypeMirror[] directSupers;
+// JLS v4 4.10.3
+if (componentType.getKind().isPrimitive() ||
+component.equals(java.lang.Object.class)) {
+directSupers = new TypeMirror[3];
+directSupers[0] = TypeFactory.instance(java.lang.Object.class);
+directSupers[1] = TypeFactory.instance(java.lang.Cloneable.class);
+directSupers[2] = TypeFactory.instance(java.io.Serializable.class);
+} else if (componentType.getKind() == TypeKind.ARRAY) {
+List<? extends TypeMirror> componentDirectSupertypes = CoreReflTypes.instance().directSupertypes(componentType);
+directSupers = new TypeMirror[componentDirectSupertypes.size()];
+for (int i = 0; i < directSupers.length; i++) {
+directSupers[i] = new CoreReflArrayType(Array.newInstance(((Reifiable)componentDirectSupertypes.get(i)).getSource(), 0).getClass());
+}
+} else {
+Class<?> superClass = component.getSuperclass();
+Class<?>[] interfaces = component.getInterfaces();
+directSupers = new TypeMirror[1 + interfaces.length];
+directSupers[0] = TypeFactory.instance(Array.newInstance(superClass, 0).getClass());
+for (int i = 0; i < interfaces.length; i++) {
+directSupers[i + 1] = TypeFactory.instance(Array.newInstance(interfaces[i],0).getClass());
+}
+}
+return Collections.unmodifiableList(Arrays.asList(directSupers));
+}
+@Override
+public String toString() {
+return getKind() + " of " + getComponentType().toString();
+}
+}
+private static class CaptureTypeVariable extends AbstractTypeMirror implements javax.lang.model.type.TypeVariable {
+private TypeMirror source = null;
+private TypeMirror upperBound = null;
+private TypeMirror lowerBound = null;
+CaptureTypeVariable(TypeMirror source,
+TypeMirror upperBound,
+TypeMirror lowerBound) {
+super(TypeKind.TYPEVAR);
+this.source = Objects.requireNonNull(source);
+this.upperBound = (upperBound == null ? CoreReflTypes.instance().getNullType() : upperBound);
+this.lowerBound = (lowerBound == null ? CoreReflTypes.instance().getNullType() : lowerBound);
+}
+protected Class<?> getSource() {
+if (source instanceof CoreReflDeclaredType) {
+return ((CoreReflDeclaredType)source).getSource();
+} else {
+return null;
+}
+}
+@Override
+public TypeMirror getUpperBound() {
+return upperBound;
+}
+@Override
+public TypeMirror getLowerBound() {
+return lowerBound;
+}
+@Override
+public Element asElement() {
+if (null == getSource()) {
+return null;
+}
+return CoreReflectionFactory.createMirror(getSource());
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+throw new UnsupportedOperationException();
+}
+@Override
+public String toString() {
+return getKind() + " CAPTURE of: " + source.toString();
+}
+}
+private static class CoreReflElements implements ReflectionElements {
+private CoreReflElements() {} // mostly one instance for you
+private static CoreReflElements instance = new CoreReflElements();
+static CoreReflElements instance() {
+return instance;
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public ReflectionPackageElement getPackageElement(CharSequence name) {
+return createMirror(Package.getPackage(name.toString()));
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public ReflectionTypeElement getTypeElement(CharSequence name) {
+// where name is a Canonical Name jls 6.7
+// but this method will probably accept an equivalent FQN
+// depending on Class.forName(String)
+ReflectionTypeElement tmp = null;
+// Filter out arrays
+String n = name.toString();
+if (n.contains("[")) return null;
+if (n.equals("")) return null;
+// The intention of this loop is to handle nested
+// elements.  If finding the element using Class.forName
+// fails, an attempt is made to find the element as an
+// enclosed element by trying fo find a prefix of the name
+// (dropping a trailing ".xyz") and looking for "xyz" as
+// an enclosed element.
+Deque<String> parts = new ArrayDeque<>();
+boolean again;
+do {
+again = false;
+try {
+tmp = createMirror(Class.forName(n));
+} catch (ClassNotFoundException e) {
+tmp = null;
+}
+if (tmp != null) {
+if (parts.isEmpty()) {
+return tmp;
+}
+tmp = findInner(tmp, parts);
+if (tmp != null) {
+return tmp;
+}
+}
+int indx = n.lastIndexOf('.');
+if (indx > -1) {
+parts.addFirst(n.substring(indx + 1));
+n = n.substring(0, indx);
+again = true;
+}
+} while (again);
+return null;
+}
+// Recursively finds enclosed type elements named as part.top() popping part and repeating
+private ReflectionTypeElement findInner(ReflectionTypeElement e, Deque<String> parts) {
+if (parts.isEmpty()) {
+return e;
+}
+String part = parts.removeFirst();
+List<ReflectionElement> enclosed = e.getEnclosedElements();
+for (ReflectionElement elm : enclosed) {
+if ((elm.getKind() == ElementKind.CLASS ||
+elm.getKind() == ElementKind.INTERFACE ||
+elm.getKind() == ElementKind.ENUM ||
+elm.getKind() == ElementKind.ANNOTATION_TYPE)
+&& elm.getSimpleName().toString().equals(part)) {
+ReflectionTypeElement t = findInner((ReflectionTypeElement)elm, parts);
+if (t != null) {
+return t;
+}
+}
+}
+return null;
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public Map<? extends ReflectionExecutableElement, ? extends AnnotationValue>
+getElementValuesWithDefaults(AnnotationMirror a) {
+if (a instanceof CoreReflAnnotationMirror) {
+return ((CoreReflAnnotationMirror)a).getElementValues();
+} else {
+throw new IllegalArgumentException();
+}
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public String getDocComment(Element e) {
+checkElement(e);
+return null; // As per the doc
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public boolean isDeprecated(Element e) {
+checkElement(e);
+return ((CoreReflElement)e).getSource().isAnnotationPresent(java.lang.Deprecated.class);
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public Name getBinaryName(TypeElement type) {
+checkElement(type);
+return StringName.instance(((CoreReflTypeElement)type)
+.getSource()
+.getName());
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public ReflectionPackageElement getPackageOf(Element type) {
+checkElement(type);
+if (type instanceof ReflectionPackageElement) {
+return (ReflectionPackageElement)type;
+}
+Package p;
+if (type instanceof CoreReflTypeElement) {
+p = ((CoreReflTypeElement)type).getSource().getPackage();
+} else {
+CoreReflTypeElement enclosingTypeElement = (CoreReflTypeElement)getEnclosingTypeElement((ReflectionElement)type);
+p = enclosingTypeElement.getSource().getPackage();
+}
+return createMirror(p);
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public List<? extends ReflectionElement> getAllMembers(TypeElement type) {
+checkElement(type);
+return getAllMembers((ReflectionTypeElement)type);
+}
+// Exercise for the reader: should this method, and similar
+// ones that specialize on the more specific argument types,
+// be addd to the public ReflectionElements API?
+public List<? extends ReflectionElement> getAllMembers(ReflectionTypeElement type) {
+return type.getAllMembers();
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public List<? extends AnnotationMirror> getAllAnnotationMirrors(Element e) {
+checkElement(e);
+AnnotatedElement ae = CoreReflElement.class.cast(e).getSource();
+Annotation[] annotations = ae.getAnnotations();
+int len = annotations.length;
+if (len > 0) {
+List<AnnotationMirror> res = new ArrayList<>(len);
+for (Annotation a : annotations) {
+res.add(createMirror(a));
+}
+return Collections.unmodifiableList(res);
+} else {
+List<AnnotationMirror> ret = Collections.emptyList();
+return ret;
+}
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public boolean hides(Element hider, Element hidden) {
+checkElement(hider);
+checkElement(hidden);
+// Names must be equal
+if (!hider.getSimpleName().equals(hidden.getSimpleName())) {
+return false;
+}
+// Hides isn't reflexive
+if (hider.equals(hidden)) {
+return false;
+}
+// Hider and hidden needs to be field, method or type
+// and fields hide fields, types hide types, methods hide methods
+// IE a Field doesn't hide a Methods etc
+ElementKind hiderKind = hider.getKind();
+ElementKind hiddenKind = hidden.getKind();
+if (hiderKind.isField() && !hiddenKind.isField()) {
+return false;
+} else if (hiderKind.isClass() &&
+!(hiddenKind.isClass() || hiddenKind.isInterface())) {
+return false;
+} else if (hiderKind.isInterface() &&
+!(hiddenKind.isClass() || hiddenKind.isInterface())) {
+return false;
+} else if (hiderKind == ElementKind.METHOD && hiddenKind != ElementKind.METHOD) {
+return false;
+} else if (!(hiderKind.isClass() ||
+hiderKind.isInterface() ||
+hiderKind.isField() ||
+hiderKind == ElementKind.METHOD)) {
+return false;
+}
+Set<Modifier> hm = hidden.getModifiers();
+// jls 8.4.8.2 only static methods can hide methods
+if (hider.getKind() == ElementKind.METHOD) {
+if (!hider.getModifiers().contains(Modifier.STATIC)) {
+return false; // hider not static
+} else if (!hm.contains(Modifier.STATIC)) { // we know it's a method
+return false; // hidden not static
+}
+// For methods we also need to check parameter types
+Class<?>[] h1 = ((CoreReflMethodExecutableElement)hider).getSource().getParameterTypes();
+Class<?>[] h2 = ((CoreReflMethodExecutableElement)hidden).getSource().getParameterTypes();
+if (h1.length != h2.length) {
+return false;
+}
+for (int i = 0; i < h1.length; i++) {
+if (h1[i] != h2[i]) {
+return false;
+}
+}
+}
+// You can only hide visible elements
+if (hm.contains(Modifier.PRIVATE)) {
+return false; // hidden private, can't be hidden
+} else if ((!(hm.contains(Modifier.PUBLIC) || hm.contains(Modifier.PROTECTED))) && // not private, not (public or protected) IE package private
+(!getPackageOf(hider).equals(getPackageOf(hidden)))) {
+return false; // hidden package private, and different packages, IE not visible
+}
+// Ok so now hider actually hides hidden if hider is
+// declared on a subtype of hidden.
+//
+// TODO: should this be a proper subtype or is that taken
+// care of by the reflexive check in the beginning?
+//
+TypeMirror hiderType = getEnclosingTypeElement((ReflectionElement)hider).asType();
+TypeMirror hiddenType = getEnclosingTypeElement((ReflectionElement)hidden).asType();
+return getTypes().isSubtype(hiderType, hiddenType);
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public ReflectionTypeElement getEnclosingTypeElement(ReflectionElement e) {
+if (e.getKind() == ElementKind.PACKAGE) {
+return null;
+}
+if(e instanceof CoreReflTypeParameterElement) {
+ReflectionElement encElem = ((CoreReflTypeParameterElement)e).getEnclosingElement();
+if (encElem instanceof ReflectionTypeElement) {
+return (ReflectionTypeElement)encElem;
+} else  {
+return getEnclosingTypeElement(encElem);
+}
+}
+Class<?> encl = null;
+if (e instanceof CoreReflTypeElement) {
+encl = ((CoreReflTypeElement)e).getSource().getDeclaringClass();
+} else if (e instanceof CoreReflExecutableElement) {
+encl = (((CoreReflExecutableElement)e).getSource()).getDeclaringClass();
+} else if (e instanceof CoreReflFieldVariableElement) {
+encl = ((CoreReflFieldVariableElement)e).getSource().getDeclaringClass();
+} else if (e instanceof CoreReflParameterVariableElement) {
+encl = ((CoreReflParameterVariableElement)e).getSource().getDeclaringExecutable().getDeclaringClass();
+}
+return encl == null ? null : createMirror(encl);
+}
+/**
+*{@inheritDoc}
+*
+* Note that this implementation does not handle the situation
+* where A overrides B and B overrides C but A does not
+* directly override C. In this case, this implementation will
+* erroneously return false.
+*/
+@Override
+public boolean overrides(ExecutableElement overrider, ExecutableElement overridden,
+TypeElement type) {
+checkElement(overrider);
+checkElement(overridden);
+checkElement(type);
+// TODO handle transitive overrides
+return overridesDirect(overrider, overridden, type);
+}
+private boolean overridesDirect(ExecutableElement overrider, ExecutableElement overridden,
+TypeElement type) {
+// Should we check that at least one of the types
+// overrider has is in fact a supertype of the TypeElement
+// 'type' supplied?
+CoreReflExecutableElement rider = (CoreReflExecutableElement)overrider;
+CoreReflExecutableElement ridden = (CoreReflExecutableElement)overridden;
+CoreReflTypeElement riderType = (CoreReflTypeElement)type;
+// Names must match, redundant - see subsignature below
+if (!rider.getSimpleName().equals(ridden.getSimpleName())) {
+return false;
+}
+// Constructors don't override
+// TODO: verify this fact
+if (rider.getKind() == ElementKind.CONSTRUCTOR ||
+ridden.getKind() == ElementKind.CONSTRUCTOR) {
+return false;
+}
+// Overridden must be visible to be overridden
+// TODO Fix transitive visibility/override
+Set<Modifier> rm = ridden.getModifiers();
+if (rm.contains(Modifier.PRIVATE)) {
+return false; // overridden private, can't be overridden
+} else if ((!(rm.contains(Modifier.PUBLIC) || rm.contains(Modifier.PROTECTED))) && // not private, not (public or protected) IE package private
+(!getPackageOf(rider).equals(getPackageOf(ridden)))) {
+return false; // ridden package private, and different packages, IE not visible
+}
+// Static methods doesn't override
+if (rm.contains(Modifier.STATIC) ||
+rider.getModifiers().contains(Modifier.STATIC)) {
+return false;
+}
+// Declaring class of overrider must be a subclass of declaring class of overridden
+// except we use the parameter type as declaring class of overrider
+if (!getTypes().isSubtype(riderType.asType(), getEnclosingTypeElement(ridden).asType())) {
+return false;
+}
+// Now overrider overrides overridden if the signature of rider is a subsignature of ridden
+return getTypes().isSubsignature(rider.asType(), ridden.asType());
+}
+/**
+*{@inheritDoc}
+*/
+@Override
+public String getConstantExpression(Object value) {
+return Constants.format(value);
+}
+// If CoreReflectionFactory were a proper part of the JDK, the
+// analogous functionality in javac could be reused.
+private static class Constants {
+/**
+* Returns a string representation of a constant value (given in
+* standard wrapped representation), quoted and formatted as in
+* Java source.
+*/
+public static String format(Object value) {
+if (value instanceof Byte)      return formatByte((Byte) value);
+if (value instanceof Short)     return formatShort((Short) value);
+if (value instanceof Long)      return formatLong((Long) value);
+if (value instanceof Float)     return formatFloat((Float) value);
+if (value instanceof Double)    return formatDouble((Double) value);
+if (value instanceof Character) return formatChar((Character) value);
+if (value instanceof String)    return formatString((String) value);
+if (value instanceof Integer ||
+value instanceof Boolean)   return value.toString();
+else
+throw new IllegalArgumentException("Argument is not a primitive type or a string; it " +
+((value == null) ?
+"is a null value." :
+"has class " +
+value.getClass().getName()) + "." );
+}
+private static String formatByte(byte b) {
+return String.format("(byte)0x%02x", b);
+}
+private static String formatShort(short s) {
+return String.format("(short)%d", s);
+}
+private static String formatLong(long lng) {
+return lng + "L";
+}
+private static String formatFloat(float f) {
+if (Float.isNaN(f))
+return "0.0f/0.0f";
+else if (Float.isInfinite(f))
+return (f < 0) ? "-1.0f/0.0f" : "1.0f/0.0f";
+else
+return f + "f";
+}
+private static String formatDouble(double d) {
+if (Double.isNaN(d))
+return "0.0/0.0";
+else if (Double.isInfinite(d))
+return (d < 0) ? "-1.0/0.0" : "1.0/0.0";
+else
+return d + "";
+}
+private static String formatChar(char c) {
+return '\'' + quote(c) + '\'';
+}
+private static String formatString(String s) {
+return '"' + quote(s) + '"';
+}
+/**
+* Escapes each character in a string that has an escape sequence or
+* is non-printable ASCII.  Leaves non-ASCII characters alone.
+*/
+private static String quote(String s) {
+StringBuilder buf = new StringBuilder();
+for (int i = 0; i < s.length(); i++) {
+buf.append(quote(s.charAt(i)));
+}
+return buf.toString();
+}
+/**
+* Escapes a character if it has an escape sequence or is
+* non-printable ASCII.  Leaves ASCII characters alone.
+*/
+private static String quote(char ch) {
+switch (ch) {
+case '\b':  return "\\b";
+case '\f':  return "\\f";
+case '\n':  return "\\n";
+case '\r':  return "\\r";
+case '\t':  return "\\t";
+case '\'':  return "\\'";
+case '\"':  return "\\\"";
+case '\\':  return "\\\\";
+default:
+return (isPrintableAscii(ch))
+? String.valueOf(ch)
+: String.format("\\u%04x", (int) ch);
+}
+}
+/**
+* Is a character printable ASCII?
+*/
+private static boolean isPrintableAscii(char ch) {
+return ch >= ' ' && ch <= '~';
+}
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public void printElements(Writer w, Element... elements) {
+ElementVisitor<?, ?> printer = getPrinter(w);
+try {
+for (Element e : elements) {
+checkElement(e);
+printer.visit(e);
+}
+} finally {
+try {
+w.flush();
+} catch (java.io.IOException e) { /* Ignore */;}
+}
+}
+private ElementVisitor<?, ?> getPrinter(Writer w) {
+// First try a reflective call into javac and if that
+// fails, fallback to a very simple toString-based
+// scanner.
+try {
+//reflective form of
+// return new com.sun.tools.javac.processing.PrintingProcessor.PrintingElementVisitor(w, getElements());
+Class<?> printProcClass =
+ClassLoader.getSystemClassLoader().loadClass("com.sun.tools.javac.processing.PrintingProcessor$PrintingElementVisitor");
+Constructor<?> printProcCtor = printProcClass.getConstructor(Writer.class, Elements.class);
+return (ElementVisitor) printProcCtor.newInstance(w, getElements());
+} catch (ReflectiveOperationException | SecurityException e) {
+return new ElementScanner8<Writer, Void>(w){
+@Override
+public Writer scan(Element e, Void v) {
+try {
+DEFAULT_VALUE.append(e.toString());
+DEFAULT_VALUE.append("\n");
+} catch (java.io.IOException ioe) {
+throw new RuntimeException(ioe);
+}
+return DEFAULT_VALUE;
+}
+};
+}
+}
+/**
+* {@inheritDoc}
+*/
+@Override
+public Name getName(CharSequence cs) {
+return StringName.instance(cs.toString());
+}
+private void checkElement(Element e) {
+if(!(e instanceof CoreReflElement)) {
+throw new IllegalArgumentException();
+}
+}
+@Override
+public boolean isFunctionalInterface(TypeElement e) {
+throw new UnsupportedOperationException();
+// Update once this functionality is in core reflection
+}
+}
+private static class CoreReflTypes implements javax.lang.model.util.Types {
+private static Types instance = new CoreReflTypes();
+public static Types instance() {
+return instance;
+}
+// Private to suppress instantiation
+private CoreReflTypes() {}
+// Types methods
+@Override
+public Element asElement(TypeMirror t) {
+checkType(t);
+if (t instanceof javax.lang.model.type.TypeVariable) {
+((javax.lang.model.type.TypeVariable)t).asElement();
+} else if (t instanceof DeclaredType) {
+return ((DeclaredType)t).asElement();
+}
+return null;
+}
+@Override
+public boolean isSameType(TypeMirror t1, TypeMirror t2) {
+if (t1.getKind() != t2.getKind()) {
+return false;
+}
+if (t1.getKind() == TypeKind.WILDCARD ||
+t2.getKind() == TypeKind.WILDCARD) {
+// Wildcards are not equal to any type
+return false;
+}
+if (t1 instanceof CoreReflDeclaredType &&
+t2 instanceof CoreReflDeclaredType) {
+return ((CoreReflDeclaredType)t1).isSameType((CoreReflDeclaredType)t2);
+} else if (t1 instanceof PrimitiveType &&
+t2 instanceof PrimitiveType) {
+return t1.getKind() == t2.getKind();
+} else if (t1 instanceof NoType &&
+t2 instanceof NoType) {
+return true;
+} else if (t1 instanceof NullType &&
+t2 instanceof NullType) {
+return true;
+} else if (t1 instanceof ArrayType &&
+t2 instanceof ArrayType) {
+return isSameType(((ArrayType)t1).getComponentType(), ((ArrayType)t2).getComponentType());
+}
+return false;
+}
+@Override
+public boolean isSubtype(TypeMirror t1, TypeMirror t2) {
+checkType(t1);
+checkType(t2);
+if (isSameType(t1, t2)) {
+return true;
+} else if(t1.getKind() == TypeKind.NULL) {
+return true;
+}
+// This depth first traversal should terminate due to the ban on circular inheritance
+List<? extends TypeMirror> directSupertypes = directSupertypes(t1);
+if (directSupertypes.isEmpty()) {
+return false;
+}
+for (TypeMirror ti : directSupertypes) {
+if (isSameType(ti, t2) || isSubtype(ti, t2)) {
+return true;
+}
+}
+return false;
+}
+@Override
+public boolean isAssignable(TypeMirror t1, TypeMirror t2) {
+throw new UnsupportedOperationException();
+}
+@Override
+public boolean contains(TypeMirror t1, TypeMirror t2) {
+throw new UnsupportedOperationException();
+}
+@Override
+public boolean isSubsignature(ExecutableType m1, ExecutableType m2) {
+checkType(m1);
+checkType(m2);
+ExecutableMethodType m0 = (ExecutableMethodType)m1;
+return m0.sameSignature((ExecutableMethodType)m2) || m0.sameSignature((ExecutableMethodType)erasure(m2));
+}
+@Override
+public List<? extends TypeMirror> directSupertypes(TypeMirror t) {
+checkType(t);
+if (t instanceof ExecutableType ||
+t.getKind() == TypeKind.PACKAGE) {
+throw new IllegalArgumentException("You can't ask for direct supertypes for type: " + t);
+}
+return ((AbstractTypeMirror)t).directSuperTypes();
+}
+@Override
+public TypeMirror erasure(TypeMirror t) {
+checkType(t);
+return ((AbstractTypeMirror)t).erasure();
+}
+@Override
+public TypeElement boxedClass(javax.lang.model.type.PrimitiveType p) {
+throw new UnsupportedOperationException();
+}
+@Override
+public PrimitiveType unboxedType(TypeMirror t) {
+throw new UnsupportedOperationException();
+}
+@Override
+public TypeMirror capture(TypeMirror t) {
+checkType(t);
+return ((AbstractTypeMirror)t).capture();
+}
+@Override
+public PrimitiveType getPrimitiveType(TypeKind kind) {
+return PrimitiveType.instance(kind);
+}
+@Override
+public NullType getNullType() {
+return CoreReflNullType.getInstance();
+}
+@Override
+public javax.lang.model.type.NoType getNoType(TypeKind kind) {
+if (kind == TypeKind.NONE) {
+return NoType.getNoneInstance();
+} else if (kind == TypeKind.VOID) {
+return NoType.getVoidInstance();
+} else {
+throw new IllegalArgumentException("No NoType of kind: " + kind);
+}
+}
+@Override
+public ArrayType getArrayType(TypeMirror componentType) {
+throw new UnsupportedOperationException();
+}
+@Override
+public javax.lang.model.type.WildcardType getWildcardType(TypeMirror extendsBound,
+TypeMirror superBound) {
+throw new UnsupportedOperationException();
+}
+@Override
+public DeclaredType getDeclaredType(TypeElement typeElem, TypeMirror... typeArgs) {
+throw new UnsupportedOperationException();
+}
+@Override
+public javax.lang.model.type.DeclaredType getDeclaredType(javax.lang.model.type.DeclaredType containing,
+TypeElement typeElem,
+TypeMirror... typeArgs) {
+throw new UnsupportedOperationException();
+}
+@Override
+public TypeMirror asMemberOf(javax.lang.model.type.DeclaredType containing, Element element) {
+throw new UnsupportedOperationException();
+}
+private void checkType(TypeMirror t) {
+if (!(t instanceof AbstractTypeMirror)) {
+throw new IllegalArgumentException("This Types implementation can only operate on CoreReflectionFactory type classes");
+}
+}
+}
+private abstract static class CoreReflDeclaredType extends AbstractTypeMirror
+implements javax.lang.model.type.DeclaredType {
+private Class<?> source = null;
+private CoreReflDeclaredType(Class<?> source) {
+super(TypeKind.DECLARED);
+this.source = source;
+}
+static DeclaredType instance(Class<?> source, Type genericSource) {
+if (genericSource instanceof ParameterizedType) {
+return new ParameterizedDeclaredType(source, (ParameterizedType)genericSource);
+} else if (genericSource instanceof Class) { // This happens when a field has a raw type
+if (!source.equals(genericSource)) {
+throw new IllegalArgumentException("Don't know how to handle this");
+}
+return instance(source);
+}
+throw new IllegalArgumentException("Don't know how to create a declared type from: " +
+source +
+" and genericSource " +
+genericSource);
+}
+static DeclaredType instance(Class<?> source) {
+return new RawDeclaredType(source);
+}
+protected Class<?> getSource() {
+return source;
+}
+@Override
+public Element asElement() {
+return CoreReflectionFactory.createMirror(getSource());
+}
+abstract boolean isSameType(DeclaredType other);
+@Override
+TypeMirror capture() {
+return new CaptureDeclaredType(this);
+}
+private static class CaptureDeclaredType extends CoreReflDeclaredType {
+CoreReflDeclaredType cap;
+CaptureDeclaredType(CoreReflDeclaredType t) {
+super(t.source);
+this.cap = t;
+}
+@Override
+public List<? extends TypeMirror> getTypeArguments() {
+List<? extends TypeMirror> wrapped = cap.getTypeArguments();
+ArrayList<TypeMirror> res = new ArrayList<>(wrapped.size());
+res.ensureCapacity(wrapped.size());
+for (int i = 0; i < wrapped.size(); i++) {
+TypeMirror t = wrapped.get(i);
+if (t instanceof javax.lang.model.type.WildcardType) {
+res.add(i, convert(t));
+} else {
+res.add(i, t);
+}
+}
+return Collections.unmodifiableList(res);
+}
+private TypeMirror convert(TypeMirror t) {
+if (!(t instanceof javax.lang.model.type.WildcardType)) {
+throw new IllegalArgumentException();
+} else {
+javax.lang.model.type.WildcardType w = (javax.lang.model.type.WildcardType)t;
+return TypeFactory.typeVariableInstance(w, w.getExtendsBound(), w.getSuperBound());
+}
+}
+@Override
+public TypeMirror getEnclosingType() {
+return cap.getEnclosingType();
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+return cap.directSuperTypes();
+}
+@Override
+boolean isSameType(DeclaredType other) {
+return other == this;
+}
+@Override
+public String toString() {
+return " CAPTURE of: " + cap.toString();
+}
+}
+private static class RawDeclaredType extends CoreReflDeclaredType
+implements Reifiable {
+private RawDeclaredType(Class<?> source) {
+super(source);
+}
+@Override
+public Class<?> getSource() {
+return super.getSource();
+}
+@Override
+public TypeMirror getEnclosingType() {
+Class<?> enclosing = getSource().getEnclosingClass();
+if (null == enclosing) {
+return NoType.getNoneInstance();
+} else {
+return TypeFactory.instance(enclosing);
+}
+}
+@Override
+public List<? extends TypeMirror> getTypeArguments() {
+return Collections.emptyList();
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+if (getSource().isEnum()) {
+return enumSuper();
+}
+if (getSource() == java.lang.Object.class) {
+return Collections.emptyList();
+}
+List<TypeMirror> res = new ArrayList<>();
+Type[] superInterfaces = getSource().getInterfaces();
+if (!getSource().isInterface()) {
+res.add(TypeFactory.instance(getSource().getSuperclass()));
+} else if (superInterfaces.length == 0) {
+// Interfaces that don't extend another interface
+// have java.lang.Object as a direct supertype.
+return Collections.unmodifiableList(Arrays.asList(TypeFactory.instance(java.lang.Object.class)));
+}
+for (Type t : superInterfaces) {
+res.add(TypeFactory.instance(t));
+}
+return Collections.unmodifiableList(res);
+}
+private List<? extends TypeMirror> enumSuper() {
+Class<?> rawSuper = getSource().getSuperclass();
+Type[] actualArgs = ((ParameterizedTypeImpl)getSource().getGenericSuperclass()).getActualTypeArguments();
+// Reconsider this : assume the problem is making
+// Enum<MyEnum> rather than just a raw enum.
+return Collections.unmodifiableList(Arrays.asList(TypeFactory.instance(ParameterizedTypeImpl.make(rawSuper,
+Arrays.copyOf(actualArgs,
+actualArgs.length),
+null))));
+}
+@Override
+boolean isSameType(DeclaredType other) {
+if (other instanceof RawDeclaredType) {
+return Objects.equals(getSource(), ((RawDeclaredType)other).getSource());
+} else {
+return false;
+}
+}
+@Override
+public String toString() {
+return getSource().toString();
+}
+}
+private static class ParameterizedDeclaredType extends CoreReflDeclaredType {
+private ParameterizedType genericSource = null;
+private ParameterizedDeclaredType(Class<?> source, ParameterizedType genericSource) {
+super(source);
+this.genericSource = genericSource;
+}
+@Override
+public TypeMirror getEnclosingType() {
+Type me = genericSource;
+Type owner = GenericTypes.getEnclosingType(me);
+if (owner == null) {
+return NoType.getNoneInstance();
+}
+return TypeFactory.instance(owner);
+}
+@Override
+public List<? extends TypeMirror> getTypeArguments() {
+Type[] typeArgs = genericSource.getActualTypeArguments();
+int length = typeArgs.length;
+if (length == 0)
+return Collections.emptyList();
+else {
+List<TypeMirror> tmp = new ArrayList<>(length);
+for (Type t : typeArgs) {
+tmp.add(TypeFactory.instance(t));
+}
+return Collections.unmodifiableList(tmp);
+}
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+if (getSource() == java.lang.Object.class) {
+return Collections.emptyList();
+}
+List<TypeMirror> res = new ArrayList<>();
+Type[] superInterfaces = getSource().getGenericInterfaces();
+if (!getSource().isInterface()) {
+// Replace actual type arguments with our type arguments
+res.add(TypeFactory.instance(substituteTypeArgs(getSource().getGenericSuperclass())));
+} else if (superInterfaces.length == 0) {
+// Interfaces that don't extend another interface
+// have java.lang.Object as a direct supertype, plus
+// possibly the interface's raw type
+res.add(TypeFactory.instance(java.lang.Object.class));
+}
+for (Type t : superInterfaces) {
+res.add(TypeFactory.instance(substituteTypeArgs(t)));
+}
+res.add(TypeFactory.instance(getSource())); // Add raw type
+return Collections.unmodifiableList(res);
+}
+private Type substituteTypeArgs(Type type) {
+if (!(type instanceof ParameterizedType)) {
+return type;
+}
+ParameterizedType target = (ParameterizedType)type;
+// Cast to get a Class instead of a plain type.
+Class<?> raw = ((ParameterizedTypeImpl)target).getRawType();
+Type[] actualArgs = genericSource.getActualTypeArguments();
+return  ParameterizedTypeImpl.make(raw, Arrays.copyOf(actualArgs, actualArgs.length), null);
+}
+@Override
+boolean isSameType(DeclaredType other) {
+if (other instanceof ParameterizedDeclaredType) {
+return GenericTypes.isSameGenericType(genericSource,
+((ParameterizedDeclaredType)other).genericSource);
+} else {
+return false;
+}
+}
+@Override
+public String toString() {
+return getKind().toString() + " " + genericSource.toString();
+}
+}
+/**
+* Implementing class for ParameterizedType interface.
+* Derived from sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
+*/
+private static class ParameterizedTypeImpl implements ParameterizedType {
+private Type[] actualTypeArguments;
+private Class<?>  rawType;
+private Type   ownerType;
+private ParameterizedTypeImpl(Class<?> rawType,
+Type[] actualTypeArguments,
+Type ownerType) {
+this.actualTypeArguments = actualTypeArguments;
+this.rawType             = rawType;
+if (ownerType != null) {
+this.ownerType = ownerType;
+} else {
+this.ownerType = rawType.getDeclaringClass();
+}
+validateConstructorArguments();
+}
+private void validateConstructorArguments() {
+java.lang.reflect.TypeVariable/*<?>*/[] formals = rawType.getTypeParameters();
+// check correct arity of actual type args
+if (formals.length != actualTypeArguments.length){
+throw new MalformedParameterizedTypeException();
+}
+}
+/**
+* Static factory. Given a (generic) class, actual type arguments
+* and an owner type, creates a parameterized type.
+* This class can be instantiated with a a raw type that does not
+* represent a generic type, provided the list of actual type
+* arguments is empty.
+* If the ownerType argument is null, the declaring class of the
+* raw type is used as the owner type.
+* <p> This method throws a MalformedParameterizedTypeException
+* under the following circumstances:
+* If the number of actual type arguments (i.e., the size of the
+* array {@code typeArgs}) does not correspond to the number of
+* formal type arguments.
+* If any of the actual type arguments is not an instance of the
+* bounds on the corresponding formal.
+* @param rawType the Class representing the generic type declaration being
+* instantiated
+* @param actualTypeArguments - a (possibly empty) array of types
+* representing the actual type arguments to the parameterized type
+* @param ownerType - the enclosing type, if known.
+* @return An instance of {@code ParameterizedType}
+* @throws MalformedParameterizedTypeException - if the instantiation
+* is invalid
+*/
+public static ParameterizedTypeImpl make(Class<?> rawType,
+Type[] actualTypeArguments,
+Type ownerType) {
+return new ParameterizedTypeImpl(rawType, actualTypeArguments,
+ownerType);
+}
+/**
+* Returns an array of {@code Type} objects representing the actual type
+* arguments to this type.
+*
+* <p>Note that in some cases, the returned array be empty. This can occur
+* if this type represents a non-parameterized type nested within
+* a parameterized type.
+*
+* @return an array of {@code Type} objects representing the actual type
+*     arguments to this type
+* @throws {@code TypeNotPresentException} if any of the
+*     actual type arguments refers to a non-existent type declaration
+* @throws {@code MalformedParameterizedTypeException} if any of the
+*     actual type parameters refer to a parameterized type that cannot
+*     be instantiated for any reason
+* @since 1.5
+*/
+public Type[] getActualTypeArguments() {
+return actualTypeArguments.clone();
+}
+/**
+* Returns the {@code Type} object representing the class or interface
+* that declared this type.
+*
+* @return the {@code Type} object representing the class or interface
+*     that declared this type
+*/
+public Class<?> getRawType() {
+return rawType;
+}
+/**
+* Returns a {@code Type} object representing the type that this type
+* is a member of.  For example, if this type is {@code O<T>.I<S>},
+* return a representation of {@code O<T>}.
+*
+* <p>If this type is a top-level type, {@code null} is returned.
+*
+* @return a {@code Type} object representing the type that
+*     this type is a member of. If this type is a top-level type,
+*     {@code null} is returned
+*/
+public Type getOwnerType() {
+return ownerType;
+}
+/*
+* From the JavaDoc for java.lang.reflect.ParameterizedType
+* "Instances of classes that implement this interface must
+* implement an equals() method that equates any two instances
+* that share the same generic type declaration and have equal
+* type parameters."
+*/
+@Override
+public boolean equals(Object o) {
+if (o instanceof ParameterizedType) {
+// Check that information is equivalent
+ParameterizedType that = (ParameterizedType) o;
+if (this == that)
+return true;
+Type thatOwner   = that.getOwnerType();
+Type thatRawType = that.getRawType();
+return Objects.equals(ownerType, thatOwner) &&
+Objects.equals(rawType, thatRawType) &&
+Arrays.equals(actualTypeArguments, // avoid clone
+that.getActualTypeArguments());
+} else
+return false;
+}
+@Override
+public int hashCode() {
+return
+Arrays.hashCode(actualTypeArguments) ^
+Objects.hashCode(ownerType) ^
+Objects.hashCode(rawType);
+}
+public String toString() {
+StringBuilder sb = new StringBuilder();
+if (ownerType != null) {
+if (ownerType instanceof Class)
+sb.append(((Class)ownerType).getName());
+else
+sb.append(ownerType.toString());
+sb.append(".");
+if (ownerType instanceof ParameterizedTypeImpl) {
+// Find simple name of nested type by removing the
+// shared prefix with owner.
+sb.append(rawType.getName().replace( ((ParameterizedTypeImpl)ownerType).rawType.getName() + "$",
+""));
+} else
+sb.append(rawType.getName());
+} else
+sb.append(rawType.getName());
+if (actualTypeArguments != null &&
+actualTypeArguments.length > 0) {
+sb.append("<");
+boolean first = true;
+for (Type t: actualTypeArguments) {
+if (!first)
+sb.append(", ");
+if (t instanceof Class)
+sb.append(((Class)t).getName());
+else
+sb.append(t.toString());
+first = false;
+}
+sb.append(">");
+}
+return sb.toString();
+}
+}
+}
+private static class ErasedMethodType extends ExecutableMethodType implements javax.lang.model.type.ExecutableType {
+private final Method m;
+ErasedMethodType(Method m) {
+super(m);
+this.m = Objects.requireNonNull(m);
+}
+@Override
+public List<javax.lang.model.type.TypeVariable> getTypeVariables() {
+return Collections.emptyList();
+}
+@Override
+public List<? extends TypeMirror> getThrownTypes() {
+Class<?>[] exceptions = m.getExceptionTypes();
+int len = exceptions.length;
+if (len > 0) {
+List<TypeMirror> res = new ArrayList<TypeMirror>(len);
+for (Class<?> t : exceptions) {
+res.add(TypeFactory.instance(t));
+}
+return Collections.unmodifiableList(res);
+} else {
+List<TypeMirror> ret = Collections.emptyList();
+return ret;
+}
+}
+@Override
+public List<? extends TypeMirror> getParameterTypes() {
+Class<?>[] params = m.getParameterTypes();
+int len = params.length;
+if (len > 0) {
+List<TypeMirror> res = new ArrayList<TypeMirror>(len);
+for (Class<?> t : params) {
+res.add(TypeFactory.instance(t));
+}
+return Collections.unmodifiableList(res);
+} else {
+List<TypeMirror> ret = Collections.emptyList();
+return ret;
+}
+}
+@Override
+public TypeMirror getReturnType() {
+return TypeFactory.instance(m.getReturnType());
+}
+@Override
+TypeMirror erasure() {
+return this;
+}
+}
+private static class ErrorType extends AbstractTypeMirror implements javax.lang.model.type.ErrorType {
+private static ErrorType errorType = new ErrorType();
+public static ErrorType getErrorInstance() {
+return errorType;
+}
+private ErrorType() {
+super(TypeKind.ERROR);
+}
+@Override
+public List<? extends TypeMirror> getTypeArguments() {
+throw new UnsupportedOperationException();
+}
+@Override
+public TypeMirror getEnclosingType() {
+throw new UnsupportedOperationException();
+}
+@Override
+public Element asElement() {
+throw new UnsupportedOperationException();
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+throw new UnsupportedOperationException();
+}
+}
+private static class ExecutableMethodType extends AbstractTypeMirror
+implements javax.lang.model.type.ExecutableType {
+private final Method m;
+ExecutableMethodType(Method m) {
+super(TypeKind.EXECUTABLE);
+this.m = Objects.requireNonNull(m);
+}
+@Override
+public List<? extends TypeMirror> getThrownTypes() {
+Type[] exceptions = m.getGenericExceptionTypes();
+int len = exceptions.length;
+if (len > 0) {
+List<TypeMirror> res = new ArrayList<TypeMirror>(len);
+for (Type t : exceptions) {
+res.add(TypeFactory.instance(t));
+}
+return Collections.unmodifiableList(res);
+} else {
+List<TypeMirror> ret = Collections.emptyList();
+return ret;
+}
+}
+@Override
+public List<javax.lang.model.type.TypeVariable> getTypeVariables() {
+java.lang.reflect.TypeVariable[] variables = m.getTypeParameters();
+int len = variables.length;
+if (len > 0) {
+List<javax.lang.model.type.TypeVariable> res = new ArrayList<>(len);
+for (java.lang.reflect.TypeVariable<?> t : variables) {
+res.add(TypeFactory.typeVariableInstance(t));
+}
+return Collections.unmodifiableList(res);
+} else {
+return Collections.emptyList();
+}
+}
+@Override
+public TypeMirror getReturnType() {
+return TypeFactory.instance(m.getGenericReturnType());
+}
+@Override
+public List<? extends TypeMirror> getParameterTypes() {
+Type[] params = m.getGenericParameterTypes();
+int len = params.length;
+if (len > 0) {
+List<TypeMirror> res = new ArrayList<TypeMirror>(len);
+for (Type t : params) {
+res.add(TypeFactory.instance(t));
+}
+return Collections.unmodifiableList(res);
+} else {
+return Collections.emptyList();
+}
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+// Spec says we don't need this
+throw new UnsupportedOperationException();
+}
+@Override
+TypeMirror erasure() {
+return new ErasedMethodType(m);
+}
+@Override
+public TypeMirror getReceiverType() {
+throw new UnsupportedOperationException();
+}
+boolean sameSignature(ExecutableMethodType other){
+if (!m.getName().equals(other.m.getName())) {
+return false;
+}
+List<? extends TypeMirror> thisParams = getParameterTypes();
+List<? extends TypeMirror> otherParams = other.getParameterTypes();
+if (thisParams.size() != otherParams.size()) {
+return false;
+}
+for (int i = 0; i < thisParams.size(); i++) {
+if (!CoreReflTypes.instance().isSameType(thisParams.get(i), otherParams.get(i))) {
+return false;
+}
+}
+return true;
+}
+}
+private static class GenericTypes {
+public static boolean isSameGenericType(Type t1, Type t2) {
+if (t1 instanceof Class) {
+return ((Class)t1).equals(t2);
+} else if (t1 instanceof ParameterizedType) {
+return ((ParameterizedType)t1).equals(t2);
+}
+throw new UnsupportedOperationException();
+}
+public static Type getEnclosingType(Type t1) {
+if (t1 instanceof Class) {
+return ((Class)t1).getEnclosingClass();
+} else if (t1 instanceof ParameterizedType) {
+return ((ParameterizedType)t1).getOwnerType();
+}
+throw new UnsupportedOperationException();
+}
+}
+private static class IntersectionDeclaredType extends AbstractTypeMirror
+implements javax.lang.model.type.DeclaredType {
+private Type[] sources = null;
+IntersectionDeclaredType(Type[] sources) {
+super(TypeKind.DECLARED);
+this.sources = Arrays.copyOf(Objects.requireNonNull(sources),
+sources.length);
+}
+@Override
+public TypeMirror getEnclosingType() {
+return NoType.getNoneInstance();
+}
+@Override
+public  Element asElement() {
+throw new UnsupportedOperationException();
+}
+@Override
+public List<? extends TypeMirror> getTypeArguments() {
+throw new UnsupportedOperationException();
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+int len = sources.length;
+if (len > 0) {
+List<TypeMirror> res = new ArrayList<TypeMirror>(len);
+for (Type c : sources) {
+res.add(TypeFactory.instance(c));
+}
+return Collections.unmodifiableList(res);
+} else {
+return Collections.emptyList();
+}
+}
+}
+private static class ModelWildcardType extends AbstractTypeMirror
+implements javax.lang.model.type.WildcardType {
+private java.lang.reflect.WildcardType genericSource;
+ModelWildcardType(java.lang.reflect.WildcardType genericSource) {
+super(TypeKind.WILDCARD);
+this.genericSource = Objects.requireNonNull(genericSource);
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+// TODO Add support for this operation
+throw new UnsupportedOperationException();
+}
+@Override
+public TypeMirror getExtendsBound() {
+Type[] t = genericSource.getUpperBounds();
+if (t.length == 1) {
+if (t[0].equals(Object.class) && getSuperBound() != null) { // can't have both lower and upper explicit
+return null;
+}
+return TypeFactory.instance(t[0]);
+}
+throw new UnsupportedOperationException(); // TODO: intersection type?
+}
+@Override
+public TypeMirror getSuperBound() {
+Type[] t = genericSource.getLowerBounds();
+if (t.length == 0) { // bound is null
+return null;
+} else if (t.length == 1) {
+return TypeFactory.instance(t[0]);
+}
+throw new UnsupportedOperationException(); // TODO: intersection type?
+}
+@Override
+public String toString() {
+return getKind() + " " + genericSource.toString();
+}
+}
+private static class NoType extends AbstractTypeMirror
+implements javax.lang.model.type.NoType {
+private static NoType noneType = new NoType(TypeKind.NONE, "none");
+private static NoType packageType = new NoType(TypeKind.PACKAGE, "package");
+private static NoType voidType = new NoType(TypeKind.VOID, "void");
+private String str;
+public static NoType getNoneInstance() {
+return noneType;
+}
+public static NoType getPackageInstance() {
+return packageType;
+}
+public static NoType getVoidInstance() {
+return voidType;
+}
+private NoType(TypeKind k, String str) {
+super(k);
+this.str = str;
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+// TODO We don't need this for the Package instance, how about the others?
+throw new UnsupportedOperationException();
+}
+@Override
+public String toString() {
+return str;
+}
+}
+private static class CoreReflNullType extends AbstractTypeMirror
+implements javax.lang.model.type.NullType {
+private static CoreReflNullType nullType = new CoreReflNullType();
+public static NullType getInstance() {
+return nullType;
+}
+private CoreReflNullType() {
+super(TypeKind.NULL);
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+// JLS 4.10.2 says:
+// "The direct supertypes of the null type are all reference types other than the null type itself."
+// TODO return null? an empty list? the error type? anyhow fix this
+throw new UnsupportedOperationException();
+}
+}
+private static interface Reifiable {
+Class<?> getSource();
+}
+private static class PrimitiveType extends AbstractTypeMirror
+implements javax.lang.model.type.PrimitiveType,
+Reifiable {
+private Class<?> source;
+private static PrimitiveType booleanInstance = new PrimitiveType(TypeKind.BOOLEAN, boolean.class);
+private static PrimitiveType byteInstance =    new PrimitiveType(TypeKind.BYTE, byte.class);
+private static PrimitiveType charInstance =    new PrimitiveType(TypeKind.CHAR, char.class);
+private static PrimitiveType shortInstance =   new PrimitiveType(TypeKind.SHORT, short.class);
+private static PrimitiveType intInstance =     new PrimitiveType(TypeKind.INT, int.class);
+private static PrimitiveType longInstance =    new PrimitiveType(TypeKind.LONG, long.class);
+private static PrimitiveType floatInstance =   new PrimitiveType(TypeKind.FLOAT, float.class);
+private static PrimitiveType doubleInstance =  new PrimitiveType(TypeKind.DOUBLE, double.class);
+private PrimitiveType(TypeKind kind, Class<?> source) {
+super(kind);
+this.source = source;
+}
+@Override
+public Class<?> getSource() {
+return source;
+}
+static PrimitiveType instance(Class<?> c) {
+switch(c.getName()) {
+case "boolean":
+return booleanInstance;
+case "byte":
+return byteInstance;
+case "char":
+return charInstance;
+case "short":
+return shortInstance;
+case "int":
+return intInstance;
+case "long":
+return longInstance;
+case "float":
+return floatInstance;
+case "double":
+return doubleInstance;
+default:
+throw new IllegalArgumentException();
+}
+}
+static PrimitiveType instance(TypeKind k) {
+switch(k) {
+case BOOLEAN:
+return booleanInstance;
+case BYTE:
+return byteInstance;
+case CHAR:
+return charInstance;
+case SHORT:
+return shortInstance;
+case INT:
+return intInstance;
+case LONG:
+return longInstance;
+case FLOAT:
+return floatInstance;
+case DOUBLE:
+return doubleInstance;
+default:
+throw new IllegalArgumentException();
+}
+}
+@Override
+public String toString() {
+return source.getName();
+}
+//Types methods
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+switch (getKind()) {
+case DOUBLE:
+return Collections.emptyList();
+case FLOAT:
+return Arrays.asList(doubleInstance);
+case LONG:
+return Arrays.asList(floatInstance);
+case INT:
+return Arrays.asList(longInstance);
+case CHAR:
+return Arrays.asList(intInstance);
+case SHORT:
+return Arrays.asList(intInstance);
+case BYTE:
+return Arrays.asList(shortInstance);
+default:
+return Collections.emptyList();
+}
+}
+}
+private static class TypeFactory {
+private TypeFactory() { }// no instances for you
+public static TypeMirror instance(Class<?> c) {
+if (c.isPrimitive()) {
+if (c.getName().equals("void")) {
+return NoType.getVoidInstance();
+} else {
+return PrimitiveType.instance(c);
+}
+} else if (c.isArray()) {
+return new CoreReflArrayType(c);
+} else if (c.isAnonymousClass() ||
+c.isLocalClass() ||
+c.isMemberClass() ||
+c.isInterface() || // covers annotations
+c.isEnum()) {
+return CoreReflDeclaredType.instance(c);
+} else { // plain old class ??
+return CoreReflDeclaredType.instance(c);
+}
+}
+public static TypeMirror instance(Type t) {
+if (t instanceof Class) {
+return instance((Class)t);
+} else if (t instanceof ParameterizedType) {
+ParameterizedType tmp = (ParameterizedType)t;
+Type raw = tmp.getRawType();
+if (!(raw instanceof Class)) {
+throw new IllegalArgumentException(t + " " + raw );
+}
+return CoreReflDeclaredType.instance((Class)raw, tmp);
+} else if (t instanceof java.lang.reflect.WildcardType) {
+return new ModelWildcardType((java.lang.reflect.WildcardType)t);
+} else if (t instanceof java.lang.reflect.TypeVariable) {
+return new CoreReflTypeVariable((java.lang.reflect.TypeVariable)t);
+}
+throw new IllegalArgumentException("Don't know how to make instance from: " + t.getClass());
+}
+public static TypeMirror instance(Field f) {
+return CoreReflDeclaredType.instance(f.getType(), f.getGenericType());
+}
+public static ExecutableType instance(Method m) {
+return new ExecutableMethodType(m);
+}
+public static javax.lang.model.type.TypeVariable typeVariableInstance(java.lang.reflect.TypeVariable<?> v) {
+return new CoreReflTypeVariable(v);
+}
+public static javax.lang.model.type.TypeVariable typeVariableInstance(TypeMirror source,
+TypeMirror upperBound,
+TypeMirror lowerBound) {
+return new CaptureTypeVariable(source, upperBound, lowerBound);
+}
+}
+private static class CoreReflTypeVariable extends AbstractTypeMirror
+implements javax.lang.model.type.TypeVariable {
+private final java.lang.reflect.TypeVariable<?> source;
+private boolean isCapture = false;
+protected CoreReflTypeVariable(java.lang.reflect.TypeVariable<?> source) {
+super(TypeKind.TYPEVAR);
+Objects.requireNonNull(source);
+this.source = source;
+}
+@Override
+public TypeMirror getUpperBound() {
+return new IntersectionDeclaredType(source.getBounds());
+}
+@Override
+public TypeMirror getLowerBound() {
+return CoreReflTypes.instance().getNullType();
+}
+@Override
+public Element asElement() {
+return CoreReflectionFactory.createMirror(source);
+}
+@Override
+List<? extends TypeMirror> directSuperTypes() {
+return ((AbstractTypeMirror)getUpperBound()).directSuperTypes();
+}
+@Override
+public int hashCode() {
+return source.hashCode();
+}
+@Override
+public boolean equals(Object other) {
+if (other instanceof CoreReflTypeVariable) {
+return this.source.equals(((CoreReflTypeVariable)other).source);
+} else {
+return false;
+}
+}
+}
+}

changeset 17581	69b191cb1d7e
child 17806	b694bd72f635