*/
    Property<T> value(@Nullable T value);

    /**
     * Sets the property to have the same value as the given provider, replacing whatever value the property already had.
     * This property will track the value of the provider and query its value each time the value of the property is queried.
     * When the provider has no value, this property will also have no value. This is the same as {@link #set(Provider)}

  <packaging>pom</packaging>

  <profiles>

    <profile>
      <id>property-name-project-version</id>
      <activation>
        <property>
          <name>${project.version}</name>
        </property>
      </activation>
    </profile>
    <profile>
      <id>property-value-project-version</id>
      <activation>
        <property>
          <name>project.version</name>
          <value>${project.version}</value>

Laura Kassovic <******@****.***> 1712936267 -0700

}


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:

    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<*>

// 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")
        )
    }

    private
    fun kotlinPropertyGetter(property: KProperty<*>) =
        DeclarativeRuntimePropertyGetter { property.call(it) }

    private
    fun kotlinPropertySetter(property: KMutableProperty<*>) =
        DeclarativeRuntimePropertySetter { receiver, value -> property.setter.call(receiver, value) }

    private