import kotlin.reflect.KClass

class KaNonBoundToPsiErrorDiagnostic(
    override val factoryName: String,
    override val defaultMessage: String,
    override val token: KaLifetimeToken,
) : KaDiagnostic {
    override val severity: KaSeverity
        get() = withValidityAssertion { KaSeverity.ERROR }

    override val diagnosticClass: KClass<*>
        get() = KaNonBoundToPsiErrorDiagnostic::class
}

import org.gradle.internal.declarativedsl.schemaBuilder.PropertyExtractor
import org.gradle.internal.declarativedsl.schemaBuilder.TypeDiscovery
import org.gradle.internal.declarativedsl.schemaBuilder.schemaFromTypes
import kotlin.reflect.KClass


internal
interface EvaluationSchemaBuilder {
    fun registerAnalysisSchemaComponent(analysisSchemaComponent: AnalysisSchemaComponent)
    val typeDiscoveries: List<TypeDiscovery>

Lubomir I. Ivanov <******@****.***> 1716462099 +0300

import org.jetbrains.kotlin.analysis.api.symbols.pointers.KaSymbolPointer
import org.jetbrains.kotlin.name.ClassId
import kotlin.reflect.KClass

internal class KaFirClassLikeSymbolPointer<T : KaClassLikeSymbol>(
    private val classId: ClassId,
    private val expectedClass: KClass<T>,
) : KaSymbolPointer<T>() {
    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KaSession.restoreSymbol")

 */

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

import com.intellij.openapi.project.Project
import com.intellij.openapi.util.ModificationTracker
import kotlin.reflect.KClass

public abstract class KaLifetimeToken {
    public abstract val factory: KaLifetimeTokenFactory

    public abstract fun isValid(): Boolean
    public abstract fun getInvalidationReason(): String

public object KotlinAlwaysAccessibleLifetimeTokenFactory : KaLifetimeTokenFactory() {
    override val identifier: KClass<out KaLifetimeToken> = KotlinAlwaysAccessibleLifetimeToken::class

    override fun create(project: Project, modificationTracker: ModificationTracker): KaLifetimeToken =
        KotlinAlwaysAccessibleLifetimeToken(project)
}

public class KotlinAlwaysAccessibleLifetimeTokenProvider : KotlinLifetimeTokenProvider() {

                        implementation project(':library')
                    }
                }
            """.stripIndent()
        }
        file("app/src/main/${language.name}/AClass.${language.name}") << 'public class AClass { }'
    }

    String getAppCompileTask(CompiledLanguage language = CompiledLanguage.JAVA) {
        ":app:${language.compileTaskName}"
    }

import kotlin.reflect.KClass
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.http2.Http2

object OkHttpDebugLogging {
  // Keep references to loggers to prevent their configuration from being GC'd.
  private val configuredLoggers = CopyOnWriteArraySet<Logger>()

  fun enableHttp2() = enable(Http2::class)

  fun enableTaskRunner() = enable(TaskRunner::class)

  fun logHandler() =

    operator fun <U : Task> String.invoke(type: KClass<U>, configuration: U.() -> Unit): TaskProvider<U> =
        container.named(this, type, configuration)

    /**
     * Locates a task by name and type, without triggering its creation or configuration, failing if there is no such task.
     *
     * @see [TaskContainer.named]
     */
    operator fun <U : Task> String.invoke(type: KClass<U>): TaskProvider<U> =

import org.junit.Assert.assertTrue
import org.junit.Test
import kotlin.reflect.KClass


class GeneralGradleDslSchemaTest {
    @Test
    fun `general dsl schema has types discovered via action functions`() {
        val schema = schemaFrom(TopLevelReceiver::class)
        assertTrue(schema.analysisSchema.dataClassesByFqName.keys.any { it.simpleName == NestedReceiver::class.simpleName })
    }

    @Test