/*

 *

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

     */

        implements ReflectionElementVisitor<R, P> {

            super();

        }

    }

    /**

     * Base class for simple visitors of elements that are backed by core reflection.

     */

        implements ReflectionElementVisitor<R, P> {

            super();

        }

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