import java.lang.reflect.Type;

class TypeStringFormatter {

    static String format(Type type) {
        if (type instanceof Class) {
            Class<?> aClass = (Class) type;
            Class<?> enclosingClass = aClass.getEnclosingClass();
            if (enclosingClass != null) {
                return format(enclosingClass) + "$" + aClass.getSimpleName();
            } else {

 * based on the static type of the provider.
 */
class RegisteringDomainObjectDelegateProviderWithType<T, U : Any>
private constructor(
    internal val delegateProvider: T,
    internal val type: KClass<U>
) {
    companion object {
        fun <T, U : Any> of(delegateProvider: T, type: KClass<U>) =
            RegisteringDomainObjectDelegateProviderWithType(delegateProvider, type)
    }

import org.jetbrains.kotlin.analysis.api.symbols.markers.KaSymbolKind
import kotlin.reflect.KClass

public class CanNotCreateSymbolPointerForLocalLibraryDeclarationException(identifier: String) :
    IllegalStateException("Could not create a symbol pointer for local symbol $identifier") {
    public constructor(klass: KClass<*>) : this(klass.java.simpleName)
}

public class UnsupportedSymbolKind(identifier: String, kind: KaSymbolKind) : IllegalStateException(

import kotlin.reflect.KCallable
import kotlin.reflect.KClass
import kotlin.reflect.KFunction
import kotlin.reflect.KVisibility


fun schemaFromTypes(
    topLevelReceiver: KClass<*>,
    types: Iterable<KClass<*>>,
    externalFunctions: List<KFunction<*>> = emptyList(),
    externalObjects: Map<FqName, KClass<*>> = emptyMap(),
    defaultImports: List<FqName> = emptyList(),

        override fun memberFunctions(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<SchemaMemberFunction> =
            if (kClass == MyReceiver::class) {
                listOf(
                    DefaultDataMemberFunction(
                        MyReceiver::class.toDataTypeRef(),
                        "configureCustomInstance",
                        emptyList(),

        checkScriptRecognizedByLegacy(KotlinInitScript::class, ScriptType.INIT)
    }

    private
    fun checkScriptRecognizedBy(scriptParserClass: KClass<*>, supportedScriptType: ScriptType) {
        assertScriptFilePatternMatches(filePathPatternFrom(scriptParserClass), supportedScriptType)
    }

    private
    fun checkScriptRecognizedByLegacy(scriptParserClass: KClass<*>, supportedScriptType: ScriptType) {

    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@Placeholder"
      }
    }
  }
}
node {
  name: "cond/MatMul/Switch_1"
  op: "Switch"
  input: "Const"
  input: "cond/pred_id"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@Const"

            Base::class,
            Core::class
        )
    }

    private
    inline fun <reified T> assertAccessorTypePrecedenceOf(vararg types: KClass<*>) {
        assertTypeSequence(
            T::class.java.accessorTypePrecedenceSequence(),
            *types
        )
    }

    private
    fun assertTypeSequence(sequence: Sequence<Class<*>>, vararg types: KClass<*>) {
        assertThat(

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>

 */

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