"""
            inner.x = 1
            inner.y = 1
            inner.f()
            """.trimIndent()
        )

        val errors = result.errors
        assertEquals(2, errors.size)
        assertTrue { errors.all { it.errorReason is ErrorReason.AccessOnCurrentReceiverOnlyViolation } }
    }

    @Test
    fun `access on an outer receiver is not allowed`() {
        val result = schema.resolve(

    return content.matchesPairwise(other.content, DocumentNode::structurallyEquals)
}


private
fun <T> Collection<T>.matchesPairwise(other: Collection<T>, pairMatches: (T, T) -> Boolean): Boolean =

                TestCoverage(5, TestType.quickFeedbackCrossVersion, Os.LINUX, JvmCategory.MIN_VERSION, QUICK_CROSS_VERSION_BUCKETS.size),
                TestCoverage(6, TestType.quickFeedbackCrossVersion, Os.WINDOWS, JvmCategory.MIN_VERSION_WINDOWS_MAC, QUICK_CROSS_VERSION_BUCKETS.size)
            ),
            performanceTests = performanceRegressionTestCoverages
        ),
        Stage(

                    val lowerOwnTypeArguments = lower.typeArguments
                    val upperOwnTypeArguments = upper.typeArguments
                    if (lowerOwnTypeArguments.size == upperOwnTypeArguments.size) {
                        for ((index, kaTypeProjection) in lowerOwnTypeArguments.withIndex()) {
                            if (upperOwnTypeArguments[index].type != kaTypeProjection.type) {

        val latests = buildList {
            versionsByMinor.entries.forEachIndexed { idx, entry ->
                add(entry.value.lastOrNull { !it.contains("-") })
                if (idx < versionsByMinor.size - 1) {
                    add(entry.value.first())
                } else {
                    add(entry.value.firstOrNull { !it.contains("-") })
                    add(entry.value.first())
                }

}

class C<T>(val x: Int): <expr>I</expr><T> {
    companion object {
        val K: Int = 58
    }

    fun test(): Int {
        return 45 * K
    }

    fun count(xs: List<T>): Int {
        return xs.size
    }

    override fun i(t: T): Int {
        return test() + t.hashCode()
    }

    inner class B() {

    }

}

class C<T>(val x: Int): I<<expr>T</expr>> {
    companion object {
        val K: Int = 58
    }

    fun test(): Int {
        return 45 * K
    }

    fun count(xs: List<T>): Int {
        return xs.size
    }

    override fun i(t: T): Int {
        return test() + t.hashCode()
    }

    inner class B() {

    }

    firstCandidates: List<KaCallCandidateInfo>,
    secondCandidates: List<KaCallCandidateInfo>,
) {
    val assertions = testServices.assertions
    assertions.assertEquals(firstCandidates.size, secondCandidates.size)

    for ((firstCandidate, secondCandidate) in firstCandidates.zip(secondCandidates)) {
        assertions.assertEquals(firstCandidate::class, secondCandidate::class)

 * classes and the classes they depend on. The classes are not relocated, they all
 * remain in their original namespace. This reduces the final Gradle distribution
 * size and makes us more conscious of which parts of a library we really need.
 */
val keepPatterns = mapOf(
    "fastutil" to setOf(
        // For Java compilation incremental analysis

        current: List<File>
    ): InvalidationReason? =
        when (val upToDatePrefix = countUpToDatePrefixOf(previous, current)) {
            previous.size -> {
                val added = current.size - upToDatePrefix
                when {
                    added == 1 -> "init script '${displayNameOf(current[upToDatePrefix])}' has been added"