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

abstract public class ProblemRecordingTypeValidationContext implements TypeValidationContext {
    private final Class<?> rootType;
    private final Supplier<Optional<PluginId>> pluginId;

    public ProblemRecordingTypeValidationContext(
        @Nullable Class<?> rootType,
        Supplier<Optional<PluginId>> pluginId
    ) {

            parameters,
            object : ProblemRecordingTypeValidationContext(type, { Optional.empty() }) {
                override fun recordProblem(problem: Problem) {
                    problems.add(problem)
                }
            },
            object : PropertyVisitor {

    }

    @Override
    public Optional<FileCollectionExecutionTimeValue> calculateExecutionTimeValue() {
        FileCollectionExecutionTimeValue executionTimeValue = displayName.equals(DEFAULT_COLLECTION_DISPLAY_NAME)
            ? EmptyExecutionTimeValue.INSTANCE
            : new EmptyExecutionTimeValue(displayName);

        return Optional.of(executionTimeValue);
    }

     * and deserialized at execution time, utilizing the logic encapsulated within the value.
     */
    default Optional<FileCollectionExecutionTimeValue> calculateExecutionTimeValue() {
        return Optional.empty();
    }

    /**
     * Some representation of a source of files.
     */
    interface Source {
    }

    /**
     * An opaque source of files.

    @Override
    public Problem build() {
        Problem problem = super.build();
        Optional<TypeValidationData> additionalData = Optional.ofNullable((TypeValidationData) problem.getAdditionalData());
        String prefix = introductionFor(additionalData, isTypeIrrelevantInErrorMessage(problem.getDefinition().getId()));
        String text = Optional.ofNullable(problem.getContextualLabel()).orElseGet(() -> problem.getDefinition().getId().getDisplayName());

            ConfigureBlockRequirement.NotAllowed::class,
            ConfigureBlockRequirement.Optional::class,
            ConfigureBlockRequirement.Required::class
        ])
        sealed interface ConfigureBlockRequirement : Serializable {
            interface NotAllowed : ConfigureBlockRequirement
            interface Optional : ConfigureBlockRequirement
            interface Required : ConfigureBlockRequirement

import org.gradle.api.specs.Spec;
import org.gradle.util.internal.CollectionUtils;

import java.io.File;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Optional;
import java.util.Set;
import java.util.function.Supplier;

public class FilteredFileCollection extends AbstractFileCollection {
    private final FileCollectionInternal collection;

        DefaultTypeAwareProblemBuilder.introductionFor(Optional.of(data), true) == "Property 'bar' "
    }

    def "render introduction with type"() {
        given:
        def data = DefaultTypeValidationData.builder()
            .typeName("foo")
            .propertyName("bar")
            .build()

        expect:
        DefaultTypeAwareProblemBuilder.introductionFor(Optional.of(data), false) == "Type 'foo' property 'bar' "
    }

import org.gradle.api.problems.internal.Problem;
import org.gradle.internal.logging.text.TreeFormatter;

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

import static java.util.Optional.ofNullable;
import static org.apache.commons.lang.StringUtils.capitalize;
import static org.gradle.util.internal.TextUtil.endLineWithDot;

public class TypeValidationProblemRenderer {

 */

package org.gradle.internal.cc.impl

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.internal.ConventionTask
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.Optional
import org.gradle.api.tasks.TaskAction

class ConfigurationCacheConventionMappingIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "doesn't restore convention value to incompatible field type"() {