/*
     We do not need guava in the generator, but because of a bug in the IJ project importing, we need to have a dependency on intellijCore
     the same as it is in `:fir:tree:tree-generator` module to the project be imported correctly
     */
    compileOnly(intellijCore())
    compileOnly(libs.guava)

    implementation(project(":compiler:psi"))
}

application {
    mainClass.set("org.jetbrains.kotlin.analysis.api.fir.generator.MainKt")

 * Scope tests should not forget checking contained names, as they're a public part of the [KaScope] API.
 *
 * Note: Many scopes wouldn't work correctly if the contained name sets were broken, as these names are often the basis for the search.
 * But this is not a good reason for a lack of tests, as the scope implementation is not forced to use these name sets internally, and

     */
    lazyArguments: Lazy<List<KaNamedAnnotationValue>>,
    index: Int?,

    /**
     * The constructor symbol into which this annotation resolves if the annotation is correctly resolved
     */
    constructorSymbol: KaConstructorSymbol?,
    override val token: KaLifetimeToken
) : KaAnnotation {
    private val backingClassId: ClassId? = classId

    override val classId: ClassId?

 */

package org.jetbrains.kotlin.analysis.api.standalone.base.permissions

import org.jetbrains.kotlin.analysis.api.platform.permissions.KotlinAnalysisPermissionOptions

// TODO (KT-68386): Currently unused due to KT-68386, but will be used again.
class KotlinStandaloneAnalysisPermissionOptions : KotlinAnalysisPermissionOptions {
    override val defaultIsAnalysisAllowedOnEdt: Boolean get() = true

     * overridden by [org.jetbrains.kotlin.analysis.api.permissions.allowAnalysisOnEdt].
     *
     * TODO (KT-68186): Due to KT-68386, the implementation currently doesn't apply the default to
     * [KaAnalysisPermissionRegistry][org.jetbrains.kotlin.analysis.api.permissions.KaAnalysisPermissionRegistry], but it is taken into
     * account by [KaAnalysisPermissionChecker].
     */

        val generatedTopLevelClassifiers = declarationGenerators
            .asSequence()
            .flatMap {
                // FIXME this function should be called only once during plugin's lifetime, so this usage is not really correct (2)
                it.getTopLevelClassIds()
            }
            .filter { it.packageFqName == packageFqName }
            .map { it.shortClassName }

        return generatedTopLevelClassifiers.toSet()
    }

import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.analysis.api.platform.KaEngineService

/**
 * [KaAnalysisPermissionChecker] is an *engine service* which allows checking whether analysis is currently allowed.
 */
public interface KaAnalysisPermissionChecker : KaEngineService {
    public fun isAnalysisAllowed(): Boolean

    public fun getRejectionReason(): String

    public companion object {

            // Standalone modes) to have different test results (since `testPrefix` normally supports this functionality), but (1) we are
            // currently only testing the IDE mode and (2) the test results between different modes should not differ for session
            // invalidation in the first place.
            testPrefix = resultFileSuffix,
        )
    }

 * can make use of the [KaLifetimeTracker][org.jetbrains.kotlin.analysis.api.platform.lifetime.KaLifetimeTracker] engine service to retrieve
 * the currently active lifetime token for comparison.
 *
 * As a marker interface, [KaEngineService] clearly separates an engine service from [KotlinPlatformComponent]s which need to be implemented

 * are not, such as file-based declaration providers. Not all declarations provided by such declaration providers can be provided by the
 * main declaration provider, even if the correct scope is provided (such as a file-based scope). For example, the main declaration provider
 * may be based on an index which doesn't contain the declarations provided by file-based declaration providers.
 *