result.beginControlFlow("if (invocation.getArgsCount() > $L)", paramIndex);
                result.addStatement("Object arg$1L = invocation.getArgument($1L)", paramIndex);
            }
            // Visit non-vararg invocations first and varargs after:
            children.forEach((entry, child) -> {
                if (entry.kind != VARARG) {

    }

    @After
    fun stopDaemons() {
        build("--stop")
    }

    protected
    fun buildForCacheInspection(vararg arguments: String): ExecutionResult =
        executerForCacheInspection(*arguments).run()

    protected
    fun buildWithDaemonHeapSize(heapMb: Int, vararg arguments: String): ExecutionResult =
        executerForCacheInspection(*arguments)
            .withBuildJvmOpts("-Xms${heapMb}m", "-Xmx${heapMb}m")

    private val dynamicCallProblemReporting: DynamicCallProblemReporting
) : DynamicObject {
    override fun hasMethod(name: String, vararg arguments: Any?): Boolean {
        onAccess(MemberKind.METHOD, name)
        return delegate.hasMethod(name, *arguments)
    }

    override fun tryInvokeMethod(name: String, vararg arguments: Any?): DynamicInvokeResult {
        onAccess(MemberKind.METHOD, name)

        fun assertHasInformation(vararg information: String) {
            assertThat("Has information", richReport.information.map { it.message }, CoreMatchers.equalTo(information.toList()))
        }

        fun assertHasAccepted(vararg accepted: String) {
            assertThat("Has accepted", richReport.accepted.map { it.message }, CoreMatchers.equalTo(accepted.toList()))
        }

        File(projectRoot, relativePath).canonicalFile

    fun build(vararg arguments: String): ExecutionResult =
        gradleExecuterFor(arguments).run()

    protected
    fun buildFailureOutput(vararg arguments: String): String =
        buildAndFail(*arguments).error

    protected
    fun buildAndFail(vararg arguments: String): ExecutionFailure =
        gradleExecuterFor(arguments).runWithFailure()

internal
class ClassLoadingCache(private val result: ExecutionResult) : KotlinDslCacheFixture {

    override fun misses(vararg cachedScripts: CachedScript) =
        cachedScripts.forEach { assertClassLoads(it, 1) }

    override fun hits(vararg cachedScripts: CachedScript) =
        cachedScripts.forEach { assertClassLoads(it, 0) }

    private

          bars: CALL 'public final fun listOf <T> (vararg elements: T of kotlin.collections.listOf): kotlin.collections.List<T of kotlin.collections.listOf> declared in kotlin.collections' type=kotlin.collections.List<@[MyComposable] some.MyComposableFunction0<kotlin.Unit>> origin=null
            <T>: @[MyComposable] some.MyComposableFunction0<kotlin.Unit>

                }
            }

        public fun onlyWith(vararg modifiers: KtKeywordToken): KaRendererKeywordFilter =
            KaRendererKeywordFilter { modifier, _ -> modifier in modifiers }

        public fun onlyWith(modifiers: TokenSet): KaRendererKeywordFilter =
            KaRendererKeywordFilter { modifier, _ -> modifier in modifiers }

        public fun without(vararg modifiers: KtKeywordToken): KaRendererKeywordFilter =

import org.gradle.kotlin.dsl.execution.templateIdFor
import org.gradle.kotlin.dsl.support.uppercaseFirstChar
import java.io.File


internal
interface KotlinDslCacheFixture {
    fun misses(vararg cachedScripts: CachedScript)
    fun hits(vararg cachedScripts: CachedScript)
}


sealed class CachedScript {

    class WholeFile(
        val stage1: CompilationStage,
        val stage2: CompilationStage
    ) : CachedScript() {

    }

    private
    inline fun <reified K : Any> setPropertyOf(vararg values: K) =
        objectFactory().setProperty(K::class.java).apply {
            if (values.isNotEmpty()) {
                addAll(*values)
            }
        }

    private
    inline fun <reified K : Any, reified V : Any> mapPropertyOf(vararg values: Pair<K, V>) =
        objectFactory().mapProperty(K::class.java, V::class.java).apply {