import org.jetbrains.kotlin.analysis.api.symbols.KaClassifierSymbol
import org.jetbrains.kotlin.analysis.api.symbols.nameOrAnonymous
import org.jetbrains.kotlin.name.Name

public sealed interface KaClassTypeQualifier : KaLifetimeOwner {
    public val name: Name
    public val typeArguments: List<KaTypeProjection>

    public class KaResolvedClassTypeQualifier(

import org.gradle.internal.declarativedsl.evaluator.checks.DocumentCheckFailure
import org.gradle.internal.declarativedsl.language.SingleFailureResult
import org.gradle.internal.declarativedsl.objectGraph.AssignmentTraceElement


sealed interface EvaluationResult<out R : StepResult> {
    class Evaluated<R : StepResult>(val stepResult: R) : EvaluationResult<R>

    class NotEvaluated<R : StepResult>(
        val stageFailures: List<StageFailure>,

## Contributing code

Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html) before sending patches.

Unless otherwise noted, the Go source files are distributed under

        val property: Property<String>
    }

    @Test
    fun `can serialize Java lambda with Gradle model`() {
        val stored = newInstance<Dsl>().apply {
            property.set("42")
        }
        val loaded = valueCarriedBy(roundtripOf(isolatedActionLambdaWith(stored)))
        assertThat(
            loaded.property.get(),
            equalTo("42")
        )
    }

    private

        when (fragment) {
            is Fragment.Text -> fragment.text
            is Fragment.Reference -> "'${fragment.name}'"
        }
    }

    sealed class Fragment {

        data class Text(val text: String) : Fragment()

        data class Reference(val name: String) : Fragment()
    }

    companion object {

import org.jetbrains.kotlin.analysis.api.base.KaConstantValue
import org.jetbrains.kotlin.psi.KtExpression

/**
 * Value representing some property or variable initializer
 */
public sealed class KaInitializerValue {
    /**
     * [com.intellij.psi.PsiElement] of initializer. May be null if property/variable came from non-source file.
     */
    public abstract val initializerPsi: KtExpression?
}

/**

sealed class Foo {
    object A : Foo()
    class B(val i: Int) : Foo()
}

fun test(e: Foo) {
    <caret>when (e) {
        else -> {}
    }

sealed class Foo {
    object A : Foo()
    class B(val i: Int) : Foo()
}

fun test(e: Foo) {
    <caret>when (e) {
        Foo.A -> {}
    }

import org.jetbrains.kotlin.fir.types.isNullableAny

/**
 * [KaFirTypeParameterSymbolBase] provides shared implementations for [KaFirTypeParameterSymbol] and [KaFirPsiJavaTypeParameterSymbol].
 */
internal sealed class KaFirTypeParameterSymbolBase : KaTypeParameterSymbol(), KaFirSymbol<FirTypeParameterSymbol> {
    override val annotations: KaAnnotationList
        get() = withValidityAssertion {

interface HostServiceProvider {
    fun <T> service(serviceType: Class<T>): T
}


inline fun <reified T : Any> HostServiceProvider.service(): T =
    service(T::class.java)


sealed class IsolateOwners : IsolateOwner {

    class OwnerTask(
        override val delegate: Task,
        // TODO:configuration-cache - consider immutability
        var allowTaskReferences: Boolean = false