}


internal
fun propertyDelegateFor(dynamicLookupRoutine: DynamicLookupRoutine, target: Any, property: KProperty<*>): PropertyDelegate =
    dynamicObjectFor(target).let { owner ->
        if (property.returnType.isMarkedNullable) NullableDynamicPropertyDelegate(dynamicLookupRoutine, owner, property.name)
        else NonNullDynamicPropertyDelegate(dynamicLookupRoutine, owner, property.name) { target.toString() }

            println "buildscript.property = \${propertyProvider.get()}"

            task check {}
        """

        when:
        succeeds("check", "-Dproperty=value")

        then:
        outputContains("backgroundJob.property = value")
        outputContains("buildscript.property = value")
        configurationCache.assertStateStored()

        when:

package org.gradle.kotlin.dsl

import org.gradle.api.provider.Property

import kotlin.reflect.KProperty


/**
 * Property delegate for [Property] instances.
 *
 * Example: `val someProperty by somePropertyState`
 */
operator fun <T> Property<T>.getValue(receiver: Any?, property: KProperty<*>): T = get()


/**
 * Property delegate for [Property] instances.
 *
 * Example: `var someProperty by somePropertyState`

    property: KProperty<*>
) = ExistingDomainObjectDelegate.of(
    delegateProvider.named(property.name, type)
)


/**
 * Provides a [TaskProvider] delegate for the task of the given type named after the property after configuring it with the given action.
 */
operator fun <U : Task> ExistingDomainObjectDelegateProviderWithTypeAndAction<out TaskContainer, U>.provideDelegate(
    receiver: Any?,
    property: KProperty<*>

        then:
        property.type == String.class
    }

    def "picks the best matching typed setter"() {
        when:
        def property = writeableProperty(JavaTestSubject, "myProperty3", Arrays.asList("foo", "bar").class)

        then:
        property.type == Collection.class

        when:

import org.gradle.api.file.FileCollection
import kotlin.reflect.KProperty


/**
 * Property delegate for [ConfigurableFileCollection] instances.
 *
 * Example: `val aFileCollection by project.files()`
 */
operator fun ConfigurableFileCollection.getValue(receiver: Any?, property: KProperty<*>): ConfigurableFileCollection =
    this


/**
 * Property delegate for [ConfigurableFileCollection] instances.
 *

    }

    operator fun provideDelegate(thisRef: Any?, property: KProperty<*>) = ExistingDomainObjectDelegate.of(
        when (configuration) {
            null -> container.create(property.name)
            else -> container.create(property.name, configuration)
        }
    )
}


/**
 * Provides a property delegate that creates elements of the given [type].
 */

// MODULE: context

// FILE: context.kt
import kotlin.reflect.KProperty

class Delegate(private var value: String) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return value
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        this.value = value
    }
}

fun test() {
    var x by Delegate("a")
    <caret_context>x
}


// MODULE: main

        .filter { property ->
            (includeMemberFilter.shouldIncludeMember(property) ||
                kClass.primaryConstructor?.parameters.orEmpty().any { it.name == property.name && it.type == property.returnType })
                && property.visibility == KVisibility.PUBLIC
                && propertyNamePredicate(property.name)
        }.map { property -> kPropertyInformation(property) }

    private

    }

    interface Dsl {
        val property: Property<String>
    }

    @Test
    fun `can serialize Java lambda with Gradle model`() {
        val stored = newInstance<Dsl>().apply {
            property.set("42")
        }
        val loaded = valueCarriedBy(roundtripOf(isolatedActionLambdaWith(stored)))
        assertThat(
            loaded.property.get(),
            equalTo("42")
        )
    }