Java

// Test.java
package NAMESPACE;

public @interface Test {}

// TestProcessor.java
package NAMESPACE;

import java.util.Set;

import javax.annotation.processing.*;
import javax.lang.model.element.TypeElement;

@SupportedAnnotationTypes({"NAMESPACE.Test"})
public class TestProcessor extends AbstractProcessor {
    @Override
    public boolean process(
            Set<? extends TypeElement> annotations,
            RoundEnvironment roundEnv) {
        return true;
    }
}

// RequiredStaticField.java
import java.lang.annotation.*;
 
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
@Inherited
public @interface RequiredStaticField {
    public String name();
    public Class<?> type();
}

// MyClass.java
@RequiredStaticField(name="StaticField", type=Number.class)
public class MyClass {
    private static Integer StaticField;
}

// RequiredStaticFieldProcessor.java
import java.util.Set;
 
import javax.annotation.processing.*;
import javax.lang.model.element.*;
import javax.lang.model.util.Types;
 
@SupportedAnnotationTypes("NAMESPACE.RequiredStaticField");
public class RequiredStaticFieldProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment environment) {
        // Get all classes that have the annotation
        Set<? extends Element> elementsWithAnnotation =
            environment.getElementsAnnotatedWith(RequiredStaticField.class);
        for (Element elementWithAnnotation : elementsWithAnnotation) {
            // If the element kind is not ElementKind.CLASS, display warning and continue
            // If the class is abstract, continue
            boolean isFound = false;
            RequiredStaticMethod annotation = elementWithAnnotation
                .getAnnotation(RequiredStaticMethod.class);
            for (Element member : elementWithAnnotation.getEnclosedElements()) {
                // If not a field, continue
                // If the field has the wrong name, continue

                // THIS IS WHERE I NEED HELP!  The following does not compile.
                // In the following, I either need to get the Class<?>
                // of member.asType(), or I need to iterate through the superclasses
                // of member.asType(), or I need to convert annotation.type()
                // to a TypeMirror object. Any Ideas?
                isFound = Types.isSubType(member.asType(), annotation.type());
 
                if (isFound) {
                    break;
                } else {
                    // Display error about declaring with invalid type
                }
            }
            if (!isFound) {
                // Display error about missing field
            }
        }
        return true;
    }
}