# UNKNOWN: /docs/
/docs/analysis/ "Kotlin IDE Analysis Core"
/docs/code_authoring_and_core_review.md Vsevolod.Tolstopyato Simon.Ogorodnik

/generators/analysis-api-generator/ "Kotlin IDE Analysis Core"
/generators/builtins/ A.Qurbonzoda Vsevolod.Tolstopyato Ilya.Gorbunov Filipp.Zhinkin
/generators/evaluate/ "Kotlin Compiler Core"
/generators/ide-iml-to-gradle-generator/ "Kotlin Build Infrastructure"

            // Support differing result data. Using `testPrefix` takes away the ability for different kinds of tests (such as IDE vs.
            // 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.

     * Also, might multiple targets in a case of ambiguity or multiple targets for a [symbol]
     *
     * Returned [PsiElement] will be used as a navigation target inside the IDE.
     */
    public abstract fun KaSession.getNavigationTargets(element: KtElement): Collection<PsiElement>
}

 * 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).
 *
 * However, since symbol names providers may not be able to compute name sets per their contract, we may have to fall back to the

    private fun KtClassOrObject.toFirSymbol(classId: ClassId, ktModule: KtModule): FirClassLikeSymbol<*>? {
        // Using a resolve session/source-preferred session will cause class stubs from binary libraries to be AST-loaded in IDE mode tests,
        // which results in an exception since we don't have a decompiler for them. See KT-64898, KT-64899, and KT-64900. If not for these
        // issues, we would be able to use `analyze` instead of custom session logic.

    return try {
        action()
    } finally {
        permissionRegistry.explicitAnalysisRestriction = null
    }
}

@RequiresOptIn("Analysis should not be allowed to be run from the EDT, as otherwise it may cause IDE freezes.")
public annotation class KaAllowAnalysisOnEdt

/**
 * Allows [analyze][org.jetbrains.kotlin.analysis.api.analyze] to be called on the EDT in the given [action], which is normally not allowed.
 *

import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestServiceRegistrar
import org.jetbrains.kotlin.test.services.TestServices

/**
 * An extension to [AnalysisApiBaseTestServiceRegistrar] for IDE mode tests. Standalone mode tests should remove this service registrar from
 * the list of [serviceRegistrars][org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator.serviceRegistrars].
 *

import com.intellij.util.messages.MessageBus

/**
 * Provides the [project]'s [MessageBus] as the Analysis API message bus. This is the default implementation for both the standalone and the
 * IDE Analysis API.
 *
 * [KotlinMessageBusProvider] exists so that this default may change in the future without breaking the API. Hence, it should not be assumed

import com.intellij.core.CoreApplicationEnvironment
import com.intellij.ide.plugins.ContainerDescriptor
import com.intellij.ide.plugins.DataLoader
import com.intellij.ide.plugins.PluginXmlPathResolver
import com.intellij.ide.plugins.RawPluginDescriptor
import com.intellij.ide.plugins.ReadModuleContext
import com.intellij.mock.MockApplication
import com.intellij.mock.MockComponentManager

/**
 * The IDE can run analysis before calling CodeGen API. We found some cases that generate different FIR expressions between analysis
 * and CodeGen API. For example, AA generates `FirLiteralExpression` for an initializer of a property, while CodeGen API generates
 * `FirLazyExpression`. The difference can result in crashes. This class helps us test the IDE situation that first calls analysis
 * APIs and conducts CodeGen.