From b13a225949ea728388b44614daf2a65603b21254 Mon Sep 17 00:00:00 2001 From: Stanislav Ruban Date: Mon, 24 Jul 2023 18:37:10 +0300 Subject: [PATCH] [tests] BI (1P&1TV/1TIO): add tests for basic cases single builder parameter single postponed type variable single origin of type information relevant issues: KT-59551 --- ...CompilerTestFE10TestdataTestGenerated.java | 46 ++++++++++ ...sticCompilerFE10TestDataTestGenerated.java | 46 ++++++++++ ...eeOldFrontendDiagnosticsTestGenerated.java | 46 ++++++++++ ...siOldFrontendDiagnosticsTestGenerated.java | 46 ++++++++++ ...LightTreeBlackBoxCodegenTestGenerated.java | 64 ++++++++++++++ .../FirPsiBlackBoxCodegenTestGenerated.java | 64 ++++++++++++++ ...mousFunctionArgumentAndBuildeeParameter.kt | 43 ++++++++++ ...ymousFunctionArgumentAndBuildeeReceiver.kt | 46 ++++++++++ .../LambdaArgumentAndBuildeeParameter.kt | 43 ++++++++++ .../LambdaArgumentAndBuildeeReceiver.kt | 43 ++++++++++ ...sFunctionArgumentAndBuildeeReceiver.fir.kt | 37 ++++++++ ...ymousFunctionArgumentAndBuildeeReceiver.kt | 37 ++++++++ .../test/runners/DiagnosticTestGenerated.java | 46 ++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 64 ++++++++++++++ .../IrBlackBoxCodegenTestGenerated.java | 64 ++++++++++++++ ...kBoxCodegenWithIrInlinerTestGenerated.java | 64 ++++++++++++++ .../LightAnalysisModeTestGenerated.java | 72 ++++++++++++++++ .../fir/FirJsCodegenBoxTestGenerated.java | 64 ++++++++++++++ .../test/ir/IrJsCodegenBoxTestGenerated.java | 64 ++++++++++++++ .../ir/IrJsES6CodegenBoxTestGenerated.java | 64 ++++++++++++++ .../FirNativeCodegenBoxTestGenerated.java | 76 +++++++++++++++++ .../FirNativeCodegenBoxTestNoPLGenerated.java | 84 +++++++++++++++++++ .../NativeCodegenBoxTestGenerated.java | 72 ++++++++++++++++ .../NativeCodegenBoxTestNoPLGenerated.java | 76 +++++++++++++++++ .../test/FirWasmCodegenBoxTestGenerated.java | 64 ++++++++++++++ .../test/K1WasmCodegenBoxTestGenerated.java | 64 ++++++++++++++ 26 files changed, 1499 insertions(+) create mode 100644 compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt create mode 100644 compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt create mode 100644 compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt create mode 100644 compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt create mode 100644 compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.fir.kt create mode 100644 compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java index 55bce2060e9..340596ba071 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java @@ -3229,6 +3229,52 @@ public class DiagnosticCompilerTestFE10TestdataTestGenerated extends AbstractDia } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/callableReference") @TestDataPath("$PROJECT_ROOT") diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java index bed59b4f0b2..9e97e9e2a8e 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java @@ -3229,6 +3229,52 @@ public class LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/callableReference") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java index 1c57c867e5e..f770ec41bd6 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java @@ -3229,6 +3229,52 @@ public class FirLightTreeOldFrontendDiagnosticsTestGenerated extends AbstractFir } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/callableReference") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java index ad82bac83ae..5b2e5e2b48f 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java @@ -3235,6 +3235,52 @@ public class FirPsiOldFrontendDiagnosticsTestGenerated extends AbstractFirPsiDia } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/callableReference") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java index 1a5092435e6..12c8938d3fc 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java @@ -2698,6 +2698,70 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java index dcbae359e18..432fab48901 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java @@ -2698,6 +2698,70 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt b/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt new file mode 100644 index 00000000000..b6f893b6b4b --- /dev/null +++ b/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt @@ -0,0 +1,43 @@ +// IGNORE_BACKEND: NATIVE +// IGNORE_BACKEND: WASM +// IGNORE_BACKEND: JS, JS_IR, JS_IR_ES6 +// IGNORE_LIGHT_ANALYSIS + +// CHECK_TYPE_WITH_EXACT + +class Buildee { + fun yield(arg: CT) {} + fun materialize(): CT = UserKlass() as CT +} + +fun build( + instructions: (Buildee) -> Unit +): Buildee { + return Buildee().apply(instructions) +} + +class UserKlass + +// test 1: PTV is in consuming position (yield-case) +fun testYield() { + val arg: UserKlass = UserKlass() + val buildee = build(fun(it) { + it.yield(arg) + }) + checkExactType>(buildee) +} + +// test 2: PTV is in producing position (materialize-case) +fun testMaterialize() { + fun consume(arg: UserKlass) {} + val buildee = build(fun(it) { + consume(it.materialize()) + }) + checkExactType>(buildee) +} + +fun box(): String { + testYield() + testMaterialize() + return "OK" +} diff --git a/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt b/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt new file mode 100644 index 00000000000..70aa9bcca20 --- /dev/null +++ b/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt @@ -0,0 +1,46 @@ +// IGNORE_BACKEND_K2: NATIVE +// IGNORE_BACKEND_K2: WASM +// IGNORE_BACKEND_K2: JS, JS_IR, JS_IR_ES6 +// IGNORE_LIGHT_ANALYSIS + +// CHECK_TYPE_WITH_EXACT + +// IGNORE_BACKEND_K1: ANY +// ISSUE: KT-59551 + +class Buildee { + fun yield(arg: CT) {} + fun materialize(): CT = UserKlass() as CT +} + +fun build( + instructions: Buildee.() -> Unit +): Buildee { + return Buildee().apply(instructions) +} + +class UserKlass + +// test 1: PTV is in consuming position (yield-case) +fun testYield() { + val arg: UserKlass = UserKlass() + val buildee = build(fun(it) { + it.yield(arg) + }) + checkExactType>(buildee) +} + +// test 2: PTV is in producing position (materialize-case) +fun testMaterialize() { + fun consume(arg: UserKlass) {} + val buildee = build(fun(it) { + consume(it.materialize()) + }) + checkExactType>(buildee) +} + +fun box(): String { + testYield() + testMaterialize() + return "OK" +} diff --git a/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt b/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt new file mode 100644 index 00000000000..aa3dd604d0c --- /dev/null +++ b/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt @@ -0,0 +1,43 @@ +// IGNORE_BACKEND: NATIVE +// IGNORE_BACKEND: WASM +// IGNORE_BACKEND: JS, JS_IR, JS_IR_ES6 +// IGNORE_LIGHT_ANALYSIS + +// CHECK_TYPE_WITH_EXACT + +class Buildee { + fun yield(arg: CT) {} + fun materialize(): CT = UserKlass() as CT +} + +fun build( + instructions: (Buildee) -> Unit +): Buildee { + return Buildee().apply(instructions) +} + +class UserKlass + +// test 1: PTV is in consuming position (yield-case) +fun testYield() { + val arg: UserKlass = UserKlass() + val buildee = build { + it.yield(arg) + } + checkExactType>(buildee) +} + +// test 2: PTV is in producing position (materialize-case) +fun testMaterialize() { + fun consume(arg: UserKlass) {} + val buildee = build { + consume(it.materialize()) + } + checkExactType>(buildee) +} + +fun box(): String { + testYield() + testMaterialize() + return "OK" +} diff --git a/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt b/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt new file mode 100644 index 00000000000..39da5883d67 --- /dev/null +++ b/compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt @@ -0,0 +1,43 @@ +// IGNORE_BACKEND: NATIVE +// IGNORE_BACKEND: WASM +// IGNORE_BACKEND: JS, JS_IR, JS_IR_ES6 +// IGNORE_LIGHT_ANALYSIS + +// CHECK_TYPE_WITH_EXACT + +class Buildee { + fun yield(arg: CT) {} + fun materialize(): CT = UserKlass() as CT +} + +fun build( + instructions: Buildee.() -> Unit +): Buildee { + return Buildee().apply(instructions) +} + +class UserKlass + +// test 1: PTV is in consuming position (yield-case) +fun testYield() { + val arg: UserKlass = UserKlass() + val buildee = build { + yield(arg) + } + checkExactType>(buildee) +} + +// test 2: PTV is in producing position (materialize-case) +fun testMaterialize() { + fun consume(arg: UserKlass) {} + val buildee = build { + consume(materialize()) + } + checkExactType>(buildee) +} + +fun box(): String { + testYield() + testMaterialize() + return "OK" +} diff --git a/compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.fir.kt b/compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.fir.kt new file mode 100644 index 00000000000..da5b8e18021 --- /dev/null +++ b/compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.fir.kt @@ -0,0 +1,37 @@ +// DIAGNOSTICS: -UNCHECKED_CAST + +// CHECK_TYPE_WITH_EXACT + +// ISSUE: KT-59551 +// (also see an analogous codegen test) + +class Buildee { + fun yield(arg: CT) {} + fun materialize(): CT = UserKlass() as CT +} + +fun build( + instructions: Buildee.() -> Unit +): Buildee { + return Buildee().apply(instructions) +} + +class UserKlass + +// test 1: PTV is in consuming position (yield-case) +fun testYield() { + val arg: UserKlass = UserKlass() + val buildee = build(fun(it) { + it.yield(arg) + }) + checkExactType>(buildee) +} + +// test 2: PTV is in producing position (materialize-case) +fun testMaterialize() { + fun consume(arg: UserKlass) {} + val buildee = build(fun(it) { + consume(it.materialize()) + }) + checkExactType>(buildee) +} diff --git a/compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt b/compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt new file mode 100644 index 00000000000..069893f28ae --- /dev/null +++ b/compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt @@ -0,0 +1,37 @@ +// DIAGNOSTICS: -UNCHECKED_CAST + +// CHECK_TYPE_WITH_EXACT + +// ISSUE: KT-59551 +// (also see an analogous codegen test) + +class Buildee { + fun yield(arg: CT) {} + fun materialize(): CT = UserKlass() as CT +} + +fun build( + instructions: Buildee.() -> Unit +): Buildee { + return Buildee().apply(instructions) +} + +class UserKlass + +// test 1: PTV is in consuming position (yield-case) +fun testYield() { + val arg: UserKlass = UserKlass() + val buildee = build(fun(it) { + it.yield(arg) + }) + checkExactType>(buildee) +} + +// test 2: PTV is in producing position (materialize-case) +fun testMaterialize() { + fun consume(arg: UserKlass) {} + val buildee = build(fun(it) { + consume(it.materialize()) + }) + checkExactType>(buildee) +} diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index a1be3ff6b86..1098ac89e73 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -3235,6 +3235,52 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/callableReference") @TestDataPath("$PROJECT_ROOT") 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 941b48a2600..0c151b5ae14 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 @@ -2536,6 +2536,70 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") 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 abac0c8c97c..d671324c819 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 @@ -2698,6 +2698,70 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java index 31dfc76b4cd..ba5cf890c02 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java @@ -2698,6 +2698,70 @@ public class IrBlackBoxCodegenWithIrInlinerTestGenerated extends AbstractIrBlack } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 8b8db1cb584..cbbcfb47e97 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -2351,6 +2351,78 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } } + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class BuilderInference extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OneParameter extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OneTypeVariable extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OneTypeInfoOrigin extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java index 2f93ca80fcc..e5324bcf026 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java @@ -1822,6 +1822,70 @@ public class FirJsCodegenBoxTestGenerated extends AbstractFirJsCodegenBoxTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java index 0df9160a91b..c3d3dba835c 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java @@ -1822,6 +1822,70 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java index 00ebb2269d9..4d9012f0c4d 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java @@ -1822,6 +1822,70 @@ public class IrJsES6CodegenBoxTestGenerated extends AbstractIrJsES6CodegenBoxTes } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java index e363c643af0..3568602433a 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java @@ -1878,6 +1878,82 @@ public class FirNativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTe } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + @Tag("frontend-fir") + @FirPipeline() + @UseExtTestCaseGroupProvider() + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + @Tag("frontend-fir") + @FirPipeline() + @UseExtTestCaseGroupProvider() + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + @Tag("frontend-fir") + @FirPipeline() + @UseExtTestCaseGroupProvider() + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + @Tag("frontend-fir") + @FirPipeline() + @UseExtTestCaseGroupProvider() + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestNoPLGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestNoPLGenerated.java index eceec4b088f..c9e87d0f274 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestNoPLGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestNoPLGenerated.java @@ -1922,6 +1922,90 @@ public class FirNativeCodegenBoxTestNoPLGenerated extends AbstractNativeCodegenB } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + @Tag("frontend-fir") + @FirPipeline() + @UseExtTestCaseGroupProvider() + @UsePartialLinkage(mode = Mode.DISABLED) + @Tag("no-partial-linkage-may-be-skipped") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + @Tag("frontend-fir") + @FirPipeline() + @UseExtTestCaseGroupProvider() + @UsePartialLinkage(mode = Mode.DISABLED) + @Tag("no-partial-linkage-may-be-skipped") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + @Tag("frontend-fir") + @FirPipeline() + @UseExtTestCaseGroupProvider() + @UsePartialLinkage(mode = Mode.DISABLED) + @Tag("no-partial-linkage-may-be-skipped") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + @Tag("frontend-fir") + @FirPipeline() + @UseExtTestCaseGroupProvider() + @UsePartialLinkage(mode = Mode.DISABLED) + @Tag("no-partial-linkage-may-be-skipped") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java index 4402f065306..80373488264 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java @@ -1857,6 +1857,78 @@ public class NativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTest } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + @UseExtTestCaseGroupProvider() + @DisabledTestsIfProperty(sourceLocations = { "compiler/testData/codegen/box/coroutines/featureIntersection/defaultExpect.kt", "compiler/testData/codegen/box/multiplatform/defaultArguments/*.kt", "compiler/testData/codegen/box/multiplatform/migratedOldTests/*.kt", "compiler/testData/codegen/boxInline/multiplatform/defaultArguments/receiversAndParametersInLambda.kt" }, property = ClassLevelProperty.TEST_MODE, propertyValue = "ONE_STAGE_MULTI_MODULE") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + @UseExtTestCaseGroupProvider() + @DisabledTestsIfProperty(sourceLocations = { "compiler/testData/codegen/box/coroutines/featureIntersection/defaultExpect.kt", "compiler/testData/codegen/box/multiplatform/defaultArguments/*.kt", "compiler/testData/codegen/box/multiplatform/migratedOldTests/*.kt", "compiler/testData/codegen/boxInline/multiplatform/defaultArguments/receiversAndParametersInLambda.kt" }, property = ClassLevelProperty.TEST_MODE, propertyValue = "ONE_STAGE_MULTI_MODULE") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + @UseExtTestCaseGroupProvider() + @DisabledTestsIfProperty(sourceLocations = { "compiler/testData/codegen/box/coroutines/featureIntersection/defaultExpect.kt", "compiler/testData/codegen/box/multiplatform/defaultArguments/*.kt", "compiler/testData/codegen/box/multiplatform/migratedOldTests/*.kt", "compiler/testData/codegen/boxInline/multiplatform/defaultArguments/receiversAndParametersInLambda.kt" }, property = ClassLevelProperty.TEST_MODE, propertyValue = "ONE_STAGE_MULTI_MODULE") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + @UseExtTestCaseGroupProvider() + @DisabledTestsIfProperty(sourceLocations = { "compiler/testData/codegen/box/coroutines/featureIntersection/defaultExpect.kt", "compiler/testData/codegen/box/multiplatform/defaultArguments/*.kt", "compiler/testData/codegen/box/multiplatform/migratedOldTests/*.kt", "compiler/testData/codegen/boxInline/multiplatform/defaultArguments/receiversAndParametersInLambda.kt" }, property = ClassLevelProperty.TEST_MODE, propertyValue = "ONE_STAGE_MULTI_MODULE") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestNoPLGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestNoPLGenerated.java index f67fa294556..b93efbe0ed1 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestNoPLGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestNoPLGenerated.java @@ -1879,6 +1879,82 @@ public class NativeCodegenBoxTestNoPLGenerated extends AbstractNativeCodegenBoxT } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + @UseExtTestCaseGroupProvider() + @UsePartialLinkage(mode = Mode.DISABLED) + @Tag("no-partial-linkage-may-be-skipped") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + @UseExtTestCaseGroupProvider() + @UsePartialLinkage(mode = Mode.DISABLED) + @Tag("no-partial-linkage-may-be-skipped") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + @UseExtTestCaseGroupProvider() + @UsePartialLinkage(mode = Mode.DISABLED) + @Tag("no-partial-linkage-may-be-skipped") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + @UseExtTestCaseGroupProvider() + @UsePartialLinkage(mode = Mode.DISABLED) + @Tag("no-partial-linkage-may-be-skipped") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxTestGenerated.java index 32e91e5bced..82c9ca6ace2 100644 --- a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxTestGenerated.java +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxTestGenerated.java @@ -1810,6 +1810,70 @@ public class FirWasmCodegenBoxTestGenerated extends AbstractFirWasmCodegenBoxTes } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxTestGenerated.java index 0419b5f643d..7aa97d7039c 100644 --- a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxTestGenerated.java +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxTestGenerated.java @@ -1810,6 +1810,70 @@ public class K1WasmCodegenBoxTestGenerated extends AbstractK1WasmCodegenBoxTest } } + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter") + @TestDataPath("$PROJECT_ROOT") + public class OneParameter { + @Test + public void testAllFilesPresentInOneParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeVariable { + @Test + public void testAllFilesPresentInOneTypeVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin") + @TestDataPath("$PROJECT_ROOT") + public class OneTypeInfoOrigin { + @Test + public void testAllFilesPresentInOneTypeInfoOrigin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeParameter.kt") + public void testAnonymousFunctionArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("AnonymousFunctionArgumentAndBuildeeReceiver.kt") + public void testAnonymousFunctionArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/AnonymousFunctionArgumentAndBuildeeReceiver.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeParameter.kt") + public void testLambdaArgumentAndBuildeeParameter() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeParameter.kt"); + } + + @Test + @TestMetadata("LambdaArgumentAndBuildeeReceiver.kt") + public void testLambdaArgumentAndBuildeeReceiver() throws Exception { + runTest("compiler/testData/codegen/box/builderInference/oneParameter/oneTypeVariable/oneTypeInfoOrigin/LambdaArgumentAndBuildeeReceiver.kt"); + } + } + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT")