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

        }
        System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", value);
    }

    @Override
    public void activate() {
        // property for root logger level or System.out redirection need to be taken into account
        MavenSlf4jSimpleFriend.init();
    }

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

import org.hamcrest.CoreMatchers.not
import org.hamcrest.MatcherAssert.assertThat

import org.junit.Test


class ProjectSchemaHashCodeTest : TestWithClassPath() {

    @Test
    fun `hash code takes configurations into account`() {

        assertThat(
            hashCodeFor(
                configurations = listOf("api")
            ),
            equalTo(
                hashCodeFor(

func (i token) String() string {
	i -= 1
	if i >= token(len(_token_index)-1) {
		return "token(" + strconv.FormatInt(int64(i+1), 10) + ")"
	}
	return _token_name[_token_index[i]:_token_index[i+1]]

                        builder.token
                    )
                }

            is ConeUnresolvedNameError -> listOf(
                KaClassTypeQualifier.KaUnresolvedClassTypeQualifier(coneDiagnostic.name, emptyList(), builder.token)
            )

            is ConeUnresolvedReferenceError -> listOf(

 */
public class KaContractParameterValue(private val backingParameterSymbol: KaParameterSymbol) : KaLifetimeOwner {
    override val token: KaLifetimeToken get() = backingParameterSymbol.token
    public val parameterSymbol: KaParameterSymbol get() = withValidityAssertion { backingParameterSymbol }

    override fun hashCode(): Int = backingParameterSymbol.hashCode()

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