import com.intellij.psi.PsiElementFinder
import com.intellij.psi.impl.PsiElementFinderImpl
import org.jetbrains.kotlin.analysis.api.KaAnalysisNonPublicApi
import org.jetbrains.kotlin.asJava.finder.JavaElementFinder

@OptIn(KaAnalysisNonPublicApi::class)
object FirStandaloneServiceRegistrar : AnalysisApiSimpleServiceRegistrar() {
    private const val PLUGIN_RELATIVE_PATH = "/META-INF/analysis-api/analysis-api-fir-standalone-base.xml"

    override val annotations: KaAnnotationList
        get() = withValidityAssertion {
            KaFirAnnotationListForDeclaration.create(firSymbol, builder)
        }

    @OptIn(UnexpandedTypeCheck::class)
    override val upperBounds: List<KaType> by cached {
        firSymbol.resolvedBounds.mapNotNull { type ->
            if (type.isNullableAny) return@mapNotNull null

        val textRange = testServices.expressionMarkerProvider.getSelectedRange(mainFile)
        val statements = findStatements(mainFile, textRange)

        @OptIn(KaAnalysisNonPublicApi::class)
        val actualText = analyseForTest(mainFile) {
            val snapshot = getExitPointSnapshot(statements)
            stringRepresentation(snapshot)
        }

internal object KaFirReferenceResolver : ResolveCache.PolyVariantResolver<KtReference> {
    class KotlinResolveResult(element: PsiElement) : PsiElementResolveResult(element)

    @OptIn(KaAllowAnalysisOnEdt::class, KaAllowAnalysisFromWriteAction::class)
    override fun resolve(ref: KtReference, incompleteCode: Boolean): Array<ResolveResult> {

import org.jetbrains.kotlin.resolve.references.ReferenceAccess
import org.jetbrains.kotlin.types.expressions.OperatorConventions

internal class ReadWriteAccessCheckerDescriptorsImpl : ReadWriteAccessChecker {
    @OptIn(KaAllowAnalysisOnEdt::class, KaAllowAnalysisFromWriteAction::class)
    override fun readWriteAccessWithFullExpressionByResolve(assignment: KtBinaryExpression): Pair<ReferenceAccess, KtExpression> {

    }
}

/**
 * This implementation is a workaround for KT-68386, as we currently cannot register it as an application service in Standalone mode.
 */
@OptIn(KaAnalysisApiInternals::class)
private class KaAnalysisPermissionRegistryImpl : KaAnalysisPermissionRegistry {
    private val threadLocalExplicitAnalysisRestriction: ThreadLocal<KaExplicitAnalysisRestriction?> =

import org.jetbrains.kotlin.psi.KtNamedFunction
import org.jetbrains.kotlin.psi.KtTypeReference
import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType
import org.junit.jupiter.api.Assertions
import java.nio.file.Path

@OptIn(KaAnalysisApiInternals::class)
abstract class AbstractStandaloneSessionBuilderAgainstStdlibTest : TestWithDisposable() {
    protected fun doTestKotlinStdLibResolve(
        targetPlatform: TargetPlatform, platformStdlibPath: Path,

}

public typealias KtSubstitutorFactory = KaSubstitutorFactory

/**
 * Creates new [KaSubstitutor] using substitutions specified inside [build] lambda
 */
@OptIn(ExperimentalContracts::class, KaAnalysisApiInternals::class)
public inline fun KaSession.buildSubstitutor(
    build: KaSubstitutorBuilder.() -> Unit,
): KaSubstitutor {
    contract {

import org.jetbrains.kotlin.psi.KtCallExpression
import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType
import org.junit.jupiter.api.Test

@OptIn(KaAnalysisApiInternals::class)
class NativeStandaloneSessionBuilderTest {
    @Test
    fun testResolveAgainstCommonKlib() {
        lateinit var sourceModule: KtSourceModule

import org.gradle.internal.declarativedsl.language.LanguageTreeElement
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract


@OptIn(ExperimentalContracts::class)
internal
inline fun AnalysisContext.withScope(scope: AnalysisScope, action: () -> Unit) {
    contract {
        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
    }
    enterScope(scope)