extensionTools.mapTo(this) { it.packageProvider }
            }
        )
    }

    fun getScopeSessionFor(session: FirSession): ScopeSession = withValidityAssertion { firResolveSession.getScopeSessionFor(session) }

    companion object {
        internal fun createAnalysisSessionByFirResolveSession(
            firResolveSession: LLFirResolveSession,

/native/objcexport-header-generator/impl/analysis-api/ "Kotlin in Fleet"

/plugins/allopen/ "Kotlin Compiler Core"
/plugins/android-extensions/ "Kotlin Compiler Core"
/plugins/assign-plugin/ "Kotlin Compiler Core"
/plugins/atomicfu/ "Kotlin Libraries"
/plugins/compose/ Compose
/plugins/fir-plugin-prototype/ "Kotlin Compiler Core"
/plugins/imports-dumper/ "Kotlin Compiler Core"

  <xi:include href="/META-INF/extensions/compiler.xml"/>

  <extensions defaultExtensionNs="com.intellij">
    <projectService
        serviceInterface="org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider"
        serviceImplementation="org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSessionProvider"
    />

    <projectService

                            import.resolvedParentClassId?.createNestedClassId(importedName) ?: ClassId(import.packageFqName, importedName)
                        importedClassId.takeIf { firScope.session.symbolProvider.getClassLikeSymbolByClassId(it) != null }
                    }
                    NonStarImport(
                        import.packageFqName,
                        importedClassId?.relativeClassName,

                typeContext.createTypeArgument(type.coneType, variance.convertVariance()) as ConeTypeProjection
            }
        }

    fun createTypeCheckerContext(): TypeCheckerState {
        // TODO use correct session here,
        return analysisSession.firResolveSession.useSiteFirSession.typeContext.newTypeCheckerState(
            errorTypesEqualToAnything = true,
            stubTypesEqualToAnything = true
        )
    }

            fakeFirQualifiedAccess = buildFunctionCall {
                annotations.addAll(functionCall.annotations)

                /**
                 * It is important to avoid passing type arguments when they are implicit type arguments.
                 * For example,
                 *   package a.b.c
                 *   fun <T, E> foo(a: T, b: E) {}      // A
                 *   fun test() {

            else -> baseFir
        }
        val session = analysisSession.firResolveSession.useSiteFirSession
        return when (fir) {
            is FirResolvedTypeRef -> getSymbolsForResolvedTypeRef(fir, expression, session, symbolBuilder)
            is FirResolvedQualifier ->
                getSymbolsForResolvedQualifier(fir, expression, session, symbolBuilder)

 * [FirDeclarationGenerationExtension][org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension]s.
 *
 * [DeclarationsInPackageProvider] first tries the [FirSymbolNamesProvider] of the analysis session's underlying FIR session, because it
 * provides symbol names from binary libraries in Standalone mode, which the Standalone declaration provider does not contain (to avoid

        }
    }
}

private fun FirBasedSymbol<*>.isFromCompilerRequiredAnnotationsPhase(classId: ClassId, session: FirSession): Boolean {
    val requiredAnnotations = session.annotationPlatformSupport.requiredAnnotations
    return fir.resolvePhase < FirResolvePhase.TYPES && classId in requiredAnnotations

(see [gradle.properties](./gradle.properties#L5) for supported variable names). To ensure Gradle uses only JDKs 
from environmental variables - disable Gradle toolchain auto-detection by passing `-Porg.gradle.java.installations.auto-detect=false` option
(or put it into `$GRADLE_USER_HOME/gradle.properties`).

On Windows you might need to add long paths setting to the repo:

    git config core.longpaths true