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

	"LACON",
	"DACON",
	"SBRA",
	"LBRA",
	"SAUTO",
	"LAUTO",
	"ZOREG",
	"SOREG",
	"LOREG",
	"TLS_LE",
	"TLS_IE",
	"GOK",
	"ADDR",
	"SYMADDR",
	"GOTADDR",
	"TEXTSIZE",
	"ANY",
	"NCLASS",

2.1-lifecycle-refactor-class-diagram.png...

	"LACON",
	"DACON",
	"BRA",
	"BRAPIC",
	"ZOREG",
	"SOREG",
	"LOREG",
	"XOREG",
	"FPSCR",
	"LR",
	"CTR",
	"ANY",
	"GOK",
	"ADDR",
	"TLS_LE",
	"TLS_IE",
	"TEXTSIZE",
	"NCLASS",

import org.jetbrains.kotlin.psi.KtElement
import java.util.concurrent.ConcurrentMap
import kotlin.reflect.KClass

/**
 * [KaFirSessionProvider] keeps [KaFirSession]s in a cache, which are actively invalidated with their associated underlying
 * [LLFirSession][org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession]s.
 */
internal class KaFirSessionProvider(project: Project) : KaBaseSessionProvider(project) {

    private
    fun configureLambdaTypeFor(configuredType: KType) =
        Function1::class.createType(
            listOf(
                KTypeProjection.contravariant(configuredType),
                KTypeProjection(KVariance.INVARIANT, Unit::class.createType())
            )
        )
}


class CompositeConfigureLambdas(internal val implementations: List<ConfigureLambdaHandler>) : ConfigureLambdaHandler {

     */
    public static <T> Transformer<Class<T>, T> type() {
        return new Transformer<Class<T>, T>() {
            @Override
            public Class<T> transform(T original) {
                @SuppressWarnings("unchecked")
                Class<T> aClass = (Class<T>) original.getClass();
                return aClass;
            }
        };
    }

            taskAssertion("cabin", Copy::class),
            taskAssertion("castle", Task::class, equalTo("null!")),
            taskAssertion("valley", Copy::class, equalTo("null!")),
            taskAssertion("hill", Copy::class, equalTo("null!")),
            taskAssertion("bat"),
            taskAssertion("pipistrelle", Copy::class, equalTo("nullABC")),
            taskAssertion("yate"),
            taskAssertion("quartern", Copy::class),