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>

  }

  private fun createSocketWithEnabledProtocols(vararg tlsVersions: TlsVersion): SSLSocket {
    return (handshakeCertificates.sslSocketFactory().createSocket() as SSLSocket).apply {
      enabledProtocols = javaNames(*tlsVersions)
    }
  }

  private fun assertEnabledProtocols(
    socket: SSLSocket,
    vararg required: TlsVersion,
  ) {

    block(assertInstanceOf<T>(o))
}


inline fun <reified T> assertInstanceOf(o: Any): T {
    assertThat(o, instanceOf(T::class.java))
    return o as T
}


inline fun withClassLoaderFor(vararg classPath: File, action: ClassLoader.() -> Unit) =
    classLoaderFor(*classPath).use(action)


inline fun withClassLoaderFor(classPath: ClassPath, action: ClassLoader.() -> Unit) =
    classLoaderFor(classPath).use(action)

        )
    }

    private
    inline fun <reified T> assertAccessorTypePrecedenceOf(vararg types: KClass<*>) {
        assertTypeSequence(
            T::class.java.accessorTypePrecedenceSequence(),
            *types
        )
    }

    private
    fun assertTypeSequence(sequence: Sequence<Class<*>>, vararg types: KClass<*>) {
        assertThat(
            sequence.mapTo(mutableListOf()) { it.simpleName },

                }
            }

        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() {

            // Groovy named arguments to vararg of Pair
            fileTree("dir" to "src", "excludes" to listOf("**/ignore/**", "**/.data/**"))

            // Class<T> + Action<T> to KClass<T> + T.() -> Unit
            tasks.register("foo", Copy::class) {
                from("src")
                into("dst")

                // Class<T> + Groovy named arguments to KClass<T> + vararg of Pair

annotation class Annotation(vararg val values: Int)

@Annotation(<expr>-1</expr>)

// FILE: A.java
public @interface A {
    String[] value() default {"foo", "bar"};
}

// FILE: Test.kt
annotation class B(vararg val a: A)

@B(A(), A(*[]))

annotation class A(vararg val strings: String)

@A(strings = ["foo", "bar"])