private final InputFilePropertyType filePropertyType;

    public AbstractInputFilePropertyAnnotationHandler(Class<? extends Annotation> annotationType, InputFilePropertyType filePropertyType, ImmutableSet<Class<? extends Annotation>> allowedModifiers) {
        super(annotationType, allowedModifiers);
        this.filePropertyType = filePropertyType;
    }

    @Override
    public boolean isPropertyRelevant() {

        }
        assert result != null;
        return result;
    }

    private static boolean hasAnnotation(Iterable<Annotation> annotations, Class<? extends Annotation> annotationType) {
        for (Annotation annotation : annotations) {
            if (annotationType.isInstance(annotation)) {
                return true;
            }
        }
        return false;
    }

    }

    @Override
    public List<String> getAnnotationTypeNames() {
        return annotationNames;
    }

    public void addAnnotationTypeName(String annotationType) {
        annotationNames.add(annotationType);
    }

    @Override
    public boolean isDeprecated() {
        return annotationNames.contains(Deprecated.class.getName());
    }

    @Override

        });

        return Collections.singletonList(originalRequest);
    }

    public static Predicate<CallInterceptionRequest> ifHasAnnotation(Class<? extends Annotation> annotationType) {
        return request -> {
            Optional<ExecutableElement> maybeOriginatingElement = request.getRequestExtras()
                .getByType(OriginatingElement.class)

    }

    def "can use custom annotation handler"() {
        def annotationHandler = Stub(PropertyAnnotationHandler)
        _ * annotationHandler.propertyRelevant >> true
        _ * annotationHandler.annotationType >> SearchPath

        def metadataStore = new DefaultTypeMetadataStore([], [annotationHandler], [], typeAnnotationMetadataStore, TestPropertyTypeResolver.INSTANCE, cacheFactory, MissingPropertyAnnotationHandler.DO_NOTHING)

    @Override
    public int value() {
        return timeout;
    }

    @Override
    public TimeUnit unit() {
        return unit;
    }

    @Override
    public Class<? extends Annotation> annotationType() {
        return getClass();
    }

        required
    }

    static <A> Collection<A> getAllAnnotations(testAnnotations, Class<A> annotationType) {
        (Collection<A>) testAnnotations.findAll { annotationType.isAssignableFrom(it.getClass()) }
    }

    def isInvalidCombination(Map<String, String> values) {
        false
    }

    @Override

            error(unsupportedValueTypeConfig { type('MyTask').property('nestedBean.nestedInput').annotationType(annotation).unsupportedValueType(...

    @Nullable
    @Override
    Class<? extends Annotation> resolveAnnotationType(Map<AnnotationCategory, Annotation> propertyAnnotations) {
        propertyAnnotations.get(AnnotationCategory.TYPE)?.annotationType()
    }

    override fun topLevelFunction(function: KFunction<*>, preIndex: DataSchemaBuilder.PreIndex) = null
}


private
class CachedHierarchyAnnotationChecker(private val annotationType: KClass<out Annotation>) {
    fun isAnnotatedMaybeInSupertypes(kClass: KClass<*>): Boolean {
        // Can't use computeIfAbsent because of recursive calls