/compiler/compiler-runner/ "Kotlin Compiler Core" Simon.Ogorodnik
/compiler/compiler-runner-unshaded/ "Kotlin Build Tools"
/compiler/config/ "Kotlin Compiler Core" Simon.Ogorodnik
/compiler/config.jvm/ "Kotlin JVM"
/compiler/container/ "Kotlin Compiler Core" Simon.Ogorodnik
/compiler/daemon/ "Kotlin Build Tools"
/compiler/fir/ "Kotlin Compiler Core" Simon.Ogorodnik

        }
    }

    /**
     * Returns the [KtSymbol]s called [fqName] found in the member scope and companion object's member scope of the [KtDeclaration]s that
     * contain the [contextElement].
     *
     * If [fqName] has two or more segments, e.g. `Foo.bar`, the member and companion object scope of the containing [KtDeclaration] will be

                        return listOfNotNull(symbolBuilder.createPackageSymbolIfOneExists(classId.packageFqName))
                    } else {
                        // This is unexpected. The code probably contains some weird structures. In this case, we just fail the resolution
                        // with zero results.
                        return emptyList()
                    }
                }

        /**
         * A scope containing both non-static and static members. A smart combined scope (as opposed to a naive combination of [KtScope]s
         * with [getCompositeScope]) avoids duplicate inner classes, as they are contained in non-static and static scopes.
         *
         * A proper combined declared member scope kind also makes it easier to cache combined scopes directly (if needed).
         */
        COMBINED,
    }

            // Because the file to compile may be contained in a "common" multiplatform module, an `expect` declaration doesn't necessarily
            // have an obvious associated `actual` symbol. `shouldStubOrphanedExpectSymbols` generates stubs for such `expect` declarations.
            shouldStubOrphanedExpectSymbols = true,

    /**
     * Returns `true` if the control graph contains at least one of the [firCandidates].
     */
    private fun ControlFlowGraph.contains(firCandidates: Set<FirElement>): Boolean {
        for (node in nodes) {
            if (node.fir in firCandidates) {
                return true
            }
            if (node is CFGNodeWithSubgraphs<*> && node.subGraphs.any { it.contains(firCandidates) }) {
                return true

        correspondingImport.importPath?.pathStr
    }

    val canonicalSignature = signatureWriter.toString()
    require(!canonicalSignature.contains(SpecialNames.ANONYMOUS_STRING))

    if (canonicalSignature.contains("L<error>")) return null
    if (canonicalSignature.contains(SpecialNames.NO_NAME_PROVIDED.asString())) return null

    val signature = StringCharacterIterator(canonicalSignature)

import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.types.UnwrappedType
import org.jetbrains.kotlin.types.expressions.OperatorConventions
import org.jetbrains.kotlin.types.typeUtil.contains
import org.jetbrains.kotlin.util.OperatorNameConventions
import org.jetbrains.kotlin.utils.addToStdlib.safeAs

internal class KtFe10CallResolver(
    override val analysisSession: KtFe10AnalysisSession