import org.jetbrains.kotlin.analysis.api.symbols.markers.KaSymbolWithVisibility
import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils.isVisible
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.psi.KtCallableDeclaration
import org.jetbrains.kotlin.psi.KtExpression
import org.jetbrains.kotlin.psi.KtPsiUtil

public interface KaVisibilityCheckerMixIn : KaSessionMixIn {
    public fun isVisible(
        candidateSymbol: KaSymbolWithVisibility,
        useSiteFile: KaFileSymbol,
        receiverExpression: KtExpression? = null,
        position: PsiElement
    ): Boolean = withValidityAssertion {
        analysisSession.visibilityChecker.isVisible(candidateSymbol, useSiteFile, position, receiverExpression)
    }

    /**

        for (TaskReportModel project : projects) {
            for (String group : project.getGroups()) {
                if (isVisible(group)) {
                    for (final TaskDetails task : project.getTasksForGroup(group)) {
                        groups.put(group, mergeTasksWithSameName ? mergedTaskDetails(task) : task);
                    }

import org.jetbrains.kotlin.analysis.api.symbols.KaCallableSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KaClassOrObjectSymbol

public abstract class KaOverrideInfoProvider : KaSessionComponent() {
    public abstract fun isVisible(memberSymbol: KaCallableSymbol, classSymbol: KaClassOrObjectSymbol): Boolean
    public abstract fun getImplementationStatus(
        memberSymbol: KaCallableSymbol,
        parentClassSymbol: KaClassOrObjectSymbol

addDependenciesAndConfigurations("smokeIde")

val smokeIdeTestImplementation: Configuration by configurations
val smokeIdeTestDistributionRuntimeOnly: Configuration by configurations
val ideStarter by configurations.creating {
    isVisible = false
    isCanBeConsumed = false
}

val unzipIdeStarter by tasks.registering(ProcessResources::class) {
    from(zipTree(ideStarter.elements.map { it.single() }))
    into(layout.buildDirectory.dir("ideStarter"))

internal class KaFirVisibilityChecker(
    override val analysisSession: KaFirSession,
    override val token: KaLifetimeToken
) : KaVisibilityChecker(), KaFirSessionComponent {

    override fun isVisible(
        candidateSymbol: KaSymbolWithVisibility,
        useSiteFile: KaFileSymbol,
        position: PsiElement,
        receiverExpression: KtExpression?
    ): Boolean {

    override val analysisSession: KaFe10Session
) : KaOverrideInfoProvider(), KaFe10SessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun isVisible(memberSymbol: KaCallableSymbol, classSymbol: KaClassOrObjectSymbol): Boolean  {
        val memberDescriptor = getSymbolDescriptor(memberSymbol) as? DeclarationDescriptorWithVisibility ?: return false

}

configurations {
    create("gradleScriptsElements") {
        isVisible = false
        isCanBeResolved = false
        isCanBeConsumed = true
        attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named("start-scripts"))
        outgoing.artifact(startScripts)
    }

                ?: findFirstUseSiteElement(mainFile)
                ?: error("Cannot find use-site element to check visibility at.")

            val useSiteFileSymbol = mainFile.getFileSymbol()

            val visible = isVisible(declarationSymbol, useSiteFileSymbol, null, useSiteElement)
            """
                Declaration: ${(declarationSymbol as KaDeclarationSymbol).render(KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES)}

internal class KaFirOverrideInfoProvider(
    override val analysisSession: KaFirSession,
    override val token: KaLifetimeToken,
) : KaOverrideInfoProvider(), KaFirSessionComponent {

    override fun isVisible(memberSymbol: KaCallableSymbol, classSymbol: KaClassOrObjectSymbol): Boolean {
        require(memberSymbol is KaFirSymbol<*>)
        require(classSymbol is KaFirSymbol<*>)