val xProperty = 10
    fun xFunction() = 11
    typealias xTypealias = 10
    class XClass<XT> {}
    enum class XEnum {
        X_ENUM_ENTRY;

        fun xEnumMember(){}
    }

    class Y <YT> {
        val yProperty = 10
        fun yFunction() = 11
        typealias yTypealias = 10
        class YClass<YTT> {}
        enum class YEnum {
            Y_ENUM_ENTRY;

            fun yEnumMember(){}

        }

        sourceWithFileSuffixForProject("java", "impl", "class F {}")
        sourceWithFileSuffixForProject("groovy", "impl", "class G {}")
        run ":impl:compileGroovy"

        when:
        aClass.text = "class A { void m1() {}; void m2() {}; }"
        eClass.text = "class E { boolean isCacheEnabled = D.cache; garbage }"

I can eat glass and it doesn't hurt me....

)

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

                    subject.collectionOfClasses(listOf(Number::class, Int::class))

                    subject.methodParameterizedClass(type = Int::class)
                    subject.covariantMethodParameterizedClass(type = Int::class)
                    subject.methodParameterizedCovariantClass(type = Int::class)
                    subject.methodParameterizedContravariantClass(type = Int::class)

  func.return
}

// -----

// Test case: Invalid multiple location information in a class attribute on VariableV2 op.

func.func @f() {
  // expected-error @+1 {{'tf.VariableV2' op expects only one named location in '_class' attribute, but got ["loc:@v1", "loc:@v2"]}}
  %val0 = "tf.VariableV2"() {_class = ["loc:@v1", "loc:@v2"], container = "", device = "", shape = #tf_type.shape<96>, shared_name = ""} : () -> tensor<96x!tf_type.f32ref>

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

// MODULE_KIND: LibraryBinary
// FILE: issue/pack/RowIcon.java
package issue.pack;

public class RowIcon {
    public static class RClass {}
}

// MODULE: main(lib)
// FILE: usage.kt
package usage

fun testJavaNestedClass(alignment: issue.pack.RowIcon.RClass) {
}

fun checkIt() {
    testJavaNestedClass(issue.pack.RowIcon.RClass())