annotations/el/AnnotationDef.java

package annotations.el;

/*>>>
import org.checkerframework.checker.nullness.qual.Nullable;
*/

import java.io.File;
import java.util.*;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;

import annotations.el.AElement;
import annotations.AnnotationBuilder;
import annotations.field.*;
import annotations.Annotation;
import annotations.Annotations;

/**
 * An annotation type definition, consisting of the annotation name,
 * its meta-annotations, and its field names and
 * types. <code>AnnotationDef</code>s are immutable.  An AnnotationDef with
 * a non-null retention policy is called a "top-level annotation definition".
 */
public final class AnnotationDef extends AElement {

    /**
     * The binary name of the annotation type, such as
     * "foo.Bar$Baz" for inner class Baz in class Bar in package foo.
     */
    public final String name;

    /**
     * A map of the names of this annotation type's fields to their types. Since
     * {@link AnnotationDef}s are immutable, attempting to modify this
     * map will result in an exception.
     */
    public Map<String, AnnotationFieldType> fieldTypes;

    /**
     * Constructs an annotation definition with the given name.
     * You MUST call setFieldTypes afterward, even if with an empty map.  (Yuck.)
     */
    public AnnotationDef(String name) {
        super("annotation: " + name);
        assert name != null;
        this.name = name;
    }

    @Override
    public AnnotationDef clone() {
        throw new UnsupportedOperationException("can't duplicate AnnotationDefs");
    }

    // Problem:  I am not sure how to handle circularities (annotations meta-annotated with themselves)
    /**
     * Look up an AnnotationDefs in adefs.
     * If not found, read from a class and insert in adefs.
     */
    public static AnnotationDef fromClass(Class<? extends java.lang.annotation.Annotation> annoType, Map<String,AnnotationDef> adefs) {
        String name = annoType.getName();
        assert name != null;

        if (adefs.containsKey(name)) {
            return adefs.get(name);
        }

        Map<String,AnnotationFieldType> fieldTypes = new LinkedHashMap<String,AnnotationFieldType>();
        for (Method m : annoType.getDeclaredMethods()) {
            AnnotationFieldType aft = AnnotationFieldType.fromClass(m.getReturnType(), adefs);
            fieldTypes.put(m.getName(), aft);
        }

        AnnotationDef result = new AnnotationDef(name, Annotations.noAnnotations, fieldTypes);
        adefs.put(name, result);

        // An annotation can be meta-annotated with itself, so add
        // meta-annotations after putting the annotation in the map.
        java.lang.annotation.Annotation[] jannos;
        try {
            jannos = annoType.getDeclaredAnnotations();
        } catch (Exception e) {
            printClasspath();
            throw new Error("Exception in anno.getDeclaredAnnotations() for anno = " + annoType, e);
        }
        for (java.lang.annotation.Annotation ja : jannos) {
            result.tlAnnotationsHere.add(new Annotation(ja, adefs));
        }

        return result;
    }

    public AnnotationDef(String name, Set<Annotation> tlAnnotationsHere) {
        super("annotation: " + name);
        assert name != null;
        this.name = name;
        if (tlAnnotationsHere != null) {
            this.tlAnnotationsHere.addAll(tlAnnotationsHere);
        }
    }

    public AnnotationDef(String name, Set<Annotation> tlAnnotationsHere, Map<String, ? extends AnnotationFieldType> fieldTypes) {
        this(name, tlAnnotationsHere);
        setFieldTypes(fieldTypes);
    }

    /**
     * Constructs an annotation definition with the given name and field types.
     * The field type map is copied and then wrapped in an
     * {@linkplain Collections#unmodifiableMap unmodifiable map} to protect the
     * immutability of the annotation definition.
     * You MUST call setFieldTypes afterward, even if with an empty map.  (Yuck.)
     */
    public void setFieldTypes(Map<String, ? extends AnnotationFieldType> fieldTypes) {
        this.fieldTypes = Collections.unmodifiableMap(
                new LinkedHashMap<String, AnnotationFieldType>(fieldTypes)
                );
    }


    /**
     * The retention policy for annotations of this type.
     * If non-null, this is called a "top-level" annotation definition.
     * It may be null for annotations that are used only as a field of other
     * annotations.
     */
    public /*@Nullable*/ RetentionPolicy retention() {
        if (tlAnnotationsHere.contains(Annotations.aRetentionClass)) {
            return RetentionPolicy.CLASS;
        } else if (tlAnnotationsHere.contains(Annotations.aRetentionRuntime)) {
            return RetentionPolicy.RUNTIME;
        } else if (tlAnnotationsHere.contains(Annotations.aRetentionSource)) {
            return RetentionPolicy.SOURCE;
        } else {
            return null;
        }
    }

    /**
     * True if this is a type annotation (was meta-annotated
     * with @Target(ElementType.TYPE_USE) or @TypeQualifier).
     */
    public boolean isTypeAnnotation() {
        return (tlAnnotationsHere.contains(Annotations.aTargetTypeUse)
                || tlAnnotationsHere.contains(Annotations.aTypeQualifier));
    }


    /**
     * This {@link AnnotationDef} equals <code>o</code> if and only if
     * <code>o</code> is another nonnull {@link AnnotationDef} and
     * <code>this</code> and <code>o</code> define annotation types of the same
     * name with the same field names and types.
     */
    @Override
    public boolean equals(Object o) {
        return o instanceof AnnotationDef
            && ((AnnotationDef) o).equals(this);
    }

    /**
     * Returns whether this {@link AnnotationDef} equals <code>o</code>; a
     * slightly faster variant of {@link #equals(Object)} for when the argument
     * is statically known to be another nonnull {@link AnnotationDef}.
     */
    public boolean equals(AnnotationDef o) {
        boolean sameName = name.equals(o.name);
        boolean sameMetaAnnotations = equalsElement(o);
        boolean sameFieldTypes = fieldTypes.equals(o.fieldTypes);
        // Can be useful for debugging
        if (false && sameName && (! (sameMetaAnnotations
                            && sameFieldTypes))) {
            String message = String.format("Warning: incompatible definitions of annotation %s%n  %s%n  %s%n",
                                           name, this, o);
            new Exception(message).printStackTrace(System.out);
        }
        return sameName
            && sameMetaAnnotations
            && sameFieldTypes;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int hashCode() {
        return name.hashCode()
            // Omit tlAnnotationsHere, becase it should be unique and, more
            // importantly, including it causes an infinite loop.
            // + tlAnnotationsHere.hashCode()
            + fieldTypes.hashCode();
    }

    /**
     * Returns an <code>AnnotationDef</code> containing all the information
     * from both arguments, or <code>null</code> if the two arguments
     * contradict each other.  Currently this just
     * {@linkplain AnnotationFieldType#unify unifies the field types}
     * to handle arrays of unknown element type, which can arise via
     * {@link AnnotationBuilder#addEmptyArrayField}.
     */
    public static AnnotationDef unify(AnnotationDef def1,
            AnnotationDef def2) {
        // if (def1.name.equals(def2.name)
        //     && def1.fieldTypes.keySet().equals(def2.fieldTypes.keySet())
        //     && ! def1.equalsElement(def2)) {
        //     throw new Error(String.format("Unifiable except for meta-annotations:%n  %s%n  %s%n",
        //                                   def1, def2));
        // }
        if (def1.equals(def2)) {
            return def1;
        } else if (def1.name.equals(def2.name)
                 && def1.equalsElement(def2)
                 && def1.fieldTypes.keySet().equals(def2.fieldTypes.keySet())) {
            Map<String, AnnotationFieldType> newFieldTypes
                = new LinkedHashMap<String, AnnotationFieldType>();
            for (String fieldName : def1.fieldTypes.keySet()) {
                AnnotationFieldType aft1 = def1.fieldTypes.get(fieldName);
                AnnotationFieldType aft2 = def2.fieldTypes.get(fieldName);
                AnnotationFieldType uaft = AnnotationFieldType.unify(aft1, aft2);
                if (uaft == null) {
                    return null;
                } else {
                    newFieldTypes.put(fieldName, uaft);
                }
            }
            return new AnnotationDef(def1.name, def1.tlAnnotationsHere, newFieldTypes);
        } else {
            return null;
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        // Not: sb.append(((AElement) this).toString());
        // because it causes an infinite loop.
        boolean first;
        first = true;
        for (Annotation a : tlAnnotationsHere) {
            if (!first) {
                sb.append(" ");
            } else {
                first=false;
            }
            sb.append(a);
        }
        sb.append("] ");
        sb.append("@");
        sb.append(name);
        sb.append("(");
        first = true;
        for (Map.Entry<String, AnnotationFieldType> entry : fieldTypes.entrySet()) {
            if (!first) {
                sb.append(",");
            } else {
                first = false;
            }
            sb.append(entry.getValue().toString());
            sb.append(" ");
            sb.append(entry.getKey());
        }
        sb.append(")");
        return sb.toString();
    }

    public static void printClasspath() {
        System.out.println();
        System.out.println("Classpath:");
        StringTokenizer tokenizer =
            new StringTokenizer(System.getProperty("java.class.path"), File.pathSeparator);
        while (tokenizer.hasMoreTokens()) {
            String cpelt = tokenizer.nextToken();
            boolean exists = new File(cpelt).exists();
            if (! exists) {
                System.out.print(" non-existent:");
            }
            System.out.println("  " + cpelt);
        }
    }

}