package org.jetbrains.kotlin.analysis.api.lifetime

public interface KaLifetimeOwner {
    public val token: KaLifetimeToken
}

public typealias KtLifetimeOwner = KaLifetimeOwner

public fun KaLifetimeOwner.isValid(): Boolean = token.isValid()

@Suppress("NOTHING_TO_INLINE")
public inline fun KaLifetimeOwner.assertIsValidAndAccessible() {
    token.assertIsValidAndAccessible()
}

 */
internal class ValidityAwareCachedValue<T>(
    private val token: KaLifetimeToken,
    init: () -> T
) : ReadOnlyProperty<Any, T> {
    private val lazyValue = lazy(LazyThreadSafetyMode.PUBLICATION, init)

    override fun getValue(thisRef: Any, property: KProperty<*>): T {
        token.assertIsValidAndAccessible()
        return lazyValue.value
    }
}

    }

    override fun substitute(substitutor: KaSubstitutor): KaFirFunctionLikeSignature<S> = withValidityAssertion {
        if (substitutor is KaSubstitutor.Empty) return@withValidityAssertion this
        require(substitutor is AbstractKaFirSubstitutor<*>)

        KaFirFunctionLikeSubstitutorBasedSignature(token, firSymbol, firSymbolBuilder, substitutor.substitutor)

                KaCompilerPluginDiagnostic0Impl(it as KtPsiSimpleDiagnostic, token)
            }
            is KtDiagnosticFactory1<*> -> KaFirDiagnostic1Creator<Any?> { // Type argument specified because of KT-55281
                KaCompilerPluginDiagnostic1Impl(
                    it as KtPsiDiagnosticWithParameters1<*>,
                    token,
                    convertArgument(it.a, this)
                )
            }

    }

    companion object {
        fun create(subScopes: List<KaScope>, token: KaLifetimeToken): KaScope =
            when (subScopes.size) {
                0 -> KaEmptyScope(token)
                1 -> subScopes.single()
                else -> KaCompositeScope(subScopes, token)
            }
    }

) : KaResolveExtensionInfoProvider(), KaFirSessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun getResolveExtensionScopeWithTopLevelDeclarations(): KaScope {
        val tools = analysisSession.extensionTools
        if (tools.isEmpty()) return KaEmptyScope(token)
        return KaFirResolveExtensionScope(analysisSession, tools)
    }

        backingArguments += KaTypeArgumentWithVariance(type, variance, type.token)
    }

    public class ByClassId(classId: ClassId, override val token: KaLifetimeToken) : KaClassTypeBuilder() {
        public val classId: ClassId by validityAsserted(classId)
    }

    public class BySymbol(symbol: KaClassLikeSymbol, override val token: KaLifetimeToken) : KaClassTypeBuilder() {

        other as KaFirPackageSymbol

        if (fqName != other.fqName) return false
        if (token != other.token) return false

        return true
    }

    override fun hashCode(): Int {
        var result = fqName.hashCode()
        result = 31 * result + token.hashCode()
        return result
    }
}

class KtPackage(
    manager: PsiManager,
    private val fqName: FqName,

    override val token: KaLifetimeToken
        get() = owner.token

    override val origin: KaSymbolOrigin
        get() = withValidityAssertion { KaSymbolOrigin.JS_DYNAMIC }

    override val psi: PsiElement?
        get() = withValidityAssertion { null }

    override val annotations: KaAnnotationList
        get() = withValidityAssertion { KaEmptyAnnotationList(token) }

    override val name: Name

@OptIn(KaAnalysisApiInternals::class, KaAnalysisNonPublicApi::class)
@Suppress("LeakingThis")
class KaFe10Session(
    val analysisContext: Fe10AnalysisContext,
    override val useSiteModule: KtModule,
    token: KaLifetimeToken,
) : KaSession(token) {

    override val smartCastProviderImpl: KaSmartCastProvider = KaFe10SmartCastProvider(this)
    override val diagnosticProviderImpl: KaDiagnosticProvider = KaFe10DiagnosticProvider(this)