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

import org.gradle.api.problems.internal.InternalProblemSpec;

import javax.annotation.Nullable;

@NonNullApi
public interface TypeAwareProblemBuilder extends InternalProblemSpec {
    TypeAwareProblemBuilder withAnnotationType(@Nullable Class<?> classWithAnnotationAttached);

    TypeAwareProblemBuilder forProperty(String propertyName);

    TypeAwareProblemBuilder parentProperty(@Nullable String parentProperty);

            .sorted()
            .collect(Collectors.toList());

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

    public DefaultTypeAwareProblemBuilder(InternalProblemBuilder problemBuilder) {
        super(problemBuilder);
    }

    @Override
    public TypeAwareProblemBuilder withAnnotationType(@Nullable Class<?> classWithAnnotationAttached) {
        if (classWithAnnotationAttached != null) {

        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())

    public void visitPropertyProblem(Action<? super TypeAwareProblemBuilder> problemSpec) {
        DefaultTypeAwareProblemBuilder problemBuilder = getDefaultTypeAwareProblemBuilder(problemSpec);
        problemBuilder.withAnnotationType(rootType);
        pluginId()
            .map(PluginId::getId)
            .ifPresent(id -> problemBuilder.additionalData(TypeValidationDataSpec.class, data -> data.pluginId(id)));

                String workType = isTask ? "task" : "transform action";
                validationContext.visitTypeProblem(problem -> {
                        ProblemSpec builder = problem
                            .withAnnotationType(topLevelBean)
                            .id(TextUtil.screamingSnakeToKebabCase(ValidationTypes.NOT_CACHEABLE_WITHOUT_REASON), "Not cacheable without reason", GradleCoreProblemGroup.validation().type())

                    validationContext.visitTypeProblem(problem ->
                        problem
                            .withAnnotationType(type)
                            .id(TextUtil.screamingSnakeToKebabCase(IGNORED_ANNOTATIONS_ON_FIELD), "Incorrect annotations on field", GradleCoreProblemGroup.validation().property()) // TODO (donat) missing test coverage

        _ * typeAnnotationHandler.validateTypeMetadata(_, _) >> { Class type, TypeValidationContext context ->
            context.visitTypeProblem {
                it
                    .withAnnotationType(type)
                    .id("test-problem", "type is broken", GradleCoreProblemGroup.validation())
                    .documentedAt(userManual("id", "section"))
                    .severity(Severity.WARNING)

        def invalidWork = builder
            .withValidator { validationContext ->
                validationContext.forType(Object, true).visitTypeProblem {
                    it
                        .withAnnotationType(Object)
                        .id("test-problem", "Validation error", GradleCoreProblemGroup.validation())
                        .documentedAt(Documentation.userManual("id", "section"))