.withAttachment("contextualModule", contextualModule?.asDebugString())
        }

        return allKtModules.firstOrNull { module -> virtualFile in module.contentScope }
            ?: throw KotlinExceptionWithAttachments("Cannot find a KtModule for the VirtualFile")
                .withPsiAttachment("containingFile", containingFile)
                .withAttachment("contextualModule", contextualModule?.asDebugString())

 * additional information not available in the [scope].
 */
public fun Project.createDeclarationProvider(scope: GlobalSearchScope, contextualModule: KtModule?): KotlinDeclarationProvider =
    KotlinDeclarationProviderFactory.getInstance(this).createDeclarationProvider(scope, contextualModule)

public fun Project.mergeDeclarationProviders(declarationProviders: List<KotlinDeclarationProvider>): KotlinDeclarationProvider =

            val fileSymbol = mainFile.getFileSymbol()
            val module = fileSymbol.getContainingModule()

            val providerModule = ProjectStructureProvider.getModule(mainFile.project, mainFile, contextualModule = null)
            assert(module == providerModule)
            assert(module == mainModule.ktModule)

            val actualString = buildString {
                append("File: ").appendLine(mainFile.name)

            ).single().first

        val project = declaration.project
        val declarationModule = ProjectStructureProvider.getModule(project, declaration, contextualModule = null)
        val restoreAtModule = ProjectStructureProvider.getModule(project, restoreAt, contextualModule = null)

        val (debugRendered, prettyRendered, pointer) = analyseForTest(declaration) {
            val symbol = declaration.getSymbol()

        // or removed only in the dangling file.
        val baseKtModule = when (val ktModule = ProjectStructureProvider.getModule(project, ktClass, contextualModule = null)) {
            is KtDanglingFileModule -> ktModule.contextModule
            else -> ktModule
        }

    ktFiles: Collection<KtFile>,
    scope: GlobalSearchScope
) : KotlinAnnotationsResolver {
    private val declarationProvider: KotlinDeclarationProvider by lazy {
        project.createDeclarationProvider(scope, contextualModule = null)
    }

    private val filesInScope = ktFiles.filter { scope.contains(it.virtualFile) }

    private val allDeclarations: List<KtDeclaration> by lazy {
        val result = mutableListOf<KtDeclaration>()

        val context = facade.getAnalysisContext(useSiteKtElement, token)
        val useSiteModule = ProjectStructureProvider.getModule(project, useSiteKtElement, contextualModule = null)
        return KaFe10Session(context, useSiteModule, token)
    }

    override fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule): KaSession {

        val codeFragment = KtExpressionCodeFragment(project, "fragment.kt", "x - 1", imports = null, contextElement)

        val codeFragmentModule = ProjectStructureProvider.getModule(project, codeFragment, contextualModule = contextModule)
        requireIsInstance<KtDanglingFileModule>(codeFragmentModule)
        assertEquals(codeFragmentModule.contextModule, contextModule)

        analyze(codeFragment) {

        LowMemoryWatcher.register(::clearCaches, project)
    }

    override fun getAnalysisSession(useSiteKtElement: KtElement): KaSession {
        val module = ProjectStructureProvider.getModule(project, useSiteKtElement, contextualModule = null)
        return getAnalysisSessionByUseSiteKtModule(module)
    }

    override fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule): KaSession {

    }

    private fun getHandler(useSiteElement: KtElement): KaFe10AnalysisHandlerExtension {
        val project = useSiteElement.project
        val ktModule = ProjectStructureProvider.getModule(project, useSiteElement, contextualModule = null)
        return KaFe10AnalysisHandlerExtension.getInstance(project, ktModule)
    }

    private fun <T : Any> T?.orThrowResolutionNotPerformedError(): T =
        this ?: error("Resolution is not performed")