work.visitOutputs(context.getWorkspace(), new UnitOfWork.OutputVisitor() {
            @Override
            public void visitOutputProperty(String propertyName, TreeType type, UnitOfWork.OutputFileValueSupplier value) {
                ensureOutput(propertyName, value.getValue(), type);
            }

            @Override
            public void visitLocalState(File localStateRoot) {

    }

    def "querying flag status notifies listener"() {
        def flag = Stub(FeatureFlag)
        flag.systemPropertyName >> propertyName

        when:
        flags.isEnabled(flag)

        then:
        1 * featureFlagListener.flagRead(flag)

        where:
        propertyName << ["prop", null]
    }

        return outer
    }
}


class Outer {
    @get:Restricted
    val inner: Inner = Inner()

    @Configuring(propertyName = "inner")
    fun configureInner(fn: Functional) {
        fn.configure(inner)
    }

    @Configuring(propertyName = "inner")
    fun configureInnerWithGeneric(fn: GenericFunctional<Inner>) {
        fn.configure(inner)
    }
}


interface Functional {

        getArchivesName().set(archivesBaseName);
    }

    private static void logPropertyDeprecation(String propertyName, String replacementPropertyName) {
        DeprecationLogger.deprecateProperty(BasePluginExtension.class, propertyName)
            .replaceWith(replacementPropertyName)
            .willBeRemovedInGradle9()

        return true;
    }

    @Override
    public void visitPropertyValue(String propertyName, PropertyValue value, PropertyMetadata propertyMetadata, PropertyVisitor visitor) {
        propertyMetadata.getAnnotation(SoftwareType.class).ifPresent(softwareType ->
            visitor.visitSoftwareTypeProperty(propertyName, value, softwareType)
        );
    }

    @Override

    }

    @Override
    public boolean isPropertyRelevant() {
        return true;
    }

    @Override
    public void visitPropertyValue(String propertyName, PropertyValue value, PropertyMetadata propertyMetadata, PropertyVisitor visitor) {
        propertyMetadata.getAnnotation(ServiceReference.class).ifPresent(annotation -> {
            String serviceName = annotation.value();

    @Override
    public InputFilePropertyType getFilePropertyType() {
        return filePropertyType;
    }

    @Override
    public TaskInputFilePropertyBuilderInternal withPropertyName(String propertyName) {
        setPropertyName(propertyName);
        return this;
    }

    @Override
    public boolean isSkipWhenEmpty() {
        return skipWhenEmpty;
    }

    @Override

        property(name) { jsonString(value) }
    }

    private
    inline fun property(name: String, value: () -> Unit) {
        propertyName(name)
        value()
    }

    private
    fun propertyName(name: String) {
        simpleString(name)
        write(':')
    }

    private
    fun simpleString(name: String) {
        write('"')
        write(name)

            "output", staleFileAddedBetweenExecutions
        )

        when:
        def overlaps = detector.detect(previousOutputFiles, outputFilesBeforeExecution)

        then:
        overlaps.propertyName == "output"
        overlaps.overlappedFilePath == "/absolute/path"
    }

    def "detects overlap when there is a stale #type in an output directory"() {

        for (Method method : methods) {
            if (isGetter(method)) {
                String propertyName = getPropertyName(method.getName());
                try {
                    Object propertyValue = method.invoke(parameter);
                    properties.put(propertyName, propertyValue);
                } catch (IllegalAccessException | InvocationTargetException e) {