From a0d7b703f4b41c487b534af1f0d118ad73418228 Mon Sep 17 00:00:00 2001 From: Mikhail Zarechenskiy Date: Wed, 26 Apr 2017 16:23:54 +0300 Subject: [PATCH] Align generic signature for inner classes to work as in Java #KT-10397 Fixed According to JVMS (p. 4.3.4) inner classes should be separated with `$` in generic signature. Note that in Java, inner types separated with `.` after first parameterized type, and now we preserve the same behaviour. See tests for clarification. --- .../codegen/state/KotlinTypeMapper.java | 32 ++++++--- .../signatureOfDeepGenericInner.kt | 23 ++++++ .../genericSignature/signatureOfDeepInner.kt | 22 ++++++ .../signatureOfDeepInnerLastGeneric.kt | 23 ++++++ .../signatureOfGenericInnerGenericOuter.kt | 15 ++++ .../signatureOfGenericInnerSimpleOuter.kt | 15 ++++ .../signatureOfSimpleInnerSimpleOuter.kt | 15 ++++ .../writeSignature/DeepGenericInnerClass.kt | 15 ++++ .../GenericInnerClassWithSimpleOuter.kt | 9 +++ .../ir/IrBlackBoxCodegenTestGenerated.java | 36 ++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 36 ++++++++++ .../LightAnalysisModeTestGenerated.java | 36 ++++++++++ .../compiler/WriteSignatureTestGenerated.java | 12 ++++ .../semantics/JsCodegenBoxTestGenerated.java | 72 +++++++++++++++++++ .../OutputPrefixPostfixTestGenerated.java | 1 - ...SourceMapGenerationSmokeTestGenerated.java | 1 - 16 files changed, 350 insertions(+), 13 deletions(-) create mode 100644 compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepGenericInner.kt create mode 100644 compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInner.kt create mode 100644 compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInnerLastGeneric.kt create mode 100644 compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerGenericOuter.kt create mode 100644 compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerSimpleOuter.kt create mode 100644 compiler/testData/codegen/box/reflection/genericSignature/signatureOfSimpleInnerSimpleOuter.kt create mode 100644 compiler/testData/writeSignature/DeepGenericInnerClass.kt create mode 100644 compiler/testData/writeSignature/GenericInnerClassWithSimpleOuter.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.java index 36be48bc9eb..656de027dc7 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2016 JetBrains s.r.o. + * Copyright 2010-2017 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -530,25 +530,35 @@ public class KotlinTypeMapper { List innerTypesAsList = possiblyInnerType.segments(); - if (innerTypesAsList.size() == 1) { + int indexOfParameterizedType = CollectionsKt.indexOfFirst(innerTypesAsList, innerPart -> !innerPart.getArguments().isEmpty()); + if (indexOfParameterizedType < 0 || innerTypesAsList.size() == 1) { signatureVisitor.writeClassBegin(asmType); + writeGenericArguments(signatureVisitor, possiblyInnerType, mode); } else { - ClassDescriptor outermostClass = innerTypesAsList.get(0).getClassDescriptor(); - signatureVisitor.writeOuterClassBegin(asmType, mapType(outermostClass.getDefaultType()).getInternalName()); - } + PossiblyInnerType outerType = innerTypesAsList.get(indexOfParameterizedType); - for (int i = 0; i < innerTypesAsList.size(); i++) { - PossiblyInnerType innerPart = innerTypesAsList.get(i); - if (i > 0) { - signatureVisitor.writeInnerClass(getJvmShortName(innerPart.getClassDescriptor())); - } - writeGenericArguments(signatureVisitor, innerPart, mode); + signatureVisitor.writeOuterClassBegin(asmType, mapType(outerType.getClassDescriptor()).getInternalName()); + writeGenericArguments(signatureVisitor, outerType, mode); + + writeInnerParts(innerTypesAsList, signatureVisitor, mode, indexOfParameterizedType + 1); // inner parts separated by `.` } signatureVisitor.writeClassEnd(); } + private void writeInnerParts( + @NotNull List innerTypesAsList, + @NotNull JvmSignatureWriter signatureVisitor, + @NotNull TypeMappingMode mode, + int index + ) { + for (PossiblyInnerType innerPart : innerTypesAsList.subList(index, innerTypesAsList.size())) { + signatureVisitor.writeInnerClass(getJvmShortName(innerPart.getClassDescriptor())); + writeGenericArguments(signatureVisitor, innerPart, mode); + } + } + @NotNull private static String getJvmShortName(@NotNull ClassDescriptor klass) { ClassId classId = JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(DescriptorUtils.getFqName(klass)); diff --git a/compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepGenericInner.kt b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepGenericInner.kt new file mode 100644 index 00000000000..810db7f3fd9 --- /dev/null +++ b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepGenericInner.kt @@ -0,0 +1,23 @@ +// WITH_REFLECT +// IGNORE_BACKEND: JS, NATIVE + +abstract class Outer { + + inner class FirstInner { + inner class SecondInner { + inner class ThirdInnner { + inner class FourthInner + + fun foo(): FourthInner = TODO() + } + } + } +} + +fun box(): String { + kotlin.test.assertEquals( + "Outer\$FirstInner.Outer\$FirstInner\$SecondInner.ThirdInnner.FourthInner", + Outer.FirstInner.SecondInner.ThirdInnner::class.java.declaredMethods.single().genericReturnType.toString()) + + return "OK" +} diff --git a/compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInner.kt b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInner.kt new file mode 100644 index 00000000000..30400feef74 --- /dev/null +++ b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInner.kt @@ -0,0 +1,22 @@ +// WITH_REFLECT +// IGNORE_BACKEND: JS, NATIVE + +abstract class Outer { + + inner class FirstInner { + inner class SecondInner { + inner class ThirdInnner { + inner class FourthInner + + fun foo(): FourthInner = TODO() + } + } + } +} + +fun box(): String { + kotlin.test.assertEquals( + "Outer\$FirstInner.Outer\$FirstInner\$SecondInner.ThirdInnner.FourthInner", + Outer.FirstInner.SecondInner.ThirdInnner::class.java.declaredMethods.single().genericReturnType.toString()) + return "OK" +} diff --git a/compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInnerLastGeneric.kt b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInnerLastGeneric.kt new file mode 100644 index 00000000000..3515cafd88c --- /dev/null +++ b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInnerLastGeneric.kt @@ -0,0 +1,23 @@ +// WITH_REFLECT +// IGNORE_BACKEND: JS, NATIVE + +abstract class Outer { + + inner class FirstInner { + inner class SecondInner { + inner class ThirdInnner { + inner class FourthInner + + fun foo(): FourthInner = TODO() + } + } + } +} + +fun box(): String { + kotlin.test.assertEquals( + "Outer\$FirstInner\$SecondInner\$ThirdInnner.Outer\$FirstInner\$SecondInner\$ThirdInnner\$FourthInner", + Outer.FirstInner.SecondInner.ThirdInnner::class.java.declaredMethods.single().genericReturnType.toString()) + + return "OK" +} diff --git a/compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerGenericOuter.kt b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerGenericOuter.kt new file mode 100644 index 00000000000..5e1c8338697 --- /dev/null +++ b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerGenericOuter.kt @@ -0,0 +1,15 @@ +// WITH_REFLECT +// IGNORE_BACKEND: JS, NATIVE + +abstract class Outer { + inner class Inner + fun foo(): Inner? = null +} + +fun box(): String { + kotlin.test.assertEquals( + "Outer.Inner", + Outer::class.java.declaredMethods.single().genericReturnType.toString()) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerSimpleOuter.kt b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerSimpleOuter.kt new file mode 100644 index 00000000000..a43c48307fc --- /dev/null +++ b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerSimpleOuter.kt @@ -0,0 +1,15 @@ +// WITH_REFLECT +// IGNORE_BACKEND: JS, NATIVE + +abstract class Outer { + inner class Inner + fun foo(): Inner? = null +} + +fun box(): String { + kotlin.test.assertEquals( + "Outer.Outer\$Inner", + Outer::class.java.declaredMethods.single().genericReturnType.toString()) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/reflection/genericSignature/signatureOfSimpleInnerSimpleOuter.kt b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfSimpleInnerSimpleOuter.kt new file mode 100644 index 00000000000..76a39f00bdc --- /dev/null +++ b/compiler/testData/codegen/box/reflection/genericSignature/signatureOfSimpleInnerSimpleOuter.kt @@ -0,0 +1,15 @@ +// WITH_REFLECT +// IGNORE_BACKEND: JS, NATIVE + +abstract class Outer { + inner class Inner + fun foo(): Inner? = null +} + +fun box(): String { + kotlin.test.assertEquals( + "class Outer\$Inner", + Outer::class.java.declaredMethods.single().genericReturnType.toString()) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/writeSignature/DeepGenericInnerClass.kt b/compiler/testData/writeSignature/DeepGenericInnerClass.kt new file mode 100644 index 00000000000..2763cb81991 --- /dev/null +++ b/compiler/testData/writeSignature/DeepGenericInnerClass.kt @@ -0,0 +1,15 @@ +abstract class Outer { + inner class FirstInner { + inner class SecondInner { + inner class ThirdInnner { + inner class FourthInner + } + } + } + + fun foo(): FirstInner.SecondInner.ThirdInnner.FourthInner = TODO() +} + +// method: Outer::foo +// jvm signature: ()LOuter$FirstInner$SecondInner$ThirdInnner$FourthInner; +// generic signature: ()LOuter$FirstInner$SecondInner.ThirdInnner.FourthInner; \ No newline at end of file diff --git a/compiler/testData/writeSignature/GenericInnerClassWithSimpleOuter.kt b/compiler/testData/writeSignature/GenericInnerClassWithSimpleOuter.kt new file mode 100644 index 00000000000..02041e67167 --- /dev/null +++ b/compiler/testData/writeSignature/GenericInnerClassWithSimpleOuter.kt @@ -0,0 +1,9 @@ +class Outer { + inner class Inner + + fun foo(): Inner = TODO() +} + +// method: Outer::foo +// jvm signature: ()LOuter$Inner; +// generic signature: ()LOuter$Inner; \ No newline at end of file diff --git a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 10cdd05c76f..c2de24c76f4 100644 --- a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -14514,6 +14514,42 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/kt6106.kt"); doTest(fileName); } + + @TestMetadata("signatureOfDeepGenericInner.kt") + public void testSignatureOfDeepGenericInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepGenericInner.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfDeepInner.kt") + public void testSignatureOfDeepInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInner.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfDeepInnerLastGeneric.kt") + public void testSignatureOfDeepInnerLastGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInnerLastGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfGenericInnerGenericOuter.kt") + public void testSignatureOfGenericInnerGenericOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerGenericOuter.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfGenericInnerSimpleOuter.kt") + public void testSignatureOfGenericInnerSimpleOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerSimpleOuter.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfSimpleInnerSimpleOuter.kt") + public void testSignatureOfSimpleInnerSimpleOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfSimpleInnerSimpleOuter.kt"); + doTest(fileName); + } } @TestMetadata("compiler/testData/codegen/box/reflection/isInstance") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index b1fe20a4424..1f54d4909cf 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -14514,6 +14514,42 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/kt6106.kt"); doTest(fileName); } + + @TestMetadata("signatureOfDeepGenericInner.kt") + public void testSignatureOfDeepGenericInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepGenericInner.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfDeepInner.kt") + public void testSignatureOfDeepInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInner.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfDeepInnerLastGeneric.kt") + public void testSignatureOfDeepInnerLastGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInnerLastGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfGenericInnerGenericOuter.kt") + public void testSignatureOfGenericInnerGenericOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerGenericOuter.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfGenericInnerSimpleOuter.kt") + public void testSignatureOfGenericInnerSimpleOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerSimpleOuter.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfSimpleInnerSimpleOuter.kt") + public void testSignatureOfSimpleInnerSimpleOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfSimpleInnerSimpleOuter.kt"); + doTest(fileName); + } } @TestMetadata("compiler/testData/codegen/box/reflection/isInstance") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 1caaf7c68bc..71453afbb0e 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -14514,6 +14514,42 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/kt6106.kt"); doTest(fileName); } + + @TestMetadata("signatureOfDeepGenericInner.kt") + public void testSignatureOfDeepGenericInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepGenericInner.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfDeepInner.kt") + public void testSignatureOfDeepInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInner.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfDeepInnerLastGeneric.kt") + public void testSignatureOfDeepInnerLastGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInnerLastGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfGenericInnerGenericOuter.kt") + public void testSignatureOfGenericInnerGenericOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerGenericOuter.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfGenericInnerSimpleOuter.kt") + public void testSignatureOfGenericInnerSimpleOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerSimpleOuter.kt"); + doTest(fileName); + } + + @TestMetadata("signatureOfSimpleInnerSimpleOuter.kt") + public void testSignatureOfSimpleInnerSimpleOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfSimpleInnerSimpleOuter.kt"); + doTest(fileName); + } } @TestMetadata("compiler/testData/codegen/box/reflection/isInstance") diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java index ae894a774be..8d62d8c79f5 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java @@ -60,12 +60,24 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { doTest(fileName); } + @TestMetadata("DeepGenericInnerClass.kt") + public void testDeepGenericInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/DeepGenericInnerClass.kt"); + doTest(fileName); + } + @TestMetadata("GenericInnerClass.kt") public void testGenericInnerClass() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/GenericInnerClass.kt"); doTest(fileName); } + @TestMetadata("GenericInnerClassWithSimpleOuter.kt") + public void testGenericInnerClassWithSimpleOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/GenericInnerClassWithSimpleOuter.kt"); + doTest(fileName); + } + @TestMetadata("Int.kt") public void testInt() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/writeSignature/Int.kt"); diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index 5ce0915f7f0..f4917bb88d7 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -17216,6 +17216,78 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } throw new AssertionError("Looks like this test can be unmuted. Remove IGNORE_BACKEND directive for that."); } + + @TestMetadata("signatureOfDeepGenericInner.kt") + public void testSignatureOfDeepGenericInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepGenericInner.kt"); + try { + doTest(fileName); + } + catch (Throwable ignore) { + return; + } + throw new AssertionError("Looks like this test can be unmuted. Remove IGNORE_BACKEND directive for that."); + } + + @TestMetadata("signatureOfDeepInner.kt") + public void testSignatureOfDeepInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInner.kt"); + try { + doTest(fileName); + } + catch (Throwable ignore) { + return; + } + throw new AssertionError("Looks like this test can be unmuted. Remove IGNORE_BACKEND directive for that."); + } + + @TestMetadata("signatureOfDeepInnerLastGeneric.kt") + public void testSignatureOfDeepInnerLastGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfDeepInnerLastGeneric.kt"); + try { + doTest(fileName); + } + catch (Throwable ignore) { + return; + } + throw new AssertionError("Looks like this test can be unmuted. Remove IGNORE_BACKEND directive for that."); + } + + @TestMetadata("signatureOfGenericInnerGenericOuter.kt") + public void testSignatureOfGenericInnerGenericOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerGenericOuter.kt"); + try { + doTest(fileName); + } + catch (Throwable ignore) { + return; + } + throw new AssertionError("Looks like this test can be unmuted. Remove IGNORE_BACKEND directive for that."); + } + + @TestMetadata("signatureOfGenericInnerSimpleOuter.kt") + public void testSignatureOfGenericInnerSimpleOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfGenericInnerSimpleOuter.kt"); + try { + doTest(fileName); + } + catch (Throwable ignore) { + return; + } + throw new AssertionError("Looks like this test can be unmuted. Remove IGNORE_BACKEND directive for that."); + } + + @TestMetadata("signatureOfSimpleInnerSimpleOuter.kt") + public void testSignatureOfSimpleInnerSimpleOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reflection/genericSignature/signatureOfSimpleInnerSimpleOuter.kt"); + try { + doTest(fileName); + } + catch (Throwable ignore) { + return; + } + throw new AssertionError("Looks like this test can be unmuted. Remove IGNORE_BACKEND directive for that."); + } } @TestMetadata("compiler/testData/codegen/box/reflection/isInstance") diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/OutputPrefixPostfixTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/OutputPrefixPostfixTestGenerated.java index 4e3aaea953d..76c4255046c 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/OutputPrefixPostfixTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/OutputPrefixPostfixTestGenerated.java @@ -59,5 +59,4 @@ public class OutputPrefixPostfixTestGenerated extends AbstractOutputPrefixPostfi String fileName = KotlinTestUtils.navigationMetadata("js/js.translator/testData/outputPrefixPostfix/simpleWithPrefixAndPostfix.kt"); doTest(fileName); } - } diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/SourceMapGenerationSmokeTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/SourceMapGenerationSmokeTestGenerated.java index dccfefd35fb..d9470ebf8c7 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/SourceMapGenerationSmokeTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/SourceMapGenerationSmokeTestGenerated.java @@ -53,5 +53,4 @@ public class SourceMapGenerationSmokeTestGenerated extends AbstractSourceMapGene String fileName = KotlinTestUtils.navigationMetadata("js/js.translator/testData/sourcemap/methodCallInMethod.kt"); doTest(fileName); } - }