name = propertyName,
                    valueParameters = listOf(
                        newValueParameterOf("dependency", KotlinType.typeParameter),
                        newValueParameterOf("action", actionTypeOf(KotlinType.typeParameter))
                    ),
                    typeParameters = listOf(

                    for (allowErrorTypes in listOf(false, true)) {
                        for (typeMappingMode in KaTypeMappingMode.entries) {
                            for (isAnnotationMethod in listOf(false, true)) {
                                val psiType = returnType.asPsiType(psiContext, allowErrorTypes, typeMappingMode, isAnnotationMethod)

    // Less than 16,384 chars, because we index on a 14-bit index in the ranges table.
    assertThat(compactTable.mappings.length).isLessThan(1 shl 14)

    // Confirm the data strings are ASCII.
    for (dataString in listOf<String>(compactTable.sections, compactTable.ranges)) {
      for (codePoint in dataString.codePoints()) {
        assertThat(codePoint and 0x7f).isEqualTo(codePoint)
      }
    }

}

// Configurations to resolve dependencies
val runtimeClasspath by libraryResolver(listOf(coreRuntimeOnly, pluginsRuntimeOnly))
runtimeClasspath.description = "Resolves to all Jars that need to be in the distribution including all transitive dependencies"
val coreRuntimeClasspath by libraryResolver(listOf(coreRuntimeOnly))

    register<JavaExec>("runScript") {
        mainClass = "scope"
        classpath = sourceSets.main.get().runtimeClasspath
        if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_1_9)) {
            jvmArgs = listOf("--add-opens", "java.base/java.lang=ALL-UNNAMED")
        }
    }

// tag::apply-plugin[]
plugins {
    `cpp-unit-test`
}
// end::apply-plugin[]

// tag::configure-target-machines[]
unitTest {
    targetMachines = listOf(machines.linux.x86_64,
        machines.windows.x86, machines.windows.x86_64,
        machines.macOS.x86_64)
}

                        builder.token
                    )
                }

            is ConeUnresolvedNameError -> listOf(
                KaClassTypeQualifier.KaUnresolvedClassTypeQualifier(coneDiagnostic.name, emptyList(), builder.token)
            )

            is ConeUnresolvedReferenceError -> listOf(
                KaClassTypeQualifier.KaUnresolvedClassTypeQualifier(coneDiagnostic.name, emptyList(), builder.token)
            )

        checkWithAttachment(
            declaration.isLocal,
            message = { "${declaration::class} is not local" }
        ) {
            withFirEntry("firDeclaration", declaration)
        }
        return when (declaration) {
            is FirAnonymousObject -> listOf(declaration)

package jvmTest

import common.greetEachOther
import some.example.Person

private class MyPerson(
    name: String
) : Person(name) {
    override fun greet() = "Hi"
}

fun test() {
    greetEachOther(
        listOf(
            Person("Alice"),
            MyPerson("Bob"),
        )
    )

val jdkVariables = listOf("JDK_8", "JDK_11", "JDK_17")
val jdkLocations = jdkVariables.filter { v ->
    System.getenv(v) != null
}.associate { v ->
    v to System.getenv(v)