import org.gradle.internal.reflect.validation.TypeValidationContext;
import org.gradle.plugin.use.PluginId;

import java.util.List;
import java.util.Optional;

public interface WorkValidationContext {
    TypeValidationContext forType(Class<?> type, boolean cacheable);

    InternalProblems getProblemsService();

    List<Problem> getProblems();

    ImmutableSet<Class<?>> getValidatedTypes();

        TypeValidationContext workValidationContext = validationContext.forType(workType, true);
        validateImplementation(workValidationContext, beforeExecutionState.getImplementation(), "Implementation of ", work);
        beforeExecutionState.getAdditionalImplementations()
            .forEach(additionalImplementation -> validateImplementation(workValidationContext, additionalImplementation, "Additional action of ", work));

import org.gradle.internal.execution.WorkValidationContext;

import javax.annotation.Nullable;
import java.util.Optional;

public class ExecutionRequestContext implements Context {
    private final String nonIncrementalReason;
    private final WorkValidationContext validationContext;

    public ExecutionRequestContext(@Nullable String nonIncrementalReason, WorkValidationContext validationContext) {

            hasMessage """A problem was found with the configuration of job ':test' (type 'ValidateStepTest.JobType').
  - ${validationProblem}"""
        }
        _ * work.validate(_ as WorkValidationContext) >> { WorkValidationContext validationContext ->
            validationContext.forType(JobType, true).visitTypeProblem {
                it
                    .withAnnotationType(Object)

import org.gradle.internal.execution.WorkValidationContext;
import org.gradle.internal.operations.BuildOperationContext;

import java.util.Optional;

public class DefaultTaskExecutionContext implements TaskExecutionContext {

    private final LocalTaskNode localTaskNode;
    private final TaskProperties properties;
    private final WorkValidationContext validationContext;

    public Request createRequest(UnitOfWork work) {
        return new Request() {
            private String nonIncrementalReason;
            private WorkValidationContext validationContext;

            private ExecutionRequestContext createExecutionRequestContext() {
                WorkValidationContext validationContext = this.validationContext != null
                    ? this.validationContext

    public boolean hasValidationProblems(LocalTaskNode node) {
        WorkValidationContext validationContext = validateNode(node);
        List<? extends Problem> problems = validationContext.getProblems();
        logWarnings(problems);
        reportErrors(problems, node.getTask(), validationContext);
        return !problems.isEmpty();
    }

    private WorkValidationContext validateNode(LocalTaskNode node) {

        ProjectBuilderImpl.stop(project)
    }

    void execute(Task task) {
        def workValidationContext = new DefaultWorkValidationContext(WorkValidationContext.TypeOriginInspector.NO_OP)
        def taskExecutionContext = new DefaultTaskExecutionContext(
            new LocalTaskNode(task as TaskInternal, workValidationContext, { null }),

    private TaskProperties taskProperties;
    private ProjectInternal taskProject;

    public LocalTaskNode(TaskInternal task, WorkValidationContext workValidationContext, Function<LocalTaskNode, ResolveMutationsNode> resolveNodeFactory) {
        this.task = task;
        this.validationContext = workValidationContext;
        this.resolveMutationsNode = resolveNodeFactory.apply(this);
        this.taskProject = (ProjectInternal) task.getProject();

        return new Builder(problems);
    }

    /**
     * A Stepwise builder for a {@code WorkValidationException}.
     *
     * This class represents step 1, call {@link #withSummaryForContext(String, WorkValidationContext)} or {@link #withSummaryForPlugin()} to return Step 2.
     */
    public final static class Builder {
        private final List<String> problems;

        public Builder(Collection<String> problems) {