* Create a Kotlin/Native declaration provider for [ktModule].
     *
     * Generally, only Kotlin/Native KLIB libraries can declare forward declarations.
     * For other types of [KtModule]s the provider normally shouldn't be created.
     *
     * @return a declaration provider for [ktModule] or `null` if the module cannot contain forward declarations
     */
    public abstract fun createDeclarationProvider(ktModule: KtModule): KotlinDeclarationProvider?

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

/**
 * 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 fun KaType.getTypeScope(): KaTypeScope? =
        withValidityAssertion { analysisSession.scopeProvider.getTypeScope(this) }

    /**
     * Returns a [KaTypeScope] with synthetic Java properties created for a given [KaType].
     */
    public fun KaType.getSyntheticJavaPropertiesScope(): KaTypeScope? =
        withValidityAssertion { analysisSession.scopeProvider.getSyntheticJavaPropertiesScope(this) }

    /**

- [`KT-65600`](https://youtrack.jetbrains.com/issue/KT-65600) Analysis Api: FirFile for KtCodeFragments are created and not updated on changes
- [`KT-64919`](https://youtrack.jetbrains.com/issue/KT-64919) K2 IDE: Implement KMP support for sealed class inheritors

    crossinline mergeTargets: (List<T>) -> P,
): P {
    // We should flatten providers before merging so that the merger has access to all individual providers, and also after merging because
    // composite providers may be created by the merger.
    return factory.createFlattened(factory.flatten(this).mergeOnly<_, T> { mergeTargets(it) })

    public fun annotationsOnDeclaration(declaration: KtAnnotated): Set<ClassId>
}

public interface KotlinAnnotationsResolverFactory : KotlinPlatformComponent {
    /**
     * @param searchScope A scope in which the created [KotlinAnnotationsResolver] will operate. Make sure that this scope contains all
     * the annotations that you might want to resolve.
     */

        public fun getInstance(project: Project): KotlinDeclarationProviderFactory =
            project.getService(KotlinDeclarationProviderFactory::class.java)
    }
}

/**
 * While the main declaration provider created via [createDeclarationProvider] is scope-based, there are other declaration providers which
 * are not, such as file-based declaration providers. Not all declarations provided by such declaration providers can be provided by the

    (a) under intellectual property rights (other than patent or
    trademark) Licensable by Contributor to use, reproduce, modify,
    display, perform, sublicense and distribute the Modifications
    created by such Contributor (or portions thereof), either on an
    unmodified basis, with other Modifications, as Covered Software
    and/or as part of a Larger Work; and

            //KotlinClassFileDecompiler is registered as application service so it's available for the tests run in parallel as well
            //when the decompiler is registered, for compiled class KtClsFile is created instead of ClsFileImpl
            //and KtFile doesn't return any classes in classOwner.getClasses if there is no KtFileClassProvider

            ProjectionKind.IN -> Variance.IN_VARIANCE
            ProjectionKind.INVARIANT -> Variance.INVARIANT
            ProjectionKind.STAR -> error("KtStarProjectionTypeArgument should not be directly created")
        }

        fun buildSubstitutor(substitutor: ConeSubstitutor): KaSubstitutor {
            if (substitutor == ConeSubstitutor.Empty) return KaSubstitutor.Empty(token)
            return when (substitutor) {