Rename Kotlin/Native modules for uniformity

native/commonizer/testData/callableMemberCommonization/extensionReceivers/commonized/common/package_root.kt

@@ -0,0 +1,24 @@
+expect class Planet(name: String, diameter: Double) {
+    val name: String
+    val diameter: Double
+}
+
+expect val intProperty: Int
+expect val Int.intProperty: Int
+expect val Short.intProperty: Int
+expect val Long.intProperty: Int
+expect val String.intProperty: Int
+expect val Planet.intProperty: Int
+
+expect fun intFunction(): Int
+expect fun Int.intFunction(): Int
+expect fun Short.intFunction(): Int
+expect fun Long.intFunction(): Int
+expect fun String.intFunction(): Int
+expect fun Planet.intFunction(): Int
+
+expect val <T> T.propertyWithTypeParameter1: Int
+expect val <T : Any?> T.propertyWithTypeParameter2: Int
+expect val <T : CharSequence> T.propertyWithTypeParameter4: Int
+
+expect fun <T> T.functionWithTypeParameter1()

native/commonizer/testData/callableMemberCommonization/extensionReceivers/commonized/js/package_root.kt

@@ -0,0 +1,36 @@
+actual class Planet actual constructor(actual val name: String, actual val diameter: Double)
+
+actual val intProperty get() = 42
+actual val Int.intProperty get() = this
+actual val Short.intProperty get() = toInt()
+actual val Long.intProperty get() = toInt()
+actual val String.intProperty get() = length
+actual val Planet.intProperty get() = diameter.toInt()
+
+actual fun intFunction() = 42
+actual fun Int.intFunction() = this
+actual fun Short.intFunction() = toInt()
+actual fun Long.intFunction() = toInt()
+actual fun String.intFunction() = length
+actual fun Planet.intFunction() = diameter.toInt()
+
+val String.mismatchedProperty1 get() = 42
+val mismatchedProperty2 get() = 42
+
+fun String.mismatchedFunction1() = 42
+fun mismatchedFunction2() = 42
+
+actual val <T> T.propertyWithTypeParameter1 get() = 42
+actual val <T> T.propertyWithTypeParameter2 get() = 42
+val <T> T.propertyWithTypeParameter3 get() = 42
+actual val <T : CharSequence> T.propertyWithTypeParameter4 get() = length
+val <T : CharSequence> T.propertyWithTypeParameter5: Int get() = length
+val <T : CharSequence> T.propertyWithTypeParameter6: Int get() = length
+val <T : CharSequence> T.propertyWithTypeParameter7: Int get() = length
+val <T> T.propertyWithTypeParameter8 get() = 42
+val <T> T.propertyWithTypeParameter9 get() = 42
+
+actual fun <T> T.functionWithTypeParameter1() {}
+fun <T> T.functionWithTypeParameter2() {}
+fun <T> T.functionWithTypeParameter3() {}
+fun <T> T.functionWithTypeParameter4() {}

native/commonizer/testData/callableMemberCommonization/extensionReceivers/commonized/jvm/package_root.kt

@@ -0,0 +1,36 @@
+actual class Planet actual constructor(actual val name: String, actual val diameter: Double)
+
+actual val intProperty get() = 42
+actual val Int.intProperty get() = this
+actual val Short.intProperty get() = toInt()
+actual val Long.intProperty get() = toInt()
+actual val String.intProperty get() = length
+actual val Planet.intProperty get() = diameter.toInt()
+
+actual fun intFunction() = 42
+actual fun Int.intFunction() = this
+actual fun Short.intFunction() = toInt()
+actual fun Long.intFunction() = toInt()
+actual fun String.intFunction() = length
+actual fun Planet.intFunction() = diameter.toInt()
+
+val mismatchedProperty1 get() = 42
+val Double.mismatchedProperty2 get() = 42
+
+fun mismatchedFunction1() = 42
+fun Double.mismatchedFunction2() = 42
+
+actual val <T> T.propertyWithTypeParameter1 get() = 42
+actual val <T : Any?> T.propertyWithTypeParameter2 get() = 42
+val <T : Any> T.propertyWithTypeParameter3 get() = 42
+actual val <T : CharSequence> T.propertyWithTypeParameter4 get() = length
+val <T : Appendable> T.propertyWithTypeParameter5: Int get() = length
+val <T : String> T.propertyWithTypeParameter6: Int get() = length
+val String.propertyWithTypeParameter7: Int get() = length
+val <Q> Q.propertyWithTypeParameter8 get() = 42
+val <T, Q> T.propertyWithTypeParameter9 get() = 42
+
+actual fun <T> T.functionWithTypeParameter1() {}
+fun <Q> Q.functionWithTypeParameter2() {}
+fun <T, Q> T.functionWithTypeParameter3() {}
+fun <T, Q> Q.functionWithTypeParameter4() {}

native/commonizer/testData/callableMemberCommonization/extensionReceivers/original/js/package_root.kt

@@ -0,0 +1,36 @@
+class Planet(val name: String, val diameter: Double)
+
+val intProperty get() = 42
+val Int.intProperty get() = this
+val Short.intProperty get() = toInt()
+val Long.intProperty get() = toInt()
+val String.intProperty get() = length
+val Planet.intProperty get() = diameter.toInt()
+
+fun intFunction() = 42
+fun Int.intFunction() = this
+fun Short.intFunction() = toInt()
+fun Long.intFunction() = toInt()
+fun String.intFunction() = length
+fun Planet.intFunction() = diameter.toInt()
+
+val String.mismatchedProperty1 get() = 42
+val mismatchedProperty2 get() = 42
+
+fun String.mismatchedFunction1() = 42
+fun mismatchedFunction2() = 42
+
+val <T> T.propertyWithTypeParameter1 get() = 42
+val <T> T.propertyWithTypeParameter2 get() = 42
+val <T> T.propertyWithTypeParameter3 get() = 42
+val <T : CharSequence> T.propertyWithTypeParameter4: Int get() = length
+val <T : CharSequence> T.propertyWithTypeParameter5: Int get() = length
+val <T : CharSequence> T.propertyWithTypeParameter6: Int get() = length
+val <T : CharSequence> T.propertyWithTypeParameter7: Int get() = length
+val <T> T.propertyWithTypeParameter8 get() = 42
+val <T> T.propertyWithTypeParameter9 get() = 42
+
+fun <T> T.functionWithTypeParameter1() {}
+fun <T> T.functionWithTypeParameter2() {}
+fun <T> T.functionWithTypeParameter3() {}
+fun <T> T.functionWithTypeParameter4() {}

native/commonizer/testData/callableMemberCommonization/extensionReceivers/original/jvm/package_root.kt

@@ -0,0 +1,36 @@
+class Planet(val name: String, val diameter: Double)
+
+val intProperty get() = 42
+val Int.intProperty get() = this
+val Short.intProperty get() = toInt()
+val Long.intProperty get() = toInt()
+val String.intProperty get() = length
+val Planet.intProperty get() = diameter.toInt()
+
+fun intFunction() = 42
+fun Int.intFunction() = this
+fun Short.intFunction() = toInt()
+fun Long.intFunction() = toInt()
+fun String.intFunction() = length
+fun Planet.intFunction() = diameter.toInt()
+
+val mismatchedProperty1 get() = 42
+val Double.mismatchedProperty2 get() = 42
+
+fun mismatchedFunction1() = 42
+fun Double.mismatchedFunction2() = 42
+
+val <T> T.propertyWithTypeParameter1 get() = 42
+val <T : Any?> T.propertyWithTypeParameter2 get() = 42
+val <T : Any> T.propertyWithTypeParameter3 get() = 42
+val <T : CharSequence> T.propertyWithTypeParameter4: Int get() = length
+val <T : Appendable> T.propertyWithTypeParameter5: Int get() = length
+val <T : String> T.propertyWithTypeParameter6: Int get() = length
+val String.propertyWithTypeParameter7: Int get() = length
+val <Q> Q.propertyWithTypeParameter8 get() = 42
+val <T, Q> T.propertyWithTypeParameter9 get() = 42
+
+fun <T> T.functionWithTypeParameter1() {}
+fun <Q> Q.functionWithTypeParameter2() {}
+fun <T, Q> T.functionWithTypeParameter3() {}
+fun <T, Q> Q.functionWithTypeParameter4() {}

native/commonizer/testData/callableMemberCommonization/returnTypes/commonized/common/package_root.kt

@@ -0,0 +1,42 @@
+expect class Planet(name: String, diameter: Double) {
+    val name: String
+    val diameter: Double
+}
+
+expect val propertyWithInferredType1: Int
+expect val propertyWithInferredType2: String
+expect val propertyWithInferredType3: String
+expect val propertyWithInferredType4: Nothing?
+expect val propertyWithInferredType5: Planet
+
+expect class C
+
+expect val property1: Int
+expect val property2: String
+expect val property3: Planet
+expect val property6: Planet
+expect val property7: C
+
+expect fun function1(): Int
+expect fun function2(): String
+expect fun function3(): Planet
+expect fun function6(): Planet
+expect fun function7(): C
+
+expect class Box<T>(value: T) {
+    val value: T
+}
+expect class Fox()
+
+expect fun functionWithTypeParametersInReturnType1(): Array<Int>
+expect fun functionWithTypeParametersInReturnType3(): Array<String>
+expect fun functionWithTypeParametersInReturnType4(): List<Int>
+expect fun functionWithTypeParametersInReturnType6(): List<String>
+expect fun functionWithTypeParametersInReturnType7(): Box<Int>
+expect fun functionWithTypeParametersInReturnType9(): Box<String>
+expect fun functionWithTypeParametersInReturnType10(): Box<Planet>
+expect fun functionWithTypeParametersInReturnType12(): Box<Fox>
+
+expect fun <T> functionWithUnsubstitutedTypeParametersInReturnType1(): T
+expect fun <T> functionWithUnsubstitutedTypeParametersInReturnType2(): T
+expect fun <T> functionWithUnsubstitutedTypeParametersInReturnType8(): Box<T>

native/commonizer/testData/callableMemberCommonization/returnTypes/commonized/js/package_root.kt

@@ -0,0 +1,64 @@
+actual class Planet actual constructor(actual val name: String, actual val diameter: Double)
+
+actual val propertyWithInferredType1 = 1
+actual val propertyWithInferredType2 = "hello"
+actual val propertyWithInferredType3 = 42.toString()
+actual val propertyWithInferredType4 = null
+actual val propertyWithInferredType5 = Planet("Earth", 12742)
+
+typealias A = Planet
+actual typealias C = Planet
+
+actual val property1 = 1
+actual val property2 = "hello"
+actual val property3 = Planet("Earth", 12742)
+val property4 = A("Earth", 12742)
+val property5 = A("Earth", 12742)
+actual val property6 = Planet("Earth", 12742)
+actual val property7 = C("Earth", 12742)
+
+actual fun function1() = 1
+actual fun function2() = "hello"
+actual fun function3() = Planet("Earth", 12742)
+fun function4() = A("Earth", 12742)
+fun function5() = A("Earth", 12742)
+actual fun function6() = Planet("Earth", 12742)
+actual fun function7() = C("Earth", 12742)
+
+val propertyWithMismatchedType1: Int = 1
+val propertyWithMismatchedType2: Int = 1
+val propertyWithMismatchedType3: Int = 1
+val propertyWithMismatchedType4: Int = 1
+val propertyWithMismatchedType5: Int = 1
+
+fun functionWithMismatchedType1(): Int = 1
+fun functionWithMismatchedType2(): Int = 1
+fun functionWithMismatchedType3(): Int = 1
+fun functionWithMismatchedType4(): Int = 1
+fun functionWithMismatchedType5(): Int = 1
+
+actual class Box<T> actual constructor(actual val value: T)
+actual class Fox actual constructor()
+
+actual fun functionWithTypeParametersInReturnType1() = arrayOf(1)
+fun functionWithTypeParametersInReturnType2() = arrayOf(1)
+actual fun functionWithTypeParametersInReturnType3() = arrayOf("hello")
+actual fun functionWithTypeParametersInReturnType4(): List<Int> = listOf(1)
+fun functionWithTypeParametersInReturnType5(): List<Int> = listOf(1)
+actual fun functionWithTypeParametersInReturnType6(): List<String> = listOf("hello")
+actual fun functionWithTypeParametersInReturnType7() = Box(1)
+fun functionWithTypeParametersInReturnType8() = Box(1)
+actual fun functionWithTypeParametersInReturnType9() = Box("hello")
+actual fun functionWithTypeParametersInReturnType10() = Box(Planet("Earth", 12742))
+fun functionWithTypeParametersInReturnType11() = Box(Planet("Earth", 12742))
+actual fun functionWithTypeParametersInReturnType12() = Box(Fox())
+
+actual fun <T> functionWithUnsubstitutedTypeParametersInReturnType1(): T = TODO()
+actual fun <T> functionWithUnsubstitutedTypeParametersInReturnType2(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType3(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType4(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType5(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType6(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType7(): T = TODO()
+actual fun <T> functionWithUnsubstitutedTypeParametersInReturnType8(): Box<T> = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType9(): Box<T> = TODO()

native/commonizer/testData/callableMemberCommonization/returnTypes/commonized/jvm/package_root.kt

@@ -0,0 +1,64 @@
+actual class Planet actual constructor(actual val name: String, actual val diameter: Double)
+
+actual val propertyWithInferredType1 get() = 1
+actual val propertyWithInferredType2 get() = "hello"
+actual val propertyWithInferredType3 get() = 42.toString()
+actual val propertyWithInferredType4 get() = null
+actual val propertyWithInferredType5 get() = Planet("Earth", 12742)
+
+typealias B = Planet
+actual typealias C = Planet
+
+actual val property1 = 1
+actual val property2 = "hello"
+actual val property3 = Planet("Earth", 12742)
+val property4: B = Planet("Earth", 12742)
+val property5: Planet = A("Earth", 12742)
+actual val property6: Planet = A("Earth", 12742)
+actual val property7: C = Planet("Earth", 12742)
+
+actual fun function1(): Int = 1
+actual fun function2(): String = "hello"
+actual fun function3(): Planet = Planet("Earth", 12742)
+fun function4(): B = A("Earth", 12742)
+fun function5(): Planet = A("Earth", 12742)
+actual fun function6(): Planet = Planet("Earth", 12742)
+actual fun function7(): C = C("Earth", 12742)
+
+val propertyWithMismatchedType1: Long = 1
+val propertyWithMismatchedType2: Short = 1
+val propertyWithMismatchedType3: Number = 1
+val propertyWithMismatchedType4: Comparable<Int> = 1
+val propertyWithMismatchedType5: String = 1.toString()
+
+fun functionWithMismatchedType1(): Long = 1
+fun functionWithMismatchedType2(): Short = 1
+fun functionWithMismatchedType3(): Number = 1
+fun functionWithMismatchedType4(): Comparable<Int> = 1
+fun functionWithMismatchedType5(): String = 1.toString()
+
+actual class Box<T> actual constructor(actual val value: T)
+actual class Fox actual constructor()
+
+actual fun functionWithTypeParametersInReturnType1() = arrayOf(1)
+fun functionWithTypeParametersInReturnType2() = arrayOf("hello")
+actual fun functionWithTypeParametersInReturnType3() = arrayOf("hello")
+actual fun functionWithTypeParametersInReturnType4(): List<Int> = listOf(1)
+fun functionWithTypeParametersInReturnType5(): List<String> = listOf("hello")
+actual fun functionWithTypeParametersInReturnType6(): List<String> = listOf("hello")
+actual fun functionWithTypeParametersInReturnType7() = Box(1)
+fun functionWithTypeParametersInReturnType8() = Box("hello")
+actual fun functionWithTypeParametersInReturnType9() = Box("hello")
+actual fun functionWithTypeParametersInReturnType10() = Box(Planet("Earth", 12742))
+fun functionWithTypeParametersInReturnType11() = Box(Fox())
+actual fun functionWithTypeParametersInReturnType12() = Box(Fox())
+
+actual fun <T> functionWithUnsubstitutedTypeParametersInReturnType1(): T = TODO()
+actual fun <T : Any?> functionWithUnsubstitutedTypeParametersInReturnType2(): T = TODO()
+fun <T : Any> functionWithUnsubstitutedTypeParametersInReturnType3(): T = TODO()
+fun <Q> functionWithUnsubstitutedTypeParametersInReturnType4(): Q = TODO()
+fun <T, Q> functionWithUnsubstitutedTypeParametersInReturnType5(): T = TODO()
+fun <T, Q> functionWithUnsubstitutedTypeParametersInReturnType6(): Q = TODO()
+fun functionWithUnsubstitutedTypeParametersInReturnType7(): String = TODO()
+actual fun <T> functionWithUnsubstitutedTypeParametersInReturnType8(): Box<T> = TODO()
+fun functionWithUnsubstitutedTypeParametersInReturnType9(): Box<String> = TODO()

native/commonizer/testData/callableMemberCommonization/returnTypes/original/js/package_root.kt

@@ -0,0 +1,66 @@
+class Planet(val name: String, val diameter: Double)
+
+val propertyWithInferredType1 = 1
+val propertyWithInferredType2 = "hello"
+val propertyWithInferredType3 = 42.toString()
+val propertyWithInferredType4 = null
+val propertyWithInferredType5 = Planet("Earth", 12742)
+
+typealias A = Planet
+typealias C = Planet
+
+// with inferred type:
+val property1 = 1
+val property2 = "hello"
+val property3 = Planet("Earth", 12742)
+val property4 = A("Earth", 12742)
+val property5 = A("Earth", 12742)
+val property6 = Planet("Earth", 12742)
+val property7 = C("Earth", 12742)
+
+// with inferred type:
+fun function1() = 1
+fun function2() = "hello"
+fun function3() = Planet("Earth", 12742)
+fun function4() = A("Earth", 12742)
+fun function5() = A("Earth", 12742)
+fun function6() = Planet("Earth", 12742)
+fun function7() = C("Earth", 12742)
+
+val propertyWithMismatchedType1: Int = 1
+val propertyWithMismatchedType2: Int = 1
+val propertyWithMismatchedType3: Int = 1
+val propertyWithMismatchedType4: Int = 1
+val propertyWithMismatchedType5: Int = 1
+
+fun functionWithMismatchedType1(): Int = 1
+fun functionWithMismatchedType2(): Int = 1
+fun functionWithMismatchedType3(): Int = 1
+fun functionWithMismatchedType4(): Int = 1
+fun functionWithMismatchedType5(): Int = 1
+
+class Box<T>(val value: T)
+class Fox
+
+fun functionWithTypeParametersInReturnType1() = arrayOf(1)
+fun functionWithTypeParametersInReturnType2() = arrayOf(1)
+fun functionWithTypeParametersInReturnType3() = arrayOf("hello")
+fun functionWithTypeParametersInReturnType4(): List<Int> = listOf(1)
+fun functionWithTypeParametersInReturnType5(): List<Int> = listOf(1)
+fun functionWithTypeParametersInReturnType6(): List<String> = listOf("hello")
+fun functionWithTypeParametersInReturnType7() = Box(1)
+fun functionWithTypeParametersInReturnType8() = Box(1)
+fun functionWithTypeParametersInReturnType9() = Box("hello")
+fun functionWithTypeParametersInReturnType10() = Box(Planet("Earth", 12742))
+fun functionWithTypeParametersInReturnType11() = Box(Planet("Earth", 12742))
+fun functionWithTypeParametersInReturnType12() = Box(Fox())
+
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType1(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType2(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType3(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType4(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType5(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType6(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType7(): T = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType8(): Box<T> = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType9(): Box<T> = TODO()

native/commonizer/testData/callableMemberCommonization/returnTypes/original/jvm/package_root.kt

@@ -0,0 +1,66 @@
+class Planet(val name: String, val diameter: Double)
+
+val propertyWithInferredType1 get() = 1
+val propertyWithInferredType2 get() = "hello"
+val propertyWithInferredType3 get() = 42.toString()
+val propertyWithInferredType4 get() = null
+val propertyWithInferredType5 get() = Planet("Earth", 12742)
+
+typealias B = Planet
+typealias C = Planet
+
+// with explicit type:
+val property1: Int = 1
+val property2: String = "hello"
+val property3: Planet = Planet("Earth", 12742)
+val property4: B = Planet("Earth", 12742)
+val property5: Planet = A("Earth", 12742)
+val property6: Planet = A("Earth", 12742)
+val property7: C = Planet("Earth", 12742)
+
+// with explicit type:
+fun function1(): Int = 1
+fun function2(): String = "hello"
+fun function3(): Planet = Planet("Earth", 12742)
+fun function4(): B = A("Earth", 12742)
+fun function5(): Planet = A("Earth", 12742)
+fun function6(): Planet = Planet("Earth", 12742)
+fun function7(): C = C("Earth", 12742)
+
+val propertyWithMismatchedType1: Long = 1
+val propertyWithMismatchedType2: Short = 1
+val propertyWithMismatchedType3: Number = 1
+val propertyWithMismatchedType4: Comparable<Int> = 1
+val propertyWithMismatchedType5: String = 1.toString()
+
+fun functionWithMismatchedType1(): Long = 1
+fun functionWithMismatchedType2(): Short = 1
+fun functionWithMismatchedType3(): Number = 1
+fun functionWithMismatchedType4(): Comparable<Int> = 1
+fun functionWithMismatchedType5(): String = 1.toString()
+
+class Box<T>(val value: T)
+class Fox
+
+fun functionWithTypeParametersInReturnType1() = arrayOf(1)
+fun functionWithTypeParametersInReturnType2() = arrayOf("hello")
+fun functionWithTypeParametersInReturnType3() = arrayOf("hello")
+fun functionWithTypeParametersInReturnType4(): List<Int> = listOf(1)
+fun functionWithTypeParametersInReturnType5(): List<String> = listOf("hello")
+fun functionWithTypeParametersInReturnType6(): List<String> = listOf("hello")
+fun functionWithTypeParametersInReturnType7() = Box(1)
+fun functionWithTypeParametersInReturnType8() = Box("hello")
+fun functionWithTypeParametersInReturnType9() = Box("hello")
+fun functionWithTypeParametersInReturnType10() = Box(Planet("Earth", 12742))
+fun functionWithTypeParametersInReturnType11() = Box(Fox())
+fun functionWithTypeParametersInReturnType12() = Box(Fox())
+
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType1(): T = TODO()
+fun <T : Any?> functionWithUnsubstitutedTypeParametersInReturnType2(): T = TODO()
+fun <T : Any> functionWithUnsubstitutedTypeParametersInReturnType3(): T = TODO()
+fun <Q> functionWithUnsubstitutedTypeParametersInReturnType4(): Q = TODO()
+fun <T, Q> functionWithUnsubstitutedTypeParametersInReturnType5(): T = TODO()
+fun <T, Q> functionWithUnsubstitutedTypeParametersInReturnType6(): Q = TODO()
+fun functionWithUnsubstitutedTypeParametersInReturnType7(): String = TODO()
+fun <T> functionWithUnsubstitutedTypeParametersInReturnType8(): Box<T> = TODO()
+fun functionWithUnsubstitutedTypeParametersInReturnType9(): Box<String> = TODO()

native/commonizer/testData/callableMemberCommonization/visibility/commonized/common/package_root.kt

@@ -0,0 +1,43 @@
+expect public val publicProperty: Int
+expect internal val publicOrInternalProperty: Int
+expect internal val internalProperty: Int
+
+expect public fun publicFunction(): Int
+expect internal fun publicOrInternalFunction(): Int
+expect internal fun internalFunction(): Int
+
+expect open class Outer1() {
+    public val publicProperty: Int
+    internal val publicOrInternalProperty: Int
+    internal val internalProperty: Int
+
+    public fun publicFunction(): Int
+    internal fun publicOrInternalFunction(): Int
+    internal fun internalFunction(): Int
+
+    open class Inner1() {
+        public val publicProperty: Int
+        internal val publicOrInternalProperty: Int
+        internal val internalProperty: Int
+
+        public fun publicFunction(): Int
+        internal fun publicOrInternalFunction(): Int
+        internal fun internalFunction(): Int
+    }
+}
+
+expect open class Outer2() {
+    public open val publicProperty: Int
+    internal open val internalProperty: Int
+
+    public open fun publicFunction(): Int
+    internal open fun internalFunction(): Int
+
+    open class Inner2() {
+        public open val publicProperty: Int
+        internal open val internalProperty: Int
+
+        public open fun publicFunction(): Int
+        internal open fun internalFunction(): Int
+    }
+}

native/commonizer/testData/callableMemberCommonization/visibility/commonized/js/package_root.kt

@@ -0,0 +1,67 @@
+actual public val publicProperty = 1
+actual public val publicOrInternalProperty = 1
+actual internal val internalProperty = 1
+internal val internalOrPrivateProperty = 1
+private val privateProperty = 1
+
+actual public fun publicFunction() = 1
+actual public fun publicOrInternalFunction() = 1
+actual internal fun internalFunction() = 1
+internal fun internalOrPrivateFunction() = 1
+private fun privateFunction() = 1
+
+actual open class Outer1 actual constructor() {
+    actual public val publicProperty = 1
+    actual public val publicOrInternalProperty = 1
+    actual internal val internalProperty = 1
+    internal val internalOrPrivateProperty = 1
+    private val privateProperty = 1
+
+    actual public fun publicFunction() = 1
+    actual public fun publicOrInternalFunction() = 1
+    actual internal fun internalFunction() = 1
+    internal fun internalOrPrivateFunction() = 1
+    private fun privateFunction() = 1
+
+    actual open class Inner1 actual constructor() {
+        actual public val publicProperty = 1
+        actual public val publicOrInternalProperty = 1
+        actual internal val internalProperty = 1
+        internal val internalOrPrivateProperty = 1
+        private val privateProperty = 1
+
+        actual public fun publicFunction() = 1
+        actual public fun publicOrInternalFunction() = 1
+        actual internal fun internalFunction() = 1
+        internal fun internalOrPrivateFunction() = 1
+        private fun privateFunction() = 1
+    }
+}
+
+actual open class Outer2 actual constructor() {
+    actual public open val publicProperty = 1
+    public open val publicOrInternalProperty = 1
+    actual internal open val internalProperty = 1
+    internal open val internalOrPrivateProperty = 1
+    private val privateProperty = 1
+
+    actual public open fun publicFunction() = 1
+    public open fun publicOrInternalFunction() = 1
+    actual internal open fun internalFunction() = 1
+    internal open fun internalOrPrivateFunction() = 1
+    private fun privateFunction() = 1
+
+    actual open class Inner2 actual constructor() {
+        actual public open val publicProperty = 1
+        public open val publicOrInternalProperty = 1
+        actual internal open val internalProperty = 1
+        internal open val internalOrPrivateProperty = 1
+        private val privateProperty = 1
+
+        actual public open fun publicFunction() = 1
+        public open fun publicOrInternalFunction() = 1
+        actual internal open fun internalFunction() = 1
+        internal open fun internalOrPrivateFunction() = 1
+        private fun privateFunction() = 1
+    }
+}

native/commonizer/testData/callableMemberCommonization/visibility/commonized/jvm/package_root.kt

@@ -0,0 +1,67 @@
+actual public val publicProperty = 1
+actual internal val publicOrInternalProperty = 1
+actual internal val internalProperty = 1
+private val internalOrPrivateProperty = 1
+private val privateProperty = 1
+
+actual public fun publicFunction() = 1
+actual internal fun publicOrInternalFunction() = 1
+actual internal fun internalFunction() = 1
+private fun internalOrPrivateFunction() = 1
+private fun privateFunction() = 1
+
+actual open class Outer1 actual constructor() {
+    actual public val publicProperty = 1
+    actual internal val publicOrInternalProperty = 1
+    actual internal val internalProperty = 1
+    private val internalOrPrivateProperty = 1
+    private val privateProperty = 1
+
+    actual public fun publicFunction() = 1
+    actual internal fun publicOrInternalFunction() = 1
+    actual internal fun internalFunction() = 1
+    private fun internalOrPrivateFunction() = 1
+    private fun privateFunction() = 1
+
+    actual open class Inner1 actual constructor() {
+        actual public val publicProperty = 1
+        actual internal val publicOrInternalProperty = 1
+        actual internal val internalProperty = 1
+        private val internalOrPrivateProperty = 1
+        private val privateProperty = 1
+
+        actual public fun publicFunction() = 1
+        actual internal fun publicOrInternalFunction() = 1
+        actual internal fun internalFunction() = 1
+        private fun internalOrPrivateFunction() = 1
+        private fun privateFunction() = 1
+    }
+}
+
+actual open class Outer2 actual constructor() {
+    actual public open val publicProperty = 1
+    internal open val publicOrInternalProperty = 1
+    actual internal open val internalProperty = 1
+    private val internalOrPrivateProperty = 1
+    private val privateProperty = 1
+
+    actual public open fun publicFunction() = 1
+    internal open fun publicOrInternalFunction() = 1
+    actual internal open fun internalFunction() = 1
+    private fun internalOrPrivateFunction() = 1
+    private fun privateFunction() = 1
+
+    actual open class Inner2 actual constructor() {
+        actual public open val publicProperty = 1
+        internal open val publicOrInternalProperty = 1
+        actual internal open val internalProperty = 1
+        private val internalOrPrivateProperty = 1
+        private val privateProperty = 1
+
+        actual public open fun publicFunction() = 1
+        internal open fun publicOrInternalFunction() = 1
+        actual internal open fun internalFunction() = 1
+        private fun internalOrPrivateFunction() = 1
+        private fun privateFunction() = 1
+    }
+}

native/commonizer/testData/callableMemberCommonization/visibility/original/js/package_root.kt

@@ -0,0 +1,67 @@
+public val publicProperty = 1
+public val publicOrInternalProperty = 1
+internal val internalProperty = 1
+internal val internalOrPrivateProperty = 1
+private val privateProperty = 1
+
+public fun publicFunction() = 1
+public fun publicOrInternalFunction() = 1
+internal fun internalFunction() = 1
+internal fun internalOrPrivateFunction() = 1
+private fun privateFunction() = 1
+
+open class Outer1 {
+    public val publicProperty = 1
+    public val publicOrInternalProperty = 1
+    internal val internalProperty = 1
+    internal val internalOrPrivateProperty = 1
+    private val privateProperty = 1
+
+    public fun publicFunction() = 1
+    public fun publicOrInternalFunction() = 1
+    internal fun internalFunction() = 1
+    internal fun internalOrPrivateFunction() = 1
+    private fun privateFunction() = 1
+
+    open class Inner1 {
+        public val publicProperty = 1
+        public val publicOrInternalProperty = 1
+        internal val internalProperty = 1
+        internal val internalOrPrivateProperty = 1
+        private val privateProperty = 1
+
+        public fun publicFunction() = 1
+        public fun publicOrInternalFunction() = 1
+        internal fun internalFunction() = 1
+        internal fun internalOrPrivateFunction() = 1
+        private fun privateFunction() = 1
+    }
+}
+
+open class Outer2 {
+    public open val publicProperty = 1
+    public open val publicOrInternalProperty = 1
+    internal open val internalProperty = 1
+    internal open val internalOrPrivateProperty = 1
+    private val privateProperty = 1
+
+    public open fun publicFunction() = 1
+    public open fun publicOrInternalFunction() = 1
+    internal open fun internalFunction() = 1
+    internal open fun internalOrPrivateFunction() = 1
+    private fun privateFunction() = 1
+
+    open class Inner2 {
+        public open val publicProperty = 1
+        public open val publicOrInternalProperty = 1
+        internal open val internalProperty = 1
+        internal open val internalOrPrivateProperty = 1
+        private val privateProperty = 1
+
+        public open fun publicFunction() = 1
+        public open fun publicOrInternalFunction() = 1
+        internal open fun internalFunction() = 1
+        internal open fun internalOrPrivateFunction() = 1
+        private fun privateFunction() = 1
+    }
+}

native/commonizer/testData/callableMemberCommonization/visibility/original/jvm/package_root.kt

@@ -0,0 +1,67 @@
+public val publicProperty = 1
+internal val publicOrInternalProperty = 1
+internal val internalProperty = 1
+private val internalOrPrivateProperty = 1
+private val privateProperty = 1
+
+public fun publicFunction() = 1
+internal fun publicOrInternalFunction() = 1
+internal fun internalFunction() = 1
+private fun internalOrPrivateFunction() = 1
+private fun privateFunction() = 1
+
+open class Outer1 {
+    public val publicProperty = 1
+    internal val publicOrInternalProperty = 1
+    internal val internalProperty = 1
+    private val internalOrPrivateProperty = 1
+    private val privateProperty = 1
+
+    public fun publicFunction() = 1
+    internal fun publicOrInternalFunction() = 1
+    internal fun internalFunction() = 1
+    private fun internalOrPrivateFunction() = 1
+    private fun privateFunction() = 1
+
+    open class Inner1 {
+        public val publicProperty = 1
+        internal val publicOrInternalProperty = 1
+        internal val internalProperty = 1
+        private val internalOrPrivateProperty = 1
+        private val privateProperty = 1
+
+        public fun publicFunction() = 1
+        internal fun publicOrInternalFunction() = 1
+        internal fun internalFunction() = 1
+        private fun internalOrPrivateFunction() = 1
+        private fun privateFunction() = 1
+    }
+}
+
+open class Outer2 {
+    public open val publicProperty = 1
+    internal open val publicOrInternalProperty = 1
+    internal open val internalProperty = 1
+    private val internalOrPrivateProperty = 1
+    private val privateProperty = 1
+
+    public open fun publicFunction() = 1
+    internal open fun publicOrInternalFunction() = 1
+    internal open fun internalFunction() = 1
+    private fun internalOrPrivateFunction() = 1
+    private fun privateFunction() = 1
+
+    open class Inner2 {
+        public open val publicProperty = 1
+        internal open val publicOrInternalProperty = 1
+        internal open val internalProperty = 1
+        private val internalOrPrivateProperty = 1
+        private val privateProperty = 1
+
+        public open fun publicFunction() = 1
+        internal open fun publicOrInternalFunction() = 1
+        internal open fun internalFunction() = 1
+        private fun internalOrPrivateFunction() = 1
+        private fun privateFunction() = 1
+    }
+}

native/commonizer/testData/classifierCommonization/classKindAndModifiers/commonized/common/package_root.kt

@@ -0,0 +1,84 @@
+expect class A1()
+expect interface B1
+expect annotation class C1()
+expect object D1
+expect enum class E1 { FOO, BAR, BAZ }
+
+expect class F() {
+    inner class G1()
+    class H1()
+    interface I1
+    object J1
+    enum class K1 { FOO, BAR, BAZ }
+}
+
+expect interface L {
+    class M1()
+    interface N1
+    object O1
+    enum class P1 { FOO, BAR, BAZ }
+}
+
+expect object R {
+    class S1()
+    interface T1
+    object U1
+    enum class V1 { FOO, BAR, BAZ }
+}
+
+expect class W() {
+    object X {
+        interface Y {
+            class Z() {
+                enum class AA { FOO, BAR, BAZ }
+            }
+        }
+    }
+}
+
+expect class BB1() { companion object }
+expect class BB2()
+
+expect class CC1() { companion object DD1 }
+expect class CC2()
+expect class CC3()
+
+expect inline class EE1(val value: String)
+
+expect class FF1(property1: String) {
+    val property1: String
+    val property2: String
+    val property3: String
+    val property4: String
+
+    fun function1(): String
+    fun function2(): String
+}
+expect class FF2()
+
+expect sealed class GG1
+expect sealed class GG2 {
+    class HH1(): GG2
+    object HH2 : GG2
+}
+
+expect class HH5(): GG2
+expect object HH6 : GG2
+
+expect enum class II1
+expect enum class II2 { FOO }
+
+expect interface JJ {
+    val property: String
+    fun function(): String
+}
+
+expect class KK1(property: String) : JJ {
+    override val property: String
+    override fun function(): String
+}
+
+expect class KK2(wrapped: JJ) : JJ
+
+expect class LL1(value: String) { val value: String }
+expect class LL2(value: String) { val value: String }

native/commonizer/testData/classifierCommonization/classKindAndModifiers/commonized/js/package_root.kt

@@ -0,0 +1,133 @@
+actual class A1 actual constructor()
+class A2
+class A3
+class A4
+class A5
+
+actual interface B1
+interface B2
+interface B3
+interface B4
+
+actual annotation class C1 actual constructor()
+annotation class C2
+annotation class C3
+
+actual object D1
+object D2
+
+actual enum class E1 { FOO, BAR, BAZ }
+
+actual class F actual constructor() {
+    actual inner class G1 actual constructor()
+    inner class G2
+    inner class G3
+    inner class G4
+    inner class G5
+    inner class G6
+
+    actual class H1 actual constructor()
+    class H2
+    class H3
+    class H4
+
+    actual interface I1
+    interface I2
+    interface I3
+
+    actual object J1
+    object J2
+
+    actual enum class K1 { FOO, BAR, BAZ }
+}
+
+actual interface L {
+    actual class M1 actual constructor()
+    class M2
+    class M3
+    class M4
+    class M5
+
+    actual interface N1
+    interface N2
+    interface N3
+
+    actual object O1
+    object O2
+
+    actual enum class P1 { FOO, BAR, BAZ }
+}
+
+actual object R {
+    actual class S1 actual constructor()
+    class S2
+    class S3
+    class S4
+
+    actual interface T1
+    interface T2
+    interface T3
+
+    actual object U1
+    object U2
+
+    actual enum class V1 { FOO, BAR, BAZ }
+}
+
+actual class W actual constructor() {
+    actual object X {
+        actual interface Y {
+            actual class Z actual constructor() {
+                actual enum class AA { FOO, BAR, BAZ }
+            }
+        }
+    }
+}
+
+actual class BB1 actual constructor() { actual companion object }
+actual class BB2 actual constructor() { companion object }
+
+actual class CC1 actual constructor() { actual companion object DD1 }
+actual class CC2 actual constructor() { companion object DD2 }
+actual class CC3 actual constructor() { companion object DD3 }
+
+actual inline class EE1 actual constructor(actual val value: String)
+inline class EE2(val value: String)
+
+actual external class FF1 actual constructor(actual val property1: String) {
+    actual val property2 = property1
+    actual val property3 get() = property1
+    actual val property4: String
+
+    actual fun function1() = property1
+    actual fun function2(): String
+}
+actual external class FF2 actual constructor()
+
+actual sealed class GG1
+actual sealed class GG2 {
+    actual class HH1 actual constructor(): GG2()
+    actual object HH2 : GG2()
+    class HH3 : GG2()
+}
+
+actual class HH5 actual constructor(): GG2()
+actual object HH6 : GG2()
+class HH7 : GG2()
+
+actual enum class II1
+actual enum class II2 { FOO, BAR }
+
+actual interface JJ {
+    actual val property: String
+    actual fun function(): String
+}
+
+actual class KK1 actual constructor(actual override val property: String) : JJ {
+    actual override fun function() =  property
+}
+
+actual class KK2 actual constructor(private val wrapped: JJ) : JJ by wrapped
+
+actual data class LL1 actual constructor(actual val value: String)
+actual data class LL2 actual constructor(actual val value: String)

native/commonizer/testData/classifierCommonization/classKindAndModifiers/commonized/jvm/package_root.kt

@@ -0,0 +1,135 @@
+actual class A1 actual constructor()
+interface A2
+annotation class A3
+object A4
+enum class A5 { FOO, BAR, BAZ }
+
+actual interface B1
+annotation class B2
+object B3
+enum class B4 { FOO, BAR, BAZ }
+
+actual annotation class C1 actual constructor()
+object C2
+enum class C3 { FOO, BAR, BAZ }
+
+actual object D1
+enum class D2 { FOO, BAR, BAZ }
+
+actual enum class E1 { FOO, BAR, BAZ }
+
+actual class F actual constructor() {
+    actual inner class G1 actual constructor()
+    class G2
+    interface G3
+    object G4
+    enum class G5 { FOO, BAR, BAZ }
+    companion object G6
+
+    actual class H1 actual constructor()
+    interface H2
+    object H3
+    enum class H4 { FOO, BAR, BAZ }
+
+    actual interface I1
+    object I2
+    enum class I3 { FOO, BAR, BAZ }
+
+    actual object J1
+    enum class J2 { FOO, BAR, BAZ }
+
+    actual enum class K1 { FOO, BAR, BAZ }
+}
+
+actual interface L {
+    actual class M1 actual constructor()
+    interface M2
+    object M3
+    enum class M4 { FOO, BAR, BAZ }
+    companion object M5
+
+    actual interface N1
+    object N2
+    enum class N3 { FOO, BAR, BAZ }
+
+    actual object O1
+    enum class O2 { FOO, BAR, BAZ }
+
+    actual enum class P1 { FOO, BAR, BAZ }
+}
+
+actual object R {
+    actual class S1 actual constructor()
+    interface S2
+    object S3
+    enum class S4 { FOO, BAR, BAZ }
+
+    actual interface T1
+    object T2
+    enum class T3 { FOO, BAR, BAZ }
+
+    actual object U1
+    enum class U2 { FOO, BAR, BAZ }
+
+    actual enum class V1 { FOO, BAR, BAZ }
+}
+
+actual class W actual constructor() {
+    actual object X {
+        actual interface Y {
+            actual class Z actual constructor() {
+                actual enum class AA { FOO, BAR, BAZ }
+            }
+        }
+    }
+}
+
+actual class BB1 actual constructor() { actual companion object }
+actual class BB2 actual constructor()
+
+actual class CC1 actual constructor() { actual companion object DD1 }
+actual class CC2 actual constructor() { companion object CompanionWithAnotherName }
+actual class CC3 actual constructor() { companion object }
+
+actual inline class EE1 actual constructor(actual val value: String)
+class EE2(val value: String)
+
+actual class FF1 actual constructor(actual val property1: String) {
+    actual val property2 = property1
+    actual val property3 get() = property1
+    actual val property4 = property1
+
+    actual fun function1() = property1
+    actual fun function2() = function1()
+}
+actual external class FF2 actual constructor()
+
+actual sealed class GG1
+actual sealed class GG2 {
+    actual class HH1 actual constructor(): GG2()
+    actual object HH2 : GG2()
+    class HH4 : GG2()
+}
+
+actual class HH5 actual constructor(): GG2()
+actual object HH6 : GG2()
+class HH8 : GG2()
+
+actual enum class II1
+actual enum class II2 { FOO, BAZ }
+
+actual interface JJ {
+    actual val property: String
+    val property2: String
+    actual fun function(): String
+}
+
+actual class KK1 actual constructor(actual override val property: String) : JJ {
+    val property2 = property
+    actual override fun function() =  property
+}
+
+actual class KK2 actual constructor(wrapped: JJ) : JJ by wrapped
+
+actual data class LL1 actual constructor(actual val value: String)
+actual class LL2 actual constructor(actual val value: String)

native/commonizer/testData/classifierCommonization/classKindAndModifiers/original/js/package_root.kt

@@ -0,0 +1,133 @@
+class A1
+class A2
+class A3
+class A4
+class A5
+
+interface B1
+interface B2
+interface B3
+interface B4
+
+annotation class C1
+annotation class C2
+annotation class C3
+
+object D1
+object D2
+
+enum class E1 { FOO, BAR, BAZ }
+
+class F {
+    inner class G1
+    inner class G2
+    inner class G3
+    inner class G4
+    inner class G5
+    inner class G6
+
+    class H1
+    class H2
+    class H3
+    class H4
+
+    interface I1
+    interface I2
+    interface I3
+
+    object J1
+    object J2
+
+    enum class K1 { FOO, BAR, BAZ }
+}
+
+interface L {
+    class M1
+    class M2
+    class M3
+    class M4
+    class M5
+
+    interface N1
+    interface N2
+    interface N3
+
+    object O1
+    object O2
+
+    enum class P1 { FOO, BAR, BAZ }
+}
+
+object R {
+    class S1
+    class S2
+    class S3
+    class S4
+
+    interface T1
+    interface T2
+    interface T3
+
+    object U1
+    object U2
+
+    enum class V1 { FOO, BAR, BAZ }
+}
+
+class W {
+    object X {
+        interface Y {
+            class Z {
+                enum class AA { FOO, BAR, BAZ }
+            }
+        }
+    }
+}
+
+class BB1 { companion object }
+class BB2 { companion object }
+
+class CC1 { companion object DD1 }
+class CC2 { companion object DD2 }
+class CC3 { companion object DD3 }
+
+inline class EE1(val value: String)
+inline class EE2(val value: String)
+
+external class FF1(val property1: String) {
+    val property2 = property1
+    val property3 get() = property1
+    val property4: String
+
+    fun function1() = property1
+    fun function2(): String
+}
+external class FF2()
+
+sealed class GG1
+sealed class GG2 {
+    class HH1 : GG2()
+    object HH2 : GG2()
+    class HH3 : GG2()
+}
+
+class HH5 : GG2()
+object HH6 : GG2()
+class HH7 : GG2()
+
+enum class II1
+enum class II2 { FOO, BAR }
+
+interface JJ {
+    val property: String
+    fun function(): String
+}
+
+class KK1(override val property: String) : JJ {
+    override fun function() = property
+}
+
+class KK2(private val wrapped: JJ) : JJ by wrapped
+
+data class LL1(val value: String)
+data class LL2(val value: String)

native/commonizer/testData/classifierCommonization/classKindAndModifiers/original/jvm/package_root.kt

@@ -0,0 +1,135 @@
+class A1
+interface A2
+annotation class A3
+object A4
+enum class A5 { FOO, BAR, BAZ }
+
+interface B1
+annotation class B2
+object B3
+enum class B4 { FOO, BAR, BAZ }
+
+annotation class C1
+object C2
+enum class C3 { FOO, BAR, BAZ }
+
+object D1
+enum class D2 { FOO, BAR, BAZ }
+
+enum class E1 { FOO, BAR, BAZ }
+
+class F {
+    inner class G1
+    class G2
+    interface G3
+    object G4
+    enum class G5 { FOO, BAR, BAZ }
+    companion object G6
+
+    class H1
+    interface H2
+    object H3
+    enum class H4 { FOO, BAR, BAZ }
+
+    interface I1
+    object I2
+    enum class I3 { FOO, BAR, BAZ }
+
+    object J1
+    enum class J2 { FOO, BAR, BAZ }
+
+    enum class K1 { FOO, BAR, BAZ }
+}
+
+interface L {
+    class M1
+    interface M2
+    object M3
+    enum class M4 { FOO, BAR, BAZ }
+    companion object M5
+
+    interface N1
+    object N2
+    enum class N3 { FOO, BAR, BAZ }
+
+    object O1
+    enum class O2 { FOO, BAR, BAZ }
+
+    enum class P1 { FOO, BAR, BAZ }
+}
+
+object R {
+    class S1
+    interface S2
+    object S3
+    enum class S4 { FOO, BAR, BAZ }
+
+    interface T1
+    object T2
+    enum class T3 { FOO, BAR, BAZ }
+
+    object U1
+    enum class U2 { FOO, BAR, BAZ }
+
+    enum class V1 { FOO, BAR, BAZ }
+}
+
+class W {
+    object X {
+        interface Y {
+            class Z {
+                enum class AA { FOO, BAR, BAZ }
+            }
+        }
+    }
+}
+
+class BB1 { companion object }
+class BB2
+
+class CC1 { companion object DD1 }
+class CC2 { companion object CompanionWithAnotherName }
+class CC3 { companion object }
+
+inline class EE1(val value: String)
+class EE2(val value: String)
+
+class FF1(val property1: String) {
+    val property2 = property1
+    val property3 get() = property1
+    val property4 = property1
+
+    fun function1() = property1
+    fun function2() = function1()
+}
+external class FF2()
+
+sealed class GG1
+sealed class GG2 {
+    class HH1 : GG2()
+    object HH2 : GG2()
+    class HH4 : GG2()
+}
+
+class HH5 : GG2()
+object HH6 : GG2()
+class HH8 : GG2()
+
+enum class II1
+enum class II2 { FOO, BAZ }
+
+interface JJ {
+    val property: String
+    val property2: String
+    fun function(): String
+}
+
+class KK1(override val property: String) : JJ {
+    val property2 = property
+    override fun function() = property
+}
+
+class KK2(wrapped: JJ) : JJ by wrapped
+
+data class LL1(val value: String)
+class LL2(val value: String)

native/commonizer/testData/classifierCommonization/constructors/commonized/common/package_root.kt

@@ -0,0 +1,30 @@
+expect class A1(text: String) { constructor(number: Int) }
+expect class A2(text: String) { constructor(number: Int) }
+expect class A3
+expect class A4
+expect class A5
+
+expect class B1 protected constructor(text: String) { protected constructor(number: Int) }
+expect class B2
+expect class B3
+
+expect class C1 internal constructor(text: String) { internal constructor(number: Int) }
+expect class C2
+
+expect class D1
+
+expect class E {
+    constructor(a: Any)
+
+    constructor(a: Any, b: String)
+    constructor(a: Any, b: Int)
+}
+
+expect enum class F {
+    FOO,
+    BAR,
+    BAZ;
+
+    // no constructor allowed for enum class
+    val alias: String
+}

native/commonizer/testData/classifierCommonization/constructors/commonized/js/package_root.kt

@@ -0,0 +1,30 @@
+actual class A1 actual constructor(text: String) { actual constructor(number: Int) : this(number.toString()) }
+actual class A2 actual constructor(text: String) { actual constructor(number: Int) : this(number.toString()) }
+actual class A3(text: String) { constructor(number: Int) : this(number.toString()) }
+actual class A4(text: String) { constructor(number: Int) : this(number.toString()) }
+actual class A5(text: String) { constructor(number: Int) : this(number.toString()) }
+
+actual class B1 protected actual constructor(text: String) { protected actual constructor(number: Int) : this(number.toString()) }
+actual class B2 protected constructor(text: String) { protected constructor(number: Int) : this(number.toString()) }
+actual class B3 protected constructor(text: String) { protected constructor(number: Int) : this(number.toString()) }
+
+actual class C1 internal actual constructor(text: String) { internal actual constructor(number: Int) : this(number.toString()) }
+actual class C2 internal constructor(text: String) { internal constructor(number: Int) : this(number.toString()) }
+
+actual class D1 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+actual class E {
+    constructor(a: Int)
+    actual constructor(a: Any)
+
+    constructor(a: Int, b: String)
+    constructor(a: Int, b: Any)
+    actual constructor(a: Any, b: String)
+    actual constructor(a: Any, b: Int)
+}
+
+actual enum class F(actual val alias: String) {
+    FOO("foo"),
+    BAR("bar"),
+    BAZ("baz")
+}

native/commonizer/testData/classifierCommonization/constructors/commonized/jvm/package_root.kt

@@ -0,0 +1,30 @@
+actual class A1 actual constructor(text: String) { actual constructor(number: Int) : this(number.toString()) }
+actual class A2 actual constructor(text: String) { actual constructor(number: Int) : this(number.toString()) }
+actual class A3 protected constructor(text: String) { protected constructor(number: Int) : this(number.toString()) }
+actual class A4 internal constructor(text: String) { internal constructor(number: Int) : this(number.toString()) }
+actual class A5 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+actual class B1 protected actual constructor(text: String) { protected actual constructor(number: Int) : this(number.toString()) }
+actual class B2 internal constructor(text: String) { internal constructor(number: Int) : this(number.toString()) }
+actual class B3 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+actual class C1 internal actual constructor(text: String) { internal actual constructor(number: Int) : this(number.toString()) }
+actual class C2 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+actual class D1 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+actual class E {
+    constructor(a: String)
+    actual constructor(a: Any)
+
+    constructor(a: String, b: Int)
+    constructor(a: String, b: Any)
+    actual constructor(a: Any, b: String)
+    actual constructor(a: Any, b: Int)
+}
+
+actual enum class F(actual val alias: String) {
+    FOO("foo"),
+    BAR("bar"),
+    BAZ("baz")
+}

native/commonizer/testData/classifierCommonization/constructors/original/js/package_root.kt

@@ -0,0 +1,30 @@
+class A1(text: String) { constructor(number: Int) : this(number.toString()) }
+class A2(text: String) { constructor(number: Int) : this(number.toString()) }
+class A3(text: String) { constructor(number: Int) : this(number.toString()) }
+class A4(text: String) { constructor(number: Int) : this(number.toString()) }
+class A5(text: String) { constructor(number: Int) : this(number.toString()) }
+
+class B1 protected constructor(text: String) { protected constructor(number: Int) : this(number.toString()) }
+class B2 protected constructor(text: String) { protected constructor(number: Int) : this(number.toString()) }
+class B3 protected constructor(text: String) { protected constructor(number: Int) : this(number.toString()) }
+
+class C1 internal constructor(text: String) { internal constructor(number: Int) : this(number.toString()) }
+class C2 internal constructor(text: String) { internal constructor(number: Int) : this(number.toString()) }
+
+class D1 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+class E {
+    constructor(a: Int)
+    constructor(a: Any)
+
+    constructor(a: Int, b: String)
+    constructor(a: Int, b: Any)
+    constructor(a: Any, b: String)
+    constructor(a: Any, b: Int)
+}
+
+enum class F(val alias: String) {
+    FOO("foo"),
+    BAR("bar"),
+    BAZ("baz")
+}

native/commonizer/testData/classifierCommonization/constructors/original/jvm/package_root.kt

@@ -0,0 +1,30 @@
+class A1(text: String) { constructor(number: Int) : this(number.toString()) }
+class A2 constructor(text: String) { constructor(number: Int) : this(number.toString()) }
+class A3 protected constructor(text: String) { protected constructor(number: Int) : this(number.toString()) }
+class A4 internal constructor(text: String) { internal constructor(number: Int) : this(number.toString()) }
+class A5 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+class B1 protected constructor(text: String) { protected constructor(number: Int) : this(number.toString()) }
+class B2 internal constructor(text: String) { internal constructor(number: Int) : this(number.toString()) }
+class B3 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+class C1 internal constructor(text: String) { internal constructor(number: Int) : this(number.toString()) }
+class C2 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+class D1 private constructor(text: String) { private constructor(number: Int) : this(number.toString()) }
+
+class E {
+    constructor(a: String)
+    constructor(a: Any)
+
+    constructor(a: String, b: Int)
+    constructor(a: String, b: Any)
+    constructor(a: Any, b: String)
+    constructor(a: Any, b: Int)
+}
+
+enum class F(val alias: String) {
+    FOO("foo"),
+    BAR("bar"),
+    BAZ("baz")
+}

native/commonizer/testData/classifierCommonization/modality/commonized/common/package_root.kt

@@ -0,0 +1,17 @@
+expect final class A1()
+expect final class A2()
+expect open class B1()
+expect abstract class C1()
+expect sealed class D1
+
+expect abstract class E() {
+    final val p1: Int
+    final val p2: Int
+    open val p4: Int
+    abstract val p6: Int
+
+    final fun f1(): Int
+    final fun f2(): Int
+    open fun f4(): Int
+    abstract fun f6(): Int
+}

native/commonizer/testData/classifierCommonization/modality/commonized/js/package_root.kt

@@ -0,0 +1,33 @@
+actual final class A1 actual constructor()
+actual final class A2 actual constructor()
+final class A3
+final class A4
+
+actual open class B1 actual constructor()
+open class B2
+open class B3
+
+actual abstract class C1 actual constructor()
+abstract class C2
+
+actual sealed class D1
+
+actual abstract class E actual constructor() {
+    actual final val p1: Int = 1
+    actual final val p2: Int = 1
+    final val p3: Int = 1
+
+    actual open val p4: Int = 1
+    open val p5: Int = 1
+
+    actual abstract val p6: Int
+
+    actual final fun f1(): Int = 1
+    actual final fun f2(): Int = 1
+    final fun f3(): Int = 1
+
+    actual open fun f4(): Int = 1
+    open fun f5(): Int = 1
+
+    actual abstract fun f6(): Int
+}

native/commonizer/testData/classifierCommonization/modality/commonized/jvm/package_root.kt

@@ -0,0 +1,33 @@
+actual final class A1 actual constructor()
+actual open class A2 actual constructor()
+abstract class A3
+sealed class A4
+
+actual open class B1 actual constructor()
+abstract class B2
+sealed class B3
+
+actual abstract class C1 actual constructor()
+sealed class C2
+
+actual sealed class D1
+
+actual abstract class E actual constructor() {
+    actual final val p1: Int = 1
+    actual open val p2: Int = 1
+    abstract val p3: Int
+
+    actual open val p4: Int = 1
+    abstract val p5: Int
+
+    actual abstract val p6: Int
+
+    actual final fun f1(): Int = 1
+    actual open fun f2(): Int = 1
+    abstract fun f3(): Int
+
+    actual open fun f4(): Int = 1
+    abstract fun f5(): Int
+
+    actual abstract fun f6(): Int
+}

native/commonizer/testData/classifierCommonization/modality/original/js/package_root.kt

@@ -0,0 +1,33 @@
+final class A1
+final class A2
+final class A3
+final class A4
+
+open class B1
+open class B2
+open class B3
+
+abstract class C1
+abstract class C2
+
+sealed class D1
+
+abstract class E {
+    final val p1: Int = 1
+    final val p2: Int = 1
+    final val p3: Int = 1
+
+    open val p4: Int = 1
+    open val p5: Int = 1
+
+    abstract val p6: Int
+
+    final fun f1(): Int = 1
+    final fun f2(): Int = 1
+    final fun f3(): Int = 1
+
+    open fun f4(): Int = 1
+    open fun f5(): Int = 1
+
+    abstract fun f6(): Int
+}

native/commonizer/testData/classifierCommonization/modality/original/jvm/package_root.kt

@@ -0,0 +1,33 @@
+final class A1
+open class A2
+abstract class A3
+sealed class A4
+
+open class B1
+abstract class B2
+sealed class B3
+
+abstract class C1
+sealed class C2
+
+sealed class D1
+
+abstract class E {
+    final val p1: Int = 1
+    open val p2: Int = 1
+    abstract val p3: Int
+
+    open val p4: Int = 1
+    abstract val p5: Int
+
+    abstract val p6: Int
+
+    final fun f1(): Int = 1
+    open fun f2(): Int = 1
+    abstract fun f3(): Int
+
+    open fun f4(): Int = 1
+    abstract fun f5(): Int
+
+    abstract fun f6(): Int
+}

native/commonizer/testData/classifierCommonization/supertypes/commonized/common/package_root.kt

@@ -0,0 +1,64 @@
+expect interface A1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+expect abstract class A2(): A1 {
+    abstract val property2: Int
+    abstract fun function2(): Int
+}
+
+expect class A3 (): A2 {
+    override val property1: Int
+    override val property2: Int
+    val property3: Int
+
+    override fun function1(): Int
+    override fun function2(): Int
+    fun function3(): Int
+}
+
+expect interface B1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+expect class B3(): B1 {
+    override val property1: Int
+    open val property2: Int
+    val property3: Int
+
+    override fun function1(): Int
+    open fun function2(): Int
+    fun function3(): Int
+}
+
+expect interface C1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+expect class C3 (): C1 {
+    override val property1: Int
+    val property2: Int
+    val property3: Int
+
+    override fun function1(): Int
+    fun function2(): Int
+    fun function3(): Int
+}
+
+expect interface D2 {
+    val property2: Int
+    fun function2(): Int
+}
+
+expect class D3(): D2 {
+    open val property1: Int
+    override val property2: Int
+    val property3: Int
+
+    open fun function1(): Int
+    override fun function2(): Int
+    fun function3(): Int
+}

native/commonizer/testData/classifierCommonization/supertypes/commonized/js/package_root.kt

@@ -0,0 +1,79 @@
+actual interface A1 {
+    actual val property1: Int
+    actual fun function1(): Int
+}
+
+actual abstract class A2 actual constructor(): A1 {
+    actual abstract val property2: Int
+    actual abstract fun function2(): Int
+}
+
+actual class A3 actual constructor(): A2() {
+    actual override val property1 = 1
+    actual override val property2 = 1
+    actual val property3 = 1
+
+    actual override fun function1() = 1
+    actual override fun function2() = 1
+    actual fun function3() = 1
+}
+
+actual interface B1 {
+    actual val property1: Int
+    actual fun function1(): Int
+}
+
+interface B2 {
+    val property2: Int
+    fun function2(): Int
+}
+
+actual class B3 actual constructor(): B1, B2 {
+    actual override val property1 = 1
+    actual override val property2 = 1
+    actual val property3 = 1
+
+    actual override fun function1() = 1
+    actual override fun function2() = 1
+    actual fun function3() = 1
+}
+
+actual interface C1 {
+    actual val property1: Int
+    actual fun function1(): Int
+}
+
+interface C2 {
+    val property2: Int
+    fun function2(): Int
+}
+
+actual class C3 actual constructor(): C1, C2 {
+    actual override val property1 = 1
+    actual override val property2 = 1
+    actual val property3 = 1
+
+    actual override fun function1() = 1
+    actual override fun function2() = 1
+    actual fun function3() = 1
+}
+
+interface D1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+actual interface D2 {
+    actual val property2: Int
+    actual fun function2(): Int
+}
+
+actual class D3 actual constructor(): D1, D2 {
+    actual override val property1 = 1
+    actual override val property2 = 1
+    actual val property3 = 1
+
+    actual override fun function1() = 1
+    actual override fun function2() = 1
+    actual fun function3() = 1
+}

native/commonizer/testData/classifierCommonization/supertypes/commonized/jvm/package_root.kt

@@ -0,0 +1,72 @@
+actual interface A1 {
+    actual val property1: Int
+    actual fun function1(): Int
+}
+
+actual abstract class A2 actual constructor(): A1 {
+    actual abstract val property2: Int
+    actual abstract fun function2(): Int
+}
+
+actual class A3 actual constructor(): A2(), A1 {
+    actual override val property1 = 1
+    actual override val property2 = 1
+    actual val property3 = 1
+
+    actual override fun function1() = 1
+    actual override fun function2() = 1
+    actual fun function3() = 1
+}
+
+actual interface B1 {
+    actual val property1: Int
+    val property2: Int
+
+    actual fun function1(): Int
+    fun function2(): Int
+}
+
+actual class B3 actual constructor(): B1 {
+    actual override val property1 = 1
+    actual override val property2 = 1
+    actual val property3 = 1
+
+    actual override fun function1() = 1
+    actual override fun function2() = 1
+    actual fun function3() = 1
+}
+
+actual interface C1 {
+    actual val property1: Int
+    actual fun function1(): Int
+}
+
+actual class C3 actual constructor(): C1 {
+    actual override val property1 = 1
+    actual val property2 = 1
+    actual val property3 = 1
+
+    actual override fun function1() = 1
+    actual fun function2() = 1
+    actual fun function3() = 1
+}
+
+abstract class D1 {
+    abstract val property1: Int
+    abstract fun function1(): Int
+}
+
+actual interface D2 {
+    actual val property2: Int
+    actual fun function2(): Int
+}
+
+actual class D3 actual constructor(): D1(), D2 {
+    actual override val property1 = 1
+    actual override val property2 = 1
+    actual val property3 = 1
+
+    actual override fun function1() = 1
+    actual override fun function2() = 1
+    actual fun function3() = 1
+}

native/commonizer/testData/classifierCommonization/supertypes/original/js/package_root.kt

@@ -0,0 +1,79 @@
+interface A1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+abstract class A2 : A1 {
+    abstract val property2: Int
+    abstract fun function2(): Int
+}
+
+class A3 : A2() {
+    override val property1 = 1
+    override val property2 = 1
+    val property3 = 1
+
+    override fun function1() = 1
+    override fun function2() = 1
+    fun function3() = 1
+}
+
+interface B1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+interface B2 {
+    val property2: Int
+    fun function2(): Int
+}
+
+class B3 : B1, B2 {
+    override val property1 = 1
+    override val property2 = 1
+    val property3 = 1
+
+    override fun function1() = 1
+    override fun function2() = 1
+    fun function3() = 1
+}
+
+interface C1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+interface C2 {
+    val property2: Int
+    fun function2(): Int
+}
+
+class C3 : C1, C2 {
+    override val property1 = 1
+    override val property2 = 1
+    val property3 = 1
+
+    override fun function1() = 1
+    override fun function2() = 1
+    fun function3() = 1
+}
+
+interface D1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+interface D2 {
+    val property2: Int
+    fun function2(): Int
+}
+
+class D3 : D1, D2 {
+    override val property1 = 1
+    override val property2 = 1
+    val property3 = 1
+
+    override fun function1() = 1
+    override fun function2() = 1
+    fun function3() = 1
+}

native/commonizer/testData/classifierCommonization/supertypes/original/jvm/package_root.kt

@@ -0,0 +1,72 @@
+interface A1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+abstract class A2 : A1 {
+    abstract val property2: Int
+    abstract fun function2(): Int
+}
+
+class A3 : A2(), A1 {
+    override val property1 = 1
+    override val property2 = 1
+    val property3 = 1
+
+    override fun function1() = 1
+    override fun function2() = 1
+    fun function3() = 1
+}
+
+interface B1 {
+    val property1: Int
+    val property2: Int
+
+    fun function1(): Int
+    fun function2(): Int
+}
+
+class B3 : B1 {
+    override val property1 = 1
+    override val property2 = 1
+    val property3 = 1
+
+    override fun function1() = 1
+    override fun function2() = 1
+    fun function3() = 1
+}
+
+interface C1 {
+    val property1: Int
+    fun function1(): Int
+}
+
+class C3 : C1 {
+    override val property1 = 1
+    val property2 = 1
+    val property3 = 1
+
+    override fun function1() = 1
+    fun function2() = 1
+    fun function3() = 1
+}
+
+abstract class D1 {
+    abstract val property1: Int
+    abstract fun function1(): Int
+}
+
+interface D2 {
+    val property2: Int
+    fun function2(): Int
+}
+
+class D3 : D1(), D2 {
+    override val property1 = 1
+    override val property2 = 1
+    val property3 = 1
+
+    override fun function1() = 1
+    override fun function2() = 1
+    fun function3() = 1
+}

native/commonizer/testData/classifierCommonization/typeAliases/commonized/common/package_root.kt

@@ -0,0 +1,2 @@
+expect class A ()
+expect class B

native/commonizer/testData/classifierCommonization/typeAliases/commonized/js/package_root.kt

@@ -0,0 +1,8 @@
+actual class A actual constructor()
+actual typealias B = A
+typealias C = B
+typealias D = List<String>
+typealias E<T> = List<T>
+typealias F<R> = Function<R>
+typealias G = () -> Unit
+typealias H = (String) -> Int

native/commonizer/testData/classifierCommonization/typeAliases/commonized/jvm/package_root.kt

@@ -0,0 +1,8 @@
+actual class A actual constructor()
+actual typealias B = A
+typealias C = B
+typealias D = List<String>
+typealias E<T> = List<T>
+typealias F<R> = Function<R>
+typealias G = () -> Unit
+typealias H = (String) -> Int

native/commonizer/testData/classifierCommonization/typeAliases/original/js/package_root.kt

@@ -0,0 +1,8 @@
+class A
+typealias B = A
+typealias C = B
+typealias D = List<String>
+typealias E<T> = List<T>
+typealias F<R> = Function<R>
+typealias G = () -> Unit
+typealias H = (String) -> Int

native/commonizer/testData/classifierCommonization/typeAliases/original/jvm/package_root.kt

@@ -0,0 +1,8 @@
+class A
+typealias B = A
+typealias C = B
+typealias D = List<String>
+typealias E<T> = List<T>
+typealias F<R> = Function<R>
+typealias G = () -> Unit
+typealias H = (String) -> Int

native/commonizer/testData/classifierCommonization/typeParameters/commonized/common/package_root.kt

@@ -0,0 +1,149 @@
+expect class A2<T : Any?>() {
+    val property: T
+    fun function(value: T): T
+
+    expect class Nested<T : Any?>() {
+        val property: T
+        fun function(value: T): T
+    }
+
+    expect inner class Inner() {
+        val property: T
+        fun function(value: T): T
+    }
+}
+expect class B4<T : Any>() {
+    val property: T
+    fun function(value: T): T
+
+    expect class Nested<T : Any>() {
+        val property: T
+        fun function(value: T): T
+    }
+
+    expect inner class Inner() {
+        val property: T
+        fun function(value: T): T
+    }
+}
+expect class C5<T : CharSequence>() {
+    val property: T
+    fun function(value: T): T
+
+    expect class Nested<T : CharSequence>() {
+        val property: T
+        fun function(value: T): T
+    }
+
+    expect inner class Inner() {
+        val property: T
+        fun function(value: T): T
+    }
+}
+expect class D6<T : String>() {
+    val property: T
+    fun function(value: T): T
+
+    expect class Nested<T : String>() {
+        val property: T
+        fun function(value: T): T
+    }
+
+    expect inner class Inner() {
+        val property: T
+        fun function(value: T): T
+    }
+}
+expect class E7<String>() {
+    val property: String
+    fun function(value: String): String
+
+    expect class Nested<String>() {
+        val property: String
+        fun function(value: String): String
+    }
+
+    expect inner class Inner() {
+        val property: String
+        fun function(value: String): String
+    }
+}
+expect class F1<T>() {
+    val property: T
+    fun function(value: T): T
+
+    expect class Nested<T>() {
+        val property: T
+        fun function(value: T): T
+    }
+
+    expect inner class Inner() {
+        val property: T
+        fun function(value: T): T
+    }
+}
+expect class G1<T, R>() {
+    val property1: T
+    val property2: R
+    fun function(value: T): R
+
+    expect class Nested<T, R>() {
+        val property1: T
+        val property2: R
+        fun function(value: T): R
+    }
+
+    expect inner class Inner() {
+        val property1: T
+        val property2: R
+        fun function(value: T): R
+    }
+}
+
+expect class H1<T>() {
+    val dependentProperty: T
+    fun dependentFunction(value: T): T
+
+    val T.dependentExtensionProperty: T
+    fun T.dependentExtensionFunction(): T
+
+    fun <T> independentFunction(): T
+
+    val <T> T.independentExtensionProperty: T
+    fun <T> T.independentExtensionFunction(): T
+}
+expect class H2<T>() {
+    val dependentProperty: T
+    fun dependentFunction(value: T): T
+
+    val T.dependentExtensionProperty: T
+    fun T.dependentExtensionFunction(): T
+}
+
+expect class I<T : I<T>>() {
+    val property: T
+    fun function(value: T): T
+}
+
+expect interface J1<A> {
+    fun a(): A
+}
+expect interface J2<A, B> {
+    fun a(b: B): A
+    fun b(a: A): B
+}
+expect interface J3<A, B, C> {
+    fun a(b: B, c: C): A
+    fun b(a: A, c: C): B
+    fun c(a: A, b: B): C
+}
+
+expect class K<A, B : A, C : J1<B>, D : J2<C, A>>() : J3<D, C, B> {
+    override fun a(b: C, c: B): D
+    override fun b(a: D, c: B): C
+    override fun c(a: D, b: C): B
+    inner class Inner<C, D : C, E : J2<C, D>>() {
+        fun dependentFunction(value: A): E
+        fun <A : CharSequence, E : Number> independentFunction(value: A): E
+    }
+}

native/commonizer/testData/classifierCommonization/typeParameters/commonized/js/package_root.kt

@@ -0,0 +1,659 @@
+class A1<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+actual class A2<T> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class A3<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A4<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A5<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A6<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A7<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+class B1<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B2<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B3<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+actual class B4<T : Any> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T : Any> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class B5<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B6<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B7<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+class C1<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C2<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C3<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C4<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+actual class C5<T : CharSequence> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T : CharSequence> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class C6<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C7<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+class D1<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D2<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D3<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D4<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D5<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+actual class D6<T : String> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T : String> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class D7<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+class E1<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E2<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E3<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E4<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E5<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E6<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+actual class E7<String> actual constructor() {
+    actual val property: String get() = TODO()
+    actual fun function(value: String): String = value
+
+    actual class Nested<String> actual constructor() {
+        actual val property: String get() = TODO()
+        actual fun function(value: String): String = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: String get() = TODO()
+        actual fun function(value: String): String = value
+    }
+}
+
+actual class F1<T> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class F2<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class F3<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+actual class G1<T, R> actual constructor() {
+    actual val property1: T get() = TODO()
+    actual val property2: R get() = TODO()
+    actual fun function(value: T): R = TODO()
+
+    actual class Nested<T, R> actual constructor() {
+        actual val property1: T get() = TODO()
+        actual val property2: R get() = TODO()
+        actual fun function(value: T): R = TODO()
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property1: T get() = TODO()
+        actual val property2: R get() = TODO()
+        actual fun function(value: T): R = TODO()
+    }
+}
+class G2<T, R> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<T, R> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+class G3<T, R> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<T, R> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+class G4<T, R> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<T, R> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+
+actual class H1<T> actual constructor() {
+    actual val dependentProperty: T get() = TODO()
+    actual fun dependentFunction(value: T): T = value
+
+    actual val T.dependentExtensionProperty: T get() = this
+    actual fun T.dependentExtensionFunction(): T = this
+
+    actual fun <T> independentFunction(): T = TODO()
+
+    actual val <T> T.independentExtensionProperty: T get() = this
+    actual fun <T> T.independentExtensionFunction(): T = this
+}
+actual class H2<T> actual constructor() {
+    actual val dependentProperty: T get() = TODO()
+    actual fun dependentFunction(value: T): T = value
+
+    actual val T.dependentExtensionProperty: T get() = this
+    actual fun T.dependentExtensionFunction(): T = this
+
+    fun <T> independentFunction(): T = TODO()
+
+    val <T> T.independentExtensionProperty: T get() = this
+    fun <T> T.independentExtensionFunction(): T = this
+}
+
+actual class I<T : I<T>> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+}
+
+actual interface J1<A> {
+    actual fun a(): A
+}
+actual interface J2<A, B> {
+    actual fun a(b: B): A
+    actual fun b(a: A): B
+}
+actual interface J3<A, B, C> {
+    actual fun a(b: B, c: C): A
+    actual fun b(a: A, c: C): B
+    actual fun c(a: A, b: B): C
+}
+
+actual class K<A, B : A, C : J1<B>, D : J2<C, A>> actual constructor() : J3<D, C, B> {
+    actual override fun a(b: C, c: B): D = TODO()
+    actual override fun b(a: D, c: B): C = TODO()
+    actual override fun c(a: D, b: C): B = TODO()
+    actual inner class Inner<C, D : C, E : J2<C, D>> actual constructor() {
+        actual fun dependentFunction(value: A): E = TODO()
+        actual fun <A : CharSequence, E : Number> independentFunction(value: A): E = TODO()
+    }
+}

native/commonizer/testData/classifierCommonization/typeParameters/commonized/jvm/package_root.kt

@@ -0,0 +1,659 @@
+class A1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+actual class A2<T : Any?> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T : Any?> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class A3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class A4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class B1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+class B2<T : Any?> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any?> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+actual class B4<T : Any> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T : Any> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class B5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class C1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+class C2<T : Any?> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any?>{
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class C4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+actual class C5<T : CharSequence> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T : CharSequence> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class C6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class D1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+class D2<T : Any?> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any?> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class D4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+actual class D6<T : String> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T : String> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class D7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class E1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+class E2<T : Any?> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any?> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class E3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class E4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class E5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class E6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+actual class E7<String> actual constructor() {
+    actual val property: String get() = TODO()
+    actual fun function(value: String): String = value
+
+    actual class Nested<String> actual constructor() {
+        actual val property: String get() = TODO()
+        actual fun function(value: String): String = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: String get() = TODO()
+        actual fun function(value: String): String = value
+    }
+}
+
+actual class F1<T> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+
+    actual class Nested<T> actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property: T get() = TODO()
+        actual fun function(value: T): T = value
+    }
+}
+class F2<in T> {
+    val property: String get() = TODO()
+    fun function(value: T): Any = TODO()
+
+    class Nested<in T> {
+        val property: String get() = TODO()
+        fun function(value: T): Any = TODO()
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: T): Any = TODO()
+    }
+}
+class F3<out T> {
+    val property: T get() = TODO()
+    fun function(value: Any): T = TODO()
+
+    class Nested<out T> {
+        val property: T get() = TODO()
+        fun function(value: Any): T = TODO()
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: Any): T = TODO()
+    }
+}
+
+actual class G1<T, R> actual constructor() {
+    actual val property1: T get() = TODO()
+    actual val property2: R get() = TODO()
+    actual fun function(value: T): R = TODO()
+
+    actual class Nested<T, R> actual constructor() {
+        actual val property1: T get() = TODO()
+        actual val property2: R get() = TODO()
+        actual fun function(value: T): R = TODO()
+    }
+
+    actual inner class Inner actual constructor() {
+        actual val property1: T get() = TODO()
+        actual val property2: R get() = TODO()
+        actual fun function(value: T): R = TODO()
+    }
+}
+class G2<T> {
+    val property1: T get() = TODO()
+    val property2: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property1: T get() = TODO()
+        val property2: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class G3<R> {
+    val property1: R get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R> {
+        val property1: R get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property1: R get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class G4<R, T> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<R, T> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+
+actual class H1<T> actual constructor() {
+    actual val dependentProperty: T get() = TODO()
+    actual fun dependentFunction(value: T): T = value
+
+    actual val T.dependentExtensionProperty: T get() = this
+    actual fun T.dependentExtensionFunction(): T = this
+
+    actual fun <T> independentFunction(): T = TODO()
+
+    actual val <T> T.independentExtensionProperty: T get() = this
+    actual fun <T> T.independentExtensionFunction(): T = this
+}
+actual class H2<T> actual constructor() {
+    actual val dependentProperty: T get() = TODO()
+    actual fun dependentFunction(value: T): T = value
+
+    actual val T.dependentExtensionProperty: T get() = this
+    actual fun T.dependentExtensionFunction(): T = this
+
+    fun independentFunction(): T = TODO()
+
+    val T.independentExtensionProperty: T get() = this
+    fun T.independentExtensionFunction(): T = this
+}
+
+actual class I<T : I<T>> actual constructor() {
+    actual val property: T get() = TODO()
+    actual fun function(value: T): T = value
+}
+
+actual interface J1<A> {
+    actual fun a(): A
+}
+actual interface J2<A, B> {
+    actual fun a(b: B): A
+    actual fun b(a: A): B
+}
+actual interface J3<A, B, C> {
+    actual fun a(b: B, c: C): A
+    actual fun b(a: A, c: C): B
+    actual fun c(a: A, b: B): C
+}
+
+actual class K<A, B : A, C : J1<B>, D : J2<C, A>> actual constructor() : J3<D, C, B> {
+    actual override fun a(b: C, c: B): D = TODO()
+    actual override fun b(a: D, c: B): C = TODO()
+    actual override fun c(a: D, b: C): B = TODO()
+    actual inner class Inner<C, D : C, E : J2<C, D>> actual constructor() {
+        actual fun dependentFunction(value: A): E = TODO()
+        actual fun <A : CharSequence, E : Number> independentFunction(value: A): E = TODO()
+    }
+}

native/commonizer/testData/classifierCommonization/typeParameters/original/js/package_root.kt

@@ -0,0 +1,659 @@
+class A1<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A2<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A3<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A4<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A5<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A6<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A7<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+class B1<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B2<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B3<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B5<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B6<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B7<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+class C1<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C2<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C3<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C4<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C6<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C7<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+class D1<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D2<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D3<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D4<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D5<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D7<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+class E1<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E2<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E3<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E4<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E5<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E6<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+class E7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class F1<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class F2<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class F3<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+
+class G1<T, R> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<T, R> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+class G2<T, R> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<T, R> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+class G3<T, R> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<T, R> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+class G4<T, R> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<T, R> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+
+class H1<T> {
+    val dependentProperty: T get() = TODO()
+    fun dependentFunction(value: T): T = value
+
+    val T.dependentExtensionProperty: T get() = this
+    fun T.dependentExtensionFunction(): T = this
+
+    fun <T> independentFunction(): T = TODO()
+
+    val <T> T.independentExtensionProperty: T get() = this
+    fun <T> T.independentExtensionFunction(): T = this
+}
+class H2<T> {
+    val dependentProperty: T get() = TODO()
+    fun dependentFunction(value: T): T = value
+
+    val T.dependentExtensionProperty: T get() = this
+    fun T.dependentExtensionFunction(): T = this
+
+    fun <T> independentFunction(): T = TODO()
+
+    val <T> T.independentExtensionProperty: T get() = this
+    fun <T> T.independentExtensionFunction(): T = this
+}
+
+class I<T : I<T>> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+}
+
+interface J1<A> {
+    actual fun a(): A
+}
+interface J2<A, B> {
+    actual fun a(b: B): A
+    actual fun b(a: A): B
+}
+interface J3<A, B, C> {
+    actual fun a(b: B, c: C): A
+    actual fun b(a: A, c: C): B
+    actual fun c(a: A, b: B): C
+}
+
+class K<A, B : A, C : J1<B>, D : J2<C, A>> : J3<D, C, B> {
+    override fun a(b: C, c: B): D = TODO()
+    override fun b(a: D, c: B): C = TODO()
+    override fun c(a: D, b: C): B = TODO()
+    inner class Inner<C, D : C, E : J2<C, D>> {
+        fun dependentFunction(value: A): E = TODO()
+        fun <A : CharSequence, E : Number> independentFunction(value: A): E = TODO()
+    }
+}

native/commonizer/testData/classifierCommonization/typeParameters/original/jvm/package_root.kt

@@ -0,0 +1,659 @@
+class A1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+class A2<T : Any?> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any?> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class A4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class A7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class B1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+class B2<T : Any?> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any?> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class B4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class B7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class C1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+class C2<T : Any?> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any?>{
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class C4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class C7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class D1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+class D2<T : Any?> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any?> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class D4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class D7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class E1 {
+    val property: Any get() = TODO()
+    fun function(value: Any): Any = value
+
+    class Nested {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+
+    inner class Inner {
+        val property: Any get() = TODO()
+        fun function(value: Any): Any = value
+    }
+}
+class E2<T : Any?> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any?> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class E3<R : Any?> {
+    val property: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R : Any?> {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class E4<T : Any> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : Any> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class E5<T : CharSequence> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : CharSequence> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class E6<T : String> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T : String> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class E7<String> {
+    val property: String get() = TODO()
+    fun function(value: String): String = value
+
+    class Nested<String> {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: String): String = value
+    }
+}
+
+class F1<T> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class F2<in T> {
+    val property: String get() = TODO()
+    fun function(value: T): Any = TODO()
+
+    class Nested<in T> {
+        val property: String get() = TODO()
+        fun function(value: T): Any = TODO()
+    }
+
+    inner class Inner {
+        val property: String get() = TODO()
+        fun function(value: T): Any = TODO()
+    }
+}
+class F3<out T> {
+    val property: T get() = TODO()
+    fun function(value: Any): T = TODO()
+
+    class Nested<out T> {
+        val property: T get() = TODO()
+        fun function(value: Any): T = TODO()
+    }
+
+    inner class Inner {
+        val property: T get() = TODO()
+        fun function(value: Any): T = TODO()
+    }
+}
+
+class G1<T, R> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<T, R> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+class G2<T> {
+    val property1: T get() = TODO()
+    val property2: T get() = TODO()
+    fun function(value: T): T = value
+
+    class Nested<T> {
+        val property1: T get() = TODO()
+        val property2: T get() = TODO()
+        fun function(value: T): T = value
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: T get() = TODO()
+        fun function(value: T): T = value
+    }
+}
+class G3<R> {
+    val property1: R get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: R): R = value
+
+    class Nested<R> {
+        val property1: R get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: R): R = value
+    }
+
+    inner class Inner {
+        val property1: R get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: R): R = value
+    }
+}
+class G4<R, T> {
+    val property1: T get() = TODO()
+    val property2: R get() = TODO()
+    fun function(value: T): R = TODO()
+
+    class Nested<R, T> {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+
+    inner class Inner {
+        val property1: T get() = TODO()
+        val property2: R get() = TODO()
+        fun function(value: T): R = TODO()
+    }
+}
+
+class H1<T> {
+    val dependentProperty: T get() = TODO()
+    fun dependentFunction(value: T): T = value
+
+    val T.dependentExtensionProperty: T get() = this
+    fun T.dependentExtensionFunction(): T = this
+
+    fun <T> independentFunction(): T = TODO()
+
+    val <T> T.independentExtensionProperty: T get() = this
+    fun <T> T.independentExtensionFunction(): T = this
+}
+class H2<T> {
+    val dependentProperty: T get() = TODO()
+    fun dependentFunction(value: T): T = value
+
+    val T.dependentExtensionProperty: T get() = this
+    fun T.dependentExtensionFunction(): T = this
+
+    fun independentFunction(): T = TODO()
+
+    val T.independentExtensionProperty: T get() = this
+    fun T.independentExtensionFunction(): T = this
+}
+
+class I<T : I<T>> {
+    val property: T get() = TODO()
+    fun function(value: T): T = value
+}
+
+interface J1<A> {
+    actual fun a(): A
+}
+interface J2<A, B> {
+    actual fun a(b: B): A
+    actual fun b(a: A): B
+}
+interface J3<A, B, C> {
+    actual fun a(b: B, c: C): A
+    actual fun b(a: A, c: C): B
+    actual fun c(a: A, b: B): C
+}
+
+class K<A, B : A, C : J1<B>, D : J2<C, A>> : J3<D, C, B> {
+    override fun a(b: C, c: B): D = TODO()
+    override fun b(a: D, c: B): C = TODO()
+    override fun c(a: D, b: C): B = TODO()
+    inner class Inner<C, D : C, E : J2<C, D>> {
+        fun dependentFunction(value: A): E = TODO()
+        fun <A : CharSequence, E : Number> independentFunction(value: A): E = TODO()
+    }
+}

native/commonizer/testData/classifierCommonization/visibility/commonized/common/package_root.kt

@@ -0,0 +1,20 @@
+expect public class A1()
+expect protected class B1()
+expect internal class C1()
+
+expect public class E1
+expect protected class E2
+expect internal class E3
+expect private class E4
+
+expect protected class F1
+expect private class F3
+
+expect internal class G1
+expect private class G2
+
+expect private class H1
+
+expect public class I1
+expect public class I2
+expect public class I3

native/commonizer/testData/classifierCommonization/visibility/commonized/js/package_root.kt

@@ -0,0 +1,32 @@
+actual public class A1 actual constructor()
+public class A2
+public class A3
+public class A4
+
+actual protected class B1 actual constructor()
+protected class B2
+protected class B3
+
+actual internal class C1 actual constructor()
+internal class C2
+
+private class D1
+
+actual public typealias E1 = A1
+actual public typealias E2 = A1
+actual public typealias E3 = A1
+actual public typealias E4 = A1
+
+actual protected typealias F1 = A1
+protected typealias F2 = A1
+actual protected typealias F3 = A1
+
+actual internal typealias G1 = A1
+actual internal typealias G2 = A1
+
+actual private typealias H1 = A1
+
+actual public typealias I1 = A1 // points to public
+actual public typealias I2 = B1 // points to protected
+actual public typealias I3 = C1 // points to internal
+public typealias I4 = D1 // points to private

native/commonizer/testData/classifierCommonization/visibility/commonized/jvm/package_root.kt

@@ -0,0 +1,32 @@
+actual public class A1 actual constructor()
+protected class A2
+internal class A3
+private class A4
+
+actual protected class B1 actual constructor()
+internal class B2
+private class B3
+
+actual internal class C1 actual constructor()
+private class C2
+
+private class D1
+
+actual public typealias E1 = A1
+actual protected typealias E2 = A1
+actual internal typealias E3 = A1
+actual private typealias E4 = A1
+
+actual protected typealias F1 = A1
+internal typealias F2 = A1
+actual private typealias F3 = A1
+
+actual internal typealias G1 = A1
+actual private typealias G2 = A1
+
+actual private typealias H1 = A1
+
+actual public typealias I1 = A1 // points to public
+actual public typealias I2 = B1 // points to protected
+actual public typealias I3 = C1 // points to internal
+public typealias I4 = D1 // points to private

native/commonizer/testData/classifierCommonization/visibility/original/js/package_root.kt

@@ -0,0 +1,32 @@
+public class A1
+public class A2
+public class A3
+public class A4
+
+protected class B1
+protected class B2
+protected class B3
+
+internal class C1
+internal class C2
+
+private class D1
+
+public typealias E1 = A1
+public typealias E2 = A1
+public typealias E3 = A1
+public typealias E4 = A1
+
+protected typealias F1 = A1
+protected typealias F2 = A1
+protected typealias F3 = A1
+
+internal typealias G1 = A1
+internal typealias G2 = A1
+
+private typealias H1 = A1
+
+public typealias I1 = A1 // points to public
+public typealias I2 = B1 // points to protected
+public typealias I3 = C1 // points to internal
+public typealias I4 = D1 // points to private

native/commonizer/testData/classifierCommonization/visibility/original/jvm/package_root.kt

@@ -0,0 +1,32 @@
+public class A1
+protected class A2
+internal class A3
+private class A4
+
+protected class B1
+internal class B2
+private class B3
+
+internal class C1
+private class C2
+
+private class D1
+
+public typealias E1 = A1
+protected typealias E2 = A1
+internal typealias E3 = A1
+private typealias E4 = A1
+
+protected typealias F1 = A1
+internal typealias F2 = A1
+private typealias F3 = A1
+
+internal typealias G1 = A1
+private typealias G2 = A1
+
+private typealias H1 = A1
+
+public typealias I1 = A1 // points to public
+public typealias I2 = B1 // points to protected
+public typealias I3 = C1 // points to internal
+public typealias I4 = D1 // points to private

native/commonizer/testData/functionCommonization/specifics/commonized/common/package_root.kt

@@ -0,0 +1,18 @@
+expect suspend fun suspendFunction1(): Int
+
+expect class Qux()
+
+expect operator fun Qux.get(index: Int): String
+expect fun Qux.set(index: Int, value: String)
+
+expect infix fun Qux.infixFunction1(another: Qux)
+expect fun Qux.infixFunction2(another: Qux)
+
+expect tailrec fun tailrecFunction1()
+expect fun tailrecFunction2()
+
+expect external fun externalFunction1()
+expect fun externalFunction2()
+
+expect inline fun inlineFunction1() {}
+expect fun inlineFunction2() {}

native/commonizer/testData/functionCommonization/specifics/commonized/js/package_root.kt

@@ -0,0 +1,19 @@
+actual suspend fun suspendFunction1() = 1
+suspend fun suspendFunction2() = 1
+
+actual class Qux actual constructor()
+
+actual operator fun Qux.get(index: Int) = "$index"
+actual operator fun Qux.set(index: Int, value: String) = Unit
+
+actual infix fun Qux.infixFunction1(another: Qux) {}
+actual infix fun Qux.infixFunction2(another: Qux) {}
+
+actual tailrec fun tailrecFunction1() {}
+actual tailrec fun tailrecFunction2() {}
+
+actual external fun externalFunction1()
+actual external fun externalFunction2()
+
+actual inline fun inlineFunction1() {}
+actual inline fun inlineFunction2() {}

native/commonizer/testData/functionCommonization/specifics/commonized/jvm/package_root.kt

@@ -0,0 +1,19 @@
+actual suspend fun suspendFunction1() = 1
+fun suspendFunction2() = 1
+
+actual class Qux actual constructor()
+
+actual operator fun Qux.get(index: Int) = "$index"
+actual fun Qux.set(index: Int, value: String) = Unit
+
+actual infix fun Qux.infixFunction1(another: Qux) {}
+actual fun Qux.infixFunction2(another: Qux) {}
+
+actual tailrec fun tailrecFunction1() {}
+actual fun tailrecFunction2() {}
+
+actual external fun externalFunction1()
+actual fun externalFunction2() {}
+
+actual inline fun inlineFunction1() {}
+actual fun inlineFunction2() {}

native/commonizer/testData/functionCommonization/specifics/original/js/package_root.kt

@@ -0,0 +1,19 @@
+suspend fun suspendFunction1() = 1
+suspend fun suspendFunction2() = 1
+
+class Qux
+
+operator fun Qux.get(index: Int) = "$index"
+operator fun Qux.set(index: Int, value: String) = Unit
+
+infix fun Qux.infixFunction1(another: Qux) {}
+infix fun Qux.infixFunction2(another: Qux) {}
+
+tailrec fun tailrecFunction1() {}
+tailrec fun tailrecFunction2() {}
+
+external fun externalFunction1()
+external fun externalFunction2()
+
+inline fun inlineFunction1() {}
+inline fun inlineFunction2() {}

native/commonizer/testData/functionCommonization/specifics/original/jvm/package_root.kt

@@ -0,0 +1,19 @@
+suspend fun suspendFunction1() = 1
+fun suspendFunction2() = 1
+
+class Qux
+
+operator fun Qux.get(index: Int) = "$index"
+fun Qux.set(index: Int, value: String) = Unit
+
+infix fun Qux.infixFunction1(another: Qux) {}
+fun Qux.infixFunction2(another: Qux) {}
+
+tailrec fun tailrecFunction1() {}
+fun tailrecFunction2() {}
+
+external fun externalFunction1()
+fun externalFunction2() {}
+
+inline fun inlineFunction1() {}
+fun inlineFunction2() {}

native/commonizer/testData/functionCommonization/valueParameters/commonized/common/package_root.kt

@@ -0,0 +1,18 @@
+expect fun functionNoParameters()
+expect fun functionSingleParameter(i: Int)
+expect fun functionTwoParameters(i: Int, s: String)
+expect fun functionThreeParameters(i: Int, s: String, l: List<Double>)
+
+expect inline fun inlineFunction1(lazyMessage: () -> String)
+expect inline fun inlineFunction2(lazyMessage: () -> String)
+expect inline fun inlineFunction3(crossinline lazyMessage: () -> String)
+expect inline fun inlineFunction4(lazyMessage: () -> String)
+expect inline fun inlineFunction5(noinline lazyMessage: () -> String)
+
+expect fun functionWithVararg1(vararg numbers: Int)
+expect fun functionWithVararg5(numbers: Array<out Int>)
+expect fun functionWithVararg6(vararg names: String)
+expect fun functionWithVararg10(names: Array<out String>)
+
+expect fun <T> functionWithTypeParameters1(p1: T, p2: String)
+expect fun <Q, R> functionWithTypeParameters4(p1: Q, p2: R)

native/commonizer/testData/functionCommonization/valueParameters/commonized/js/package_root.kt

@@ -0,0 +1,40 @@
+actual fun functionNoParameters() {}
+actual fun functionSingleParameter(i: Int) {}
+actual fun functionTwoParameters(i: Int, s: String) {}
+actual fun functionThreeParameters(i: Int, s: String, l: List<Double>) {}
+
+fun functionMismatchedParameterCount1(i: Int, s: String) {}
+fun functionMismatchedParameterCount2(i: Int, s: String, l: List<Double>) {}
+
+fun functionMismatchedParameterNames1(i: Int, s: String) {}
+fun functionMismatchedParameterNames2(i: Int, s: String) {}
+
+fun functionMismatchedParameterTypes1(i: Int, s: String) {}
+fun functionMismatchedParameterTypes2(i: Int, s: String) {}
+
+fun functionDefaultValues1(i: Int = 1, s: String) {}
+fun functionDefaultValues2(i: Int, s: String = "hello") {}
+
+actual inline fun inlineFunction1(lazyMessage: () -> String) {}
+actual inline fun inlineFunction2(lazyMessage: () -> String) {}
+actual inline fun inlineFunction3(crossinline lazyMessage: () -> String) {}
+actual inline fun inlineFunction4(lazyMessage: () -> String) {}
+actual inline fun inlineFunction5(noinline lazyMessage: () -> String) {}
+
+actual fun functionWithVararg1(vararg numbers: Int) {}
+fun functionWithVararg2(vararg numbers: Int) {}
+fun functionWithVararg3(vararg numbers: Int) {}
+fun functionWithVararg4(numbers: Array<Int>) {}
+actual fun functionWithVararg5(numbers: Array<out Int>) {}
+actual fun functionWithVararg6(vararg names: String) {}
+fun functionWithVararg7(vararg names: String) {}
+fun functionWithVararg8(vararg names: String) {}
+fun functionWithVararg9(names: Array<String>) {}
+actual fun functionWithVararg10(names: Array<out String>) {}
+
+actual fun <T> functionWithTypeParameters1(p1: T, p2: String) {}
+fun <T> functionWithTypeParameters2(p1: T, p2: String) {}
+fun <T> functionWithTypeParameters3(p1: T, p2: String) {}
+actual fun <Q, R> functionWithTypeParameters4(p1: Q, p2: R) {}
+fun <Q, R> functionWithTypeParameters5(p1: Q, p2: R) {}
+fun <Q, R> functionWithTypeParameters6(p1: Q, p2: R) {}

native/commonizer/testData/functionCommonization/valueParameters/commonized/jvm/package_root.kt

@@ -0,0 +1,40 @@
+actual fun functionNoParameters() {}
+actual fun functionSingleParameter(i: Int) {}
+actual fun functionTwoParameters(i: Int, s: String) {}
+actual fun functionThreeParameters(i: Int, s: String, l: List<Double>) {}
+
+fun functionMismatchedParameterCount1(i: Int, s: String, l: List<Double>) {}
+fun functionMismatchedParameterCount2(i: Int, s: String) {}
+
+fun functionMismatchedParameterNames1(i1: Int, s: String) {}
+fun functionMismatchedParameterNames2(i: Int, s1: String) {}
+
+fun functionMismatchedParameterTypes1(i: Short, s: String) {}
+fun functionMismatchedParameterTypes2(i: Int, s: CharSequence) {}
+
+fun functionDefaultValues1(i: Int = 1, s: String) {}
+fun functionDefaultValues2(i: Int, s: String = "hello") {}
+
+actual inline fun inlineFunction1(lazyMessage: () -> String) {}
+actual inline fun inlineFunction2(crossinline lazyMessage: () -> String) {}
+actual inline fun inlineFunction3(crossinline lazyMessage: () -> String) {}
+actual inline fun inlineFunction4(noinline lazyMessage: () -> String) {}
+actual inline fun inlineFunction5(noinline lazyMessage: () -> String) {}
+
+actual fun functionWithVararg1(vararg numbers: Int) {}
+fun functionWithVararg2(numbers: Array<Int>) {}
+fun functionWithVararg3(numbers: Array<out Int>) {}
+fun functionWithVararg4(numbers: Array<out Int>) {}
+actual fun functionWithVararg5(numbers: Array<out Int>) {}
+actual fun functionWithVararg6(vararg names: String) {}
+fun functionWithVararg7(names: Array<String>) {}
+fun functionWithVararg8(names: Array<out String>) {}
+fun functionWithVararg9(names: Array<out String>) {}
+actual fun functionWithVararg10(names: Array<out String>) {}
+
+actual fun <T> functionWithTypeParameters1(p1: T, p2: String) {}
+fun <T> functionWithTypeParameters2(p1: String, p2: String) {}
+fun <T> functionWithTypeParameters2(p1: String, p2: T) {}
+actual fun <Q, R> functionWithTypeParameters4(p1: Q, p2: R) {}
+fun <R, Q> functionWithTypeParameters5(p1: Q, p2: R) {}
+fun <Q, R> functionWithTypeParameters6(p1: R, p2: Q) {}

native/commonizer/testData/functionCommonization/valueParameters/original/js/package_root.kt

@@ -0,0 +1,40 @@
+fun functionNoParameters() {}
+fun functionSingleParameter(i: Int) {}
+fun functionTwoParameters(i: Int, s: String) {}
+fun functionThreeParameters(i: Int, s: String, l: List<Double>) {}
+
+fun functionMismatchedParameterCount1(i: Int, s: String) {}
+fun functionMismatchedParameterCount2(i: Int, s: String, l: List<Double>) {}
+
+fun functionMismatchedParameterNames1(i: Int, s: String) {}
+fun functionMismatchedParameterNames2(i: Int, s: String) {}
+
+fun functionMismatchedParameterTypes1(i: Int, s: String) {}
+fun functionMismatchedParameterTypes2(i: Int, s: String) {}
+
+fun functionDefaultValues1(i: Int = 1, s: String) {}
+fun functionDefaultValues2(i: Int, s: String = "hello") {}
+
+inline fun inlineFunction1(lazyMessage: () -> String) {}
+inline fun inlineFunction2(lazyMessage: () -> String) {}
+inline fun inlineFunction3(crossinline lazyMessage: () -> String) {}
+inline fun inlineFunction4(lazyMessage: () -> String) {}
+inline fun inlineFunction5(noinline lazyMessage: () -> String) {}
+
+fun functionWithVararg1(vararg numbers: Int) {}
+fun functionWithVararg2(vararg numbers: Int) {}
+fun functionWithVararg3(vararg numbers: Int) {}
+fun functionWithVararg4(numbers: Array<Int>) {}
+fun functionWithVararg5(numbers: Array<out Int>) {}
+fun functionWithVararg6(vararg names: String) {}
+fun functionWithVararg7(vararg names: String) {}
+fun functionWithVararg8(vararg names: String) {}
+fun functionWithVararg9(names: Array<String>) {}
+fun functionWithVararg10(names: Array<out String>) {}
+
+fun <T> functionWithTypeParameters1(p1: T, p2: String) {}
+fun <T> functionWithTypeParameters2(p1: T, p2: String) {}
+fun <T> functionWithTypeParameters3(p1: T, p2: String) {}
+fun <Q, R> functionWithTypeParameters4(p1: Q, p2: R) {}
+fun <Q, R> functionWithTypeParameters5(p1: Q, p2: R) {}
+fun <Q, R> functionWithTypeParameters6(p1: Q, p2: R) {}

native/commonizer/testData/functionCommonization/valueParameters/original/jvm/package_root.kt

@@ -0,0 +1,40 @@
+fun functionNoParameters() {}
+fun functionSingleParameter(i: Int) {}
+fun functionTwoParameters(i: Int, s: String) {}
+fun functionThreeParameters(i: Int, s: String, l: List<Double>) {}
+
+fun functionMismatchedParameterCount1(i: Int, s: String, l: List<Double>) {}
+fun functionMismatchedParameterCount2(i: Int, s: String) {}
+
+fun functionMismatchedParameterNames1(i1: Int, s: String) {}
+fun functionMismatchedParameterNames2(i: Int, s1: String) {}
+
+fun functionMismatchedParameterTypes1(i: Short, s: String) {}
+fun functionMismatchedParameterTypes2(i: Int, s: CharSequence) {}
+
+fun functionDefaultValues1(i: Int = 1, s: String) {}
+fun functionDefaultValues2(i: Int, s: String = "hello") {}
+
+inline fun inlineFunction1(lazyMessage: () -> String) {}
+inline fun inlineFunction2(crossinline lazyMessage: () -> String) {}
+inline fun inlineFunction3(crossinline lazyMessage: () -> String) {}
+inline fun inlineFunction4(noinline lazyMessage: () -> String) {}
+inline fun inlineFunction5(noinline lazyMessage: () -> String) {}
+
+fun functionWithVararg1(vararg numbers: Int) {}
+fun functionWithVararg2(numbers: Array<Int>) {}
+fun functionWithVararg3(numbers: Array<out Int>) {}
+fun functionWithVararg4(numbers: Array<out Int>) {}
+fun functionWithVararg5(numbers: Array<out Int>) {}
+fun functionWithVararg6(vararg names: String) {}
+fun functionWithVararg7(names: Array<String>) {}
+fun functionWithVararg8(names: Array<out String>) {}
+fun functionWithVararg9(names: Array<out String>) {}
+fun functionWithVararg10(names: Array<out String>) {}
+
+fun <T> functionWithTypeParameters1(p1: T, p2: String) {}
+fun <T> functionWithTypeParameters2(p1: String, p2: String) {}
+fun <T> functionWithTypeParameters2(p1: String, p2: T) {}
+fun <Q, R> functionWithTypeParameters4(p1: Q, p2: R) {}
+fun <R, Q> functionWithTypeParameters5(p1: Q, p2: R) {}
+fun <Q, R> functionWithTypeParameters6(p1: R, p2: Q) {}

native/commonizer/testData/generalCommonization/annotations/commonized/common/package_root.kt

@@ -0,0 +1,18 @@
+expect annotation class CommonAnnotationForAnnotationClassesOnly(text: String) { val text: String }
+expect annotation class CommonAnnotation(text: String) { val text: String }
+
+expect annotation class CommonOuterAnnotation(inner: CommonInnerAnnotation) { val inner: CommonInnerAnnotation }
+expect annotation class CommonInnerAnnotation(text: String) { val text: String }
+
+expect var propertyWithoutBackingField: Double
+expect val propertyWithBackingField: Double
+expect val propertyWithDelegateField: Int
+expect val <T : CharSequence> T.propertyWithExtensionReceiver: Int
+
+expect fun function1(text: String): String
+expect fun <Q : Number> Q.function2(): Q
+
+expect class AnnotatedClass(value: String) { val value: String }
+expect class AnnotatedTypeAlias
+
+expect object ObjectWithNestedAnnotations

native/commonizer/testData/generalCommonization/annotations/commonized/js/package_root.kt

@@ -0,0 +1,62 @@
+import kotlin.annotation.AnnotationTarget.*
+
+@Target(ANNOTATION_CLASS)
+actual annotation class CommonAnnotationForAnnotationClassesOnly actual constructor(actual val text: String)
+
+@Target(PROPERTY, PROPERTY_GETTER, PROPERTY_SETTER, FIELD, VALUE_PARAMETER, TYPE_PARAMETER, FUNCTION, CLASS, CONSTRUCTOR, TYPEALIAS, TYPE)
+@JsAnnotationForAnnotationClassesOnly("annotation-class")
+@CommonAnnotationForAnnotationClassesOnly("annotation-class")
+actual annotation class CommonAnnotation actual constructor(actual val text: String)
+
+@Target(ANNOTATION_CLASS)
+annotation class JsAnnotationForAnnotationClassesOnly(val text: String)
+
+@Target(PROPERTY, PROPERTY_GETTER, PROPERTY_SETTER, FIELD, VALUE_PARAMETER, TYPE_PARAMETER, FUNCTION, CLASS, CONSTRUCTOR, TYPEALIAS, TYPE)
+@JsAnnotationForAnnotationClassesOnly("annotation-class")
+@CommonAnnotationForAnnotationClassesOnly("annotation-class")
+annotation class JsAnnotation(val text: String)
+
+@Target(AnnotationTarget.CLASS)
+actual annotation class CommonOuterAnnotation(actual val inner: CommonInnerAnnotation)
+actual annotation class CommonInnerAnnotation(actual val text: String)
+
+@Target(AnnotationTarget.CLASS)
+annotation class JsOuterAnnotation(val inner: JsInnerAnnotation)
+annotation class JsInnerAnnotation(val text: String)
+
+@JsAnnotation("property")
+@CommonAnnotation("property")
+actual var propertyWithoutBackingField
+    @JsAnnotation("getter") @CommonAnnotation("getter") get() = 3.14
+    @JsAnnotation("setter") @CommonAnnotation("setter") set(@JsAnnotation("parameter") @CommonAnnotation("parameter") value) = Unit
+
+@field:JsAnnotation("field")
+@field:CommonAnnotation("field")
+actual val propertyWithBackingField = 3.14
+
+@delegate:JsAnnotation("field")
+@delegate:CommonAnnotation("field")
+actual val propertyWithDelegateField: Int by lazy { 42 }
+
+actual val <@JsAnnotation("type-parameter") @CommonAnnotation("type-parameter") T : CharSequence> @receiver:JsAnnotation("receiver") @receiver:CommonAnnotation("receiver") T.propertyWithExtensionReceiver: Int
+    get() = length
+
+@JsAnnotation("function")
+@CommonAnnotation("function")
+actual fun function1(@JsAnnotation("parameter") @CommonAnnotation("parameter") text: String) = text
+
+@JsAnnotation("function")
+@CommonAnnotation("function")
+actual fun <@JsAnnotation("type-parameter") @CommonAnnotation("type-parameter") Q : @JsAnnotation("type1") @CommonAnnotation("type1") Number> @receiver:JsAnnotation("receiver") @receiver:CommonAnnotation("receiver") Q.function2(): @JsAnnotation("type2") @CommonAnnotation("type2") Q = this
+
+@JsAnnotation("class")
+@CommonAnnotation("class")
+actual class AnnotatedClass @JsAnnotation("constructor") @CommonAnnotation("constructor") actual constructor(actual val value: String)
+
+@JsAnnotation("type-alias")
+@CommonAnnotation("type-alias")
+actual typealias AnnotatedTypeAlias = AnnotatedClass
+
+@JsOuterAnnotation(inner = JsInnerAnnotation("nested-annotations"))
+@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
+actual object ObjectWithNestedAnnotations

native/commonizer/testData/generalCommonization/annotations/commonized/jvm/package_root.kt

@@ -0,0 +1,62 @@
+import kotlin.annotation.AnnotationTarget.*
+
+@Target(ANNOTATION_CLASS)
+actual annotation class CommonAnnotationForAnnotationClassesOnly actual constructor(actual val text: String)
+
+@Target(PROPERTY, PROPERTY_GETTER, PROPERTY_SETTER, FIELD, VALUE_PARAMETER, TYPE_PARAMETER, FUNCTION, CLASS, CONSTRUCTOR, TYPEALIAS, TYPE)
+@JvmAnnotationForAnnotationClassesOnly("annotation-class")
+@CommonAnnotationForAnnotationClassesOnly("annotation-class")
+actual annotation class CommonAnnotation actual constructor(actual val text: String)
+
+@Target(ANNOTATION_CLASS)
+annotation class JvmAnnotationForAnnotationClassesOnly(val text: String)
+
+@Target(PROPERTY, PROPERTY_GETTER, PROPERTY_SETTER, FIELD, VALUE_PARAMETER, TYPE_PARAMETER, FUNCTION, CLASS, CONSTRUCTOR, TYPEALIAS, TYPE)
+@JvmAnnotationForAnnotationClassesOnly("annotation-class")
+@CommonAnnotationForAnnotationClassesOnly("annotation-class")
+annotation class JvmAnnotation(val text: String)
+
+@Target(AnnotationTarget.CLASS)
+actual annotation class CommonOuterAnnotation(actual val inner: CommonInnerAnnotation)
+actual annotation class CommonInnerAnnotation(actual val text: String)
+
+@Target(AnnotationTarget.CLASS)
+annotation class JvmOuterAnnotation(val inner: JvmInnerAnnotation)
+annotation class JvmInnerAnnotation(val text: String)
+
+@JvmAnnotation("property")
+@CommonAnnotation("property")
+actual var propertyWithoutBackingField
+    @JvmAnnotation("getter") @CommonAnnotation("getter") get() = 3.14
+    @JvmAnnotation("setter") @CommonAnnotation("setter") set(@JvmAnnotation("parameter") @CommonAnnotation("parameter") value) = Unit
+
+@field:JvmAnnotation("field")
+@field:CommonAnnotation("field")
+actual val propertyWithBackingField = 3.14
+
+@delegate:JvmAnnotation("field")
+@delegate:CommonAnnotation("field")
+actual val propertyWithDelegateField: Int by lazy { 42 }
+
+actual val <@JvmAnnotation("type-parameter") @CommonAnnotation("type-parameter") T : CharSequence> @receiver:JvmAnnotation("receiver") @receiver:CommonAnnotation("receiver") T.propertyWithExtensionReceiver: Int
+    get() = length
+
+@JvmAnnotation("function")
+@CommonAnnotation("function")
+actual fun function1(@JvmAnnotation("parameter") @CommonAnnotation("parameter") text: String) = text
+
+@JvmAnnotation("function")
+@CommonAnnotation("function")
+actual fun <@JvmAnnotation("type-parameter") @CommonAnnotation("type-parameter") Q : @JvmAnnotation("type1") @CommonAnnotation("type1") Number> @receiver:JvmAnnotation("receiver") @receiver:CommonAnnotation("receiver") Q.function2(): @JvmAnnotation("type2") @CommonAnnotation("type2") Q = this
+
+@JvmAnnotation("class")
+@CommonAnnotation("class")
+actual class AnnotatedClass @JvmAnnotation("constructor") @CommonAnnotation("constructor") actual constructor(actual val value: String)
+
+@JvmAnnotation("type-alias")
+@CommonAnnotation("type-alias")
+actual typealias AnnotatedTypeAlias = AnnotatedClass
+
+@JvmOuterAnnotation(inner = JvmInnerAnnotation("nested-annotations"))
+@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
+actual object ObjectWithNestedAnnotations

native/commonizer/testData/generalCommonization/annotations/original/js/package_root.kt

@@ -0,0 +1,62 @@
+import kotlin.annotation.AnnotationTarget.*
+
+@Target(ANNOTATION_CLASS)
+annotation class CommonAnnotationForAnnotationClassesOnly(val text: String)
+
+@Target(PROPERTY, PROPERTY_GETTER, PROPERTY_SETTER, FIELD, VALUE_PARAMETER, TYPE_PARAMETER, FUNCTION, CLASS, CONSTRUCTOR, TYPEALIAS, TYPE)
+@JsAnnotationForAnnotationClassesOnly("annotation-class")
+@CommonAnnotationForAnnotationClassesOnly("annotation-class")
+annotation class CommonAnnotation(val text: String)
+
+@Target(ANNOTATION_CLASS)
+annotation class JsAnnotationForAnnotationClassesOnly(val text: String)
+
+@Target(PROPERTY, PROPERTY_GETTER, PROPERTY_SETTER, FIELD, VALUE_PARAMETER, TYPE_PARAMETER, FUNCTION, CLASS, CONSTRUCTOR, TYPEALIAS, TYPE)
+@JsAnnotationForAnnotationClassesOnly("annotation-class")
+@CommonAnnotationForAnnotationClassesOnly("annotation-class")
+annotation class JsAnnotation(val text: String)
+
+@Target(AnnotationTarget.CLASS)
+annotation class CommonOuterAnnotation(val inner: CommonInnerAnnotation)
+annotation class CommonInnerAnnotation(val text: String)
+
+@Target(AnnotationTarget.CLASS)
+annotation class JsOuterAnnotation(val inner: JsInnerAnnotation)
+annotation class JsInnerAnnotation(val text: String)
+
+@JsAnnotation("property")
+@CommonAnnotation("property")
+var propertyWithoutBackingField
+    @JsAnnotation("getter") @CommonAnnotation("getter") get() = 3.14
+    @JsAnnotation("setter") @CommonAnnotation("setter") set(@JsAnnotation("parameter") @CommonAnnotation("parameter") value) = Unit
+
+@field:JsAnnotation("field")
+@field:CommonAnnotation("field")
+val propertyWithBackingField = 3.14
+
+@delegate:JsAnnotation("field")
+@delegate:CommonAnnotation("field")
+val propertyWithDelegateField: Int by lazy { 42 }
+
+val <@JsAnnotation("type-parameter") @CommonAnnotation("type-parameter") T : CharSequence> @receiver:JsAnnotation("receiver") @receiver:CommonAnnotation("receiver") T.propertyWithExtensionReceiver: Int
+    get() = length
+
+@JsAnnotation("function")
+@CommonAnnotation("function")
+fun function1(@JsAnnotation("parameter") @CommonAnnotation("parameter") text: String) = text
+
+@JsAnnotation("function")
+@CommonAnnotation("function")
+fun <@JsAnnotation("type-parameter") @CommonAnnotation("type-parameter") Q : @JsAnnotation("type1") @CommonAnnotation("type1") Number> @receiver:JsAnnotation("receiver") @receiver:CommonAnnotation("receiver") Q.function2(): @JsAnnotation("type2") @CommonAnnotation("type2") Q = this
+
+@JsAnnotation("class")
+@CommonAnnotation("class")
+class AnnotatedClass @JsAnnotation("constructor") @CommonAnnotation("constructor") constructor(val value: String)
+
+@JsAnnotation("type-alias")
+@CommonAnnotation("type-alias")
+typealias AnnotatedTypeAlias = AnnotatedClass
+
+@JsOuterAnnotation(inner = JsInnerAnnotation("nested-annotations"))
+@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
+object ObjectWithNestedAnnotations

native/commonizer/testData/generalCommonization/annotations/original/jvm/package_root.kt

@@ -0,0 +1,62 @@
+import kotlin.annotation.AnnotationTarget.*
+
+@Target(ANNOTATION_CLASS)
+annotation class CommonAnnotationForAnnotationClassesOnly(val text: String)
+
+@Target(PROPERTY, PROPERTY_GETTER, PROPERTY_SETTER, FIELD, VALUE_PARAMETER, TYPE_PARAMETER, FUNCTION, CLASS, CONSTRUCTOR, TYPEALIAS, TYPE)
+@JvmAnnotationForAnnotationClassesOnly("annotation-class")
+@CommonAnnotationForAnnotationClassesOnly("annotation-class")
+annotation class CommonAnnotation(val text: String)
+
+@Target(ANNOTATION_CLASS)
+annotation class JvmAnnotationForAnnotationClassesOnly(val text: String)
+
+@Target(PROPERTY, PROPERTY_GETTER, PROPERTY_SETTER, FIELD, VALUE_PARAMETER, TYPE_PARAMETER, FUNCTION, CLASS, CONSTRUCTOR, TYPEALIAS, TYPE)
+@JvmAnnotationForAnnotationClassesOnly("annotation-class")
+@CommonAnnotationForAnnotationClassesOnly("annotation-class")
+annotation class JvmAnnotation(val text: String)
+
+@Target(AnnotationTarget.CLASS)
+annotation class CommonOuterAnnotation(val inner: CommonInnerAnnotation)
+annotation class CommonInnerAnnotation(val text: String)
+
+@Target(AnnotationTarget.CLASS)
+annotation class JvmOuterAnnotation(val inner: JvmInnerAnnotation)
+annotation class JvmInnerAnnotation(val text: String)
+
+@JvmAnnotation("property")
+@CommonAnnotation("property")
+var propertyWithoutBackingField
+    @JvmAnnotation("getter") @CommonAnnotation("getter") get() = 3.14
+    @JvmAnnotation("setter") @CommonAnnotation("setter") set(@JvmAnnotation("parameter") @CommonAnnotation("parameter") value) = Unit
+
+@field:JvmAnnotation("field")
+@field:CommonAnnotation("field")
+val propertyWithBackingField = 3.14
+
+@delegate:JvmAnnotation("field")
+@delegate:CommonAnnotation("field")
+val propertyWithDelegateField: Int by lazy { 42 }
+
+val <@JvmAnnotation("type-parameter") @CommonAnnotation("type-parameter") T : CharSequence> @receiver:JvmAnnotation("receiver") @receiver:CommonAnnotation("receiver") T.propertyWithExtensionReceiver: Int
+    get() = length
+
+@JvmAnnotation("function")
+@CommonAnnotation("function")
+fun function1(@JvmAnnotation("parameter") @CommonAnnotation("parameter") text: String) = text
+
+@JvmAnnotation("function")
+@CommonAnnotation("function")
+fun <@JvmAnnotation("type-parameter") @CommonAnnotation("type-parameter") Q : @JvmAnnotation("type1") @CommonAnnotation("type1") Number> @receiver:JvmAnnotation("receiver") @receiver:CommonAnnotation("receiver") Q.function2(): @JvmAnnotation("type2") @CommonAnnotation("type2") Q = this
+
+@JvmAnnotation("class")
+@CommonAnnotation("class")
+class AnnotatedClass @JvmAnnotation("constructor") @CommonAnnotation("constructor") constructor(val value: String)
+
+@JvmAnnotation("type-alias")
+@CommonAnnotation("type-alias")
+typealias AnnotatedTypeAlias = AnnotatedClass
+
+@JvmOuterAnnotation(inner = JvmInnerAnnotation("nested-annotations"))
+@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
+object ObjectWithNestedAnnotations

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/common/package_org_sample_two.kt

@@ -0,0 +1,3 @@
+package org.sample.two
+
+expect val qux: Int

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/common/package_root.kt

@@ -0,0 +1 @@
+expect val foo: Int

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/js/package_org_sample.kt

@@ -0,0 +1,3 @@
+package org.sample
+
+val bar = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/js/package_org_sample_one.kt

@@ -0,0 +1,3 @@
+package org.sample.one
+
+val baz = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/js/package_org_sample_two.kt

@@ -0,0 +1,3 @@
+package org.sample.two
+
+actual val qux = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/js/package_root.kt

@@ -0,0 +1,5 @@
+actual val foo = 1
+
+val jsSpecificProperty = 42
+val jsAndJvmSpecificProperty = 42 * 2
+val jsAndNativeSpecificProperty = 42 * 3

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/jvm/package_org_sample.kt

@@ -0,0 +1,3 @@
+package org.sample
+
+val bar = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/jvm/package_org_sample_two.kt

@@ -0,0 +1,3 @@
+package org.sample.two
+
+actual val qux = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/jvm/package_root.kt

@@ -0,0 +1,5 @@
+actual val foo = 1
+
+val jvmSpecificProperty = 42
+val jsAndJvmSpecificProperty = 42 * 2
+val jvmAndNativeSpecificProperty = 42 * 4

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/native/package_org_sample_one.kt

@@ -0,0 +1,3 @@
+package org.sample.one
+
+val baz = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/native/package_org_sample_two.kt

@@ -0,0 +1,3 @@
+package org.sample.two
+
+actual val qux = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/commonized/native/package_root.kt

@@ -0,0 +1,5 @@
+actual val foo = 1
+
+val nativeSpecificProperty = 42
+val jsAndNativeSpecificProperty = 42 * 3
+val jvmAndNativeSpecificProperty = 42 * 4

native/commonizer/testData/generalCommonization/mismatchedPackages/original/js/package_org_sample.kt

@@ -0,0 +1,3 @@
+package org.sample
+
+val bar = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/original/js/package_org_sample_one.kt

@@ -0,0 +1,3 @@
+package org.sample.one
+
+val baz = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/original/js/package_org_sample_two.kt

@@ -0,0 +1,3 @@
+package org.sample.two
+
+val qux = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/original/js/package_root.kt

@@ -0,0 +1,5 @@
+val foo = 1
+
+val jsSpecificProperty = 42
+val jsAndJvmSpecificProperty = 42 * 2
+val jsAndNativeSpecificProperty = 42 * 3

native/commonizer/testData/generalCommonization/mismatchedPackages/original/jvm/package_org_sample.kt

@@ -0,0 +1,3 @@
+package org.sample
+
+val bar = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/original/jvm/package_org_sample_two.kt

@@ -0,0 +1,3 @@
+package org.sample.two
+
+val qux = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/original/jvm/package_root.kt

@@ -0,0 +1,5 @@
+val foo = 1
+
+val jvmSpecificProperty = 42
+val jsAndJvmSpecificProperty = 42 * 2
+val jvmAndNativeSpecificProperty = 42 * 4

native/commonizer/testData/generalCommonization/mismatchedPackages/original/native/package_org_sample_one.kt

@@ -0,0 +1,3 @@
+package org.sample.one
+
+val baz = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/original/native/package_org_sample_two.kt

@@ -0,0 +1,3 @@
+package org.sample.two
+
+val qux = 1

native/commonizer/testData/generalCommonization/mismatchedPackages/original/native/package_root.kt

@@ -0,0 +1,5 @@
+val foo = 1
+
+val nativeSpecificProperty = 42
+val jsAndNativeSpecificProperty = 42 * 3
+val jvmAndNativeSpecificProperty = 42 * 4

native/commonizer/testData/propertyCommonization/setters/commonized/common/package_root.kt

@@ -0,0 +1,16 @@
+expect var defaultSetter1: Int
+expect var defaultSetter2: Int
+expect var defaultSetter3: Int
+
+expect var setterWithoutBackingField1: Int
+expect var setterWithoutBackingField2: Int
+
+expect var setterWithDelegation1: Int
+expect var setterWithDelegation2: Int
+
+expect var defaultSetteCustomVisibility1: Int
+expect var defaultSetteCustomVisibility3 = 42
+    internal set
+
+expect val propertyWithoutSetter: Int
+expect var propertyWithSetter: Int

native/commonizer/testData/propertyCommonization/setters/commonized/js/package_root.kt

@@ -0,0 +1,30 @@
+actual var defaultSetter1 = 42
+actual var defaultSetter2 = 42
+    set
+actual var defaultSetter3 = 42
+    set
+
+actual var setterWithoutBackingField1
+    get() = 42
+    set(value) = Unit
+actual var setterWithoutBackingField2
+    get() = 42
+    set(value) = Unit
+
+actual var setterWithDelegation1: Int by mutableMapOf("setterWithDelegation1" to 42)
+actual var setterWithDelegation2: Int by mutableMapOf("setterWithDelegation2" to 42)
+
+actual var defaultSetteCustomVisibility1 = 42
+    public set
+var defaultSetteCustomVisibility2 = 42
+    internal set
+actual var defaultSetteCustomVisibility3 = 42
+    internal set
+var defaultSetteCustomVisibility4 = 42
+    private set
+var defaultSetteCustomVisibility5 = 42
+    private set
+
+actual val propertyWithoutSetter = 42
+var propertyMaybeSetter = 42
+actual var propertyWithSetter = 42

native/commonizer/testData/propertyCommonization/setters/commonized/jvm/package_root.kt

@@ -0,0 +1,27 @@
+actual var defaultSetter1 = 42
+actual var defaultSetter2 = 42
+actual var defaultSetter3 = 42
+    set
+
+actual var setterWithoutBackingField1
+    get() = 42
+    set(value) = Unit
+actual var setterWithoutBackingField2 = 42
+
+actual var setterWithDelegation1: Int by mutableMapOf("setterWithDelegation1" to 42)
+actual var setterWithDelegation2 = 42
+
+actual var defaultSetteCustomVisibility1 = 42
+    public set
+var defaultSetteCustomVisibility2 = 42
+    public set
+actual var defaultSetteCustomVisibility3 = 42
+    internal set
+var defaultSetteCustomVisibility4 = 42
+    internal set
+var defaultSetteCustomVisibility5 = 42
+    private set
+
+actual val propertyWithoutSetter = 42
+val propertyMaybeSetter = 42
+actual var propertyWithSetter = 42

native/commonizer/testData/propertyCommonization/setters/original/js/package_root.kt

@@ -0,0 +1,30 @@
+var defaultSetter1 = 42
+var defaultSetter2 = 42
+    set
+var defaultSetter3 = 42
+    set
+
+var setterWithoutBackingField1
+    get() = 42
+    set(value) = Unit
+var setterWithoutBackingField2
+    get() = 42
+    set(value) = Unit
+
+var setterWithDelegation1: Int by mutableMapOf("setterWithDelegation1" to 42)
+var setterWithDelegation2: Int by mutableMapOf("setterWithDelegation2" to 42)
+
+var defaultSetteCustomVisibility1 = 42
+    public set
+var defaultSetteCustomVisibility2 = 42
+    internal set
+var defaultSetteCustomVisibility3 = 42
+    internal set
+var defaultSetteCustomVisibility4 = 42
+    private set
+var defaultSetteCustomVisibility5 = 42
+    private set
+
+val propertyWithoutSetter = 42
+var propertyMaybeSetter = 42
+var propertyWithSetter = 42

native/commonizer/testData/propertyCommonization/setters/original/jvm/package_root.kt

@@ -0,0 +1,31 @@
+var defaultSetter1 = 42
+var defaultSetter2 = 42 // intentionally commented setter declaration
+//    set
+var defaultSetter3 = 42
+    set
+
+var setterWithoutBackingField1
+    get() = 42
+    set(value) = Unit
+var setterWithoutBackingField2 = 42 // intentionally left as with backing field
+
+var setterWithDelegation1: Int by mutableMapOf("setterWithDelegation1" to 42)
+var setterWithDelegation2 = 42 // intentionally left without delegation
+
+var defaultSetteCustomVisibility1 = 42
+    public set
+var defaultSetteCustomVisibility2 = 42
+//    internal set
+    public set // intentionally used public visibility
+var defaultSetteCustomVisibility3 = 42
+    internal set
+var defaultSetteCustomVisibility4 = 42
+//    private set
+    internal set // intentionally used internal visibility
+var defaultSetteCustomVisibility5 = 42
+    private set
+
+val propertyWithoutSetter = 42
+//var propertyMaybeSetter = 42
+val propertyMaybeSetter = 42 // fixed to be a property without setter
+var propertyWithSetter = 42

native/commonizer/testData/propertyCommonization/specifics/commonized/common/package_root.kt

@@ -0,0 +1,17 @@
+expect val delegatedProperty1: Int
+expect val delegatedProperty2: Int
+expect val delegatedProperty3: Int
+expect val delegatedProperty4: Int
+
+expect val inlineProperty1: Int
+expect val inlineProperty2: Int
+expect val inlineProperty3: Int
+
+expect var inlineProperty4: Int
+expect var inlineProperty5: Int
+expect var inlineProperty6: Int
+expect var inlineProperty7: Int
+expect var inlineProperty8: Int
+
+expect external val externalProperty1: Int
+expect val externalProperty2: Int

native/commonizer/testData/propertyCommonization/specifics/commonized/js/package_root.kt

@@ -0,0 +1,33 @@
+const val constProperty1 = 42
+const val constProperty2 = 42
+
+actual val delegatedProperty1: Int by lazy { 42 }
+actual val delegatedProperty2: Int by lazy { 42 }
+actual val delegatedProperty3: Int by mapOf("delegatedProperty3" to 42)
+actual val delegatedProperty4: Int by mapOf("delegatedProperty4" to 42)
+
+lateinit var lateinitProperty1: String
+lateinit var lateinitProperty2: String
+
+actual inline val inlineProperty1 get() = 42
+actual inline val inlineProperty2 get() = 42
+actual inline val inlineProperty3 get() = 42
+
+actual inline var inlineProperty4
+    get() = 42
+    set(value) = Unit
+actual inline var inlineProperty5
+    get() = 42
+    set(value) = Unit
+actual inline var inlineProperty6
+    get() = 42
+    set(value) = Unit
+actual inline var inlineProperty7
+    get() = 42
+    set(value) = Unit
+actual inline var inlineProperty8
+    get() = 42
+    set(value) = Unit
+
+actual external val externalProperty1: Int
+actual external val externalProperty2: Int

native/commonizer/testData/propertyCommonization/specifics/commonized/jvm/package_root.kt

@@ -0,0 +1,33 @@
+const val constProperty1 = 42
+val constProperty2 = 42 // intentionally left as non-const
+
+actual val delegatedProperty1: Int by lazy { 42 }
+actual val delegatedProperty2 = 42 // intentionally left as non-delegated
+actual val delegatedProperty3: Int by mapOf("delegatedProperty3" to 42)
+actual val delegatedProperty4 = 42 // intentionally left as non-delegated
+
+lateinit var lateinitProperty1: String
+var lateinitProperty2 = "hello" // intentionally left as non-lateinit
+
+actual val inlineProperty1 inline get() = 42
+actual inline val inlineProperty2 get() = 42
+actual val inlineProperty3 = 42 // intentionally left as non-inline
+
+actual var inlineProperty4
+    inline get() = 42
+    inline set(value) = Unit
+inline actual var inlineProperty5
+    get() = 42
+    set(value) = Unit
+actual var inlineProperty6
+    inline get() = 42
+    set(value) = Unit
+actual var inlineProperty7
+    get() = 42
+    inline set(value) = Unit
+actual var inlineProperty8
+    get() = 42
+    set(value) = Unit
+
+actual external val externalProperty1: Int
+actual val externalProperty2: Int = 1

native/commonizer/testData/propertyCommonization/specifics/original/js/package_root.kt

@@ -0,0 +1,33 @@
+const val constProperty1 = 42
+const val constProperty2 = 42
+
+val delegatedProperty1: Int by lazy { 42 }
+val delegatedProperty2: Int by lazy { 42 }
+val delegatedProperty3: Int by mapOf("delegatedProperty3" to 42)
+val delegatedProperty4: Int by mapOf("delegatedProperty4" to 42)
+
+lateinit var lateinitProperty1: String
+lateinit var lateinitProperty2: String
+
+inline val inlineProperty1 get() = 42
+inline val inlineProperty2 get() = 42
+inline val inlineProperty3 get() = 42
+
+inline var inlineProperty4
+    get() = 42
+    set(value) = Unit
+inline var inlineProperty5
+    get() = 42
+    set(value) = Unit
+inline var inlineProperty6
+    get() = 42
+    set(value) = Unit
+inline var inlineProperty7
+    get() = 42
+    set(value) = Unit
+inline var inlineProperty8
+    get() = 42
+    set(value) = Unit
+
+external val externalProperty1: Int
+external val externalProperty2: Int

native/commonizer/testData/propertyCommonization/specifics/original/jvm/package_root.kt

@@ -0,0 +1,33 @@
+const val constProperty1 = 42
+val constProperty2 = 42 // intentionally left as non-const
+
+val delegatedProperty1: Int by lazy { 42 }
+val delegatedProperty2 = 42 // intentionally left as non-delegated
+val delegatedProperty3: Int by mapOf("delegatedProperty3" to 42)
+val delegatedProperty4 = 42 // intentionally left as non-delegated
+
+lateinit var lateinitProperty1: String
+var lateinitProperty2 = "hello" // intentionally left as non-lateinit
+
+inline val inlineProperty1 get() = 42
+val inlineProperty2 inline get() = 42
+val inlineProperty3 = 42 // intentionally left as non-inline
+
+inline var inlineProperty4
+    get() = 42
+    set(value) = Unit
+var inlineProperty5
+    inline get() = 42
+    inline set(value) = Unit
+var inlineProperty6
+    inline get() = 42
+    set(value) = Unit
+var inlineProperty7
+    get() = 42
+    inline set(value) = Unit
+var inlineProperty8
+    get() = 42
+    set(value) = Unit
+
+external val externalProperty1: Int
+val externalProperty2: Int = 1