class KtFirArrayAccessReference(
    expression: KtArrayAccessExpression
) : KtArrayAccessReference(expression), KtFirReference {
    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
        check(this is KtFirAnalysisSession)
        val fir = element.getOrBuildFir(firResolveSession) ?: return emptyList()
        return when (fir) {

        return KtEmptyScope(token)
    }

    override fun isResolveExtensionFile(file: VirtualFile): Boolean = false

    override fun getResolveExtensionNavigationElements(originalPsi: KtElement): Collection<PsiElement> = emptyList()

                    "value",
                    conversionForCollectionValues,
                    conversionForCollectionValues
                )
            )
            put(
                Collection::class,
                HLCollectionParameterConversion("value", conversionForCollectionValues)
            )
            put(
                Pair::class,
                HLPairParameterConversion(

            return ktConstructorCalleeExpression.parent is KtAnnotationEntry
        }

    private fun KtAnalysisSession.fixUpAnnotationCallResolveToCtor(resultsToFix: Collection<KtSymbol>): Collection<KtSymbol> {
        if (resultsToFix.isEmpty() || !isAnnotationCall) return resultsToFix

        return resultsToFix.map { targetSymbol ->

    }

    protected abstract fun collectImportsForDiagnosticParameter(diagnosticParameter: HLDiagnosticParameter): Collection<String>

    protected abstract fun SmartPrinter.render(diagnosticList: HLDiagnosticList, packageName: String)

    protected abstract val defaultImports: Collection<String>

    getResolvedSymbolOfNameReference()?.fir?.let(builder::buildSymbol)

internal fun FirErrorNamedReference.getCandidateSymbols(): Collection<FirBasedSymbol<*>> =
    diagnostic.getCandidateSymbols()

internal fun FirNamedReference.getCandidateSymbols(): Collection<FirBasedSymbol<*>> = when (this) {
    is FirResolvedNamedReference -> listOf(resolvedSymbol)
    is FirErrorNamedReference -> getCandidateSymbols()

            .map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it) }

    }

    private fun FirBasedSymbol<*>.getIntersectionOverriddenSymbols(useSiteSession: FirSession): Collection<FirCallableSymbol<*>> {
        require(this is FirCallableSymbol<*>) {
            "Required FirCallableSymbol but ${this::class} found"
        }
        return when (this) {

                    yield(ktSymbol)
                }
            }
        }
    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KtCallableSymbol> = withValidityAssertion {
        if (names.isEmpty()) return emptySequence()
        val namesSet = names.toSet()
        return getCallableSymbols { it in namesSet }
    }

import org.jetbrains.kotlin.psi.KtExpression

class KtFirInvokeFunctionReference(expression: KtCallExpression) : KtInvokeFunctionReference(expression), KtFirReference {
    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
        return expression.resolveCall()?.calls.orEmpty().mapNotNull { call ->
            (call as? KtSimpleFunctionCall)
                ?.takeIf { it.isImplicitInvoke }
                ?.partiallyAppliedSymbol

    element: KtDestructuringDeclarationEntry
) : KtDestructuringDeclarationReference(element), KtFirReference {
    override fun canRename(): Boolean = false //todo

    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
        check(this is KtFirAnalysisSession)
        val fir = expression.getOrBuildFirSafe<FirProperty>(firResolveSession) ?: return emptyList()
        return listOfNotNull(