Cleanup deprecated symbol usages in testData

compiler/testData/codegen/boxWithStdlib/reflection/annotations/annotationRetentionAnnotation.kt

@@ -6,7 +6,7 @@ annotation class Anno
 fun box(): String {
     val a = Anno::class.annotations
 
-    if (a.size() != 1) return "Fail 1: $a"
+    if (a.size != 1) return "Fail 1: $a"
     val ann = a.single() as? Retention ?: return "Fail 2: ${a.single()}"
     assertEquals(AnnotationRetention.RUNTIME, ann.value)
 

compiler/testData/codegen/boxWithStdlib/reflection/annotations/retentions.kt

@@ -13,6 +13,6 @@ annotation class RuntimeAnno
 @BinaryAnno
 @RuntimeAnno
 fun box(): String {
-    assertEquals(listOf(javaClass<RuntimeAnno>()), ::box.annotations.map { it.annotationType() })
+    assertEquals(listOf(RuntimeAnno::class.java), ::box.annotations.map { it.annotationClass.java })
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/annotations/simpleConstructorAnnotation.kt

@@ -7,7 +7,7 @@ class C @Primary constructor() {
 }
 
 fun box(): String {
-    val ans = C::class.constructors.map { it.annotations.single().annotationType().simpleName }.sorted()
+    val ans = C::class.constructors.map { it.annotations.single().annotationClass.java.simpleName }.sorted()
     if (ans != listOf("Primary", "Secondary")) return "Fail: $ans"
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/call/exceptionHappened.kt

@@ -10,7 +10,7 @@ fun box(): String {
     try {
         ::fail.call("OK")
     } catch (e: InvocationTargetException) {
-        return e.getTargetException().getMessage().toString()
+        return e.getTargetException().message.toString()
     }
 
     return "Fail: no exception was thrown"

compiler/testData/codegen/boxWithStdlib/reflection/call/incorrectNumberOfArguments.kt

@@ -19,8 +19,8 @@ object O {
 }
 
 fun check(callable: KCallable<*>, vararg args: Any?) {
-    val expected = callable.parameters.size()
-    val actual = args.size()
+    val expected = callable.parameters.size
+    val actual = args.size
 
     if (expected == actual) {
         throw AssertionError("Bad test case: expected and actual number of arguments should differ (was $expected vs $actual)")
@@ -32,10 +32,10 @@ fun check(callable: KCallable<*>, vararg args: Any?) {
         callable.call(*args)
         throw AssertionError("Fail: an IllegalArgumentException should have been thrown")
     } catch (e: IllegalArgumentException) {
-        if (e.getMessage() != expectedExceptionMessage) {
+        if (e.message != expectedExceptionMessage) {
             // This most probably means that we don't check number of passed arguments in reflection
             // and the default check from Java reflection yields an IllegalArgumentException, but with a not that helpful message
-            throw AssertionError("Fail: an exception with an unrecognized message was thrown: \"${e.getMessage()}\"" +
+            throw AssertionError("Fail: an exception with an unrecognized message was thrown: \"${e.message}\"" +
                                  "\nExpected message was: $expectedExceptionMessage")
         }
     }

compiler/testData/codegen/boxWithStdlib/reflection/call/simpleTopLevelFunctions.kt

@@ -1,4 +1,4 @@
-fun String.foo(): Int = length()
+fun String.foo(): Int = length
 
 var state = "Fail"
 

compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/reifiedTypeClassLiteral.kt

@@ -19,10 +19,10 @@ fun box(): String {
     assertEquals("Error", simpleName<Error>())
     assertEquals("Klass, Other", twoReifiedParams<Klass, Other>())
 
-    assertEquals(javaClass<String>(), myJavaClass<String>())
-    assertEquals(javaClass<IntArray>(), myJavaClass<IntArray>())
-    assertEquals(javaClass<Klass>(), myJavaClass<Klass>())
-    assertEquals(javaClass<Error>(), myJavaClass<Error>())
+    assertEquals(String::class.java, myJavaClass<String>())
+    assertEquals(IntArray::class.java, myJavaClass<IntArray>())
+    assertEquals(Klass::class.java, myJavaClass<Klass>())
+    assertEquals(Error::class.java, myJavaClass<Error>())
 
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/classes/defaultType.kt

@@ -12,10 +12,10 @@ fun simple() = Simple()
 fun genericIntString() = Generic<Int, String>()
 
 fun box(): String {
-    assertEquals(javaClass<Simple>(), Simple::class.defaultType.javaType)
+    assertEquals(Simple::class.java, Simple::class.defaultType.javaType)
     assertEquals(::simple.returnType, Simple::class.defaultType)
 
-    assertEquals(javaClass<Generic<*, *>>(), Generic::class.defaultType.javaType)
+    assertEquals(Generic::class.java, Generic::class.defaultType.javaType)
     assertEquals(Generic<*, *>::thiz.returnType, Generic::class.defaultType)
 
     // Generic<Int, String> != Generic<K, V>

compiler/testData/codegen/boxWithStdlib/reflection/constructors/simpleGetConstructors.kt

@@ -4,7 +4,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 open class A private constructor(x: Int) {
-    public constructor(s: String): this(s.length())
+    public constructor(s: String): this(s.length)
     constructor(): this("")
 }
 
@@ -16,14 +16,14 @@ class C {
 }
 
 fun box(): String {
-    assertEquals(3, A::class.constructors.size())
-    assertEquals(1, B::class.constructors.size())
+    assertEquals(3, A::class.constructors.size)
+    assertEquals(1, B::class.constructors.size)
 
     assertTrue(Collections.disjoint(A::class.members, A::class.constructors))
     assertTrue(Collections.disjoint(B::class.members, B::class.constructors))
 
-    assertEquals(1, C.Nested::class.constructors.size())
-    assertEquals(1, C.Inner::class.constructors.size())
+    assertEquals(1, C.Nested::class.constructors.size)
+    assertEquals(1, C.Inner::class.constructors.size)
 
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/enclosing/localClassInTopLevelFunction.kt

@@ -3,7 +3,7 @@
 fun box(): String {
     class C
 
-    val name = javaClass<C>().getSimpleName()
+    val name = C::class.java.getSimpleName()
     if (name != "box\$C") return "Fail: $name"
 
     return "OK"

compiler/testData/codegen/boxWithStdlib/reflection/genericSignature/kt5112.kt

@@ -20,7 +20,7 @@ fun box(): String {
     val genericTypeInClassObject = ErrorsJvmTrait.javaClass.getDeclaredField("param").getGenericType()
     if (genericTypeInClassObject.toString() != "test.G<java.lang.String>") return "fail1: $genericTypeInClassObject"
 
-    val genericTypeInClass = javaClass<ErrorsJvmClass>().getField("param").getGenericType()
+    val genericTypeInClass = ErrorsJvmClass::class.java.getField("param").getGenericType()
     if (genericTypeInClass.toString() != "test.G<java.lang.String>") return "fail1: genericTypeInClass"
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/genericSignature/kt6106.kt

@@ -13,10 +13,10 @@ class A {
 }
 
 fun box(): String {
-    val method = javaClass<A>().getDeclaredMethod("a", javaClass<B>())
+    val method = A::class.java.getDeclaredMethod("a", B::class.java)
     val genericParameterTypes = method.getGenericParameterTypes()
 
-    if (genericParameterTypes.size() != 1) return "Wrong number of generic parameters"
+    if (genericParameterTypes.size != 1) return "Wrong number of generic parameters"
 
     if (genericParameterTypes[0].toString() != "T") return "Wrong parameter type ${genericParameterTypes[0].toString()}"
 

compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/array.kt

@@ -9,7 +9,7 @@ class K
 @Ann(arrayOf(O::class, K::class)) class MyClass
 
 fun box(): String {
-    val args = javaClass<MyClass>().getAnnotation(javaClass<Ann>()).args
+    val args = MyClass::class.java.getAnnotation(Ann::class.java).args
     val argName1 = args[0].simpleName ?: "fail 1"
     val argName2 = args[1].simpleName ?: "fail 2"
     return argName1 + argName2

compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/basic.kt

@@ -8,6 +8,6 @@ class OK
 @Ann(OK::class) class MyClass
 
 fun box(): String {
-    val argName = javaClass<MyClass>().getAnnotation(javaClass<Ann>()).arg.simpleName ?: "fail 1"
+    val argName = MyClass::class.java.getAnnotation(Ann::class.java).arg.simpleName ?: "fail 1"
     return argName
 }

compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/checkcast.kt

@@ -2,7 +2,7 @@ import kotlin.reflect.KClass
 
 fun box(): String {
     try {
-        javaClass<String>() as KClass<String>
+        String::class.java as KClass<String>
     } catch (e: Exception) {
         return "OK"
     }

compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/vararg.kt

@@ -9,7 +9,7 @@ class K
 @Ann(O::class, K::class) class MyClass
 
 fun box(): String {
-    val args = javaClass<MyClass>().getAnnotation(javaClass<Ann>()).args
+    val args = MyClass::class.java.getAnnotation(Ann::class.java).args
     val argName1 = args[0].simpleName ?: "fail 1"
     val argName2 = args[1].simpleName ?: "fail 2"
     return argName1 + argName2

compiler/testData/codegen/boxWithStdlib/reflection/mapping/extensionProperty.kt

@@ -15,8 +15,8 @@ fun box(): String {
     val getter = p.javaGetter!!
     val setter = p.javaSetter!!
 
-    assertEquals(getter, Class.forName("ExtensionPropertyKt").getMethod("getExt", javaClass<K>()))
-    assertEquals(setter, Class.forName("ExtensionPropertyKt").getMethod("setExt", javaClass<K>(), javaClass<Double>()))
+    assertEquals(getter, Class.forName("ExtensionPropertyKt").getMethod("getExt", K::class.java))
+    assertEquals(setter, Class.forName("ExtensionPropertyKt").getMethod("setExt", K::class.java, Double::class.java))
 
     val k = K(42L)
     assert(getter.invoke(null, k) == 42.0) { "Fail k getter" }

compiler/testData/codegen/boxWithStdlib/reflection/mapping/functions.kt

@@ -2,10 +2,10 @@ import kotlin.reflect.*
 import kotlin.reflect.jvm.*
 
 class K {
-    fun foo(s: String): Int = s.length()
+    fun foo(s: String): Int = s.length
 }
-fun bar(s: String): Int = s.length()
-fun String.baz(): Int = this.length()
+fun bar(s: String): Int = s.length
+fun String.baz(): Int = this.length
 
 fun check(f: KFunction<Int>) {
     assert(f.javaConstructor == null) { "Fail f constructor" }

compiler/testData/codegen/boxWithStdlib/reflection/mapping/mappedClassIsEqualToClassLiteral.kt

@@ -1,7 +1,7 @@
 class A
 
 fun box(): String {
-    val a1 = javaClass<A>().kotlin
+    val a1 = A::class.java.kotlin
     val a2 = A::class
 
     if (a1 != a2) return "Fail equals"

compiler/testData/codegen/boxWithStdlib/reflection/mapping/memberProperty.kt

@@ -11,8 +11,8 @@ fun box(): String {
     val getter = p.javaGetter!!
     val setter = p.javaSetter!!
 
-    assertEquals(getter, javaClass<K>().getMethod("getValue"))
-    assertEquals(setter, javaClass<K>().getMethod("setValue", javaClass<Long>()))
+    assertEquals(getter, K::class.java.getMethod("getValue"))
+    assertEquals(setter, K::class.java.getMethod("setValue", Long::class.java))
 
     val k = K(42L)
     assert(getter.invoke(k) == 42L) { "Fail k getter" }

compiler/testData/codegen/boxWithStdlib/reflection/mapping/platformStatic/companionObjectFunction.kt

@@ -5,7 +5,7 @@ import kotlin.test.*
 
 class C {
     companion object {
-        @static fun foo(s: String): Int = s.length()
+        @static fun foo(s: String): Int = s.length
     }
 }
 
@@ -19,12 +19,12 @@ fun box(): String {
     assertEquals(3, k.call(C, "def"))
 
 
-    val staticMethod = javaClass<C>().getDeclaredMethod("foo", javaClass<String>())
+    val staticMethod = C::class.java.getDeclaredMethod("foo", String::class.java)
     val k2 = staticMethod.kotlinFunction ?:
              return "Fail: no Kotlin function found for static bridge for @JvmStatic method in companion object C::foo"
     assertEquals(3, k2.call(C, "ghi"))
 
-    assertFailsWith(javaClass<NullPointerException>()) { k2.call(null, "")!! }
+    assertFailsWith(NullPointerException::class.java) { k2.call(null, "")!! }
 
     val j2 = k2.javaMethod
     assertEquals(j, j2)

compiler/testData/codegen/boxWithStdlib/reflection/mapping/platformStatic/objectFunction.kt

@@ -4,7 +4,7 @@ import kotlin.reflect.jvm.*
 import kotlin.test.assertEquals
 
 object O {
-    @static fun foo(s: String): Int = s.length()
+    @static fun foo(s: String): Int = s.length
 }
 
 fun box(): String {

compiler/testData/codegen/boxWithStdlib/reflection/mapping/syntheticFields.kt

@@ -5,7 +5,7 @@ enum class A {
 }
 
 fun box(): String {
-    for (field in javaClass<A>().getDeclaredFields()) {
+    for (field in A::class.java.getDeclaredFields()) {
         val prop = field.kotlin
         if (prop != null) return "Fail, property found: $prop"
     }

compiler/testData/codegen/boxWithStdlib/reflection/mapping/topLevelProperty.kt

@@ -15,7 +15,7 @@ fun box(): String {
     val setter = p.javaSetter!!
 
     assertEquals(getter, Class.forName("TopLevelPropertyKt").getMethod("getTopLevel"))
-    assertEquals(setter, Class.forName("TopLevelPropertyKt").getMethod("setTopLevel", javaClass<String>()))
+    assertEquals(setter, Class.forName("TopLevelPropertyKt").getMethod("setTopLevel", String::class.java))
 
     assert(getter.invoke(null) == "123") { "Fail k getter" }
     setter.invoke(null, "456")

compiler/testData/codegen/boxWithStdlib/reflection/mapping/types/array.kt

@@ -14,9 +14,9 @@ class A<T> {
 }
 
 fun box(): String {
-    assertEquals(javaClass<Array<String>>(), ::foo.parameters[0].type.javaType)
-    assertEquals(javaClass<Array<Int>>(), ::foo.parameters[1].type.javaType)
-    assertEquals(javaClass<Array<Array<Any>>>(), ::foo.parameters[2].type.javaType)
+    assertEquals(Array<String>::class.java, ::foo.parameters[0].type.javaType)
+    assertEquals(Array<Int>::class.java, ::foo.parameters[1].type.javaType)
+    assertEquals(Array<Array<Any>>::class.java, ::foo.parameters[2].type.javaType)
 
     val g = ::bar.returnType.javaType
     if (g !is GenericArrayType || g.genericComponentType !is ParameterizedType)

compiler/testData/codegen/boxWithStdlib/reflection/mapping/types/constructors.kt

@@ -8,13 +8,13 @@ class A(d: Double, s: String, parent: A?) {
 }
 
 fun box(): String {
-    assertEquals(listOf(java.lang.Double.TYPE, javaClass<String>(), javaClass<A>()), ::A.parameters.map { it.type.javaType })
-    assertEquals(listOf(javaClass<A>()), A::Nested.parameters.map { it.type.javaType })
-    assertEquals(listOf(javaClass<A>(), javaClass<A.Nested>()), A::Inner.parameters.map { it.type.javaType })
+    assertEquals(listOf(java.lang.Double.TYPE, String::class.java, A::class.java), ::A.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java), A::Nested.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java, A.Nested::class.java), A::Inner.parameters.map { it.type.javaType })
 
-    assertEquals(javaClass<A>(), ::A.returnType.javaType)
-    assertEquals(javaClass<A.Nested>(), A::Nested.returnType.javaType)
-    assertEquals(javaClass<A.Inner>(), A::Inner.returnType.javaType)
+    assertEquals(A::class.java, ::A.returnType.javaType)
+    assertEquals(A.Nested::class.java, A::Nested.returnType.javaType)
+    assertEquals(A.Inner::class.java, A::Inner.returnType.javaType)
 
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/mapping/types/memberFunctions.kt

@@ -12,12 +12,12 @@ object O {
 
 fun box(): String {
     val foo = A::foo
-    assertEquals(listOf(javaClass<A>(), javaClass<java.lang.Long>()), foo.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java, java.lang.Long::class.java), foo.parameters.map { it.type.javaType })
     assertEquals(java.lang.Long.TYPE, foo.returnType.javaType)
 
     val bar = O::class.members.single { it.name == "bar" }
-    assertEquals(listOf(javaClass<O>(), javaClass<A>()), bar.parameters.map { it.type.javaType })
-    assertEquals(javaClass<String>(), bar.returnType.javaType)
+    assertEquals(listOf(O::class.java, A::class.java), bar.parameters.map { it.type.javaType })
+    assertEquals(String::class.java, bar.returnType.javaType)
 
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/mapping/types/overrideAnyWithPrimitive.kt

@@ -11,10 +11,10 @@ class A : I {
 }
 
 fun box(): String {
-    assertEquals(javaClass<Integer>(), A::foo.returnType.javaType)
+    assertEquals(Integer::class.java, A::foo.returnType.javaType)
     assertNotEquals(Integer.TYPE, A::foo.returnType.javaType)
 
-    assertNotEquals(javaClass<Integer>(), A::bar.returnType.javaType)
+    assertNotEquals(Integer::class.java, A::bar.returnType.javaType)
     assertEquals(Integer.TYPE, A::bar.returnType.javaType)
 
     assertEquals(java.lang.Long.TYPE, A::bar.parameters.last().type.javaType)

compiler/testData/codegen/boxWithStdlib/reflection/mapping/types/propertyAccessors.kt

@@ -11,14 +11,14 @@ object O {
 
 fun box(): String {
     val foo = A::class.members.single { it.name == "foo" } as KMutableProperty<*>
-    assertEquals(listOf(javaClass<A>()), foo.parameters.map { it.type.javaType })
-    assertEquals(listOf(javaClass<A>()), foo.getter.parameters.map { it.type.javaType })
-    assertEquals(listOf(javaClass<A>(), javaClass<String>()), foo.setter.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java), foo.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java), foo.getter.parameters.map { it.type.javaType })
+    assertEquals(listOf(A::class.java, String::class.java), foo.setter.parameters.map { it.type.javaType })
 
     val bar = O::class.members.single { it.name == "bar" } as KMutableProperty<*>
-    assertEquals(listOf(javaClass<O>()), bar.parameters.map { it.type.javaType })
-    assertEquals(listOf(javaClass<O>()), bar.getter.parameters.map { it.type.javaType })
-    assertEquals(listOf(javaClass<O>(), javaClass<String>()), bar.setter.parameters.map { it.type.javaType })
+    assertEquals(listOf(O::class.java), bar.parameters.map { it.type.javaType })
+    assertEquals(listOf(O::class.java), bar.getter.parameters.map { it.type.javaType })
+    assertEquals(listOf(O::class.java, String::class.java), bar.setter.parameters.map { it.type.javaType })
 
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/mapping/types/topLevelFunctions.kt

@@ -1,15 +1,15 @@
 import kotlin.reflect.jvm.*
 import kotlin.test.assertEquals
 
-fun free(s: String): Int = s.length()
+fun free(s: String): Int = s.length
 
 fun Any.extension() {}
 
 fun box(): String {
     assertEquals(java.lang.Integer.TYPE, ::free.returnType.javaType)
-    assertEquals(javaClass<String>(), ::free.parameters.single().type.javaType)
+    assertEquals(String::class.java, ::free.parameters.single().type.javaType)
 
-    assertEquals(javaClass<Any>(), Any::extension.parameters.single().type.javaType)
+    assertEquals(Any::class.java, Any::extension.parameters.single().type.javaType)
 
     return "OK"
 }

compiler/testData/codegen/boxWithStdlib/reflection/mapping/types/unit.kt

@@ -6,15 +6,15 @@ fun foo(unitParam: Unit, nullableUnitParam: Unit?): Unit {}
 var bar: Unit = Unit
 
 fun box(): String {
-    assert(javaClass<Unit>() != java.lang.Void.TYPE)
+    assert(Unit::class.java != java.lang.Void.TYPE)
 
-    assertEquals(javaClass<Unit>(), ::foo.parameters[0].type.javaType)
-    assertEquals(javaClass<Unit>(), ::foo.parameters[1].type.javaType)
+    assertEquals(Unit::class.java, ::foo.parameters[0].type.javaType)
+    assertEquals(Unit::class.java, ::foo.parameters[1].type.javaType)
     assertEquals(java.lang.Void.TYPE, ::foo.returnType.javaType)
 
-    assertEquals(javaClass<Unit>(), ::bar.returnType.javaType)
-    assertEquals(javaClass<Unit>(), ::bar.getter.returnType.javaType)
-    assertEquals(javaClass<Unit>(), ::bar.setter.parameters.single().type.javaType)
+    assertEquals(Unit::class.java, ::bar.returnType.javaType)
+    assertEquals(Unit::class.java, ::bar.getter.returnType.javaType)
+    assertEquals(Unit::class.java, ::bar.setter.parameters.single().type.javaType)
     assertEquals(java.lang.Void.TYPE, ::bar.setter.returnType.javaType)
 
     return "OK"

compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/memberExtensionToString.kt

@@ -9,10 +9,10 @@ class A {
 }
 
 fun box(): String {
-    val p = javaClass<A>().kotlin.memberExtensionProperties.single()
+    val p = A::class.java.kotlin.memberExtensionProperties.single()
     return if ("$p" == "var A.(kotlin.String.)id: kotlin.String") "OK" else "Fail $p"
 
-    val q = javaClass<A>().kotlin.declaredFunctions.single()
+    val q = A::class.java.kotlin.declaredFunctions.single()
     if ("$q" != "fun A.(kotlin.Int.)foo(): kotlin.Double") return "Fail q $q"
 
     return "OK"

compiler/testData/codegen/boxWithStdlib/reflection/parameters/functionParameterNameAndIndex.kt

@@ -1,7 +1,7 @@
 import kotlin.reflect.*
 import kotlin.test.assertEquals
 
-fun foo(bar: String): Int = bar.length()
+fun foo(bar: String): Int = bar.length
 
 class A(val c: String) {
     fun foz(baz: Int) {}

compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/extensionPropertyAccessors.kt

@@ -3,7 +3,7 @@ import kotlin.test.assertEquals
 var state: String = ""
 
 var String.prop: String
-    get() = length().toString()
+    get() = length.toString()
     set(value) { state = this + value }
 
 fun box(): String {

compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/memberExtensions.kt

@@ -3,7 +3,7 @@ import kotlin.test.assertEquals
 
 class C(var state: String) {
     var String.prop: String
-        get() = length().toString()
+        get() = length.toString()
         set(value) { state = this + value }
 }
 

compiler/testData/codegen/boxWithStdlib/reflection/properties/callPrivatePropertyFromGetProperties.kt

@@ -4,7 +4,7 @@ import kotlin.reflect.jvm.*
 class K(private val value: String)
 
 fun box(): String {
-    val p = javaClass<K>().kotlin.memberProperties.single() as KProperty1<K, String>
+    val p = K::class.java.kotlin.memberProperties.single() as KProperty1<K, String>
 
     try {
         return p.get(K("Fail: private property should not be accessible by default"))

compiler/testData/codegen/boxWithStdlib/reflection/properties/fakeOverridesInSubclass.kt

@@ -6,10 +6,10 @@ open class Super(val r: String)
 class Sub(r: String) : Super(r)
 
 fun box(): String {
-    val props = javaClass<Sub>().kotlin.declaredMemberProperties
+    val props = Sub::class.java.kotlin.declaredMemberProperties
     if (!props.isEmpty()) return "Fail $props"
 
-    val allProps = javaClass<Sub>().kotlin.memberProperties
+    val allProps = Sub::class.java.kotlin.memberProperties
     assertEquals(listOf("r"), allProps.map { it.name })
     return allProps.single().get(Sub("OK")) as String
 }

compiler/testData/codegen/boxWithStdlib/reflection/properties/getExtensionPropertiesMutableVsReadonly.kt

@@ -12,7 +12,7 @@ class A {
 }
 
 fun box(): String {
-    val props = javaClass<A>().kotlin.memberExtensionProperties
+    val props = A::class.java.kotlin.memberExtensionProperties
     val readonly = props.single { it.name == "readonly" }
     assert(readonly !is KMutableProperty2<A, *, *>) { "Fail 1: $readonly" }
     val mutable = props.single { it.name == "mutable" }

compiler/testData/codegen/boxWithStdlib/reflection/properties/getPropertiesMutableVsReadonly.kt

@@ -5,7 +5,7 @@ class A(val readonly: String) {
 }
 
 fun box(): String {
-    val props = javaClass<A>().kotlin.memberProperties
+    val props = A::class.java.kotlin.memberProperties
     val readonly = props.single { it.name == "readonly" }
     assert(readonly !is KMutableProperty1<A, *>) { "Fail 1: $readonly" }
     val mutable = props.single { it.name == "mutable" }

compiler/testData/codegen/boxWithStdlib/reflection/properties/memberAndMemberExtensionWithSameName.kt

@@ -7,13 +7,13 @@ class A {
 
 fun box(): String {
     run {
-        val foo: KProperty1<A, *> = javaClass<A>().kotlin.memberProperties.single()
+        val foo: KProperty1<A, *> = A::class.java.kotlin.memberProperties.single()
         assert(foo.name == "foo") { "Fail name: $foo (${foo.name})" }
         assert(foo.get(A()) == "member") { "Fail value: ${foo.get(A())}" }
     }
 
     run {
-        val foo: KProperty2<A, *, *> = javaClass<A>().kotlin.memberExtensionProperties.single()
+        val foo: KProperty2<A, *, *> = A::class.java.kotlin.memberExtensionProperties.single()
         assert(foo.name == "foo") { "Fail name: $foo (${foo.name})" }
         foo as KProperty2<A, Unit, *>
         assert(foo.get(A(), Unit) == "extension") { "Fail value: ${foo.get(A(), Unit)}" }

compiler/testData/codegen/boxWithStdlib/reflection/properties/simpleGetProperties.kt

@@ -11,7 +11,7 @@ class A(param: String) {
 }
 
 fun box(): String {
-    val klass = javaClass<A>().kotlin
+    val klass = A::class.java.kotlin
 
     val props = klass.memberProperties