From 7595f798e10da15b5f5b2e491543c9fb3725e4d4 Mon Sep 17 00:00:00 2001 From: "Evgeniy.Zhelenskiy" Date: Fri, 24 Dec 2021 04:37:30 +0300 Subject: [PATCH] [JVM] Introduce MF Value Classes to frontend --- ...irOldFrontendDiagnosticsTestGenerated.java | 13 ++ ...DiagnosticsWithLightTreeTestGenerated.java | 13 ++ .../diagnostics/FirDiagnosticsList.kt | 1 + .../fir/analysis/diagnostics/FirErrors.kt | 1 + .../FirInlineClassDeclarationChecker.kt | 75 +++++--- .../diagnostics/FirErrorsDefaultMessages.kt | 10 +- .../FirBlackBoxCodegenTestGenerated.java | 22 +++ .../jetbrains/kotlin/diagnostics/Errors.java | 3 +- .../rendering/DefaultErrorMessages.java | 5 +- .../checkers/InlineClassDeclarationChecker.kt | 55 ++++-- .../codegen/box/valueClasses/equality.kt | 167 ++++++++++++++++ .../recursiveMultiFieldValueClasses.kt | 63 +++++++ .../recursiveMultiFieldValueClasses.txt | 178 ++++++++++++++++++ ...ssWithForbiddenUnderlyingTypeMultiField.kt | 42 +++++ ...sWithForbiddenUnderlyingTypeMultiField.txt | 98 ++++++++++ .../test/runners/DiagnosticTestGenerated.java | 13 ++ .../codegen/BlackBoxCodegenTestGenerated.java | 10 + .../IrBlackBoxCodegenTestGenerated.java | 22 +++ .../LightAnalysisModeTestGenerated.java | 13 ++ .../kotlin/generators/NewTestGeneratorImpl.kt | 2 +- .../generators/model/SimpleTestClassModel.kt | 2 +- .../generators/model/SingleClassTestModel.kt | 2 +- .../js/test/JsCodegenBoxTestGenerated.java | 10 + .../test/ir/IrJsCodegenBoxTestGenerated.java | 10 + .../IrCodegenBoxWasmTestGenerated.java | 25 +-- .../blackboxtest/ExternalTestGenerated.java | 66 ++----- 26 files changed, 795 insertions(+), 126 deletions(-) create mode 100644 compiler/testData/codegen/box/valueClasses/equality.kt create mode 100644 compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.kt create mode 100644 compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.txt create mode 100644 compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.kt create mode 100644 compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.txt diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 8f81b3c3c1d..bb7ac16923d 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.utils.TransformersFunctions; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -32113,6 +32114,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt"); } + @Test + @TestMetadata("recursiveMultiFieldValueClasses.kt") + public void testRecursiveMultiFieldValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + @Test @TestMetadata("recursiveValueClasses.kt") public void testRecursiveValueClasses() throws Exception { @@ -32167,6 +32174,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt"); } + @Test + @TestMetadata("valueClassWithForbiddenUnderlyingTypeMultiField.kt") + public void testValueClassWithForbiddenUnderlyingTypeMultiField() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + @Test @TestMetadata("valueClassesInsideAnnotations.kt") public void testValueClassesInsideAnnotations() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java index 00681c2e019..5ed581c8e68 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.utils.TransformersFunctions; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -32113,6 +32114,12 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac runTest("compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt"); } + @Test + @TestMetadata("recursiveMultiFieldValueClasses.kt") + public void testRecursiveMultiFieldValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + @Test @TestMetadata("recursiveValueClasses.kt") public void testRecursiveValueClasses() throws Exception { @@ -32167,6 +32174,12 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt"); } + @Test + @TestMetadata("valueClassWithForbiddenUnderlyingTypeMultiField.kt") + public void testValueClassWithForbiddenUnderlyingTypeMultiField() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + @Test @TestMetadata("valueClassesInsideAnnotations.kt") public void testValueClassesInsideAnnotations() throws Exception { diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt index b8f9c371a6f..0b2f505e155 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt @@ -405,6 +405,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val VALUE_CLASS_NOT_FINAL by error(PositioningStrategy.MODALITY_MODIFIER) val ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_VALUE_CLASS by error(PositioningStrategy.INLINE_OR_VALUE_MODIFIER) val INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE by error() + val VALUE_CLASS_EMPTY_CONSTRUCTOR by error() val VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER by error() val PROPERTY_WITH_BACKING_FIELD_INSIDE_VALUE_CLASS by error(PositioningStrategy.DECLARATION_SIGNATURE) val DELEGATED_PROPERTY_INSIDE_VALUE_CLASS by error() diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt index ce149dbd911..fea7433e511 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt @@ -306,6 +306,7 @@ object FirErrors { val VALUE_CLASS_NOT_FINAL by error0(SourceElementPositioningStrategies.MODALITY_MODIFIER) val ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_VALUE_CLASS by error0(SourceElementPositioningStrategies.INLINE_OR_VALUE_MODIFIER) val INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE by error0() + val VALUE_CLASS_EMPTY_CONSTRUCTOR by error0() val VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER by error0() val PROPERTY_WITH_BACKING_FIELD_INSIDE_VALUE_CLASS by error0(SourceElementPositioningStrategies.DECLARATION_SIGNATURE) val DELEGATED_PROPERTY_INSIDE_VALUE_CLASS by error0() diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt index f47ebfe6797..960a69c9988 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt @@ -15,18 +15,21 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.hasModifier import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol -import org.jetbrains.kotlin.fir.analysis.diagnostics.* +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOnWithSuppression +import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.* -import org.jetbrains.kotlin.fir.expressions.toResolvedCallableReference import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.StandardClassIds object FirInlineClassDeclarationChecker : FirRegularClassChecker() { @@ -60,8 +63,9 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { } var primaryConstructor: FirConstructor? = null - var primaryConstructorParameter: FirValueParameter? = null - var primaryConstructorProperty: FirProperty? = null + var primaryConstructorParametersByName = mapOf() + val primaryConstructorPropertiesByName = mutableMapOf() + var primaryConstructorParametersSymbolsSet = setOf() for (innerDeclaration in declaration.declarations) { when (innerDeclaration) { @@ -69,7 +73,9 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { when { innerDeclaration.isPrimary -> { primaryConstructor = innerDeclaration - primaryConstructorParameter = innerDeclaration.valueParameters.singleOrNull() + primaryConstructorParametersByName = innerDeclaration.valueParameters.associateBy { it.name } + primaryConstructorParametersSymbolsSet = + primaryConstructorParametersByName.map { (_, parameter) -> parameter.symbol }.toSet() } innerDeclaration.body != null -> { @@ -100,7 +106,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { if (innerDeclaration.isSynthetic) { val symbol = innerDeclaration.initializer?.toResolvedCallableSymbol() if (context.languageVersionSettings.supportsFeature(LanguageFeature.InlineClassImplementationByDelegation) && - symbol != null && symbol == primaryConstructorParameter?.symbol + symbol != null && symbol in primaryConstructorParametersSymbolsSet ) { continue } @@ -115,8 +121,8 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { } } is FirProperty -> { - if (innerDeclaration.isRelatedToParameter(primaryConstructorParameter)) { - primaryConstructorProperty = innerDeclaration + if (innerDeclaration.isRelatedToParameter(primaryConstructorParametersByName[innerDeclaration.name])) { + primaryConstructorPropertiesByName[innerDeclaration.name] = innerDeclaration } else { when { innerDeclaration.delegate != null -> @@ -147,35 +153,42 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { return } - if (primaryConstructorParameter == null) { + if (context.languageVersionSettings.supportsFeature(LanguageFeature.ValueClasses)) { + if (primaryConstructorParametersByName.isEmpty()) { + reporter.reportOnWithSuppression(primaryConstructor, FirErrors.VALUE_CLASS_EMPTY_CONSTRUCTOR, context) + return + } + } else if (primaryConstructorParametersByName.size != 1) { reporter.reportOnWithSuppression(primaryConstructor, FirErrors.INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE, context) return } - withSuppressedDiagnostics(primaryConstructor, context) { context -> - withSuppressedDiagnostics(primaryConstructorParameter, context) { context -> - when { - primaryConstructorParameter.isNotFinalReadOnly(primaryConstructorProperty) -> - reporter.reportOn( - primaryConstructorParameter.source, - FirErrors.VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER, - context - ) + for ((name, primaryConstructorParameter) in primaryConstructorParametersByName) { + withSuppressedDiagnostics(primaryConstructor, context) { context -> + withSuppressedDiagnostics(primaryConstructorParameter, context) { context -> + when { + primaryConstructorParameter.isNotFinalReadOnly(primaryConstructorPropertiesByName[name]) -> + reporter.reportOn( + primaryConstructorParameter.source, + FirErrors.VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER, + context + ) - primaryConstructorParameter.returnTypeRef.isInapplicableParameterType() -> - reporter.reportOn( - primaryConstructorParameter.returnTypeRef.source, - FirErrors.VALUE_CLASS_HAS_INAPPLICABLE_PARAMETER_TYPE, - primaryConstructorParameter.returnTypeRef.coneType, - context - ) + primaryConstructorParameter.returnTypeRef.isInapplicableParameterType() -> + reporter.reportOn( + primaryConstructorParameter.returnTypeRef.source, + FirErrors.VALUE_CLASS_HAS_INAPPLICABLE_PARAMETER_TYPE, + primaryConstructorParameter.returnTypeRef.coneType, + context + ) - primaryConstructorParameter.returnTypeRef.coneType.isRecursiveInlineClassType(context.session) -> - reporter.reportOnWithSuppression( - primaryConstructorParameter.returnTypeRef, - FirErrors.VALUE_CLASS_CANNOT_BE_RECURSIVE, - context - ) + primaryConstructorParameter.returnTypeRef.coneType.isRecursiveInlineClassType(context.session) -> + reporter.reportOnWithSuppression( + primaryConstructorParameter.returnTypeRef, + FirErrors.VALUE_CLASS_CANNOT_BE_RECURSIVE, + context + ) + } } } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt index 5050e79771c..ec30430801b 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt @@ -534,6 +534,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_CLASS_CANNO import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_CLASS_CANNOT_EXTEND_CLASSES import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_CLASS_CANNOT_IMPLEMENT_INTERFACE_BY_DELEGATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_CLASS_EMPTY_CONSTRUCTOR import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_CLASS_HAS_INAPPLICABLE_PARAMETER_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_CLASS_NOT_FINAL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_CLASS_NOT_TOP_LEVEL @@ -1150,13 +1151,14 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { ) // Value classes - map.put(VALUE_CLASS_NOT_TOP_LEVEL, "Value classes cannot be local or inner") - map.put(VALUE_CLASS_NOT_FINAL, "Value classes can be only final") + map.put(VALUE_CLASS_NOT_TOP_LEVEL, "Value class cannot be local or inner") + map.put(VALUE_CLASS_NOT_FINAL, "Value class can be only final") map.put(ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_VALUE_CLASS, "Primary constructor is required for value class") - map.put(INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE, "Inline class must have exactly one primary constructor parameter") // + + map.put(INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE, "Inline class must have exactly one primary constructor parameter") + map.put(VALUE_CLASS_EMPTY_CONSTRUCTOR, "Value class must have at least one primary constructor parameter") map.put( VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER, - "Value class primary constructor must only have final read-only (val) property parameter" + "Value class primary constructor must only have final read-only (val) property parameters" ) map.put(PROPERTY_WITH_BACKING_FIELD_INSIDE_VALUE_CLASS, "Value class cannot have properties with backing fields") map.put(DELEGATED_PROPERTY_INSIDE_VALUE_CLASS, "Value class cannot have delegated properties") diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java index 4c6a5b0b77b..d3985780277 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java @@ -47482,6 +47482,28 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } } + @Nested + @TestMetadata("compiler/testData/codegen/box/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("equality.kt") + public void testEquality() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/equality.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("equality.kt") + public void testEquality_valueClasses() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/equality.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/vararg") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index d909b6d5b6d..19ac37634de 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -400,12 +400,13 @@ public interface Errors { DiagnosticFactory0 NON_PRIVATE_CONSTRUCTOR_IN_SEALED = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 NON_PRIVATE_OR_PROTECTED_CONSTRUCTOR_IN_SEALED = DiagnosticFactory0.create(ERROR); - // Inline classes + // Inline classes, Value classes DiagnosticFactory0 VALUE_CLASS_NOT_TOP_LEVEL = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 VALUE_CLASS_NOT_FINAL = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_VALUE_CLASS = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 VALUE_CLASS_EMPTY_CONSTRUCTOR = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 PROPERTY_WITH_BACKING_FIELD_INSIDE_VALUE_CLASS = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE); DiagnosticFactory0 DELEGATED_PROPERTY_INSIDE_VALUE_CLASS = DiagnosticFactory0.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 860e8aa3075..aabe06478ac 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -755,8 +755,9 @@ public class DefaultErrorMessages { MAP.put(VALUE_CLASS_NOT_TOP_LEVEL, "Value classes cannot be local or inner"); MAP.put(VALUE_CLASS_NOT_FINAL, "Value classes can be only final"); MAP.put(ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_VALUE_CLASS, "Primary constructor is required for value class"); - MAP.put(INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE, "Inline class must have exactly one primary constructor parameter"); // + - MAP.put(VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER, "Value class primary constructor must only have final read-only (val) property parameter"); + MAP.put(INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE, "Inline class must have exactly one primary constructor parameter"); + MAP.put(VALUE_CLASS_EMPTY_CONSTRUCTOR, "Value class must have at least one primary constructor parameter"); + MAP.put(VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER, "Value class primary constructor must only have final read-only (val) property parameters"); MAP.put(PROPERTY_WITH_BACKING_FIELD_INSIDE_VALUE_CLASS, "Value class cannot have properties with backing fields"); MAP.put(DELEGATED_PROPERTY_INSIDE_VALUE_CLASS, "Value class cannot have delegated properties"); MAP.put(VALUE_CLASS_HAS_INAPPLICABLE_PARAMETER_TYPE, "Value class cannot have value parameter of type ''{0}''", RENDER_TYPE); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt index e32d34557e0..b85afc405ca 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt @@ -80,31 +80,47 @@ object InlineClassDeclarationChecker : DeclarationChecker { return } - val baseParameter = primaryConstructor.valueParameters.singleOrNull() - if (baseParameter == null) { + if (context.languageVersionSettings.supportsFeature(LanguageFeature.ValueClasses)) { + if (primaryConstructor.valueParameters.isEmpty()) { + (primaryConstructor.valueParameterList ?: declaration).let { + trace.report(Errors.VALUE_CLASS_EMPTY_CONSTRUCTOR.on(it)) + return + } + } + } else if (primaryConstructor.valueParameters.size != 1) { (primaryConstructor.valueParameterList ?: declaration).let { trace.report(Errors.INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE.on(it)) return } } - if (!isParameterAcceptableForInlineClass(baseParameter)) { - trace.report(Errors.VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER.on(baseParameter)) - return + var baseParametersOk = true + for (baseParameter in primaryConstructor.valueParameters) { + + if (!isParameterAcceptableForInlineClass(baseParameter)) { + trace.report(Errors.VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER.on(baseParameter)) + baseParametersOk = false + continue + } + + val baseParameterType = descriptor.safeAs()?.defaultType?.substitutedUnderlyingType() + val baseParameterTypeReference = baseParameter.typeReference + if (baseParameterType != null && baseParameterTypeReference != null) { + if (baseParameterType.isInapplicableParameterType()) { + trace.report(Errors.VALUE_CLASS_HAS_INAPPLICABLE_PARAMETER_TYPE.on(baseParameterTypeReference, baseParameterType)) + baseParametersOk = false + continue + } + + if (baseParameterType.isRecursiveInlineClassType()) { // todo check work for MF VC + trace.report(Errors.VALUE_CLASS_CANNOT_BE_RECURSIVE.on(baseParameterTypeReference)) + baseParametersOk = false + continue + } + } } - - val baseParameterType = descriptor.safeAs()?.defaultType?.substitutedUnderlyingType() - val baseParameterTypeReference = baseParameter.typeReference - if (baseParameterType != null && baseParameterTypeReference != null) { - if (baseParameterType.isInapplicableParameterType()) { - trace.report(Errors.VALUE_CLASS_HAS_INAPPLICABLE_PARAMETER_TYPE.on(baseParameterTypeReference, baseParameterType)) - return - } - - if (baseParameterType.isRecursiveInlineClassType()) { - trace.report(Errors.VALUE_CLASS_CANNOT_BE_RECURSIVE.on(baseParameterTypeReference)) - return - } + if (!baseParametersOk) { + return } for (supertypeEntry in declaration.superTypeListEntries) { @@ -129,7 +145,8 @@ object InlineClassDeclarationChecker : DeclarationChecker { } if (descriptor.getAllSuperClassifiers().any { - it.fqNameUnsafe == StandardNames.FqNames.cloneable || it.fqNameUnsafe == javaLangCloneable } + it.fqNameUnsafe == StandardNames.FqNames.cloneable || it.fqNameUnsafe == javaLangCloneable + } ) { trace.report(Errors.VALUE_CLASS_CANNOT_BE_CLONEABLE.on(inlineOrValueKeyword)) return diff --git a/compiler/testData/codegen/box/valueClasses/equality.kt b/compiler/testData/codegen/box/valueClasses/equality.kt new file mode 100644 index 00000000000..587540679a8 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/equality.kt @@ -0,0 +1,167 @@ +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +value class F1(val x: Int) + +value class F2(val x: UInt) + +value class F3(val x: String) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class F4(val x: Int) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class F5(val x: UInt) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class F6(val x: String) + +value class A( + val f1: F1, + val f2: F2, + val f3: F3, + val f4: F4, + val f5: F5, + val f6: F6, + val f7: Int, + val f8: UInt, + val f9: String, +) + +value class B(val a1: A, val a2: A) { + override fun toString(): String { + return "OverridenBToString(a1 = $a1, a2 = $a2)" + } +} + +fun box(): String { + val f1 = F1(1) + val f2 = F2(UInt.MAX_VALUE) + val f3 = F3("234") + val f4 = F4(5) + val f5 = F5(UInt.MAX_VALUE.dec()) + val f6 = F6("678") + val a1 = A(f1, f2, f3, f4, f5, f6, 9, UInt.MAX_VALUE - 2U, "0") + val a2 = a1 + val b = B(a1, a2) + + assert(f1.x == 1) + assert(f2.x == UInt.MAX_VALUE) + assert(f3.x == "234") + assert(f4.x == 5) + assert(f5.x == UInt.MAX_VALUE - 1U) + assert(f6.x == "678") + + assert(f1 == a1.f1) + assert(f1.hashCode() == a1.f1.hashCode()) + assert(f1.toString() == a1.f1.toString()) + assert(f1 == a2.f1) + assert(f1.hashCode() == a2.f1.hashCode()) + assert(f1.toString() == a2.f1.toString()) + assert(a1.f1 == a2.f1) + assert(a1.f1.hashCode() == a2.f1.hashCode()) + assert(a1.f1.toString() == a2.f1.toString()) + + assert(f2 == a1.f2) + assert(f2.hashCode() == a1.f2.hashCode()) + assert(f2.toString() == a1.f2.toString()) + assert(f2 == a2.f2) + assert(f2.hashCode() == a2.f2.hashCode()) + assert(f2.toString() == a2.f2.toString()) + assert(a1.f2 == a2.f2) + assert(a1.f2.hashCode() == a2.f2.hashCode()) + assert(a1.f2.toString() == a2.f2.toString()) + + assert(f3 == a1.f3) + assert(f3.hashCode() == a1.f3.hashCode()) + assert(f3.toString() == a1.f3.toString()) + assert(f3 == a2.f3) + assert(f3.hashCode() == a2.f3.hashCode()) + assert(f3.toString() == a2.f3.toString()) + assert(a1.f3 == a2.f3) + assert(a1.f3.hashCode() == a2.f3.hashCode()) + assert(a1.f3.toString() == a2.f3.toString()) + + assert(f4 == a1.f4) + assert(f4.hashCode() == a1.f4.hashCode()) + assert(f4.toString() == a1.f4.toString()) + assert(f4 == a2.f4) + assert(f4.hashCode() == a2.f4.hashCode()) + assert(f4.toString() == a2.f4.toString()) + assert(a1.f4 == a2.f4) + assert(a1.f4.hashCode() == a2.f4.hashCode()) + assert(a1.f4.toString() == a2.f4.toString()) + + assert(f5 == a1.f5) + assert(f5.hashCode() == a1.f5.hashCode()) + assert(f5.toString() == a1.f5.toString()) + assert(f5 == a2.f5) + assert(f5.hashCode() == a2.f5.hashCode()) + assert(f5.toString() == a2.f5.toString()) + assert(a1.f5 == a2.f5) + assert(a1.f5.hashCode() == a2.f5.hashCode()) + assert(a1.f5.toString() == a2.f5.toString()) + + assert(f6 == a1.f6) + assert(f6.hashCode() == a1.f6.hashCode()) + assert(f6.toString() == a1.f6.toString()) + assert(f6 == a2.f6) + assert(f6.hashCode() == a2.f6.hashCode()) + assert(f6.toString() == a2.f6.toString()) + assert(a1.f6 == a2.f6) + assert(a1.f6.hashCode() == a2.f6.hashCode()) + assert(a1.f6.toString() == a2.f6.toString()) + + assert(9 == a1.f7) + assert(9.hashCode() == a1.f7.hashCode()) + assert(9.toString() == a1.f7.toString()) + assert(9 == a2.f7) + assert(9.hashCode() == a2.f7.hashCode()) + assert(9.toString() == a2.f7.toString()) + assert(a1.f7 == a2.f7) + assert(a1.f7.hashCode() == a2.f7.hashCode()) + assert(a1.f7.toString() == a2.f7.toString()) + + assert((UInt.MAX_VALUE - 2U) == a1.f8) + assert((UInt.MAX_VALUE - 2U).hashCode() == a1.f8.hashCode()) + assert((UInt.MAX_VALUE - 2U).toString() == a1.f8.toString()) + assert((UInt.MAX_VALUE - 2U) == a2.f8) + assert((UInt.MAX_VALUE - 2U).hashCode() == a2.f8.hashCode()) + assert((UInt.MAX_VALUE - 2U).toString() == a2.f8.toString()) + assert(a1.f8 == a2.f8) + assert(a1.f8.hashCode() == a2.f8.hashCode()) + assert(a1.f8.toString() == a2.f8.toString()) + + assert("0" == a1.f9) + assert("0".hashCode() == a1.f9.hashCode()) + assert("0".toString() == a1.f9.toString()) + assert("0" == a2.f9) + assert("0".hashCode() == a2.f9.hashCode()) + assert("0".toString() == a2.f9.toString()) + assert(a1.f9 == a2.f9) + assert(a1.f9.hashCode() == a2.f9.hashCode()) + assert(a1.f9.toString() == a2.f9.toString()) + + + assert(a1 == a2) + assert(a1.hashCode() == a2.hashCode()) + assert(a1.toString() == a2.toString()) + + assert(b == b) + assert(b.toString() == b.toString()) + assert(b.hashCode() == b.hashCode()) + + assert(f1.toString() == "to be replaced") + assert(f2.toString() == "to be replaced") + assert(f3.toString() == "to be replaced") + assert(f4.toString() == "to be replaced") + assert(f5.toString() == "to be replaced") + assert(f6.toString() == "to be replaced") + assert(a1.toString() == "to be replaced") + assert(a2.toString() == "to be replaced") + assert(b.toString() == "to be replaced") + + return "OK" +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.kt b/compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.kt new file mode 100644 index 00000000000..fcd32ff286d --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.kt @@ -0,0 +1,63 @@ +// FIR_IDENTICAL +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class A1(val x: A1) + +value class B1(val x: B1, val y: B1) + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class A2(val x: B2) + +value class B2(val x: A2, val y: A2) + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class A3(val x: B3) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class B3(val x: A3) + + +value class A4(val x: B4, val y: B4) + +value class B4(val x: A4, val y: A4) + +value class C4(val x: D4?, val y: D4?) + +value class D4(val x: D4?, val y: C4?) + + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class A5>(val x: T, val y: T) + +value class B5>(val x: T, val y: T) + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class A6T>>(val x: T, val y: T) + +value class B6T>>(val x: T, val y: T) + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class A7T>>(val x: T, val y: T) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class B7T>>(val x: T, val y: T) + + +value class A8T>>(val x: T, val y: T) + +value class B8T>>(val x: T, val y: T) + + +value class A9T>>(val x: T?, val y: T?) + +value class B9T>>(val x: T?, val y: T?) diff --git a/compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.txt b/compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.txt new file mode 100644 index 00000000000..9e41d85c77e --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.txt @@ -0,0 +1,178 @@ +package + +public final value class A1 { + public constructor A1(/*0*/ x: A1) + public final val x: A1 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class A2 { + public constructor A2(/*0*/ x: B2) + public final val x: B2 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class A3 { + public constructor A3(/*0*/ x: B3) + public final val x: B3 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class A4 { + public constructor A4(/*0*/ x: B4, /*1*/ y: B4) + public final val x: B4 + public final val y: B4 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class A5> { + public constructor A5>(/*0*/ x: T, /*1*/ y: T) + public final val x: T + public final val y: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class A6> { + public constructor A6>(/*0*/ x: T, /*1*/ y: T) + public final val x: T + public final val y: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class A7> { + public constructor A7>(/*0*/ x: T, /*1*/ y: T) + public final val x: T + public final val y: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class A8> { + public constructor A8>(/*0*/ x: T, /*1*/ y: T) + public final val x: T + public final val y: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class A9> { + public constructor A9>(/*0*/ x: T?, /*1*/ y: T?) + public final val x: T? + public final val y: T? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class B1 { + public constructor B1(/*0*/ x: B1, /*1*/ y: B1) + public final val x: B1 + public final val y: B1 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class B2 { + public constructor B2(/*0*/ x: A2, /*1*/ y: A2) + public final val x: A2 + public final val y: A2 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class B3 { + public constructor B3(/*0*/ x: A3) + public final val x: A3 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class B4 { + public constructor B4(/*0*/ x: A4, /*1*/ y: A4) + public final val x: A4 + public final val y: A4 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class B5> { + public constructor B5>(/*0*/ x: T, /*1*/ y: T) + public final val x: T + public final val y: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class B6> { + public constructor B6>(/*0*/ x: T, /*1*/ y: T) + public final val x: T + public final val y: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class B7> { + public constructor B7>(/*0*/ x: T, /*1*/ y: T) + public final val x: T + public final val y: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class B8> { + public constructor B8>(/*0*/ x: T, /*1*/ y: T) + public final val x: T + public final val y: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class B9> { + public constructor B9>(/*0*/ x: T?, /*1*/ y: T?) + public final val x: T? + public final val y: T? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class C4 { + public constructor C4(/*0*/ x: D4?, /*1*/ y: D4?) + public final val x: D4? + public final val y: D4? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class D4 { + public constructor D4(/*0*/ x: D4?, /*1*/ y: C4?) + public final val x: D4? + public final val y: C4? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.kt new file mode 100644 index 00000000000..cb5cc9998dd --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.kt @@ -0,0 +1,42 @@ +// FIR_IDENTICAL +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +value class Empty() + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class Foo(val x: T, val y: T) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class FooNullable(val x: T?, val y: T?) + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class FooGenericArray(val x: Array, val y: Array) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class FooGenericArray2(val x: Array>, val y: Array>) + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class FooStarProjectedArray(val x: Array<*>, val y: Array<*>) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class FooStarProjectedArray2(val x: Array>, val y: Array>) + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class Bar(val u: Unit, val y: Unit) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class BarNullable(val u: Unit?, val y: Unit?) + + +OPTIONAL_JVM_INLINE_ANNOTATION +value class Baz(val u: Nothing, val y: Nothing) + +OPTIONAL_JVM_INLINE_ANNOTATION +value class BazNullable(val u: Nothing?, val y: Nothing?) diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.txt b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.txt new file mode 100644 index 00000000000..d33cb63d561 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.txt @@ -0,0 +1,98 @@ +package + +public final value class Bar { + public constructor Bar(/*0*/ u: kotlin.Unit, /*1*/ y: kotlin.Unit) + public final val u: kotlin.Unit + public final val y: kotlin.Unit + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class BarNullable { + public constructor BarNullable(/*0*/ u: kotlin.Unit?, /*1*/ y: kotlin.Unit?) + public final val u: kotlin.Unit? + public final val y: kotlin.Unit? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class Baz { + public constructor Baz(/*0*/ u: kotlin.Nothing, /*1*/ y: kotlin.Nothing) + public final val u: kotlin.Nothing + public final val y: kotlin.Nothing + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class BazNullable { + public constructor BazNullable(/*0*/ u: kotlin.Nothing?, /*1*/ y: kotlin.Nothing?) + public final val u: kotlin.Nothing? + public final val y: kotlin.Nothing? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class Empty { + public constructor Empty() + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class Foo { + public constructor Foo(/*0*/ x: T, /*1*/ y: T) + public final val x: T + public final val y: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class FooGenericArray { + public constructor FooGenericArray(/*0*/ x: kotlin.Array, /*1*/ y: kotlin.Array) + public final val x: kotlin.Array + public final val y: kotlin.Array + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class FooGenericArray2 { + public constructor FooGenericArray2(/*0*/ x: kotlin.Array>, /*1*/ y: kotlin.Array>) + public final val x: kotlin.Array> + public final val y: kotlin.Array> + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class FooNullable { + public constructor FooNullable(/*0*/ x: T?, /*1*/ y: T?) + public final val x: T? + public final val y: T? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class FooStarProjectedArray { + public constructor FooStarProjectedArray(/*0*/ x: kotlin.Array<*>, /*1*/ y: kotlin.Array<*>) + public final val x: kotlin.Array<*> + public final val y: kotlin.Array<*> + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} + +public final value class FooStarProjectedArray2 { + public constructor FooStarProjectedArray2(/*0*/ x: kotlin.Array>, /*1*/ y: kotlin.Array>) + public final val x: kotlin.Array> + public final val y: kotlin.Array> + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String +} 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 0c4981aaccf..68503a9b37c 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 @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.utils.TransformersFunctions; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -32203,6 +32204,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt"); } + @Test + @TestMetadata("recursiveMultiFieldValueClasses.kt") + public void testRecursiveMultiFieldValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + @Test @TestMetadata("recursiveValueClasses.kt") public void testRecursiveValueClasses() throws Exception { @@ -32257,6 +32264,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt"); } + @Test + @TestMetadata("valueClassWithForbiddenUnderlyingTypeMultiField.kt") + public void testValueClassWithForbiddenUnderlyingTypeMultiField() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + @Test @TestMetadata("valueClassesInsideAnnotations.kt") public void testValueClassesInsideAnnotations() throws Exception { 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 3ad26964f2d..07a56d26c6c 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 @@ -44692,6 +44692,16 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/vararg") @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 4a7947433ad..6345d6ad895 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 @@ -47482,6 +47482,28 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } } + @Nested + @TestMetadata("compiler/testData/codegen/box/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("equality.kt") + public void testEquality() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/equality.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("equality.kt") + public void testEquality_valueClasses() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/equality.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/vararg") @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 15f9e4d27eb..ae006cba636 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -36253,6 +36253,19 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } } + @TestMetadata("compiler/testData/codegen/box/valueClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ValueClasses extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + } + @TestMetadata("compiler/testData/codegen/box/vararg") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGeneratorImpl.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGeneratorImpl.kt index a2b04b9e636..f4f81f96b08 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGeneratorImpl.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/NewTestGeneratorImpl.kt @@ -300,7 +300,7 @@ class NewTestGeneratorImpl( private fun TestClassModel.predefinedNativeTransformers(recursive: Boolean): List> = methods.mapNotNull { method -> (method as? TransformingTestMethodModel) - ?.takeIf { it.registerInConstructor } + ?.takeIf { it.registerInConstructor && it.shouldBeGenerated() } ?.let { it.source.file.invariantSeparatorsPath to it.transformer } } + if (recursive) innerTestClasses.flatMap { it.predefinedNativeTransformers(true) } else listOf() } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt index e3339973fdf..7d1c6c348c4 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt @@ -120,7 +120,7 @@ class SimpleTestClassModel( } } } - if (result.any { it is WithoutJvmInlineTestMethodModel }) { + if (result.any { it is TransformingTestMethodModel && it.shouldBeGenerated() }) { val additionalRunner = RunTestMethodModel(targetBackend, doTestMethodName, testRunnerMethodName, additionalRunnerArguments, withTransformer = true) result.add(additionalRunner) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt index 1c4e513259f..c45f37aebe4 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt @@ -40,7 +40,7 @@ class SingleClassTestModel( } true } - if (result.any { it is WithoutJvmInlineTestMethodModel }) { + if (result.any { it is TransformingTestMethodModel && it.shouldBeGenerated() }) { val additionalRunner = RunTestMethodModel(targetBackend, doTestMethodName, testRunnerMethodName, additionalRunnerArguments, withTransformer = true) result.add(additionalRunner) diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java index 06000acf06a..f405d20e02c 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java @@ -32376,6 +32376,16 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/vararg") @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 4aef55e6eb7..71d93b7d7bd 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 @@ -32478,6 +32478,16 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/vararg") @TestDataPath("$PROJECT_ROOT") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/testOld/wasm/semantics/IrCodegenBoxWasmTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/testOld/wasm/semantics/IrCodegenBoxWasmTestGenerated.java index 733f02b0a58..d6c6d78ba64 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/testOld/wasm/semantics/IrCodegenBoxWasmTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/testOld/wasm/semantics/IrCodegenBoxWasmTestGenerated.java @@ -14018,10 +14018,6 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); } - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - public void testAllFilesPresentInDefaultWithDefaultParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @@ -14035,10 +14031,6 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); } - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @@ -14476,10 +14468,6 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); } - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @@ -27187,6 +27175,19 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @TestMetadata("compiler/testData/codegen/box/valueClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ValueClasses extends AbstractIrCodegenBoxWasmTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); + } + + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + @TestMetadata("compiler/testData/codegen/box/vararg") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/ExternalTestGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/ExternalTestGenerated.java index e33012a31b9..9ebe44defd3 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/ExternalTestGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/ExternalTestGenerated.java @@ -15966,8 +15966,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/bridgeGenerationWithInlineClassOverAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/bridgesWhenInlineClassImplementsGenericInterface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/callComputablePropertyInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/callSpecializedEqualsViaReflection.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/callSpeciallyOverriddenPropertyOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/callableReferencesWithInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/castInsideWhenExpression.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/checkBoxUnboxOfArgumentsOnInlinedFunctions.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -15984,11 +15982,9 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/checkLambdaWithInlineClassesInFunctionalType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/checkUnboxingResultFromTypeVariable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/classInInlineClassInit.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/classLiteralOnInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/computablePropertyInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/conformToComparableAndCallInterfaceMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/constructorCallableReference.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/constructorImplVisibility.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/correctBoxingForBranchExpressions.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/createInlineClassInArgumentPosition.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/crossinlineWithInlineClassInParameter.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -16027,7 +16023,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/inlineClassEqualityShouldUseTotalOrderForFloatingPointData.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/inlineClassFieldHandling.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/inlineClassFunctionInvoke.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/inlineClassImplementsCollection.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/inlineClassInInitBlock.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/inlineClassInStringTemplate.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/inlineClassPropertyReferenceGetAndSet.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -16043,19 +16038,9 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFun2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/inlineInCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/inlineToString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValues.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/iterateOverListOfInlineClassValues.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/javaClassIntrinsicOnInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/javaPrimitiveTypeIC.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvmFieldInInlineClassCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/jvmInline.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvmOverloadsOnTopLevelFunctionReturningInlineClassValue.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvmStaticFunInInlineClassCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvmStaticPropertyAccessorInInlineClassCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvmStaticVarInInlineClassCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/kclassInAnnotation.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt25246.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt25750.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt25771.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -16083,21 +16068,16 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/kt38680.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt38680a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt38680b.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/kt44701_jvmOverloads.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt44978.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt45084.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt45991.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt46554.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/kt47609.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/kt47762.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/kt48993.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/mangledDefaultParameterFunction.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/mangledSuperCalls.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/mappingOfBoxedFlexibleInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/nestedInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/noAssertionsOnInlineClassBasedOnNullableType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/noReturnTypeMangling.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingJvmName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/nullableWrapperEquality.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/overridingFunCallingPrivateFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -16131,7 +16111,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/unboxValueOfAnyBeforeMethodInvocation.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/useInlineClassesInsideElvisOperator.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/useInlineFunctionInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/useOfInlineClassWithGenericMethodFromJava.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/useThisInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/whenWithSubject.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } @@ -17956,7 +17935,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateStaticInlineClassCompanionMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObject.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -18239,13 +18217,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { @Tag("external") @UseExtTestCaseGroupProvider() public class DefaultWithDefaultParameter { - public DefaultWithDefaultParameter() { - register("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/all.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/all-compatibility.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/compatibility.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter/default.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - } - @Test public void testAllFilesPresentInDefaultWithDefaultParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); @@ -18258,13 +18229,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { @Tag("external") @UseExtTestCaseGroupProvider() public class OverrideFunctionWithDefaultParameter { - public OverrideFunctionWithDefaultParameter() { - register("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/all-compatibility.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/compatibility.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter/default.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - } - @Test public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); @@ -18364,7 +18328,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/extensionFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/functionsWithDifferentNullabilityDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/genericFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/genericSignatureOfFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/localClassInFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsCanBeOverridden.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -18374,7 +18337,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClass2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/propertySetterWithInlineClassTypeArgument.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForLocalClassInFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForPropertyOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorForFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorsForPropertyOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -18854,21 +18816,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { @Tag("external") @UseExtTestCaseGroupProvider() public class Jvm8DefaultInterfaceMethods { - public Jvm8DefaultInterfaceMethods() { - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/javaDefaultMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/javaDefaultMethodOverriddenByKotlin.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultAll.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultAllPrimaryProperty.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultAllProperty.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultEnable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultEnablePrimaryProperty.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultEnableProperty.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultSafeCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultSmartCast.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods/jvmDefaultSuspend.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - } - @Test public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); @@ -18886,7 +18833,6 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { register("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClassWithProvideDelegate.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateCompanionVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); - register("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateJvmStaticCompanionVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateLocalVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateObjectVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); register("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegatePrivateCompanionVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -34787,6 +34733,18 @@ public class ExternalTestGenerated extends AbstractExternalNativeBlackBoxTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/valueClasses") + @TestDataPath("$PROJECT_ROOT") + @Tag("external") + @UseExtTestCaseGroupProvider() + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/vararg") @TestDataPath("$PROJECT_ROOT")