Merge boxWithStdlib testData into box, delete BoxWithStdlib test

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

@@ -0,0 +1,33 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+
+fun foo(bar: String): Int = bar.length
+
+class A(val c: String) {
+    fun foz(baz: Int) {}
+
+    fun Double.mext(mez: Long) {}
+}
+
+fun Int.qux(zux: String) {}
+
+fun checkParameters(f: KFunction<*>, names: List<String?>) {
+    val params = f.parameters
+    assertEquals(names, params.map { it.name })
+    assertEquals(params.indices.toList(), params.map { it.index })
+}
+
+fun box(): String {
+    checkParameters(::box, listOf())
+    checkParameters(::foo, listOf("bar"))
+    checkParameters(A::foz, listOf(null, "baz"))
+    checkParameters(Int::qux, listOf(null, "zux"))
+
+    checkParameters(A::class.functions.single { it.name == "mext" }, listOf(null, null, "mez"))
+
+    checkParameters(::A, listOf("c"))
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/parameters/isMarkedNullable.kt

@@ -0,0 +1,20 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class A {
+    fun <T, U : Any> foo(p1: String, p2: String?, p3: T, p4: U, p5: U?) { }
+}
+
+fun Any?.ext() {}
+
+fun box(): String {
+    val ps = A::class.declaredFunctions.single().parameters.map { it.type.isMarkedNullable }
+    assertEquals(listOf(false, false, true, false, false, true), ps)
+
+    assertTrue(Any?::ext.parameters.single().type.isMarkedNullable)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/parameters/isOptional.kt

@@ -0,0 +1,26 @@
+// WITH_REFLECT
+
+import kotlin.test.*
+
+open class A {
+    open fun foo(x: Int, y: Int = 1) {}
+}
+
+class B : A() {
+    override fun foo(x: Int, y: Int) {}
+}
+
+class C : A()
+
+
+fun Int.extFun() {}
+
+fun box(): String {
+    assertEquals(listOf(false, false, true), A::foo.parameters.map { it.isOptional })
+    assertEquals(listOf(false, false, true), B::foo.parameters.map { it.isOptional })
+    assertEquals(listOf(false, false, true), C::foo.parameters.map { it.isOptional })
+
+    assertFalse(Int::extFun.parameters.single().isOptional)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/parameters/kinds.kt

@@ -0,0 +1,20 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.reflect.KParameter.Kind.*
+import kotlin.test.assertEquals
+
+class A {
+    fun Int.foo(x: String) {}
+
+    inner class Inner(s: String) {}
+}
+
+fun box(): String {
+    val foo = A::class.memberExtensionFunctions.single()
+
+    assertEquals(listOf(INSTANCE, EXTENSION_RECEIVER, VALUE), foo.parameters.map { it.kind })
+    assertEquals(listOf(INSTANCE, VALUE), A::Inner.parameters.map { it.kind })
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/parameters/propertySetter.kt

@@ -0,0 +1,26 @@
+// WITH_REFLECT
+
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+
+var default: Int = 0
+
+var defaultAnnotated: Int = 0
+    public set
+
+var custom: Int = 0
+    set(myName: Int) {}
+
+fun checkPropertySetterParam(property: KMutableProperty<*>, name: String?) {
+    val parameter = property.setter.parameters.single()
+    assertEquals(0, parameter.index)
+    assertEquals(name, parameter.name)
+}
+
+fun box(): String {
+    checkPropertySetterParam(::default, null)
+    checkPropertySetterParam(::defaultAnnotated, null)
+    checkPropertySetterParam(::custom, "myName")
+
+    return "OK"
+}