TypeElementImpl.java

package net.florianschoppmann.java.reflect;

import javax.annotation.Nullable;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ElementVisitor;
import javax.lang.model.element.Name;
import javax.lang.model.element.NestingKind;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeMirror;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

final class TypeElementImpl extends ElementImpl implements TypeElement, ReflectionParameterizable {
    private final Class<?> clazz;
    private final ImmutableList<TypeParameterElementImpl> typeParameters;
    @Nullable private ReflectionElement enclosingElement;
    @Nullable private ReflectionTypeMirror superClass;
    @Nullable private List<ReflectionTypeMirror> interfaces;
    @Nullable private List<ElementImpl> enclosedElements;

    /**
     * Cache the type returned by {@link #asType()}.
     *
     * <p>Similarly to {@link String#hashCode()}, caching is not synchronized. This means that different threads may
     * (at least theoretically) see different values for this field. However, this is not a problem because all such
     * values would compare equal. Moreover, §17.7 JLS specifies that "Writes to and reads of references are always
     * atomic, regardless of whether they are implemented as 32-bit or 64-bit values". Hence, even if caches were
     * updated, every access to this field would yield a well-defined result.
     */
    @Nullable private DeclaredTypeImpl type;

    TypeElementImpl(Class<?> clazz) {
        this.clazz = Objects.requireNonNull(clazz);

        List<TypeParameterElementImpl> newTypeParameters = new ArrayList<>();
        for (TypeVariable<?> parameter: clazz.getTypeParameters()) {
            newTypeParameters.add(new TypeParameterElementImpl(parameter, this));
        }
        typeParameters = ImmutableList.copyOf(newTypeParameters);
    }

    @Override
    public boolean equals(@Nullable Object otherObject) {
        if (this == otherObject) {
            return true;
        } else if (otherObject == null || getClass() != otherObject.getClass()) {
            return false;
        }

        return clazz.equals(((TypeElementImpl) otherObject).clazz);
    }

    @Override
    public int hashCode() {
        return clazz.hashCode();
    }

    @Override
    public String toString() {
        return clazz.toString();
    }

    @Override
    public <R, P> R accept(ElementVisitor<R, P> visitor, @Nullable P parameter) {
        return visitor.visitType(this, parameter);
    }

    @Override
    public List<ElementImpl> getEnclosedElements() {
        requireFinished();
        assert enclosedElements != null : "must be non-null when finished";
        return enclosedElements;
    }

    @Override
    public NestingKind getNestingKind() {
        throw new UnsupportedOperationException(String.format(
            "Nesting kind not currently supported by %s.", ReflectionTypes.class
        ));
    }

    @Override
    public NameImpl getQualifiedName() {
        return new NameImpl(clazz.getCanonicalName());
    }

    @Override
    public Name getSimpleName() {
        return new NameImpl(clazz.getSimpleName());
    }

    @Override
    public TypeMirror getSuperclass() {
        requireFinished();
        assert superClass != null : "must be non-null when finished";
        return superClass;
    }

    @Override
    public List<? extends TypeMirror> getInterfaces() {
        requireFinished();
        assert interfaces != null : "must be non-null when finished";
        return interfaces;
    }

    @Override
    public List<TypeParameterElementImpl> getTypeParameters() {
        return typeParameters;
    }

    @Override
    public ReflectionElement getEnclosingElement() {
        requireFinished();

        if (enclosingElement == null) {
            throw new UnsupportedOperationException("getEnclosingElement() not supported for top-level classes.");
        } else {
            return enclosingElement;
        }
    }

    @Override
    public DeclaredTypeImpl asType() {
        requireFinished();

        @Nullable DeclaredTypeImpl localType = type;
        if (localType == null) {
            List<TypeVariableImpl> prototypicalTypeArguments = new ArrayList<>(typeParameters.size());
            for (TypeParameterElementImpl typeParameter: typeParameters) {
                prototypicalTypeArguments.add(typeParameter.asType());
            }

            ReflectionTypeMirror enclosingType = enclosingElement == null
                ? NoTypeImpl.NONE
                : enclosingElement.asType();
            localType = new DeclaredTypeImpl(enclosingType, this, prototypicalTypeArguments);
            type = localType;
        }
        return localType;
    }

    @Override
    public ElementKind getKind() {
        if (clazz.isEnum()) {
            return ElementKind.ENUM;
        } else if (clazz.isAnnotation()) {
            return ElementKind.ANNOTATION_TYPE;
        } else if (clazz.isInterface()) {
            return ElementKind.INTERFACE;
        } else {
            return ElementKind.CLASS;
        }
    }

    @Override
    protected void finishDerivedFromElement(MirrorContext mirrorContext) {
        @Nullable Class<?> enclosingClass = clazz.getEnclosingClass();
        enclosingElement = enclosingClass == null
            ? null
            : mirrorContext.typeDeclaration(enclosingClass);

        Class<?>[] declaredClasses = clazz.getDeclaredClasses();
        List<ElementImpl> newEnclosedElements = new ArrayList<>(typeParameters.size() + declaredClasses.length);
        newEnclosedElements.addAll(typeParameters);
        for (Class<?> declaredClass: declaredClasses) {
            newEnclosedElements.add(mirrorContext.typeDeclaration(declaredClass));
        }
        enclosedElements = ImmutableList.copyOf(newEnclosedElements);

        @Nullable Type genericSuperClass = clazz.getGenericSuperclass();
        superClass = genericSuperClass == null
            ? NoTypeImpl.NONE
            : mirrorContext.mirror(genericSuperClass);
        interfaces = mirrorContext.mirror(clazz.getGenericInterfaces());
        for (TypeParameterElementImpl typeParameter: typeParameters) {
            typeParameter.finish(mirrorContext);
        }

        // Field 'type' is lazily initialized in order to break a dependency chain: Constructing type requires
        // enclosingElement.asType(), which at this point may not yet be available.
    }
}