Initial internal member mangling

compiler/testData/codegen/box/mangling/internalOverride.kt

@@ -0,0 +1,29 @@
+open class A {
+    internal open val field = "AF"
+
+    internal open fun test(): String = "AM"
+}
+
+fun invokeOnA(a: A) = a.test() + a.field
+
+class Z : A() {
+    override val field: String = "ZF"
+
+    override fun test(): String = "ZM"
+}
+
+fun box() : String {
+    var invokeOnA = invokeOnA(A())
+    if (invokeOnA != "AMAF") return "fail 1: $invokeOnA"
+
+    invokeOnA = invokeOnA(Z())
+    if (invokeOnA != "ZMZF") return "fail 2: $invokeOnA"
+
+    val z = Z().test()
+    if (z != "ZM") return "fail 3: $z"
+
+    val f = Z().field
+    if (f != "ZF") return "fail 4: $f"
+
+    return "OK"
+}

compiler/testData/codegen/box/mangling/internalOverrideSuperCall.kt

@@ -0,0 +1,21 @@
+open class A {
+    internal open val field = "F"
+
+    internal open fun test(): String = "A"
+}
+
+class Z : A() {
+    override fun test(): String = super.test()
+
+    override val field = super.field
+}
+
+fun box() : String {
+    val z = Z().test()
+    if (z != "A") return "fail 1: $z"
+
+    val f = Z().field
+    if (f != "F") return "fail 2: $f"
+
+    return "OK"
+}

compiler/testData/codegen/box/mangling/publicOverride.kt

@@ -0,0 +1,29 @@
+open class A {
+    internal open val field = "AF"
+
+    internal open fun test(): String = "AM"
+}
+
+fun invokeOnA(a: A) = a.test() + a.field
+
+class Z : A() {
+    public override val field: String = "ZF"
+
+    public override fun test(): String = "ZM"
+}
+
+fun box() : String {
+    var invokeOnA = invokeOnA(A())
+    if (invokeOnA != "AMAF") return "fail 1: $invokeOnA"
+
+    invokeOnA = invokeOnA(Z())
+    if (invokeOnA != "ZMZF") return "fail 2: $invokeOnA"
+
+    val z = Z().test()
+    if (z != "ZM") return "fail 3: $z"
+
+    val f = Z().field
+    if (f != "ZF") return "fail 4: $f"
+
+    return "OK"
+}

compiler/testData/codegen/box/mangling/publicOverrideSuperCall.kt

@@ -0,0 +1,21 @@
+open class A {
+    internal open val field = "F"
+
+    internal open fun test(): String = "A"
+}
+
+class Z : A() {
+    public override fun test(): String = super.test()
+
+    public override val field = super.field
+}
+
+fun box() : String {
+    val z = Z().test()
+    if (z != "A") return "fail 1: $z"
+
+    val f = Z().field
+    if (f != "F") return "fail 2: $f"
+
+    return "OK"
+}

compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInlineObject.1.kt

@@ -1,6 +1,6 @@
 //NO_CHECK_LAMBDA_INLINING
 import test.*
 
-internal fun box(): String {
+fun box(): String {
     return bar { "OK" }.run()
 }

compiler/testData/codegen/boxWithJava/mangling/JavaClass.java

@@ -0,0 +1,5 @@
+public class JavaClass extends A {
+    public String test() {
+        return "Java";
+    }
+}

compiler/testData/codegen/boxWithJava/mangling/internalOverride.kt

@@ -0,0 +1,11 @@
+open class A {
+    internal open fun test(): String = "Kotlin"
+}
+
+fun box(): String {
+    if (A().test() != "Kotlin") return "fail 1: ${A().test()}"
+
+    if (JavaClass().test() != "Java") return "fail 2: ${JavaClass().test()}"
+
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/mangling/field.kt

@@ -0,0 +1,20 @@
+package test
+
+internal val noMangling = 1;
+
+class Z {
+    internal var noMangling = 1;
+}
+
+fun box(): String {
+    val clazz = Z::class.java
+    val classField = clazz.getDeclaredField("noMangling")
+    if (classField == null) return "Class internal backing field should exist"
+    if (!classField.isSynthetic) return "Class internal backing field should be synthetic"
+
+    val topLevel = Class.forName("test.FieldKt").getDeclaredField("noMangling")
+    if (topLevel == null) return "Top level internal backing field should exist"
+    if (!topLevel.isSynthetic) return "Top level internal backing field should be synthetic"
+
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/mangling/fun.kt

@@ -0,0 +1,24 @@
+package test
+
+internal fun noMangling() = 1;
+
+class Z {
+    internal fun mangled() = 1;
+}
+
+fun box(): String {
+    val clazz = Z::class.java
+    val declaredMethods = clazz.declaredMethods
+
+    val mangled = declaredMethods.firstOrNull {
+        it.name.startsWith("mangled$")
+    }
+    if (mangled == null) return "Class internal function should exist"
+    if (!mangled.isSynthetic) return "Class internal function should be synthetic"
+
+    val topLevel = Class.forName("test.FunKt").getMethod("noMangling")
+    if (topLevel == null) return "Top level internal function should exist"
+    if (!topLevel.isSynthetic) return "Top level internal function should be synthetic"
+
+    return "OK"
+}