Cleanup deprecated symbol usages in testData

compiler/testData/codegen/boxWithJava/annotatedSamFunExpression/annotatedSamFunExpression.kt

@@ -5,7 +5,7 @@ import kotlin.test.assertEquals
 annotation class Ann(val x: String)
 
 fun testMethod(method: Method, name: String) {
-    assertEquals("OK", method.getAnnotation(javaClass<Ann>()).x, "On method of test named `$name`")
+    assertEquals("OK", method.getAnnotation(Ann::class.java).x, "On method of test named `$name`")
 
     for ((index, annotations) in method.getParameterAnnotations().withIndex()) {
         val ann = annotations.filterIsInstance<Ann>().single()

compiler/testData/codegen/boxWithJava/annotatedSamLambda/annotatedSamLambda.kt

@@ -6,7 +6,7 @@ import kotlin.test.assertEquals
 annotation class Ann(val x: String)
 
 fun testMethod(method: Method, name: String) {
-    assertEquals("OK", method.getAnnotation(javaClass<Ann>()).x, "On method of test named `$name`")
+    assertEquals("OK", method.getAnnotation(Ann::class.java).x, "On method of test named `$name`")
 
     for ((index, annotations) in method.getParameterAnnotations().withIndex()) {
         val ann = annotations.filterIsInstance<Ann>().single()

compiler/testData/codegen/boxWithJava/annotationsWithKClass/array/array.kt

@@ -4,7 +4,7 @@ import kotlin.reflect.KClass
 annotation class Ann(val args: Array<KClass<*>>)
 
 fun box(): String {
-    val args = javaClass<Test>().getAnnotation(javaClass<Ann>()).args
+    val args = Test::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/boxWithJava/annotationsWithKClass/basic/basic.kt

@@ -4,6 +4,6 @@ import kotlin.reflect.KClass
 annotation class Ann(val arg: KClass<*>)
 
 fun box(): String {
-    val argName = javaClass<Test>().getAnnotation(javaClass<Ann>()).arg.simpleName ?: "fail 1"
+    val argName = Test::class.java.getAnnotation(Ann::class.java).arg.simpleName ?: "fail 1"
     return argName
 }

compiler/testData/codegen/boxWithJava/annotationsWithKClass/vararg/vararg.kt

@@ -4,7 +4,7 @@ import kotlin.reflect.KClass
 annotation class Ann(vararg val args: KClass<*>)
 
 fun box(): String {
-    val args = javaClass<Test>().getAnnotation(javaClass<Ann>()).args
+    val args = Test::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/boxWithJava/builtinStubMethods/extendJavaCollections/extendJavaCollections.kt

@@ -5,8 +5,8 @@ class MyMapEntry : Test.MapEntryImpl()
 fun box(): String {
 
     val b = MyMapEntry()
-    b.getKey()
-    b.getValue()
+    b.key
+    b.value
     b.setValue(null)
 
     return "OK"

compiler/testData/codegen/boxWithJava/reflection/callInstanceJavaMethod/K.kt

@@ -4,10 +4,10 @@ import kotlin.test.assertEquals
 fun box(): String {
     val f = J::foo
     assertEquals(
-            listOf(javaClass<J>(), javaClass<IntArray>(), javaClass<Array<Any>>(), javaClass<Integer>()),
+            listOf(J::class.java, IntArray::class.java, Array<Any>::class.java, Integer::class.java),
             f.parameters.map { it.type.javaType }
     )
-    assertEquals(javaClass<String>(), f.returnType.javaType)
+    assertEquals(String::class.java, f.returnType.javaType)
 
     assertEquals("01A2", f.call(J(0), intArrayOf(1), arrayOf("A"), 2))
 

compiler/testData/codegen/boxWithJava/reflection/callPrivateJavaMethod/K.kt

@@ -5,7 +5,7 @@ import kotlin.test.*
 fun box(): String {
     val c = J::class.constructors.single()
     assertFalse(c.isAccessible)
-    assertFailsWith(javaClass<IllegalCallableAccessException>()) { c.call("") }
+    assertFailsWith(IllegalCallableAccessException::class.java) { c.call("") }
 
     c.isAccessible = true
     assertTrue(c.isAccessible)
@@ -13,7 +13,7 @@ fun box(): String {
 
     val m = J::class.members.single { it.name == "getResult" }
     assertFalse(m.isAccessible)
-    assertFailsWith(javaClass<IllegalCallableAccessException>()) { m.call(j)!! }
+    assertFailsWith(IllegalCallableAccessException::class.java) { m.call(j)!! }
 
     m.isAccessible = true
     return m.call(j) as String

compiler/testData/codegen/boxWithJava/reflection/callStaticJavaMethod/K.kt

@@ -3,8 +3,8 @@ import kotlin.test.assertEquals
 
 fun box(): String {
     val f = J::foo
-    assertEquals(listOf(Integer.TYPE, javaClass<IntArray>(), javaClass<Array<Any>>()), f.parameters.map { it.type.javaType })
-    assertEquals(javaClass<String>(), f.returnType.javaType)
+    assertEquals(listOf(Integer.TYPE, IntArray::class.java, Array<Any>::class.java), f.parameters.map { it.type.javaType })
+    assertEquals(String::class.java, f.returnType.javaType)
 
     assertEquals("01A", f.call(0, intArrayOf(1), arrayOf("A")))
 

compiler/testData/codegen/boxWithJava/reflection/javaClassGetFunctions/K.kt

@@ -6,7 +6,7 @@ fun box(): String {
     assertEquals(listOf("equals", "hashCode", "member", "staticMethod", "toString"), J::class.functions.map { it.name }.sorted())
     assertEquals(listOf("member", "staticMethod"), J::class.declaredFunctions.map { it.name }.sorted())
 
-    assertEquals(1, J::class.constructors.size())
+    assertEquals(1, J::class.constructors.size)
 
     return "OK"
 }

compiler/testData/codegen/boxWithJava/reflection/kotlinPropertyInheritedInJava/K.kt

@@ -21,7 +21,7 @@ fun box(): String {
     if (prop == K::prop) return "Fail J::prop == K::prop (these are different properties)"
 
 
-    val klass = javaClass<J>().kotlin
+    val klass = J::class.java.kotlin
     if (klass.declaredMemberProperties.isNotEmpty()) return "Fail: declaredMemberProperties should be empty"
     if (klass.declaredMemberExtensionProperties.isNotEmpty()) return "Fail: declaredMemberExtensionProperties should be empty"