Cleanup deprecated symbol usages in testData

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"