private final List<BiConsumer<String, TypeValidationContext>> problems = new ArrayList<>();

    @Override
    public void visitTypeProblem(Action<? super TypeAwareProblemBuilder> problemSpec) {
        problems.add((ownerProperty, validationContext) -> validationContext.visitTypeProblem(problemSpec));
    }

    @Override
    public void visitPropertyProblem(Action<? super TypeAwareProblemBuilder> problemSpec) {

     * Callers are encouraged to provide as much information as they can on
     * the problem following the problem builder instructions.
     *
     * @param problemSpec the problem builder
     */
    void visitTypeProblem(Action<? super TypeAwareProblemBuilder> problemSpec);

    /**
     * Visits a validation problem associated with the given property.
     * Callers are encouraged to provide as much information as they can on

  - ${validationProblem}"""
        }
        _ * work.validate(_ as WorkValidationContext) >> { WorkValidationContext validationContext ->
            validationContext.forType(JobType, true).visitTypeProblem {
                it
                    .withAnnotationType(Object)
                    .id("test-problem", "Validation error", GradleCoreProblemGroup.validation())

        this.reservedFileSystemLocationRegistry = reservedFileSystemLocationRegistry;
        this.delegate = delegate;
    }

    @Override
    public void visitTypeProblem(Action<? super TypeAwareProblemBuilder> problemSpec) {
        delegate.visitTypeProblem(problemSpec);
    }

    @Override
    public void visitPropertyProblem(Action<? super TypeAwareProblemBuilder> problemSpec) {

            .map(annotation -> annotation.get().name())
            .sorted()
            .collect(Collectors.toList());

        if (exposedSoftwareTypes.isEmpty()) {
            typeValidationContext.visitTypeProblem(problem ->
                problem.withAnnotationType(softwareTypePluginImplClass)
                    .id("missing-software-type", "Missing software type annotation", GradleCoreProblemGroup.validation().type())

        void validateTypeMetadata(Class<?> classWithAnnotationAttached, TypeValidationContext visitor) {
            if (classWithAnnotationAttached.getAnnotation(ThisIsAThing)?.invalid()) {
                visitor.visitTypeProblem {
                    it.label("Annotated as invalid thing!")
                }
            }
        }
    }

    private static class SimplePropertyAnnotationHandler extends AbstractPropertyAnnotationHandler {

        Class<?> classWithAnnotationAttached,
        TypeValidationContext visitor,
        Class<? extends Annotation> annotationType,
        Class<?>... appliesOnlyTo
    ) {
        visitor.visitTypeProblem(problem ->
            problem.withAnnotationType(classWithAnnotationAttached)
                .id("invalid-use-of-type-annotation", "Incorrect use of type annotation", GradleCoreProblemGroup.validation().type())

        @Nullable Class<?> rootType,
        Supplier<Optional<PluginId>> pluginId
    ) {
        this.rootType = rootType;
        this.pluginId = pluginId;
    }

    @Override
    public void visitTypeProblem(Action<? super TypeAwareProblemBuilder> problemSpec) {
        recordProblem(getDefaultTypeAwareProblemBuilder(problemSpec).build());
    }

    private Optional<PluginId> pluginId() {
        return pluginId.get();

                String untrackedTaskAnnotation = "@" + UntrackedTask.class.getSimpleName();
                String workType = isTask ? "task" : "transform action";
                validationContext.visitTypeProblem(problem -> {
                        ProblemSpec builder = problem
                            .withAnnotationType(topLevelBean)

                    String fieldName = entry.getKey();
                    ImmutableMap<Class<? extends Annotation>, Annotation> fieldAnnotations = entry.getValue();
                    validationContext.visitTypeProblem(problem ->
                        problem
                            .withAnnotationType(type)