[Tests] KT-69681: correct synthetic accessor tests where a private ty…

…pe is leaked from the declaring file Some tests would be corrected after KT-71416
JetBrains · Nov 8, 2024 · 8423f3f · 8423f3f
1 parent 8fe5fed
commit 8423f3f
Show file tree

Hide file tree

Showing 38 changed files with 392 additions and 541 deletions.
diff --git a/...eUsageInsideNonPrivateInlineFunction/privateMember/leakingPrivateClassConstructorError.kt b/...eUsageInsideNonPrivateInlineFunction/privateMember/leakingPrivateClassConstructorError.kt
@@ -0,0 +1,11 @@
+// LANGUAGE: +ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+private class Private {
+    fun foo() = "OK"
+}
+
+internal inline fun internalInlineFun(): String {
+    return <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_ERROR!><!PRIVATE_CLASS_MEMBER_FROM_INLINE!>Private<!>()<!>.<!PRIVATE_CLASS_MEMBER_FROM_INLINE!>foo<!>()
+}
diff --git a/...sageInsideNonPrivateInlineFunction/privateMember/leakingPrivateClassConstructorWarning.kt b/...sageInsideNonPrivateInlineFunction/privateMember/leakingPrivateClassConstructorWarning.kt
@@ -0,0 +1,11 @@
+// LANGUAGE: -ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+private class Private {
+    fun foo() = "OK"
+}
+
+internal inline fun internalInlineFun(): String {
+    return <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_WARNING!><!PRIVATE_CLASS_MEMBER_FROM_INLINE!>Private<!>()<!>.<!PRIVATE_CLASS_MEMBER_FROM_INLINE!>foo<!>()
+}
diff --git a/...eInsideNonPrivateInlineFunction/privateMember/usePrivateFunInterfaceFromInlineFunError.kt b/...eInsideNonPrivateInlineFunction/privateMember/usePrivateFunInterfaceFromInlineFunError.kt
@@ -0,0 +1,11 @@
+// LANGUAGE: +ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+private fun interface I {
+    fun foo(): Int
+}
+
+inline fun publicInlineFun(): Int = (<!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_ERROR!>I { 1 }<!>).<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>foo<!>()
+
+internal inline fun internalInlineFun(): Int = (<!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_ERROR!>I { 1 }<!>).<!PRIVATE_CLASS_MEMBER_FROM_INLINE!>foo<!>()
diff --git a/...nsideNonPrivateInlineFunction/privateMember/usePrivateFunInterfaceFromInlineFunWarning.kt b/...nsideNonPrivateInlineFunction/privateMember/usePrivateFunInterfaceFromInlineFunWarning.kt
@@ -0,0 +1,11 @@
+// LANGUAGE: -ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+private fun interface I {
+    fun foo(): Int
+}
+
+inline fun publicInlineFun(): Int = (<!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_WARNING!>I { 1 }<!>).<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>foo<!>()
+
+internal inline fun internalInlineFun(): Int = (<!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_WARNING!>I { 1 }<!>).<!PRIVATE_CLASS_MEMBER_FROM_INLINE!>foo<!>()
diff --git a/...geInsideNonPrivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtKlassError.kt b/...geInsideNonPrivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtKlassError.kt
@@ -0,0 +1,10 @@
+// LANGUAGE: +ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+private class Private
+
+internal inline fun getPrivateKlass(): String {
+    <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_ERROR!>val klass = <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_ERROR!>Private::class<!><!>
+    return <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_ERROR!>klass<!>.simpleName ?: "null"
+}
diff --git a/...InsideNonPrivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtKlassWarning.kt b/...InsideNonPrivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtKlassWarning.kt
@@ -0,0 +1,10 @@
+// LANGUAGE: -ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+private class Private
+
+internal inline fun getPrivateKlass(): String {
+    <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_WARNING!>val klass = <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_WARNING!>Private::class<!><!>
+    return <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_WARNING!>klass<!>.simpleName ?: "null"
+}
diff --git a/...ivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtPrivateTopLevelFunError.kt b/...ivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtPrivateTopLevelFunError.kt
@@ -0,0 +1,14 @@
+// For now the checker is working before inlining. The test should be corrected after KT-71416.
+// LANGUAGE: +ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+interface Foo
+
+private class FooImpl : Foo
+
+private inline fun privateMethod(): Foo = FooImpl()
+
+internal inline fun internalMethod(): Foo {
+    return privateMethod()
+}
diff --git a/...ateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtPrivateTopLevelFunWarning.kt b/...ateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtPrivateTopLevelFunWarning.kt
@@ -0,0 +1,14 @@
+// For now the checker is working before inlining. The test should be corrected after KT-71416.
+// LANGUAGE: -ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+interface Foo
+
+private class FooImpl : Foo
+
+private inline fun privateMethod(): Foo = FooImpl()
+
+internal inline fun internalMethod(): Foo {
+    return privateMethod()
+}
diff --git a/...sideNonPrivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtTypecheckError.kt b/...sideNonPrivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtTypecheckError.kt
@@ -0,0 +1,19 @@
+// LANGUAGE: +ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+private class Private
+
+internal inline fun isPrivate(obj: Any): String = when (obj) {
+    <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_ERROR!>is Private<!> -> "isPrivate"
+    else -> "OK1"
+}
+
+internal inline fun asPrivate(obj: Any): String {
+    try {
+        <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_ERROR!>val privateObj = <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_ERROR!>obj as Private<!><!>
+        return "asPrivate"
+    } catch (e: ClassCastException) {
+        return "OK2"
+    }
+}
diff --git a/...deNonPrivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtTypecheckWarning.kt b/...deNonPrivateInlineFunction/topLevelPrivate/leakingPrivateClassThroughtTypecheckWarning.kt
@@ -0,0 +1,19 @@
+// LANGUAGE: -ForbidExposureOfPrivateTypesInNonPrivateInlineFunctionsInKlibs
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// FIR_IDENTICAL
+
+private class Private
+
+internal inline fun isPrivate(obj: Any): String = when (obj) {
+    <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_WARNING!>is Private<!> -> "isPrivate"
+    else -> "OK1"
+}
+
+internal inline fun asPrivate(obj: Any): String {
+    try {
+        <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_WARNING!>val privateObj = <!IR_PRIVATE_TYPE_USED_IN_NON_PRIVATE_INLINE_FUNCTION_WARNING!>obj as Private<!><!>
+        return "asPrivate"
+    } catch (e: ClassCastException) {
+        return "OK2"
+    }
+}
diff --git a/...b/syntheticAccessors/privateMember/crossFilePrivateLeak/leakingPrivateClassConstructor.kt b/...b/syntheticAccessors/privateMember/crossFilePrivateLeak/leakingPrivateClassConstructor.kt
diff --git a/...ors/privateMember/crossFilePrivateLeak/leakingPrivateCompanionThroughInternalInlineFun.kt b/...ors/privateMember/crossFilePrivateLeak/leakingPrivateCompanionThroughInternalInlineFun.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // FILE: A.kt
 class A {

diff --git a/...rs/privateMember/crossFilePrivateLeak/leakingPrivateInnerClassThroughInternalInlineFun.kt b/...rs/privateMember/crossFilePrivateLeak/leakingPrivateInnerClassThroughInternalInlineFun.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // FILE: A.kt
 class A {

diff --git a/...s/privateMember/crossFilePrivateLeak/leakingPrivateNestedClassThroughInternalInlineFun.kt b/...s/privateMember/crossFilePrivateLeak/leakingPrivateNestedClassThroughInternalInlineFun.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // FILE: A.kt
 class A {

diff --git a/...theticAccessors/privateMember/crossFilePrivateLeak/usePrivateFunInterfaceFromInlineFun.kt b/...theticAccessors/privateMember/crossFilePrivateLeak/usePrivateFunInterfaceFromInlineFun.kt
diff --git a/...syntheticAccessors/privateMember/crossModulePrivateLeak/leakingPrivateClassConstructor.kt b/...syntheticAccessors/privateMember/crossModulePrivateLeak/leakingPrivateClassConstructor.kt
diff --git a/...s/privateMember/crossModulePrivateLeak/leakingPrivateCompanionThroughInternalInlineFun.kt b/...s/privateMember/crossModulePrivateLeak/leakingPrivateCompanionThroughInternalInlineFun.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // MODULE: lib
 // FILE: A.kt

diff --git a/.../privateMember/crossModulePrivateLeak/leakingPrivateInnerClassThroughInternalInlineFun.kt b/.../privateMember/crossModulePrivateLeak/leakingPrivateInnerClassThroughInternalInlineFun.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // MODULE: lib
 // FILE: A.kt

diff --git a/...privateMember/crossModulePrivateLeak/leakingPrivateNestedClassThroughInternalInlineFun.kt b/...privateMember/crossModulePrivateLeak/leakingPrivateNestedClassThroughInternalInlineFun.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // MODULE: lib
 // FILE: A.kt

diff --git a/...eticAccessors/privateMember/crossModulePrivateLeak/usePrivateFunInterfaceFromInlineFun.kt b/...eticAccessors/privateMember/crossModulePrivateLeak/usePrivateFunInterfaceFromInlineFun.kt
diff --git a/...velPrivate/crossFilePrivateLeak/leakingPrivateClassFromLocalObjectInsideInternalInline.kt b/...velPrivate/crossFilePrivateLeak/leakingPrivateClassFromLocalObjectInsideInternalInline.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // FILE: A.kt
 private open class A {

diff --git a/...icAccessors/topLevelPrivate/crossFilePrivateLeak/leakingPrivateClassThroughGenericType.kt b/...icAccessors/topLevelPrivate/crossFilePrivateLeak/leakingPrivateClassThroughGenericType.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // FILE: a.kt
 private class Private

diff --git a/...ntheticAccessors/topLevelPrivate/crossFilePrivateLeak/leakingPrivateClassThroughtKlass.kt b/...ntheticAccessors/topLevelPrivate/crossFilePrivateLeak/leakingPrivateClassThroughtKlass.kt
diff --git a/...ors/topLevelPrivate/crossFilePrivateLeak/leakingPrivateClassThroughtPrivateTopLevelFun.kt b/...ors/topLevelPrivate/crossFilePrivateLeak/leakingPrivateClassThroughtPrivateTopLevelFun.kt
diff --git a/...ticAccessors/topLevelPrivate/crossFilePrivateLeak/leakingPrivateClassThroughtTypecheck.kt b/...ticAccessors/topLevelPrivate/crossFilePrivateLeak/leakingPrivateClassThroughtTypecheck.kt
diff --git a/...lPrivate/crossModulePrivateLeak/leakingPrivateClassFromLocalObjectInsideInternalInline.kt b/...lPrivate/crossModulePrivateLeak/leakingPrivateClassFromLocalObjectInsideInternalInline.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // MODULE: lib
 // FILE: A.kt

diff --git a/...Accessors/topLevelPrivate/crossModulePrivateLeak/leakingPrivateClassThroughGenericType.kt b/...Accessors/topLevelPrivate/crossModulePrivateLeak/leakingPrivateClassThroughGenericType.kt
@@ -1,6 +1,6 @@
 // IGNORE_BACKEND: ANY
 // ^^^ Muted because a private type is leaked from the declaring file, and the visibility validator detects this.
-//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681.
+//     This test should be converted to a test that checks reporting private types exposure. To be done in KT-69681 and KT-71416.
 
 // MODULE: lib
 // FILE: a.kt