private final String propertyName;
    private final Iterable<File> files;
    private final Type type;

    DefaultOutputFileProperty(String propertyName, Iterable<File> files, Type type) {
        this.propertyName = propertyName;
        this.files = files;
        this.type = type;
    }

    @Override
    public String getPropertyName() {
        return propertyName;
    }

    @Override

    override fun property(receiver: DynamicObject, propertyName: String): Any? =
        withDynamicCall(receiver) {
            receiver.getProperty(propertyName)
        }

    override fun findProperty(receiver: DynamicObject, propertyName: String): Any? =
        withDynamicCall(receiver) {
            val dynamicInvokeResult: DynamicInvokeResult = receiver.tryGetProperty(propertyName)

        private final String propertyName;

        public OutputFileSnapshottingException(String propertyName, Throwable cause) {
            this(String.format("Cannot snapshot output property '%s'.", propertyName), cause, propertyName);
        }

        private OutputFileSnapshottingException(String formattedMessage, Throwable cause, String propertyName) {
            super(formattedMessage, cause);

    public PropertyDescImpl(final String propertyName, final Class<?> propertyType, final Method readMethod, final Method writeMethod,
            final Field field, final BeanDesc beanDesc) {
        assertArgumentNotEmpty("propertyName", propertyName);
        assertArgumentNotNull("propertyType", propertyType);
        assertArgumentNotNull("beanDesc", beanDesc);

        this.propertyName = propertyName;
        this.propertyType = propertyType;

        outputs.fileProperties*.propertyName == ['prop$1', 'prop$2']
        outputs.fileProperties*.propertyFiles*.files.flatten() == [file("a"), file("b")]
    }

    def "can register named output files"() {
        when:
        outputs.files("fileA": "a", "fileB": "b")
        then:
        outputs.files.files == files('a', "b")
        outputs.fileProperties*.propertyName == ['$1.fileA', '$1.fileB']

        return new NamedMemberScope(CallType.GET_PROPERTY, propertyName);
    }

    /**
     * The returned scope includes writes of all properties named {@code propertyName}.
     * This scope doesn't include calls to the setter method corresponding to this property,
     * use additional explicit {@link #methodsNamed(String)} scope to intercept that.
     *

    public UnmanagedPropertyMissingSetterException(String propertyName) {
        super(getMessage(propertyName));
    }

    private static String getMessage(String propertyName) {
        return String.format(
            "unmanaged property '%s' cannot be read only, unmanaged properties must have setters",
            propertyName);
    }

    private final String propertyName;
    private final PropertyValue value;
    private final boolean optional;
    private final ValidationAction validationAction;

    public AbstractValidatingProperty(String propertyName, PropertyValue value, boolean optional, ValidationAction validationAction) {
        this.propertyName = propertyName;
        this.value = value;
        this.optional = optional;

        });

        beforeExecutionState.getInputProperties().forEach((propertyName, valueSnapshot) -> {
            if (logger.isWarnEnabled()) {
                logger.warn("Appending input value fingerprint for '{}' to build cache key: {}",
                    propertyName, Hashing.hashHashable(valueSnapshot));
            }
            cacheKeyHasher.putString(propertyName);
            valueSnapshot.appendToHasher(cacheKeyHasher);
        });

public class OverlappingOutputs {
    private final String propertyName;
    private final String overlappedFilePath;

    public OverlappingOutputs(String propertyName, String overlappedFilePath) {
        this.propertyName = propertyName;
        this.overlappedFilePath = overlappedFilePath;
    }

    public String getPropertyName() {
        return propertyName;
    }

    public String getOverlappedFilePath() {