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

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.kotlin.dsl

import org.gradle.api.plugins.ExtensionAware
import kotlin.reflect.KClass


/**
 * Returns the extension of the specified type.
 *
 * @param T the extension type.
 */
inline fun <reified T : Any> ExtensionAware.the(): T =
    extensions.getByType(typeOf<T>())


/**

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

}
node {
  name: "Variable/Assign"
  op: "Assign"
  input: "Variable"
  input: "Variable/initial_value"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@Variable"
      }
    }
  }
  attr {
    key: "use_locking"
    value {
      b: true
    }
  }
  attr {
    key: "validate_shape"
    value {

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