From f648d86d2bfec31098b8d40921bb39cd5db17026 Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Tue, 9 Mar 2021 07:12:10 +0100 Subject: [PATCH] Generate stubs for private function with default arguments as public in interfaces --- .../kotlin/codegen/FunctionCodegen.java | 4 +- .../FirBlackBoxCodegenTestGenerated.java | 18 ++++++ .../backend/jvm/codegen/FunctionCodegen.kt | 7 ++- .../privateFunWithDefaultArg.kt | 40 +++++++++++++ .../privateFunWithDefaultArg.txt | 51 ++++++++++++++++ .../privateFunWithDefaultArg2.kt | 22 +++++++ .../privateFunWithDefaultArg_ir.txt | 59 +++++++++++++++++++ .../privateFunWithDefaultArg.kt | 37 ++++++++++++ .../privateFunWithDefaultArg.txt | 42 +++++++++++++ .../privateFunWithDefaultArg_ir.txt | 44 ++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 18 ++++++ .../IrBlackBoxCodegenTestGenerated.java | 18 ++++++ .../LightAnalysisModeTestGenerated.java | 15 +++++ 13 files changed, 371 insertions(+), 4 deletions(-) create mode 100644 compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.kt create mode 100644 compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.txt create mode 100644 compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg2.kt create mode 100644 compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg_ir.txt create mode 100644 compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.kt create mode 100644 compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.txt create mode 100644 compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg_ir.txt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index 0346dc37c0a..49ad6118f17 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -1152,8 +1152,10 @@ public class FunctionCodegen { // $default methods are never private to be accessible from other class files (e.g. inner) without the need of synthetic accessors // $default methods are never protected to be accessible from subclass nested classes + // TODO: maybe best to generate private default in interface as private int visibilityFlag = - DescriptorVisibilities.isPrivate(functionDescriptor.getVisibility()) || isInlineOnlyPrivateInBytecode(functionDescriptor) + (!isInterface(functionDescriptor.getContainingDeclaration()) || kind == OwnerKind.DEFAULT_IMPLS) && + (DescriptorVisibilities.isPrivate(functionDescriptor.getVisibility()) || isInlineOnlyPrivateInBytecode(functionDescriptor)) ? AsmUtil.NO_FLAG_PACKAGE_PRIVATE : Opcodes.ACC_PUBLIC; int flags = visibilityFlag | getDeprecatedAccessFlag(functionDescriptor) | ACC_SYNTHETIC; if (!(functionDescriptor instanceof ConstructorDescriptor && diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java index cb7d3b6387f..2d0a0675ff5 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java @@ -22062,6 +22062,18 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunInInterface.kt"); } + @Test + @TestMetadata("privateFunWithDefaultArg.kt") + public void testPrivateFunWithDefaultArg() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.kt"); + } + + @Test + @TestMetadata("privateFunWithDefaultArg2.kt") + public void testPrivateFunWithDefaultArg2() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg2.kt"); + } + @Test @TestMetadata("privateSuspend.kt") public void testPrivateSuspend() throws Exception { @@ -22408,6 +22420,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunInInterface.kt"); } + @Test + @TestMetadata("privateFunWithDefaultArg.kt") + public void testPrivateFunWithDefaultArg() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.kt"); + } + @Test @TestMetadata("privateSuspend.kt") public void testPrivateSuspend() throws Exception { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt index 46a6640d5af..556252873d7 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt @@ -137,9 +137,10 @@ class FunctionCodegen( isAnonymousObject || origin == JvmLoweredDeclarationOrigin.CONTINUATION_CLASS || origin == JvmLoweredDeclarationOrigin.SUSPEND_LAMBDA private fun IrFunction.getVisibilityForDefaultArgumentStub(): Int = - when (visibility) { - DescriptorVisibilities.PUBLIC -> Opcodes.ACC_PUBLIC - JavaDescriptorVisibilities.PACKAGE_VISIBILITY -> AsmUtil.NO_FLAG_PACKAGE_PRIVATE + when { + // TODO: maybe best to generate private default in interface as private + visibility == DescriptorVisibilities.PUBLIC || parentAsClass.isJvmInterface -> Opcodes.ACC_PUBLIC + visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY -> AsmUtil.NO_FLAG_PACKAGE_PRIVATE else -> throw IllegalStateException("Default argument stub should be either public or package private: ${ir2string(this)}") } diff --git a/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.kt b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.kt new file mode 100644 index 00000000000..7b037fc484b --- /dev/null +++ b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.kt @@ -0,0 +1,40 @@ +// CHECK_BYTECODE_LISTING +// !JVM_DEFAULT_MODE: all-compatibility +// TARGET_BACKEND: JVM +// JVM_TARGET: 1.8 +// WITH_COROUTINES +// WITH_RUNTIME + +// IGNORE_BACKEND: JVM + +import helpers.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +interface Foo { + + fun bar(): String { + var result = "fail" + builder { + result = fooSuspend() + } + return foo() + result + + } + + private fun foo(s: String = "O"): String { + return s + } + + private suspend fun fooSuspend(s: String = "K"): String { + return s + } +} + +fun box(): String { + return object : Foo {}.bar() +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.txt b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.txt new file mode 100644 index 00000000000..c75607484f6 --- /dev/null +++ b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.txt @@ -0,0 +1,51 @@ +@kotlin.Metadata +public final class Foo$DefaultImpls { + // source: 'privateFunWithDefaultArg.kt' + public deprecated static @java.lang.Deprecated @org.jetbrains.annotations.NotNull method bar(@org.jetbrains.annotations.NotNull p0: Foo): java.lang.String + public final inner class Foo$DefaultImpls +} + +@kotlin.coroutines.jvm.internal.DebugMetadata +@kotlin.Metadata +final class Foo$bar$1 { + // source: 'privateFunWithDefaultArg.kt' + enclosing method Foo.bar()Ljava/lang/String; + synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef + field L$0: java.lang.Object + field label: int + synthetic final field this$0: Foo + inner (anonymous) class Foo$bar$1 + method (p0: Foo, p1: kotlin.jvm.internal.Ref$ObjectRef, p2: kotlin.coroutines.Continuation): void + public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation + public final method invoke(p0: java.lang.Object): java.lang.Object + public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object +} + +@kotlin.Metadata +public interface Foo { + // source: 'privateFunWithDefaultArg.kt' + inner (anonymous) class Foo$bar$1 + public synthetic static method access$bar$jd(p0: Foo): java.lang.String + public @org.jetbrains.annotations.NotNull method bar(): java.lang.String + public synthetic static method foo$default(p0: Foo, p1: java.lang.String, p2: int, p3: java.lang.Object): java.lang.String + private method foo(p0: java.lang.String): java.lang.String + public synthetic static method fooSuspend$default(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation, p3: int, p4: java.lang.Object): java.lang.Object + private method fooSuspend(p0: java.lang.String, p1: kotlin.coroutines.Continuation): java.lang.Object + public final inner class Foo$DefaultImpls +} + +@kotlin.Metadata +public final class PrivateFunWithDefaultArgKt$box$1 { + // source: 'privateFunWithDefaultArg.kt' + enclosing method PrivateFunWithDefaultArgKt.box()Ljava/lang/String; + inner (anonymous) class PrivateFunWithDefaultArgKt$box$1 + method (): void +} + +@kotlin.Metadata +public final class PrivateFunWithDefaultArgKt { + // source: 'privateFunWithDefaultArg.kt' + inner (anonymous) class PrivateFunWithDefaultArgKt$box$1 + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String + public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void +} diff --git a/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg2.kt b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg2.kt new file mode 100644 index 00000000000..08be8d13d49 --- /dev/null +++ b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg2.kt @@ -0,0 +1,22 @@ +// CHECK_BYTECODE_LISTING +// !JVM_DEFAULT_MODE: all-compatibility +// TARGET_BACKEND: JVM +// JVM_TARGET: 1.8 +// WITH_COROUTINES +// WITH_RUNTIME + +interface Foo { + + fun bar(): String { + return foo() + + } + + private fun foo(s: String = "OK"): String { + return s + } +} + +fun box(): String { + return object : Foo {}.bar() +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg_ir.txt b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg_ir.txt new file mode 100644 index 00000000000..8e725cbe7d4 --- /dev/null +++ b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg_ir.txt @@ -0,0 +1,59 @@ +@kotlin.Metadata +public final class Foo$DefaultImpls { + // source: 'privateFunWithDefaultArg.kt' + public synthetic final static method access$fooSuspend(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation): java.lang.Object + public deprecated static @java.lang.Deprecated @org.jetbrains.annotations.NotNull method bar(@org.jetbrains.annotations.NotNull p0: Foo): java.lang.String + public synthetic static method foo$default(p0: Foo, p1: java.lang.String, p2: int, p3: java.lang.Object): java.lang.String + private deprecated static @java.lang.Deprecated method foo(p0: Foo, p1: java.lang.String): java.lang.String + public synthetic static method fooSuspend$default(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation, p3: int, p4: java.lang.Object): java.lang.Object + private deprecated static @java.lang.Deprecated method fooSuspend(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation): java.lang.Object + public final inner class Foo$DefaultImpls +} + +@kotlin.coroutines.jvm.internal.DebugMetadata +@kotlin.Metadata +final class Foo$bar$1 { + // source: 'privateFunWithDefaultArg.kt' + enclosing method Foo.bar()Ljava/lang/String; + synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef + field L$0: java.lang.Object + field label: int + synthetic final field this$0: Foo + inner (anonymous) class Foo$bar$1 + method (p0: kotlin.jvm.internal.Ref$ObjectRef, p1: Foo, p2: kotlin.coroutines.Continuation): void + public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation + public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object + public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object + public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object +} + +@kotlin.Metadata +public interface Foo { + // source: 'privateFunWithDefaultArg.kt' + inner (anonymous) class Foo$bar$1 + public synthetic static method access$bar$jd(p0: Foo): java.lang.String + public synthetic static method access$foo(p0: Foo, p1: java.lang.String): java.lang.String + public synthetic static method access$fooSuspend(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation): java.lang.Object + public @org.jetbrains.annotations.NotNull method bar(): java.lang.String + public synthetic static method foo$default(p0: Foo, p1: java.lang.String, p2: int, p3: java.lang.Object): java.lang.String + private method foo(p0: java.lang.String): java.lang.String + public synthetic static method fooSuspend$default(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation, p3: int, p4: java.lang.Object): java.lang.Object + private method fooSuspend(p0: java.lang.String, p1: kotlin.coroutines.Continuation): java.lang.Object + public final inner class Foo$DefaultImpls +} + +@kotlin.Metadata +public final class PrivateFunWithDefaultArgKt$box$1 { + // source: 'privateFunWithDefaultArg.kt' + enclosing method PrivateFunWithDefaultArgKt.box()Ljava/lang/String; + inner (anonymous) class PrivateFunWithDefaultArgKt$box$1 + method (): void +} + +@kotlin.Metadata +public final class PrivateFunWithDefaultArgKt { + // source: 'privateFunWithDefaultArg.kt' + inner (anonymous) class PrivateFunWithDefaultArgKt$box$1 + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String + public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void +} diff --git a/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.kt b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.kt new file mode 100644 index 00000000000..259b6754137 --- /dev/null +++ b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.kt @@ -0,0 +1,37 @@ +// CHECK_BYTECODE_LISTING +// !JVM_DEFAULT_MODE: all +// TARGET_BACKEND: JVM +// JVM_TARGET: 1.8 +// WITH_COROUTINES +// WITH_RUNTIME +import helpers.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +interface Foo { + + fun bar(): String { + var result = "fail" + builder { + result = fooSuspend() + } + return foo() + result + + } + + private fun foo(s: String = "O"): String { + return s + } + + private suspend fun fooSuspend(s: String = "K"): String { + return s + } +} + +fun box(): String { + return object : Foo {}.bar() +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.txt b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.txt new file mode 100644 index 00000000000..444e091775e --- /dev/null +++ b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.txt @@ -0,0 +1,42 @@ +@kotlin.coroutines.jvm.internal.DebugMetadata +@kotlin.Metadata +final class Foo$bar$1 { + // source: 'privateFunWithDefaultArg.kt' + enclosing method Foo.bar()Ljava/lang/String; + synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef + field L$0: java.lang.Object + field label: int + synthetic final field this$0: Foo + inner (anonymous) class Foo$bar$1 + method (p0: Foo, p1: kotlin.jvm.internal.Ref$ObjectRef, p2: kotlin.coroutines.Continuation): void + public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation + public final method invoke(p0: java.lang.Object): java.lang.Object + public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object +} + +@kotlin.Metadata +public interface Foo { + // source: 'privateFunWithDefaultArg.kt' + inner (anonymous) class Foo$bar$1 + public @org.jetbrains.annotations.NotNull method bar(): java.lang.String + public synthetic static method foo$default(p0: Foo, p1: java.lang.String, p2: int, p3: java.lang.Object): java.lang.String + private method foo(p0: java.lang.String): java.lang.String + public synthetic static method fooSuspend$default(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation, p3: int, p4: java.lang.Object): java.lang.Object + private method fooSuspend(p0: java.lang.String, p1: kotlin.coroutines.Continuation): java.lang.Object +} + +@kotlin.Metadata +public final class PrivateFunWithDefaultArgKt$box$1 { + // source: 'privateFunWithDefaultArg.kt' + enclosing method PrivateFunWithDefaultArgKt.box()Ljava/lang/String; + inner (anonymous) class PrivateFunWithDefaultArgKt$box$1 + method (): void +} + +@kotlin.Metadata +public final class PrivateFunWithDefaultArgKt { + // source: 'privateFunWithDefaultArg.kt' + inner (anonymous) class PrivateFunWithDefaultArgKt$box$1 + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String + public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void +} diff --git a/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg_ir.txt b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg_ir.txt new file mode 100644 index 00000000000..48208ac8583 --- /dev/null +++ b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg_ir.txt @@ -0,0 +1,44 @@ +@kotlin.coroutines.jvm.internal.DebugMetadata +@kotlin.Metadata +final class Foo$bar$1 { + // source: 'privateFunWithDefaultArg.kt' + enclosing method Foo.bar()Ljava/lang/String; + synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef + field L$0: java.lang.Object + field label: int + synthetic final field this$0: Foo + inner (anonymous) class Foo$bar$1 + method (p0: kotlin.jvm.internal.Ref$ObjectRef, p1: Foo, p2: kotlin.coroutines.Continuation): void + public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation + public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object + public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object + public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object +} + +@kotlin.Metadata +public interface Foo { + // source: 'privateFunWithDefaultArg.kt' + inner (anonymous) class Foo$bar$1 + public synthetic static method access$fooSuspend(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation): java.lang.Object + public @org.jetbrains.annotations.NotNull method bar(): java.lang.String + public synthetic static method foo$default(p0: Foo, p1: java.lang.String, p2: int, p3: java.lang.Object): java.lang.String + private method foo(p0: java.lang.String): java.lang.String + public synthetic static method fooSuspend$default(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation, p3: int, p4: java.lang.Object): java.lang.Object + private method fooSuspend(p0: java.lang.String, p1: kotlin.coroutines.Continuation): java.lang.Object +} + +@kotlin.Metadata +public final class PrivateFunWithDefaultArgKt$box$1 { + // source: 'privateFunWithDefaultArg.kt' + enclosing method PrivateFunWithDefaultArgKt.box()Ljava/lang/String; + inner (anonymous) class PrivateFunWithDefaultArgKt$box$1 + method (): void +} + +@kotlin.Metadata +public final class PrivateFunWithDefaultArgKt { + // source: 'privateFunWithDefaultArg.kt' + inner (anonymous) class PrivateFunWithDefaultArgKt$box$1 + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String + public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void +} diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java index 3b3d6f7e7eb..10af12d2f33 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java @@ -22062,6 +22062,18 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunInInterface.kt"); } + @Test + @TestMetadata("privateFunWithDefaultArg.kt") + public void testPrivateFunWithDefaultArg() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.kt"); + } + + @Test + @TestMetadata("privateFunWithDefaultArg2.kt") + public void testPrivateFunWithDefaultArg2() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg2.kt"); + } + @Test @TestMetadata("privateSuspend.kt") public void testPrivateSuspend() throws Exception { @@ -22408,6 +22420,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunInInterface.kt"); } + @Test + @TestMetadata("privateFunWithDefaultArg.kt") + public void testPrivateFunWithDefaultArg() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.kt"); + } + @Test @TestMetadata("privateSuspend.kt") public void testPrivateSuspend() throws Exception { diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java index 3059514720a..fc77358774e 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java @@ -22062,6 +22062,18 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunInInterface.kt"); } + @Test + @TestMetadata("privateFunWithDefaultArg.kt") + public void testPrivateFunWithDefaultArg() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.kt"); + } + + @Test + @TestMetadata("privateFunWithDefaultArg2.kt") + public void testPrivateFunWithDefaultArg2() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg2.kt"); + } + @Test @TestMetadata("privateSuspend.kt") public void testPrivateSuspend() throws Exception { @@ -22408,6 +22420,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunInInterface.kt"); } + @Test + @TestMetadata("privateFunWithDefaultArg.kt") + public void testPrivateFunWithDefaultArg() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.kt"); + } + @Test @TestMetadata("privateSuspend.kt") public void testPrivateSuspend() throws Exception { diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index efe858ecb88..01b0cfd0c13 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -18423,6 +18423,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class AllCompatibility extends AbstractLightAnalysisModeTest { + @TestMetadata("privateFunWithDefaultArg.kt") + public void ignorePrivateFunWithDefaultArg() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg.kt"); + } + @TestMetadata("privateSuspend.kt") public void ignorePrivateSuspend() throws Exception { runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateSuspend.kt"); @@ -18576,6 +18581,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunInInterface.kt"); } + @TestMetadata("privateFunWithDefaultArg2.kt") + public void testPrivateFunWithDefaultArg2() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg2.kt"); + } + @TestMetadata("propertyAnnotation.kt") public void testPropertyAnnotation() throws Exception { runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/propertyAnnotation.kt"); @@ -18873,6 +18883,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunInInterface.kt"); } + @TestMetadata("privateFunWithDefaultArg.kt") + public void testPrivateFunWithDefaultArg() throws Exception { + runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg.kt"); + } + @TestMetadata("privateSuspend.kt") public void testPrivateSuspend() throws Exception { runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateSuspend.kt");