private final TreeType outputType;

    public DefaultCacheableOutputFilePropertySpec(
        String propertyName,
        @Nullable String propertySuffix,
        FileCollectionInternal outputFiles,
        TreeType outputType
    ) {
        super(propertyName, OutputNormalizer.INSTANCE, outputFiles);
        this.propertySuffix = propertySuffix;
        this.outputType = outputType;
    }

@Contextual
public class PropertyEvaluationException extends GradleException {

    public PropertyEvaluationException(Object work, String propertyName, Throwable cause) {
        super(String.format("Error while evaluating property '%s' of %s.", propertyName, work), cause);
    }

public class DefaultInputPropertySpec extends AbstractPropertySpec implements InputPropertySpec {
    private final PropertyValue value;

    public DefaultInputPropertySpec(String propertyName, PropertyValue value) {
        super(propertyName);
        this.value = value;
    }

    @Override
    public PropertyValue getValue() {
        return value;
    }

    @Override
    public String toString() {

        work.visitOutputs(context.getWorkspace(), new UnitOfWork.OutputVisitor() {
            @Override
            public void visitOutputProperty(String propertyName, TreeType type, UnitOfWork.OutputFileValueSupplier value) {
                builder.put(propertyName, FileSystemSnapshot.EMPTY);
            }
        });
        return builder.build();
    }

    @Nullable
    @Override

    public DefaultInputFilePropertySpec(
        String propertyName,
        FileNormalizer normalizer,
        FileCollectionInternal files,
        PropertyValue value,
        InputBehavior behavior,
        DirectorySensitivity directorySensitivity,
        LineEndingSensitivity lineEndingSensitivity
    ) {
        super(propertyName, normalizer, files);
        this.behavior = behavior;

) : InstrumentedExecutionAccess.Listener {

    override fun disallowedAtExecutionInjectedServiceAccessed(injectedServiceType: Class<*>, propertyName: String, consumer: String) {
        executionAccessChecker.disallowedAtExecutionInjectedServiceAccessed(injectedServiceType, propertyName, consumer)
    }

    private final ImmutableSortedSet.Builder<InputPropertySpec> inputProperties = ImmutableSortedSet.naturalOrder();

    @Override
    public void visitInputProperty(String propertyName, PropertyValue value, boolean optional) {
        inputProperties.add(new DefaultInputPropertySpec(propertyName, value));
    }

    public ImmutableSortedSet<InputPropertySpec> getProperties() {
        return inputProperties.build();
    }

public interface ValidationAction {
    /**
     * Validates the given property value according to some rule.
     *
     * @param propertyName
     * @param value a supplier of a non-null value - side effects are guaranteed to happen only once
     * @param context
     */
    void validate(String propertyName, @Nonnull Supplier<Object> value, PropertyValidationContext context);

            .typeName("foo")
            .propertyName("bar")
            .build()

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

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

        expect:

    private final FileNormalizer normalizer;
    private final FileCollectionInternal files;

    public AbstractFilePropertySpec(String propertyName, FileNormalizer normalizer, FileCollectionInternal files) {
        super(propertyName);
        this.normalizer = normalizer;
        this.files = files;
    }

    @Override
    public FileNormalizer getNormalizer() {
        return normalizer;
    }