withFirEntry("annotation", annotation)
        withClassEntry("annotationTypeRef", annotation.annotationTypeRef)
        @OptIn(UnresolvedExpressionTypeAccess::class)
        withClassEntry("coneTypeOrNull", annotation.coneTypeOrNull)
        @OptIn(UnsafeExpressionUtility::class)
        annotation.toReferenceUnsafe()?.let { withClassEntry("calleeReference", it) }
    }

import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
import org.jetbrains.kotlin.analysis.api.impl.base.components.KtRendererProviderImpl
import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken

@OptIn(KtAnalysisApiInternals::class)
internal class KtFirRendererProvider(
    analysisSession: KtAnalysisSession,
    token: KtLifetimeToken

internal class KtFirScopeSubstitution(
    override val analysisSession: KtFirAnalysisSession,
) : KtScopeSubstitution(), KtFirAnalysisSessionComponent {

    @OptIn(KtAnalysisApiInternals::class)
    override fun getDeclarationScope(scope: KtTypeScope): KtScope {
        return when (scope) {

import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolProviderByJavaPsi
import org.jetbrains.kotlin.asJava.KtLightClassMarker
import org.jetbrains.kotlin.load.java.JvmAnnotationNames
import org.jetbrains.kotlin.name.Name

@OptIn(KtAnalysisApiInternals::class)
internal class KtFirSymbolProviderByJavaPsi(
    override val analysisSession: KtFirAnalysisSession,
) : KtSymbolProviderByJavaPsi(), KtFirAnalysisSessionComponent {

 *
 * Since this fallback is not suitable for symbols from binary libraries in Standalone mode, the symbol names provider absolutely needs to
 * work there. This functionality is covered by package scope tests.
 */
@OptIn(ExperimentalTopLevelDeclarationsGenerationApi::class)
internal object DeclarationsInPackageProvider {
    internal fun getTopLevelClassifierNamesInPackageProvider(packageFqName: FqName, analysisSession: KtFirAnalysisSession): Set<Name> {

import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.psi.KtProperty
import org.jetbrains.kotlin.psi.KtTreeVisitorVoid
import org.jetbrains.kotlin.resolve.BindingContext

@OptIn(KtAnalysisNonPublicApi::class)
fun MutableSet<KtFile>.collectReachableInlineDelegatedPropertyAccessors() {
    if (isEmpty()) return

    // One of the compiler lowerings, namely `PropertyReferenceLowering`,

    override fun <T : Any> getRegisteredExtensions(module: KtSourceModule, extensionType: ProjectExtensionDescriptor<T>): List<T> {
        return extensionType.getInstances(module.project)
    }

    @OptIn(InternalNonStableExtensionPoints::class)
    override fun isPluginOfTypeRegistered(module: KtSourceModule, pluginType: CompilerPluginType): Boolean {
        val extension = when (pluginType) {

        val patchingVisitor = IrDeclarationPatchingVisitor(collectingVisitor.mappings)
        irCodeFragmentFiles.forEach { it.acceptVoid(patchingVisitor) }
    }

    @OptIn(UnsafeDuringIrConstructionAPI::class)
    private fun computeAdditionalCodeFragmentMapping(descriptor: IrBasedDeclarationDescriptor<*>): CodeFragmentCapturedValue? {
        val owner = descriptor.owner

sourceSets {
    "main" { projectDefault() }
    "test" {
        projectDefault()
        generatedTestDir()
    }
}

tasks.withType<KotlinJvmCompile>().configureEach {
    compilerOptions {
        optIn.addAll(
            listOf(
                "kotlin.RequiresOptIn",
                "org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals"
            )
        )
        freeCompilerArgs.add("-Xcontext-receivers")

            }
        }

    override val contextReceivers: List<KtContextReceiver>
        get() = withValidityAssertion { descriptor.createContextReceivers(analysisContext) }

    @OptIn(KtAnalysisApiInternals::class)
    override val classKind: KtClassKind
        get() = withValidityAssertion {
            if (DescriptorUtils.isAnonymousObject(descriptor)) {
                error("Should be an anonymous object")