KaContractReturnsSpecificValueEffectDeclaration(KaContractConstantValue(KaContractConstantType.NULL, analysisContext.token))
            ConstantReference.NOT_NULL -> KaContractReturnsNotNullEffectDeclaration(analysisContext.token)
            ConstantReference.WILDCARD -> KaContractReturnsSuccessfullyEffectDeclaration(analysisContext.token)
            is BooleanConstantReference -> KaContractReturnsSpecificValueEffectDeclaration(

 * }
 * ```
 */
public class KaImplicitReceiverValue(
    symbol: KaSymbol,
    type: KaType,
) : KaReceiverValue() {
    private val backingSymbol: KaSymbol = symbol

    override val token: KaLifetimeToken get() = backingSymbol.token
    public val symbol: KaSymbol get() = withValidityAssertion { backingSymbol }
    override val type: KaType by validityAsserted(type)
}

/**
 * A smart-casted receiver. For example
 * ```

                KaContractReturnsSpecificValueEffectDeclaration(KaContractConstantValue(KaContractConstantType.NULL, builder.token))
            ConeContractConstantValues.NOT_NULL -> KaContractReturnsNotNullEffectDeclaration(builder.token)
            ConeContractConstantValues.WILDCARD -> KaContractReturnsSuccessfullyEffectDeclaration(builder.token)
            is KtBooleanConstantReference -> KaContractReturnsSpecificValueEffectDeclaration(

    private val backingArgument: KaContractParameterValue,
    private val backingType: KaType,
    private val backingIsNegated: Boolean
) : KaContractBooleanExpression {
    override val token: KaLifetimeToken get() = backingType.token
    public val argument: KaContractParameterValue get() = withValidityAssertion { backingArgument }
    public val type: KaType get() = withValidityAssertion { backingType }

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
    }
}

                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)
                )
            }

     *
     * TODO (KT-68186): Due to KT-68386, the implementation currently doesn't apply the default to
     * [KaAnalysisPermissionRegistry][org.jetbrains.kotlin.analysis.api.permissions.KaAnalysisPermissionRegistry], but it is taken into
     * account by [KaAnalysisPermissionChecker].
     */
    public val defaultIsAnalysisAllowedOnEdt: Boolean

    /**

) : 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)
    }

                }

                return ApplicableAsExtensionCallable(substitutor, receiverCastRequired, token)
            }

            return implicitReceivers.firstNotNullOfOrNull(::processReceiver)
                ?: processReceiver(null)
                ?: NonApplicable(token)
        }
    }