public void visitValidationFailures(TypeValidationContext validationContext) {
        validationProblems.replay(null, validationContext);
    }

    @Override
    public <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType) {
        return Optional.ofNullable(Cast.uncheckedCast(annotations.get(annotationType)));
    }

                // Won't validate interfaces
                return;
            }
            if (!cacheable
                && topLevelBean.getAnnotation(DisableCachingByDefault.class) == null
                && topLevelBean.getAnnotation(UntrackedTask.class) == null
            ) {
                boolean isTask = Task.class.isAssignableFrom(topLevelBean);

     */
    @SuppressWarnings("deprecation")
    static Runner getRunnerLegacy(Class<?> testClass) throws Throwable {
        RunWith annotation = testClass.getAnnotation(RunWith.class);
        if (annotation != null) {
            Class<? extends Runner> runnerClass = annotation.value();
            try {
                return runnerClass.getConstructor(Class.class).newInstance(testClass);

        }
    }

    @Nullable
    private Throwable findNearestContextual(@Nullable Throwable t) {
        if (t == null) {
            return null;
        }
        if (t.getClass().getAnnotation(Contextual.class) != null || t instanceof MultiCauseException) {
            return t;
        }
        return findNearestContextual(t.getCause());
    }

    public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
        return annotationsByType.containsKey(annotationType);
    }

    @Override
    public <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType) {
        return Optional.ofNullable(Cast.uncheckedCast(annotationsByType.get(annotationType)));
    }

    @Override
    public ImmutableMap<AnnotationCategory, Annotation> getAnnotations() {

            }
        }));
    }

    public static boolean isTransformedBlock(Closure<?> closure) {
        Class<?> closureClass = closure.getClass();
        RulesBlock annotation = closureClass.getAnnotation(RulesBlock.class);
        return annotation != null;
    }

        Class<?>[] getParameterTypes();

        Type[] getGenericParameterTypes();

        @Nullable
        <S extends Annotation> S getAnnotation(Class<S> annotation);

        int getModifiers();
    }

    private ModelPath determineModelName(MethodRuleDefinition<?, ?> ruleDefinition, RuleSourceValidationProblemCollector problems) {
        String annotationValue = ruleDefinition.getAnnotation(Model.class).value();
        String modelName = (annotationValue == null || annotationValue.isEmpty()) ? ruleDefinition.getMethodName() : annotationValue;

        try {
            ModelPath.validatePath(modelName);

    }

    private void validateAnnotations(Set<? extends TypeElement> annotations) {
        for (TypeElement annotation : annotations) {
            Retention retention = annotation.getAnnotation(Retention.class);
            if (retention != null && retention.value() == RetentionPolicy.SOURCE) {

            return annotationMetadata.isAnnotationPresent(annotationType);
        }

        @Override
        public <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType) {
            return annotationMetadata.getAnnotation(annotationType);
        }

        @Override
        public Optional<Annotation> getAnnotationForCategory(AnnotationCategory category) {