context.visitPropertyProblem(problem -> {
            String lowerKind = kind.toLowerCase();
            problem
                .forProperty(propertyName)
                .id(TextUtil.screamingSnakeToKebabCase(INPUT_FILE_DOES_NOT_EXIST), "Input file does not exist", GradleCoreProblemGroup.validation().property())

        if (valueType.isPrimitive() && propertyMetadata.isAnnotationPresent(Optional.class)) {
            validationContext.visitPropertyProblem(problem ->
                problem
                    .forProperty(propertyMetadata.getPropertyName())
                    .id(TextUtil.screamingSnakeToKebabCase(CANNOT_USE_OPTIONAL_ON_PRIMITIVE_TYPES), "Property should be annotated with @Optional", GradleCoreProblemGroup.validation().property())

import java.util.Arrays;
import java.util.List;

import static org.gradle.model.internal.core.ModelViews.getInstance;
import static org.gradle.model.internal.core.NodeInitializerContext.forProperty;

public class StructNodeInitializer<T> implements NodeInitializer {

    protected final StructBindings<T> bindings;

    public StructNodeInitializer(StructBindings<T> bindings) {
        this.bindings = bindings;

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

    TypeAwareProblemBuilder forProperty(String propertyName);

    TypeAwareProblemBuilder parentProperty(@Nullable String parentProperty);

        Class<?> beanType
    ) {
        getUnsupportedReason(beanType).ifPresent(reason ->
            validationContext.visitPropertyProblem(problem ->
                problem
                    .forProperty(propertyName)
                    .id("nested-type-unsupported", "Nested type unsupported", GradleCoreProblemGroup.validation().property())

    @Override
    public void validatePropertyMetadata(PropertyMetadata propertyMetadata, TypeValidationContext validationContext) {
        validationContext.visitPropertyProblem(problem ->
            problem
                .forProperty(propertyMetadata.getPropertyName())
                .id("test-problem", "test problem", new DefaultProblemGroup("root", "root"))
                .documentedAt(Documentation.userManual("id", "section"))

            if (annotationHandler == null) {
                validationContext.visitPropertyProblem(problem ->
                    problem
                        .forProperty(propertyAnnotationMetadata.getPropertyName())
                        .id(TextUtil.screamingSnakeToKebabCase(ANNOTATION_INVALID_IN_CONTEXT), "Invalid annotation in context", GradleCoreProblemGroup.validation().property())

        final String missingAnnotation = "MISSING_ANNOTATION";
        problem
            .forProperty(annotationMetadata.getPropertyName())
            .id(TextUtil.screamingSnakeToKebabCase(missingAnnotation), "Missing annotation", GradleCoreProblemGroup.validation().property())

            if (publicType != Void.class && !publicType.isAssignableFrom(valueType)) {
                validationContext.visitPropertyProblem(problem ->
                    problem
                        .forProperty(propertyMetadata.getPropertyName())
                        .id("mismatched-types-for-software-type", "has @SoftwareType annotation used on property", GradleCoreProblemGroup.validation().property())

        }
        return this;
    }

    @Override
    public TypeAwareProblemBuilder forProperty(String propertyName) {
        additionalData(TypeValidationDataSpec.class, data -> data.propertyName(propertyName));
        return this;
    }

    @Override