if (this is KtQualifiedExpression && selectorExpression is KtCallExpression) return false

            // expressions like `foo.|bar|` or `foo?.|baz|` are ignored
            if (this is KtNameReferenceExpression && getQualifiedExpressionForSelector() != null) return false

            // only those types of expressions are supported

/**
 * Whether unbound IR symbols should be stubbed instead of linked.
 * This should be enabled if the compiled file could refer to symbols defined in another file of the same module.
 * Such symbols are not compiled (only the file is passed to the backend) and so they cannot be linked from a dependency.
 */
val STUB_UNBOUND_IR_SYMBOLS: CompilerConfigurationKey<Boolean> = CompilerConfigurationKey<Boolean>("stub unbound IR symbols")

        ) {
            // 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()

            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.
                add(GlobalSearchScope.EMPTY_SCOPE)

     */
    fun allFiles(): List<KtFile> = analyzedElements.mapTo(mutableSetOf()) { it.containingKtFile }.toList()

    /**
     * Returns the set of [KtObjectDeclaration]s which are defined as an object literal in one of the reached inline functions.
     */
    fun inlineObjectDeclarations(): Set<KtObjectDeclaration> {
        val results = mutableSetOf<KtObjectDeclaration>()

`Dependency verification failed` errors when local artifacts are absent or have different hashes listed in the
[verification-metadata.xml](https://github.com/JetBrains/kotlin/blob/master/gradle/verification-metadata.xml) file.

It's expected that `verification-metadata.xml` should only be updated with the commits that modify the build. There are some tips how
to perform such updates:

 * stub-indexing binary libraries). And in general, querying the symbol names provider might be faster since its sets are cached, which is
 * not necessarily the case for declaration providers (e.g. the IDE declaration provider hitting the index without caching).
 *

import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
import org.jetbrains.kotlin.name.Name

/**
 * [FirNonStaticMembersScope] includes non-static callables and inner classes.
 *
 * Inner classes are included because they are accessible from a value of the outer class. For example:
 *
 * ```
 * class Outer {
 *     inner class Inner
 * }
 *
 * fun foo() {
 *     val outer = Outer()
 *     outer.Inner()
 * }

import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
import org.jetbrains.kotlin.analysis.api.scopes.KtScope
import org.jetbrains.kotlin.psi.KtElement

// Resolve extensions are not supported on FE1.0, so return empty results.
internal class KtFe10ResolveExtensionInfoProvider(
    override val analysisSession: KtFe10AnalysisSession,
) : KtResolveExtensionInfoProvider(), Fe10KtAnalysisSessionComponent {

    }

    override fun getParameterSymbol(psi: KtParameter): KtVariableLikeSymbol {
        return when {
            psi.isFunctionTypeParameter -> error("Function type parameters are not supported in getParameterSymbol()")
            psi.isLoopParameter -> KtFe10PsiLoopParameterLocalVariableSymbol(psi, analysisContext)
            else -> KtFe10PsiValueParameterSymbol(psi, analysisContext)
        }
    }