*
     * Usually returns a single result. Might return an empty collection if there is no navigation target.
     * Also, might multiple targets in a case of ambiguity or multiple targets for a [symbol]
     *
     * Returned [PsiElement] will be used as a navigation target inside the IDE.
     */

    public abstract fun createPackageProvider(searchScope: GlobalSearchScope): KotlinPackageProvider
}

/**
 * [KotlinPackageProviderMerger] allows merging multiple [KotlinPackageProvider]s into a more efficient package provider.
 *
 * Package providers should not be naively merged by combining scopes and calling [createPackageProvider], because there may be additional

    public val candidate: KaCall get() = withValidityAssertion { backingCandidate }

    /**
     * Returns true if the [candidate] is in the final set of candidates that the call is actually resolved to. There can be multiple
     * candidates if the call is ambiguous.
     */
    public val isInBestCandidates: Boolean by validityAsserted(isInBestCandidates)
}

public typealias KtCallCandidateInfo = KaCallCandidateInfo

/**

 */

package org.jetbrains.kotlin.analysis.api.platform

/**
 * A marker interface for a provider that can be composed, i.e. multiple instances of the same provider can be composed into a single
 * provider.
 *
 * Composable providers share certain traits: There is a notion of a sequentially composed [KotlinCompositeProvider] of that kind, and there

- [`KT-53629`](https://youtrack.jetbrains.com/issue/KT-53629) K2: forbid multiple labels per statement
- [`KT-65255`](https://youtrack.jetbrains.com/issue/KT-65255) K2 / KJS: "IllegalArgumentException: Candidate is not successful, but system has no contradiction"

    override fun getAllowedContainingFiles(mainFile: KtFile, testServices: TestServices): Set<KtFile> {
        // Package scope tests may collect symbols from multiple files, so we need to allow all main test files.
        return testServices.ktTestModuleStructure.allMainKtFiles.toSet()
    }

import kotlin.reflect.KProperty

/**
 * [ApplicationServiceRegistration] centralizes registration of services with shared [MockApplication]s.
 *
 * The Kotlin core environment shares the application between multiple tests running in parallel. We need to ensure that application
 * services are only registered once, and especially that no races happen. Thread safety is ensured with a lock, while registrations are

     * original declared symbol.
     *
     * Such situation can also happen for intersection symbols (in case of multiple super types containing symbols with identical signature
     * after specialization) and delegation.
     */
    public val KaCallableSymbol.unwrapFakeOverrides: KaCallableSymbol

    }

    /**
     * All kinds of non-local named class or object symbols must have the same kind of hash code. The class ID is the best option, as the
     * same class/object may be represented by multiple different symbols.
     */
    override fun hashCode(): Int = classId?.hashCode() ?: symbolHashCode()

) : KaCallableMemberCall<S, KaFunctionLikeSignature<S>>() {

    /**
     * The mapping from argument to parameter declaration. In case of vararg parameters, multiple arguments may be mapped to the same
     * [KaValueParameterSymbol].
     */
    public val argumentMapping: LinkedHashMap<KtExpression, KaVariableLikeSignature<KaValueParameterSymbol>>