)

// Standard constants for all storage class
const (
	// Reduced redundancy storage class
	RRS = "REDUCED_REDUNDANCY"
	// Standard storage class
	STANDARD = "STANDARD"
)

// Standard constats for config info storage class
const (
	ClassStandard = "standard"
	ClassRRS      = "rrs"
	Optimize      = "optimize"
	InlineBlock   = "inline_block"

	// Reduced redundancy storage class environment variable

Ben Leggett <******@****.***> 1714764582 -0400

        fun getProperty(kClass: KClass<*>, name: String) = properties[kClass]?.get(name)
        fun getPropertyType(kClass: KClass<*>, name: String) = propertyOriginalTypes[kClass]?.get(name)
    }

    private
    fun createPreIndex(types: Iterable<KClass<*>>): PreIndex {
        val allTypesToVisit = buildSet {
            fun visit(type: KClass<*>) {

import java.io.File
import kotlin.reflect.KClass
import kotlin.reflect.full.createType

private const val CONVERT_ARGUMENT = "convertArgument"

object ArgumentsConverterGenerator {
    fun render(file: File, packageName: String) {
        val convertArgumentFunctionCallConversion = HLFunctionCallConversion(
            "$CONVERT_ARGUMENT({0}, firSymbolBuilder)",
            callType = Any::class.createType(nullable = true)
        )

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(),

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

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() {