/**
 * A declaration provider for a given scope. It can be created via [KotlinDeclarationProviderFactory].
 *
 * It may be called frequently, so implementations should cache the results.
 */
public abstract class KotlinDeclarationProvider : KotlinComposableProvider {
    public abstract fun getClassLikeDeclarationByClassId(classId: ClassId): KtClassLikeDeclaration?

    public abstract fun getAllClassesByClassId(classId: ClassId): Collection<KtClassOrObject>

 */
public fun Project.createDeclarationProvider(scope: GlobalSearchScope, contextualModule: KtModule?): KotlinDeclarationProvider =
    KotlinDeclarationProviderFactory.getInstance(this).createDeclarationProvider(scope, contextualModule)

public fun Project.mergeDeclarationProviders(declarationProviders: List<KotlinDeclarationProvider>): KotlinDeclarationProvider =

import org.jetbrains.kotlin.utils.flatMapToNullableSet

public class KotlinCompositeDeclarationProvider private constructor(
    override val providers: List<KotlinDeclarationProvider>
) : KotlinDeclarationProvider(), KotlinCompositeProvider<KotlinDeclarationProvider> {
    override fun getClassLikeDeclarationByClassId(classId: ClassId): KtClassLikeDeclaration? {

 * with such FQN is present in the [scope] with [KotlinDeclarationProvider].
 *
 * Required for and used only in the test infrastructure.
 */
private class KotlinStandaloneAnnotationsResolver(
    private val project: Project,
    ktFiles: Collection<KtFile>,
    scope: GlobalSearchScope
) : KotlinAnnotationsResolver {
    private val declarationProvider: KotlinDeclarationProvider by lazy {

            }
        }
    }
}

class KotlinStandaloneDeclarationProviderMerger(private val project: Project) : KotlinDeclarationProviderMerger() {
    override fun merge(providers: List<KotlinDeclarationProvider>): KotlinDeclarationProvider =
        providers.mergeSpecificProviders<_, KotlinStandaloneDeclarationProvider>(KotlinCompositeDeclarationProvider.factory) { targetProviders ->

     *
     * @return a declaration provider for [ktModule] or `null` if the module cannot contain forward declarations
     */
    public abstract fun createDeclarationProvider(ktModule: KtModule): KotlinDeclarationProvider?

    public companion object {
        public fun getInstance(project: Project): KotlinForwardDeclarationProviderFactory? =
            project.getService(KotlinForwardDeclarationProviderFactory::class.java)
    }

import org.jetbrains.kotlin.analysis.project.structure.KtModule
import org.jetbrains.kotlin.analysis.project.structure.allDirectDependencies
import org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinDeclarationProvider
import org.jetbrains.kotlin.analysis.api.platform.packages.KotlinPackageProvider
import org.jetbrains.kotlin.analysis.api.platform.declarations.createDeclarationProvider

import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.*

public object KotlinEmptyDeclarationProvider : KotlinDeclarationProvider() {
    override fun getClassLikeDeclarationByClassId(classId: ClassId): KtClassLikeDeclaration? = null
    override fun getAllClassesByClassId(classId: ClassId): List<KtClassOrObject> = emptyList()

 * produce a merged provider which is more efficient than the naive sequential composite provider.
 *
 * @see org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinDeclarationProvider
 * @see org.jetbrains.kotlin.analysis.api.platform.packages.KotlinPackageProvider
 */
public interface KotlinComposableProvider

/**

 *
 * However, since symbol names providers may not be able to compute name sets per their contract, we may have to fall back to the
 * [declaration provider][org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinDeclarationProvider].
 *
 * 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.
 */