jdk8-mips64-public/langtools: src/share/sample/language/model/CoreReflectionFactory.java@bc44f1f002c9 (annotated)

src/share/sample/language/model/CoreReflectionFactory.java@bc44f1f002c9 (annotated)

src/share/sample/language/model/CoreReflectionFactory.java

Wed, 22 Jun 2016 08:52:25 -0700

author: asaha
date: Wed, 22 Jun 2016 08:52:25 -0700
changeset 3235: bc44f1f002c9
parent 1781: 0f8e9a0e5d9a
child 2525: 2eb010b6cb22
permissions: -rw-r--r--

Added tag jdk8u102-b14 for changeset 0549bf2f507d

 /*
  * 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
         /**
          * {@inheritDoc}
          */
         @Override
         java.lang.reflect.TypeVariable<?> 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 java.lang.reflect.TypeVariable<?> getSource() {
             return sourceTypeVar;
         }
         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;
             }
         }
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/sample/language/model/CoreReflectionFactory.java@bc44f1f002c9 (annotated)

src/share/sample/language/model/CoreReflectionFactory.java