) {
            // there is no way to properly map KtModule to ModuleDescriptor,
            // Multi-module [KtFe10AnalysisHandlerExtension]s are used only for tests,
            // so just by name comparison should work as all module names are different
            return null
        }

        resolveSession = componentProvider.get()
        deprecationResolver = componentProvider.get()

        }

        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.

     *
     * The function unwraps certain receiver expressions. For instance, for safe calls direct counterpart to a [KtSafeQualifiedExpression]
     * is (FirCheckedSafeCallSubject)[org.jetbrains.kotlin.fir.expressions.FirCheckedSafeCallSubject] which requires additional unwrapping
     * to be used for call resolution.
     */

        sequence {
            // Only emit package symbols for top-level packages (subpackages of root). This matches the behavior
            // of the root-level KtFirPackageScope.
            val seenTopLevelPackages = mutableSetOf<Name>()
            for (tool in tools) {
                for (packageName in tool.packageFilter.getAllSubPackages(FqName.ROOT)) {

        // 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
        // `file` because of filtering in `generateClassFilter`, while only select declarations from other files are generated if needed
        // by the backend.

                super.visitDestructuringDeclaration(destructuringDeclaration)

                val bindingContext = analysisContext.analyze(destructuringDeclaration)

                for (entry in destructuringDeclaration.entries) {
                    val resolvedCall = bindingContext.get(BindingContext.COMPONENT_RESOLVED_CALL, entry)
                    collector.checkResolveCall(resolvedCall)
                }

            else -> selfName.asString()
        }
    }

    private fun computeSupertypeInternalName(descriptor: ClassDescriptor): String {
        var interfaceSupertypeInternalName: String? = null

        for (supertype in descriptor.typeConstructor.supertypes) {
            val declaration = supertype.constructor.declarationDescriptor ?: continue

            if (declaration !is ClassDescriptor || declaration.name.isSpecial) {

    override val analysisSession: KtAnalysisSession,
) : KtKlibSourceFileNameProvider() {
    override fun getKlibSourceFileName(declaration: KtDeclarationSymbol): String? {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

    override fun getExitPointSnapshot(statements: List<KtExpression>): KtDataFlowExitPointSnapshot {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

    renderAnnotationWithShortNames: Boolean,
    analysisContext: Fe10AnalysisContext,
    predicate: (ClassId) -> Boolean = { true }
) {
    val separator = if (isSingleLineAnnotations) " " else "\n"
    for (annotation in annotations) {
        val annotationClass = annotation.annotationClass ?: continue
        val classId = annotationClass.classId
        if (classId != null && !predicate(classId)) {
            continue