@Suppress("UNCHECKED_CAST")
        return with(analysisSession) {
            when (creator) {
                is KtFirDiagnostic0Creator -> with(creator) {
                    create(diagnostic as KtSimpleDiagnostic)
                }
                is KtFirDiagnostic1Creator<*> -> with(creator as KtFirDiagnostic1Creator<Any?>) {

            ?: return returnExpression.parentOfType<KtNamedFunction>()
                ?.let { with(analysisSession) { it.getSymbol() as? KtCallableSymbol } }
        val labelTarget = bindingContext[BindingContext.LABEL_TARGET, targetLabel] as? KtDeclaration ?: return null
        return with(analysisSession) { labelTarget.getSymbol() as? KtCallableSymbol }
    }

    override fun getResolveExtensionNavigationElements(originalPsi: KtElement): Collection<PsiElement> {
        val targetsProvider = originalPsi.containingFile?.virtualFile?.navigationTargetsProvider ?: return emptyList()
        return with(targetsProvider) { analysisSession.getNavigationTargets(originalPsi) }
    }
}

private class KtFirResolveExtensionScope(
    private val analysisSession: KtFirAnalysisSession,

    }

    override fun getResolvedToPsi(
        analysisSession: KtAnalysisSession,
        referenceTargetSymbols: Collection<KtSymbol>,
    ): Collection<PsiElement> = with(analysisSession) {
        referenceTargetSymbols.flatMap { symbol ->
            when (symbol) {
                is KtFirSyntheticJavaPropertySymbol -> listOfNotNull(symbol.javaGetterSymbol.psi, symbol.javaSetterSymbol?.psi)

    private fun writeGenericArguments(
        sw: JvmSignatureWriter,
        arguments: List<TypeProjection>,
        parameters: List<TypeParameterDescriptor>,
        mode: TypeMappingMode
    ) {
        with(KotlinTypeMapper) {
            typeContext.writeGenericArguments(sw, arguments, parameters, mode) { type, sw, mode ->
                mapType(type as KotlinType, mode, sw)
            }
        }
    }

        }

        val shadowedScope = GlobalSearchScope.union(
            buildSet {
                // Add an empty scope to the shadowed set to give GlobalSearchScope.union something
                // to work with if there are no extension tools.
                // If there are extension tools, any empty scopes, whether from shadowedSearchScope
                // on the extension tools or from this add() call, will be ignored.

    ): KtExtensionApplicabilityResult = analysisSession.withValidityAssertion {
        val checker = KtFirCompletionExtensionCandidateChecker(analysisSession, nameExpression, possibleExplicitReceiver, originalFile)
        return with(analysisSession) {
            checker.computeApplicability(firSymbolForCandidate)
        }
    }
}

private class KtFirCompletionExtensionCandidateChecker(
    override val analysisSession: KtFirAnalysisSession,

            }

        val disableInline = effectiveConfiguration.getBoolean(CommonConfigurationKeys.DISABLE_INLINE)

        // The binding context needs to be built from all files with reachable inline functions, as such files may contain classes whose
        // descriptors must be available in the binding context for the IR backend. Note that the full bytecode is only generated for

/libraries/tools/kotlin-maven-noarg/ "Kotlin Build Tools"
/libraries/tools/kotlin-maven-plugin/ "Kotlin Build Tools"
/libraries/tools/kotlin-maven-plugin-test/ "Kotlin Build Tools"
/libraries/tools/kotlin-maven-sam-with-receiver/ "Kotlin Build Tools"
/libraries/tools/kotlin-maven-serialization/ "Kotlin Build Tools"
/libraries/tools/kotlin-osgi-bundle/ "Kotlin Build Tools"
/libraries/tools/kotlin-noarg/ "Kotlin Build Tools"

        }
        else -> arguments.any { typeProjection ->
            // A star projection type (lazily) built by type parameter will be yet another type with a star projection,
            // resulting in stack overflow if we keep checking allowed type parameter descriptors
            !typeProjection.isStarProjection &&