// WITH_STDLIB

annotation class A(vararg val xs: ULong)

@A(1234u, 18446744073709551615u)

    }

    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 {

    /**
     * Return a sequence of [KaCallableSignature] which current scope contain if declaration, if declaration name present in [names]
     *
     * @see getCallableSignatures
     */
    public fun getCallableSignatures(vararg names: Name): Sequence<KaCallableSignature<*>> = withValidityAssertion {
        getCallableSignatures(names.toList())
    }

    /**

annotation class Annotation(vararg val values: Int)

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

  try {
    for (url in urls) {
      sendRequest(client, url)
    }
  } finally {
    client.dispatcher.executorService.shutdownNow()
    client.connectionPool.evictAll()
  }
}

private fun buildClient(vararg specs: ConnectionSpec): OkHttpClient {
  return OkHttpClient.Builder()
    .connectionSpecs(listOf(*specs))
    .build()
}

private fun sendRequest(
  client: OkHttpClient,
  url: String,
) {

annotation class A(vararg val strings: String)

@A(*arrayOf("foo", "bar"), "baz", *["quux"])

annotation class A(val a: Int, vararg val cs: KClass<*>)

@A(a = 1, Int::class, String::class)

// FILE: Anno.kt
package p3

@Target(AnnotationTarget.FUNCTION)
annotation class Anno(vararg val x: String)

// FILE: main.kt
import p3.Anno

@Anno("A", "B")
fun foo(): Int = 10

fun test() {
    val x = foo()

import kotlin.reflect.KClass


fun classEntriesFor(classes: Array<out KClass<*>>): Sequence<Pair<String, ByteArray>> =
    classes.asSequence().map { classEntryFor(it) }


fun classEntriesFor(vararg classes: Class<*>): Sequence<Pair<String, ByteArray>> =
    classes.asSequence().map { classEntryFor(it) }


fun classEntryFor(clazz: KClass<*>): Pair<String, ByteArray> =
    classEntryFor(clazz.java)

    protected
    fun configureProject(vararg tasks: String): BuildOperationsAssertions {
        val buildOperations = BuildOperationsFixture(executer, testDirectoryProvider)
        val output = executer.withTasks(*tasks).run().normalizedOutput
        return BuildOperationsAssertions(buildOperations, output)
    }

    protected
    fun configureProjectAndExpectCompileAvoidanceWarnings(vararg tasks: String): BuildOperationsAssertions {