get() = analysisSession.token

    override fun getResolveExtensionScopeWithTopLevelDeclarations(): KtScope {
        val tools = analysisSession.extensionTools
        if (tools.isEmpty()) return KtEmptyScope(token)
        return KtFirResolveExtensionScope(analysisSession, tools)
    }

    @OptIn(KtModuleStructureInternals::class)
    override fun isResolveExtensionFile(file: VirtualFile): Boolean =

        val possibleReceivers =
            getSymbolsFromScopes(receiverTypeName, contextElement).ifEmpty { null }
                ?: getNonImportedSymbolsByFullyQualifiedName(receiverTypeName).ifEmpty { null }
                ?: emptyList()

        return possibleReceivers.filterIsInstance<KtClassLikeSymbol>()
    }

    /**

    }

    private fun createFakeImportingScope(newImports: Sequence<FqName>): FirScope? {
        val resolvedNewImports = newImports.mapNotNull { createFakeResolvedImport(it) }.toList()
        if (resolvedNewImports.isEmpty()) return null

        return FirExplicitSimpleImportingScope(
            resolvedNewImports,
            firSession,
            analysisSession.getScopeSessionFor(firSession),
        )
    }

            val receiverParameter = firCallableSymbol.receiverParameter
            return if (receiverParameter?.annotations?.isEmpty() != false) {
                KtEmptyAnnotationsList(builder.token)
            } else {
                KtFirAnnotationListForReceiverParameter(firCallableSymbol, receiverParameter, builder)
            }
        }
    }

import java.lang.annotation.ElementType

internal fun mapAnnotationParameters(annotation: FirAnnotation): Map<Name, FirExpression> {
    if (annotation is FirAnnotationCall && annotation.arguments.isEmpty()) return emptyMap()

    checkWithAttachment(annotation.resolved, { "By now the annotations argument mapping should have been resolved" }) {
        withFirEntry("annotation", annotation)

                    KtFirAnnotationListForDeclaration(firSymbol, builder)
                firSymbol.annotations.isEmpty() ->
                    KtEmptyAnnotationsList(builder.token)
                else ->
                    KtFirAnnotationListForDeclaration(firSymbol, builder)
            }
        }
    }

            fe10Annotations: Annotations,
            analysisContext: Fe10AnalysisContext,
            ignoreAnnotations: Set<ClassId> = emptySet(),
        ): KtAnnotationsList {
            return if (!fe10Annotations.isEmpty()) {
                KtFe10AnnotationsList(fe10Annotations, ignoreAnnotations, analysisContext)
            } else {
                KtEmptyAnnotationsList(analysisContext.token)
            }
        }
    }

        val fir = classSymbol.getFirForScope()
        val delegateFields = fir.delegateFields

        if (delegateFields.isEmpty()) {
            return getEmptyScope()
        }

        fir.lazyResolveToPhaseWithCallableMembers(FirResolvePhase.STATUS)

        val firScope = FirDelegatedMemberScope(

        partiallyAppliedSymbol: KtPartiallyAppliedSymbol<*, *>
    ): Map<KtTypeParameterSymbol, KtType> {
        val typeParameters = partiallyAppliedSymbol.symbol.typeParameters
        if (typeParameters.isEmpty()) return emptyMap()
        if (typeArguments.size < typeParameters.size) return emptyMap()

        val result = mutableMapOf<KtTypeParameterSymbol, KtType>()

        }

    companion object {
        fun create(coneType: ConeKotlinType, builder: KtSymbolByFirBuilder): KtAnnotationsList {
            return if (coneType.customAnnotations.isEmpty()) {
                KtEmptyAnnotationsList(builder.token)
            } else {
                KtFirAnnotationListForType(coneType, builder)
            }
        }
    }
}