* Scope tests should not forget checking contained names, as they're a public part of the [KaScope] API.
 *
 * Note: Many scopes wouldn't work correctly if the contained name sets were broken, as these names are often the basis for the search.

 *
 * Further modification tracking is implemented with a subscription-based mechanism via [KotlinModificationTopics]. Modification trackers make the most
 * sense when there are many, possibly short-lived objects that need to be notified of a change. In such cases, subscriber management in the
 * message bus adds too much overhead.
 */

        withValidityAssertion { analysisSession.symbolProvider.getSymbol(this) }

    /**
     * Creates [KaVariableLikeSymbol] by [KtParameter].
     *
     * Unfortunately, [KtParameter] in PSI stands for many things, and not all of them are represented by a single type of symbol,
     * so this function does not work for all possible [KtParameter]s.
     *

     */
    private fun ClassId.dropLastNestedClasses(classesToDrop: Int) =
        generateSequence(this) { it.outerClassId }.drop(classesToDrop).firstOrNull()

    /**
     * @return How many qualifiers needs to be dropped from [wholeType] to get [nestedType].
     *
     * Example: to get `foo.bar` from `foo.bar.Baz.Inner`, you need to drop 2 qualifiers (`Inner` and `Baz`).
     */

                put(typeParameters[index], projection.asKtType())
            }
        }
    }

    /**
     * Maps [typeArguments] to the type parameters of [partiallyAppliedSymbol].
     *
     * If too many type arguments are provided, a mapping is still created. Extra type arguments are simply ignored. If this wasn't the

- [`KT-60668`](https://youtrack.jetbrains.com/issue/KT-60668) KMP: check expect and actual annotations match when actual method is fake override
- [`KT-60250`](https://youtrack.jetbrains.com/issue/KT-60250) K2: origin is set too many times for elvis operator
- [`KT-60254`](https://youtrack.jetbrains.com/issue/KT-60254) K2: Extra unset type argument on Java field reference

        // Various parts of the IJ plugin use the read/write access checker without being aware that it uses `analyze` under the hood. For
        // now, it makes more sense to allow analysis on EDT/from write actions here, as there are many such usages in the IJ plugin.
        return allowAnalysisOnEdt {
            allowAnalysisFromWriteAction {
                val resolvedCall = analyze(assignment) {

import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name

/**
 * Implements [KaNamedClassOrObjectSymbol] for a Java class. The underlying [firSymbol] is built lazily and only when needed. Many simple
 * properties are computed from the given [PsiClass] instead of [firSymbol]. This improves performance when "slow" properties don't need to
 * be accessed.
 */
internal class KaFirPsiJavaClassSymbol(

                    collectStubsFromBinaryRoot(additionalRoot, binaryClassCache)
                }?.let(::processCollectedStubs)
            }

            // In contrast to `sharedBinaryRoots`, which are shared between many different projects (e.g. the Kotlin stdlib), `binaryRoots`
            // come from binary libraries which are specific to the project. Caching them in `KotlinFakeClsStubsCache` won't have any
            // performance advantage.