}

    private fun KaSession.renderProperty(
        property: KProperty<*>,
        printer: PrettyPrinter,
        renderSymbolsFully: Boolean,
        vararg args: Any,
    ) {
        printer.append(property.name).append(": ")
        renderFunctionCall(property.getter, printer, renderSymbolsFully, args)
    }

    private fun KaSession.renderFunctionCall(

    override val annotations by cached {
        KaFirAnnotationListForDeclaration.create(firSymbol, builder)
    }

    /**
     * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.
     * Otherwise, returns `null`
     */
    override val callableId: CallableId? by cached {
        val fir = firSymbol.fir
        if (fir is FirSyntheticPropertyAccessor) {

 */

package org.gradle.internal.cc.impl

class ConfigurationCacheAllowedStartParametersIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "changing of kotlin dsl cid property doesn't invalidates cache entry"() {
        given:
        def kotlinDslCidProp = "org.gradle.kotlin.dsl.provider.cid"
        def configurationCache = newConfigurationCacheFixture()

        when:

        testClassNames.each { testClassName ->
            result.assertOutputContains("${testClassName} > execute helloWorld task STARTED")
        }
    }

    def "can control debug mode through system property"() {
        when:
        buildFile << gradleTestKitDependency() << """
            test {
                systemProperty '$DefaultGradleRunner.DEBUG_SYS_PROP', '$debug'
            }
        """

            val type: Class<Any> = readClass().uncheckedCast()
            val provider = providerCodec.run { decodeProvider() }
            val property = propertyFactory.property(type).provider(provider)
            isolate.identities.putInstance(id, property)
            property
        }
    }
}


class DirectoryPropertyCodec(
    private val filePropertyFactory: FilePropertyFactory,

 * this dependency.
 * <p>
 * This task generates a report for the task's containing project by default. But it can also generate
 * a report for multiple projects, by setting the value of the
 * <code>projects</code> property. Here's how to generate an HTML
 * dependency report for all the projects of a multi-project build, for example:
 * <pre>
 * htmlDependencyReport {
 *     projects = project.allprojects
 * }
 * </pre>
 * <p>

import org.gradle.internal.service.scopes.Scope
import java.io.File


@EventScope(Scope.BuildTree::class)
interface UndeclaredBuildInputListener {
    /**
     * Called when an undeclared system property read happens.
     */
    fun systemPropertyRead(key: String, value: Any?, consumer: String?)

    fun envVariableRead(key: String, value: String?, consumer: String?)

    fun fileOpened(file: File, consumer: String?)

            onAccess("properties")
            return delegate.properties
        }

        override fun property(propertyName: String): Any? {
            onAccess("property")
            return delegate.property(propertyName)
        }

        override fun findProperty(propertyName: String): Any? {
            onAccess("findProperty")

 * and therefore changes need to be carefully managed. Other plugins like the
 * test-retry or the test-distribution plugin clarify their usage in the {@link #value}.
 * property.
 *
 * @since 4.0
 */
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.METHOD, ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR})
public @interface UsedByScanPlugin {

    /**

    }

    private void addExtensionDeclaration(String childBuildName) {
        file("$childBuildName/src/main/groovy/my/MyExtension.groovy") << """
            import ${Property.name}

            interface MyExtension {
                Property<String> getMessage()
            }
        """
    }

    private void addModelImplementation(String targetBuildName) {