val pointer: SmartPsiElementPointer<PSI>,
    override val factory: JavaElementSourceFactory,
) : JavaElementPsiSource<PSI>() {

    // is used only for the purposes of equals/hashCode to avoid underlying PCE
    private val originalPsi: PSI = psi

    override val psi: PSI
        get() {
            return pointer.element
                ?: error("Cannot restore a PsiElement from $pointer")
        }

        variableReference: VariableReference,
        constructor: (KaParameterSymbol) -> T
    ): T = constructor(variableReference.descriptor.toKtSymbol(analysisContext) as KaParameterSymbol)

    // Util function to avoid hard coding names of the classes. Type inference will do a better job figuring out the best type to cast to.
    // This visitor isn't type-safe anyway

     *
     * **Please avoid using it**; it will probably be removed in the future.
     *
     * The function is instantly deprecated, so it's not shown in the completion.
     *
     * @receiver A target callable symbol.
     * @return A dispatch receiver type for this symbol if it has any.
     */
    @Suppress("DeprecatedCallableAddReplaceWith")
    @Deprecated("Avoid using this function")

                withFirEntry("fir", firFunctionSymbol.firSymbol.fir)
            }
        else firFunctionSymbol.valueParameters[valueParameterReference.parameterIndex]
    )

    // Util function to avoid hard coding names of the classes. Type inference will do a better job figuring out the best type to cast to.
    // This visitor isn't type-safe anyway
    private inline fun <reified T> ConeContractDescriptionElement.accept() =

 * provides symbol names from binary libraries in Standalone mode, which the Standalone declaration provider does not contain (to avoid
 * stub-indexing binary libraries). And in general, querying the symbol names provider might be faster since its sets are cached, which is

        doTestKotlinStdLibResolve(JvmPlatforms.defaultJvmPlatform, PathUtil.kotlinPathsForDistDirectory.stdlibPath.toPath())
    }

    @Test
    fun testKotlinStdLibCommon() {
        // KT-63493 to avoid using a hardcoded path
        doTestKotlinStdLibResolve(CommonPlatforms.defaultCommonPlatform, Paths.get("dist/common/kotlin-stdlib-common.jar"))
    }

    @Test
    fun testKotlinStdLibJs() {

 *
 * The recommendation to avoid caching services is due to the risk of leaks. Properties annotated with [KaCachedService] should make sure
 * that they don't leak the service: the lifetime of the property should be shorter or as long as the lifetime of the cached service.
 *
 * When caching a service inside another service, the property should also be [lazy] to avoid issues with cyclic service initialization and

        // file, the FIR class for `ktClass` will come from the dangling module. So we'd compare the original FIR class for the supertype
        // with the dangling FIR class for `ktClass`, resulting in a mismatch. To avoid such incompatible comparisons, we need to resolve
        // `ktClass` to the original FIR class.
        //

     * Caches [KaAnalysisPermissionRegistry] to avoid repeated `getService` calls in [analyze][org.jetbrains.kotlin.analysis.api.analyze]
     * and validity assertions.
     */
    @KaCachedService
    private val permissionRegistry by lazy(LazyThreadSafetyMode.PUBLICATION) {
        KaAnalysisPermissionRegistry.getInstance()
    }

    /**

    /**
     * Caches [KaAnalysisPermissionChecker] to avoid repeated [Project.getService] calls in [analyze].
     */
    @KaCachedService
    private val permissionChecker by lazy(LazyThreadSafetyMode.PUBLICATION) {
        KaAnalysisPermissionChecker.getInstance(project)
    }

    /**
     * Caches [KaBaseLifetimeTracker] to avoid repeated [Project.getService] calls in [analyze].
     */
    @KaCachedService