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)

     */
    operator fun String.invoke(vararg arguments: Any?): Any?

    /**
     * Invokes with Groovy semantics and no arguments.
     */
    operator fun String.invoke(): Any? =
        invoke(*emptyArray<Any>())

    /**
     * Invokes with Groovy semantics, [arguments] and provides a nested [GroovyBuilderScope].
     */

            psiElement.valueParameters.joinTo(this) { render(it) }
            append(")")
        }
        is KtParameter -> buildString {
            if (psiElement.isVarArg) {
                append("vararg ")
            }
            append(psiElement.name)
        }
        is KtElement -> psiElement.text
        is PsiField -> buildString {
            append("PsiField:")

        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

  private val responseCookies: Deque<List<Cookie>> = ArrayDeque()

  fun enqueueRequestCookies(vararg cookies: Cookie) {
    requestCookies.add(cookies.toList())
  }

  fun takeResponseCookies(): List<Cookie> {
    return responseCookies.removeFirst()
  }

  fun assertResponseCookies(vararg cookies: String?) {
    assertThat(takeResponseCookies().map(Cookie::toString)).containsExactly(*cookies)
  }

annotation class Annotation(vararg val values: Int)

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

annotation class Annotation(vararg val values: Int)

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

annotation class Annotation(vararg val values: String)

@Annotation(<expr>"42"</expr>)