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

import org.gradle.internal.configuration.problems.StructuredMessageBuilder
import org.gradle.internal.configuration.problems.propertyDescriptionFor

import kotlin.reflect.KClass


fun MutableIsolateContext.reportUnsupportedFieldType(
    unsupportedType: KClass<*>,
    action: String,
    fieldName: String,
    fieldValue: Any? = null
) {
    withPropertyTrace(PropertyKind.Field, fieldName) {

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

module {
  // CHECK-LABEL: func @passesSingleIslandOp
  func.func @passesSingleIslandOp() {
    // CHECK: _class = ["loc:@class"]
    tf_executor.graph {
      %c, %control0 = tf_executor.island wraps "tf.Const"() {value = dense<0> : tensor<i32>} : () -> tensor<i32>
      %a, %control1 = tf_executor.island wraps "tf.A"() {_class = ["loc:@class"]} : () -> (tensor<2xf32>)

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

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

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