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

        withBuildScript("""
            plugins { id("my-plugin") }

            extensions.getByType(MyExtension::class).some("api.get")
            extensions.configure<MyExtension> { some("api.configure") }
            the<MyExtension>().some("kotlin.reified.get")
            the(MyExtension::class).some("kotlin.kclass.get")
            configure<MyExtension> { some("kotlin.configure") }
            my.some("accessor.get")

    override val identifier: KClass<out KaLifetimeToken> = KotlinReadActionConfinementLifetimeToken::class

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

public class KotlinReadActionConfinementLifetimeTokenProvider : KotlinLifetimeTokenProvider() {

annotation class A(val a: Int, val c: KClass<*>)

@A(1, Int::class)

annotation class A(val a: Int, val c: KClass<*>)

@get:A(1, Int::class)
val foo : Int

import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile
import kotlin.reflect.KClass

internal class KaFe10DiagnosticProvider(
    override val analysisSession: KaFe10Session
) : KaDiagnosticProvider(), KaFe10SessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

 *
 * @see BuildCacheConfiguration.registerBuildCacheService
 */
inline fun <reified T : BuildCache> BuildCacheConfiguration.registerBuildCacheService(buildCacheServiceFactoryType: KClass<out BuildCacheServiceFactory<in T>>) {
    registerBuildCacheService(T::class.java, buildCacheServiceFactoryType.java)
}


/**
 * Configures a remote cache with the given type.
 *

func.func @remove_class_attribute(%arg0: tensor<i1>, %arg1: tensor<f32>, %arg2: tensor<f32>) ->  tensor<f32> {
  // CHECK: "tf_device.cluster"
  // CHECK: "tf.Add"
  // CHECK-NOT: _class
  %1 = "tf_device.cluster"() ({
    %2 = "tf.Add"(%arg1, %arg2) {_class = ["loc:@while/BiasAdd_21/handle"]} : (tensor<f32>, tensor<f32>) -> tensor<f32>
    tf_device.return %2 : tensor<f32>

    private fun getFrontendIndependentKClassOf(value: Any): KClass<*> {
        fun KClass<*>.isFrontendIndependent(): Boolean {
            if (this == Any::class) return false
            val qualifiedName = qualifiedName ?: return false
            return symbolImplementationPackageNames.none { qualifiedName.startsWith("$it.") }
        }

        val valueClass = value::class

  @JvmName("reifiedTag")
  inline fun <reified T : Any> tag(): T? = tag(T::class)

  /** Returns the tag attached with [type] as a key, or null if no tag is attached with that key. */
  fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags[type])

  /**
   * Returns the tag attached with `Object.class` as a key, or null if no tag is attached with
   * that key.
   *