diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt index f8d06fc4615a5..b7372c080439c 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt @@ -1366,6 +1366,18 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert token, ) } + add(FirErrors.VALUE_OBJECT_NOT_SEALED_INLINE_CHILD) { firDiagnostic -> + ValueObjectNotSealedInlineChildImpl( + firDiagnostic as KtPsiDiagnostic, + token, + ) + } + add(FirErrors.SEALED_INLINE_CHILD_NOT_VALUE) { firDiagnostic -> + SealedInlineChildNotValueImpl( + firDiagnostic as KtPsiDiagnostic, + token, + ) + } add(FirErrors.NONE_APPLICABLE) { firDiagnostic -> NoneApplicableImpl( firDiagnostic.a.map { firBasedSymbol -> diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt index 012ba5808c740..5a49bb321a34b 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt @@ -986,6 +986,14 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { override val diagnosticClass get() = ValueClassCannotBeCloneable::class } + abstract class ValueObjectNotSealedInlineChild : KtFirDiagnostic() { + override val diagnosticClass get() = ValueObjectNotSealedInlineChild::class + } + + abstract class SealedInlineChildNotValue : KtFirDiagnostic() { + override val diagnosticClass get() = SealedInlineChildNotValue::class + } + abstract class NoneApplicable : KtFirDiagnostic() { override val diagnosticClass get() = NoneApplicable::class abstract val candidates: List diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt index 788c97593846b..606871fe035e1 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt @@ -1182,6 +1182,16 @@ internal class ValueClassCannotBeCloneableImpl( override val token: KtLifetimeToken, ) : KtFirDiagnostic.ValueClassCannotBeCloneable(), KtAbstractFirDiagnostic +internal class ValueObjectNotSealedInlineChildImpl( + override val firDiagnostic: KtPsiDiagnostic, + override val token: KtLifetimeToken, +) : KtFirDiagnostic.ValueObjectNotSealedInlineChild(), KtAbstractFirDiagnostic + +internal class SealedInlineChildNotValueImpl( + override val firDiagnostic: KtPsiDiagnostic, + override val token: KtLifetimeToken, +) : KtFirDiagnostic.SealedInlineChildNotValue(), KtAbstractFirDiagnostic + internal class NoneApplicableImpl( override val candidates: List, override val firDiagnostic: KtPsiDiagnostic, diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java index 70c6194aebd65..8e0f19e8749a6 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java @@ -17857,12 +17857,6 @@ public void testClass_kind_children_forbidden() throws Exception { runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-kind-children-forbidden.kt"); } - @Test - @TestMetadata("doubleSealedChild.kt") - public void testDoubleSealedChild() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.kt"); - } - @Test @TestMetadata("flat.kt") public void testFlat() throws Exception { @@ -17892,6 +17886,64 @@ public void testUnsupported_inline() throws Exception { public void testWith_value() throws Exception { runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/with-value.kt"); } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing") + @TestDataPath("$PROJECT_ROOT") + public class ChildrenDistinguishing { + @Test + public void testAllFilesPresentInChildrenDistinguishing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("doubleSealedChild.kt") + public void testDoubleSealedChild() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.kt"); + } + + @Test + @TestMetadata("finalClassAndFinalClass.kt") + public void testFinalClassAndFinalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.kt"); + } + + @Test + @TestMetadata("finalClassAndInterface.kt") + public void testFinalClassAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.kt"); + } + + @Test + @TestMetadata("finalClassAndOpenClass.kt") + public void testFinalClassAndOpenClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.kt"); + } + + @Test + @TestMetadata("interfaceAndInterface.kt") + public void testInterfaceAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.kt"); + } + + @Test + @TestMetadata("openClassAndInterface.kt") + public void testOpenClassAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.kt"); + } + + @Test + @TestMetadata("openClassAndOpenClass.kt") + public void testOpenClassAndOpenClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.kt"); + } + + @Test + @TestMetadata("sealedInlineClassChild.kt") + public void testSealedInlineClassChild() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.kt"); + } + } } } 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 5b369d21dbc9b..d59b204dfb680 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 @@ -17857,12 +17857,6 @@ public void testClass_kind_children_forbidden() throws Exception { runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-kind-children-forbidden.kt"); } - @Test - @TestMetadata("doubleSealedChild.kt") - public void testDoubleSealedChild() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.kt"); - } - @Test @TestMetadata("flat.kt") public void testFlat() throws Exception { @@ -17892,6 +17886,64 @@ public void testUnsupported_inline() throws Exception { public void testWith_value() throws Exception { runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/with-value.kt"); } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing") + @TestDataPath("$PROJECT_ROOT") + public class ChildrenDistinguishing { + @Test + public void testAllFilesPresentInChildrenDistinguishing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("doubleSealedChild.kt") + public void testDoubleSealedChild() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.kt"); + } + + @Test + @TestMetadata("finalClassAndFinalClass.kt") + public void testFinalClassAndFinalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.kt"); + } + + @Test + @TestMetadata("finalClassAndInterface.kt") + public void testFinalClassAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.kt"); + } + + @Test + @TestMetadata("finalClassAndOpenClass.kt") + public void testFinalClassAndOpenClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.kt"); + } + + @Test + @TestMetadata("interfaceAndInterface.kt") + public void testInterfaceAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.kt"); + } + + @Test + @TestMetadata("openClassAndInterface.kt") + public void testOpenClassAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.kt"); + } + + @Test + @TestMetadata("openClassAndOpenClass.kt") + public void testOpenClassAndOpenClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.kt"); + } + + @Test + @TestMetadata("sealedInlineClassChild.kt") + public void testSealedInlineClassChild() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.kt"); + } + } } } 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 695d23d12c405..535803fe8cd25 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 @@ -17857,12 +17857,6 @@ public void testClass_kind_children_forbidden() throws Exception { runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-kind-children-forbidden.kt"); } - @Test - @TestMetadata("doubleSealedChild.kt") - public void testDoubleSealedChild() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.kt"); - } - @Test @TestMetadata("flat.kt") public void testFlat() throws Exception { @@ -17892,6 +17886,64 @@ public void testUnsupported_inline() throws Exception { public void testWith_value() throws Exception { runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/with-value.kt"); } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing") + @TestDataPath("$PROJECT_ROOT") + public class ChildrenDistinguishing { + @Test + public void testAllFilesPresentInChildrenDistinguishing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("doubleSealedChild.kt") + public void testDoubleSealedChild() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.kt"); + } + + @Test + @TestMetadata("finalClassAndFinalClass.kt") + public void testFinalClassAndFinalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.kt"); + } + + @Test + @TestMetadata("finalClassAndInterface.kt") + public void testFinalClassAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.kt"); + } + + @Test + @TestMetadata("finalClassAndOpenClass.kt") + public void testFinalClassAndOpenClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.kt"); + } + + @Test + @TestMetadata("interfaceAndInterface.kt") + public void testInterfaceAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.kt"); + } + + @Test + @TestMetadata("openClassAndInterface.kt") + public void testOpenClassAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.kt"); + } + + @Test + @TestMetadata("openClassAndOpenClass.kt") + public void testOpenClassAndOpenClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.kt"); + } + + @Test + @TestMetadata("sealedInlineClassChild.kt") + public void testSealedInlineClassChild() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.kt"); + } + } } } 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 59bd1a5a281e3..689a5dc928eed 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 @@ -425,6 +425,9 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val SECONDARY_CONSTRUCTOR_WITH_BODY_INSIDE_VALUE_CLASS by error() val INNER_CLASS_INSIDE_VALUE_CLASS by error(PositioningStrategy.INNER_MODIFIER) val VALUE_CLASS_CANNOT_BE_CLONEABLE by error(PositioningStrategy.INLINE_OR_VALUE_MODIFIER) + val VALUE_OBJECT_NOT_SEALED_INLINE_CHILD by error(PositioningStrategy.INLINE_OR_VALUE_MODIFIER) + val SEALED_INLINE_CHILD_NOT_VALUE by error() + val SEALED_INLINE_CHILD_OVERLAPPING_TYPE by error(PositioningStrategy.INLINE_OR_VALUE_MODIFIER) } val APPLICABILITY by object : DiagnosticGroup("Applicability") { diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInlineApplicabilityChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInlineApplicabilityChecker.kt index f1585f041a56a..2e0320a21b856 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInlineApplicabilityChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInlineApplicabilityChecker.kt @@ -5,16 +5,29 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration +import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isChildOfSealedInlineClass +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isSealedInlineClass +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.supertypeAsSealedInlineClassType import org.jetbrains.kotlin.fir.analysis.checkers.getModifier +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_INLINE_CHILD_OVERLAPPING_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId -import org.jetbrains.kotlin.fir.declarations.utils.isExpect -import org.jetbrains.kotlin.fir.declarations.utils.isInline +import org.jetbrains.kotlin.fir.declarations.getSealedClassInheritors +import org.jetbrains.kotlin.fir.declarations.inlineClassRepresentation +import org.jetbrains.kotlin.fir.declarations.utils.* +import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.types.isSubtypeOf +import org.jetbrains.kotlin.fir.types.toRegularClassSymbol import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.resolve.JVM_INLINE_ANNOTATION_CLASS_ID @@ -23,12 +36,54 @@ object FirJvmInlineApplicabilityChecker : FirRegularClassChecker() { val annotation = declaration.getAnnotationByClassId(JVM_INLINE_ANNOTATION_CLASS_ID) if (annotation != null && !declaration.isInline) { reporter.reportOn(annotation.source, FirJvmErrors.JVM_INLINE_WITHOUT_VALUE_CLASS, context) - } else if (annotation == null && declaration.isInline && !declaration.isExpect) { + } else if (annotation == null && declaration.isInline && !declaration.isExpect && declaration.classKind == ClassKind.CLASS && + !declaration.isChildOfSealedInlineClass(context.session) + ) { reporter.reportOn( declaration.getModifier(KtTokens.VALUE_KEYWORD)?.source, FirJvmErrors.VALUE_CLASS_WITHOUT_JVM_INLINE_ANNOTATION, context ) } + + if (annotation != null && declaration.isChildOfSealedInlineClass(context.session)) { + if (checkUnderlyingTypeIntersection(declaration, context.session)) { + reporter.reportOn(declaration.source, SEALED_INLINE_CHILD_OVERLAPPING_TYPE, context) + } + } + } + + @OptIn(SymbolInternals::class) + private fun checkUnderlyingTypeIntersection(firClass: FirRegularClass, session: FirSession): Boolean { + val firstType = + if (firClass.symbol.isSealedInlineClass()) session.builtinTypes.nullableAnyType.type + else firClass.inlineClassRepresentation?.underlyingType ?: return false + val first = firstType.toRegularClassSymbol(session) ?: return false + val allChildren = firClass.supertypeAsSealedInlineClassType(session)?.toRegularClassSymbol(session)?.fir + ?.getSealedClassInheritors(session) ?: return false + for (childId in allChildren) { + if (childId == firClass.classId) continue + val child = session.symbolProvider.getClassLikeSymbolByClassId(childId) as? FirRegularClassSymbol ?: continue + if (child.getAnnotationByClassId(JVM_INLINE_ANNOTATION_CLASS_ID) == null) continue + val secondType = + if (child.isSealedInlineClass()) session.builtinTypes.nullableAnyType.type + else (child.fir.inlineClassRepresentation?.underlyingType ?: continue) + + val second = secondType.toRegularClassSymbol(session) ?: continue + + val intersects = if (first.isFinal && second.isFinal) { + first.classId == second.classId + } else if (first.isFinal || first.classKind == ClassKind.CLASS) { + firstType.isSubtypeOf(secondType, session) + } else { + first.isInterface && second.isInterface + } + + if (intersects) { + return true + } + } + + return false } } \ No newline at end of file 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 db0c832a1e359..78442c25e6ddb 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 @@ -321,6 +321,9 @@ object FirErrors { val SECONDARY_CONSTRUCTOR_WITH_BODY_INSIDE_VALUE_CLASS by error0() val INNER_CLASS_INSIDE_VALUE_CLASS by error0(SourceElementPositioningStrategies.INNER_MODIFIER) val VALUE_CLASS_CANNOT_BE_CLONEABLE by error0(SourceElementPositioningStrategies.INLINE_OR_VALUE_MODIFIER) + val VALUE_OBJECT_NOT_SEALED_INLINE_CHILD by error0(SourceElementPositioningStrategies.INLINE_OR_VALUE_MODIFIER) + val SEALED_INLINE_CHILD_NOT_VALUE by error0() + val SEALED_INLINE_CHILD_OVERLAPPING_TYPE by error0(SourceElementPositioningStrategies.INLINE_OR_VALUE_MODIFIER) // Applicability val NONE_APPLICABLE by error1>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt index 5344e262373ad..da1b5081ddcf8 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt @@ -110,6 +110,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() { FirFunInterfaceDeclarationChecker, FirNestedClassChecker, FirInlineClassDeclarationChecker, + FirSealedInlineClassChildChecker, FirOuterClassArgumentsRequiredChecker, FirPropertyInitializationChecker, ) 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 108ec304e2c61..56179d41af407 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 @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration import org.jetbrains.kotlin.KtFakeSourceElementKind import org.jetbrains.kotlin.KtRealSourceElementKind import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn @@ -24,6 +25,7 @@ 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.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.lexer.KtTokens @@ -48,12 +50,19 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { reporter.reportOn(declaration.source, FirErrors.VALUE_CLASS_NOT_TOP_LEVEL, context) } - if (declaration.modality != Modality.FINAL) { + if (declaration.modality != Modality.FINAL && + !(declaration.modality == Modality.SEALED && + context.languageVersionSettings.supportsFeature(LanguageFeature.SealedInlineClasses)) + ) { reporter.reportOn(declaration.source, FirErrors.VALUE_CLASS_NOT_FINAL, context) } for (supertypeEntry in declaration.superTypeRefs) { - if (supertypeEntry.toRegularClassSymbol(context.session)?.isInterface != true) { + if (supertypeEntry.toRegularClassSymbol(context.session)?.let { + it.isInterface || (it.isSealedInlineClass() && + context.languageVersionSettings.supportsFeature(LanguageFeature.SealedInlineClasses)) + } != true + ) { reporter.reportOnWithSuppression(supertypeEntry, FirErrors.VALUE_CLASS_CANNOT_EXTEND_CLASSES, context) } } @@ -148,54 +157,55 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { } } - if (primaryConstructor?.source?.kind !is KtRealSourceElementKind) { - reporter.reportOn(declaration.source, FirErrors.ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_VALUE_CLASS, context) - return - } - - if (context.languageVersionSettings.supportsFeature(LanguageFeature.ValueClasses)) { - if (primaryConstructorParametersByName.isEmpty()) { - reporter.reportOnWithSuppression(primaryConstructor, FirErrors.VALUE_CLASS_EMPTY_CONSTRUCTOR, context) + if (declaration.modality != Modality.SEALED) { + if (primaryConstructor?.source?.kind !is KtRealSourceElementKind) { + reporter.reportOn(declaration.source, FirErrors.ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_VALUE_CLASS, context) + return + } + 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 } - } else if (primaryConstructorParametersByName.size != 1) { - reporter.reportOnWithSuppression(primaryConstructor, FirErrors.INLINE_CLASS_CONSTRUCTOR_WRONG_PARAMETERS_SIZE, context) - return - } - - 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() -> { - val inlineClassHasGenericUnderlyingType = primaryConstructorParameter.returnTypeRef.coneType.let { - (it is ConeTypeParameterType || it.isGenericArrayOfTypeParameter()) - } - if (!(context.languageVersionSettings.supportsFeature(LanguageFeature.GenericInlineClassParameter) && - inlineClassHasGenericUnderlyingType) - ) { + for ((name, primaryConstructorParameter) in primaryConstructorParametersByName) { + withSuppressedDiagnostics(primaryConstructor, context) { context -> + withSuppressedDiagnostics(primaryConstructorParameter, context) { context -> + when { + primaryConstructorParameter.isNotFinalReadOnly(primaryConstructorPropertiesByName[name]) -> reporter.reportOn( - primaryConstructorParameter.returnTypeRef.source, - FirErrors.VALUE_CLASS_HAS_INAPPLICABLE_PARAMETER_TYPE, - primaryConstructorParameter.returnTypeRef.coneType, + primaryConstructorParameter.source, + FirErrors.VALUE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER, context ) + + primaryConstructorParameter.returnTypeRef.isInapplicableParameterType() -> { + val inlineClassHasGenericUnderlyingType = primaryConstructorParameter.returnTypeRef.coneType.let { + (it is ConeTypeParameterType || it.isGenericArrayOfTypeParameter()) + } + if (!(context.languageVersionSettings.supportsFeature(LanguageFeature.GenericInlineClassParameter) && + inlineClassHasGenericUnderlyingType) + ) { + 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 + ) + } } } } @@ -253,3 +263,27 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() { relativeClassName == cloneableFqName && packageFqName == StandardClassIds.BASE_KOTLIN_PACKAGE || packageFqName == javaLangFqName } + +object FirSealedInlineClassChildChecker : FirRegularClassChecker() { + override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + if (declaration.symbol.isValueObject() && !declaration.isChildOfSealedInlineClass(context.session)) { + reporter.reportOn(declaration.source, FirErrors.VALUE_OBJECT_NOT_SEALED_INLINE_CHILD, context) + } + + if (!declaration.isChildOfSealedInlineClass(context.session)) return + + if (!declaration.isInline) { + reporter.reportOn(declaration.source, FirErrors.SEALED_INLINE_CHILD_NOT_VALUE, context) + } + } +} + +fun FirRegularClass.isChildOfSealedInlineClass(session: FirSession): Boolean = supertypeAsSealedInlineClassType(session) != null + +fun FirRegularClass.supertypeAsSealedInlineClassType(session: FirSession): FirTypeRef? = + superTypeRefs.find { superType -> + superType.toRegularClassSymbol(session)?.isSealedInlineClass() == true + } + +fun FirRegularClassSymbol.isSealedInlineClass(): Boolean = + isInline && classKind == ClassKind.CLASS && modality == Modality.SEALED 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 c07319a2e6cb1..bf863d62aee07 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 @@ -459,6 +459,8 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SAFE_CALL_WILL_CH import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_CLASS_CONSTRUCTOR_CALL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_INHERITOR_IN_DIFFERENT_MODULE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_INHERITOR_IN_DIFFERENT_PACKAGE +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_INLINE_CHILD_NOT_VALUE +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_INLINE_CHILD_OVERLAPPING_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_SUPERTYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_SUPERTYPE_IN_LOCAL_CLASS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SECONDARY_CONSTRUCTOR_WITH_BODY_INSIDE_VALUE_CLASS @@ -548,6 +550,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_CLASS_EMPTY 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 +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_OBJECT_NOT_SEALED_INLINE_CHILD import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VAL_OR_VAR_ON_CATCH_PARAMETER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.VAL_OR_VAR_ON_FUN_PARAMETER @@ -1235,6 +1238,9 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { ) map.put(INNER_CLASS_INSIDE_VALUE_CLASS, "Value class cannot have inner classes") map.put(VALUE_CLASS_CANNOT_BE_CLONEABLE, "Value class cannot be Cloneable") + map.put(VALUE_OBJECT_NOT_SEALED_INLINE_CHILD, "value object must be child of sealed inline class") + map.put(SEALED_INLINE_CHILD_NOT_VALUE, "child of sealed inline class must be value"); + map.put(SEALED_INLINE_CHILD_OVERLAPPING_TYPE, "Sealed inline class child cannot be distinguished from another one"); // Inline map.put( diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/declarationUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/declarationUtils.kt index 7f70392bd88cd..6941bc85584a8 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/declarationUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/declarationUtils.kt @@ -98,3 +98,5 @@ fun FirRegularClassSymbol.isInlineOrValueClass(): Boolean { return isInline } + +fun FirRegularClassSymbol.isValueObject(): Boolean = classKind == ClassKind.OBJECT && isInline diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmInlineApplicabilityChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmInlineApplicabilityChecker.kt index c363b8ab04df6..009308b7beedc 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmInlineApplicabilityChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmInlineApplicabilityChecker.kt @@ -16,10 +16,7 @@ package org.jetbrains.kotlin.resolve.jvm.checkers -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor -import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi.KtClass import org.jetbrains.kotlin.psi.KtDeclaration @@ -29,7 +26,12 @@ import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext import org.jetbrains.kotlin.resolve.checkers.isSealedInlineClass import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext.isClassTypeConstructor +import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext.isInterface +import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext.isInterfaceOrAnnotationClass import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf +import org.jetbrains.kotlin.types.typeUtil.makeNotNullable class JvmInlineApplicabilityChecker : DeclarationChecker { override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { @@ -63,7 +65,6 @@ class JvmInlineApplicabilityChecker : DeclarationChecker { val baseParameterType = descriptor.defaultType.substitutedUnderlyingTypes().singleOrNull() val baseParameterTypeReference = declaration.primaryConstructor?.valueParameters?.singleOrNull()?.typeReference if (baseParameterType != null && baseParameterTypeReference != null) { - // TODO: compute intersection types and check, that they are Nothing. val children = parent.sealedSubclasses.filter { it.isInlineClass() } for (child in children) { if (child == descriptor) continue @@ -71,9 +72,9 @@ class JvmInlineApplicabilityChecker : DeclarationChecker { if (child.modality == Modality.SEALED) context.moduleDescriptor.builtIns.nullableAnyType else child.defaultType.substitutedUnderlyingType() if (anotherType == null) continue - if (baseParameterType.isSubtypeOf(anotherType)) { + if (baseParameterType.cannotDistinguishFrom(anotherType)) { context.trace.report( - ErrorsJvm.INLINE_CLASS_UNDERLYING_VALUE_IS_SUBCLASS_OF_ANOTHER_UNDERLYING_VALUE.on(baseParameterTypeReference) + ErrorsJvm.SEALED_INLINE_CHILD_OVERLAPPING_TYPE.on(baseParameterTypeReference) ) break } @@ -85,12 +86,31 @@ class JvmInlineApplicabilityChecker : DeclarationChecker { ) { val sealedKeyword = declaration.modifierList?.getModifier(KtTokens.SEALED_KEYWORD) ?: declaration context.trace.report( - ErrorsJvm.INLINE_CLASS_UNDERLYING_VALUE_IS_SUBCLASS_OF_ANOTHER_UNDERLYING_VALUE.on(sealedKeyword) + ErrorsJvm.SEALED_INLINE_CHILD_OVERLAPPING_TYPE.on(sealedKeyword) ) } } } } +private fun KotlinType.cannotDistinguishFrom(secondType: KotlinType): Boolean { + val first = constructor + val second = secondType.constructor + + if (first.isFinal && second.isFinal) { + return first == second + } + if (first.isFinal && second.isClassTypeConstructor()) { + return makeNotNullable().isSubtypeOf(secondType.makeNotNullable()) + } + if (first.isClassTypeConstructor() && !first.isInterface() && second.isClassTypeConstructor()) { + return makeNotNullable().isSubtypeOf(secondType.makeNotNullable()) + } + if (first.isInterface() && second.isInterface()) { + return true + } + return false +} + val ClassDescriptor.isValueClass: Boolean get() = kind == ClassKind.CLASS && isValue diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java index 7efccb5c2067e..3ea67a961a6e5 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java @@ -221,7 +221,7 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { MAP.put(VALUE_CLASS_WITHOUT_JVM_INLINE_ANNOTATION, "Value classes without @JvmInline annotation are not supported yet"); MAP.put(JVM_INLINE_WITHOUT_VALUE_CLASS, "@JvmInline annotation is only applicable to value classes"); - MAP.put(INLINE_CLASS_UNDERLYING_VALUE_IS_SUBCLASS_OF_ANOTHER_UNDERLYING_VALUE, "Sealed inline class subclass cannot have underlying value of the same type as other subclass"); + MAP.put(SEALED_INLINE_CHILD_OVERLAPPING_TYPE, "Sealed inline class child cannot be distinguished from another one"); MAP.put(SYNCHRONIZED_ON_SUSPEND, "@Synchronized annotation is not applicable to suspend functions and lambdas"); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java index 19a516481e607..55c1c922754e8 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java @@ -202,7 +202,7 @@ public interface ErrorsJvm { DiagnosticFactory0 VALUE_CLASS_WITHOUT_JVM_INLINE_ANNOTATION = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 JVM_INLINE_WITHOUT_VALUE_CLASS = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 INLINE_CLASS_UNDERLYING_VALUE_IS_SUBCLASS_OF_ANOTHER_UNDERLYING_VALUE = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 SEALED_INLINE_CHILD_OVERLAPPING_TYPE = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 TYPEOF_SUSPEND_TYPE = DiagnosticFactory0.create(ERROR); DiagnosticFactory1 TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND = DiagnosticFactory1.create(ERROR); diff --git a/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.fir.kt new file mode 100644 index 0000000000000..b1de63ab88d7a --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.fir.kt @@ -0,0 +1,8 @@ +// !LANGUAGE: +InlineClasses, -JvmInlineValueClasses + +inline class Foo(val x: Int) + +inline interface InlineInterface +inline annotation class InlineAnn +inline object InlineObject +inline enum class InlineEnum diff --git a/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.kt b/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.kt index a7b5c29ed5134..7bf4750329cb8 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // !LANGUAGE: +InlineClasses, -JvmInlineValueClasses inline class Foo(val x: Int) diff --git a/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclarationDisabled.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclarationDisabled.fir.kt index e925d84753a9a..04039f36acf34 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclarationDisabled.fir.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclarationDisabled.fir.kt @@ -4,7 +4,7 @@ inline class Foo(val x: Int) inline annotation class InlineAnn -inline object InlineObject +inline object InlineObject inline enum class InlineEnum inline class NotVal(x: Int) diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.fir.kt similarity index 51% rename from compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.fir.kt rename to compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.fir.kt index 5f2aca4a06df6..21fe33d14768c 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.fir.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.fir.kt @@ -9,7 +9,7 @@ annotation class JvmInline sealed value class IC @JvmInline -sealed value class ICC: IC() +sealed value class ICC: IC() @JvmInline -sealed value class ICC2: IC() \ No newline at end of file +sealed value class ICC2: IC() diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.kt new file mode 100644 index 0000000000000..f7675f5a76b09 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.kt @@ -0,0 +1,15 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT + +package kotlin.jvm + +annotation class JvmInline + +@JvmInline +sealed value class IC + +@JvmInline +sealed value class ICC: IC() + +@JvmInline +sealed value class ICC2: IC() diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.fir.kt new file mode 100644 index 0000000000000..93148ba974680 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.fir.kt @@ -0,0 +1,95 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +/* ++--------------+--------------+--------------+ +| First | Second | Result | ++==============+==============+==============+ +| String | String | Error | ++--------------+--------------+--------------+ +| String | String? | Error | ++--------------+--------------+--------------+ +| String | Int | OK | ++--------------+--------------+--------------+ +| Int | Int | Error | ++--------------+--------------+--------------+ +| Int | Int? | Error | ++--------------+--------------+--------------+ +| Gen | Gen | Error | ++--------------+--------------+--------------+ +| IC | IC? | Error | ++--------------+--------------+--------------+ +*/ + +@JvmInline +sealed value class String_String { + @JvmInline + value class First(val a: String): String_String() + + @JvmInline + value class Second(val a: String): String_String() +} + +@JvmInline +sealed value class String_StringN { + @JvmInline + value class First(val a: String): String_StringN() + + @JvmInline + value class Second(val a: String?): String_StringN() +} + +@JvmInline +sealed value class String_Int { + @JvmInline + value class First(val a: String): String_Int() + + @JvmInline + value class Second(val a: Int): String_Int() +} + +@JvmInline +sealed value class Int_Int { + @JvmInline + value class First(val a: Int): Int_Int() + + @JvmInline + value class Second(val a: Int): Int_Int() +} + +@JvmInline +sealed value class Int_IntN { + @JvmInline + value class First(val a: Int): Int_IntN() + + @JvmInline + value class Second(val a: Int?): Int_IntN() +} + +class Gen + +@JvmInline +sealed value class Gen_Gen { + @JvmInline + value class First(val a: Gen): Gen_Gen() + + @JvmInline + value class Second(val a: Gen): Gen_Gen() +} + +@JvmInline +value class IC(val a: String) + +@JvmInline +sealed value class IC_IC { + @JvmInline + value class First(val a: IC): IC_IC() + + @JvmInline + value class Second(val a: IC?): IC_IC() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.kt new file mode 100644 index 0000000000000..b1d2fb0c96c5f --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.kt @@ -0,0 +1,95 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +/* ++--------------+--------------+--------------+ +| First | Second | Result | ++==============+==============+==============+ +| String | String | Error | ++--------------+--------------+--------------+ +| String | String? | Error | ++--------------+--------------+--------------+ +| String | Int | OK | ++--------------+--------------+--------------+ +| Int | Int | Error | ++--------------+--------------+--------------+ +| Int | Int? | Error | ++--------------+--------------+--------------+ +| Gen | Gen | Error | ++--------------+--------------+--------------+ +| IC | IC? | Error | ++--------------+--------------+--------------+ +*/ + +@JvmInline +sealed value class String_String { + @JvmInline + value class First(val a: String): String_String() + + @JvmInline + value class Second(val a: String): String_String() +} + +@JvmInline +sealed value class String_StringN { + @JvmInline + value class First(val a: String): String_StringN() + + @JvmInline + value class Second(val a: String?): String_StringN() +} + +@JvmInline +sealed value class String_Int { + @JvmInline + value class First(val a: String): String_Int() + + @JvmInline + value class Second(val a: Int): String_Int() +} + +@JvmInline +sealed value class Int_Int { + @JvmInline + value class First(val a: Int): Int_Int() + + @JvmInline + value class Second(val a: Int): Int_Int() +} + +@JvmInline +sealed value class Int_IntN { + @JvmInline + value class First(val a: Int): Int_IntN() + + @JvmInline + value class Second(val a: Int?): Int_IntN() +} + +class Gen + +@JvmInline +sealed value class Gen_Gen { + @JvmInline + value class First(val a: Gen): Gen_Gen() + + @JvmInline + value class Second(val a: Gen): Gen_Gen() +} + +@JvmInline +value class IC(val a: String) + +@JvmInline +sealed value class IC_IC { + @JvmInline + value class First(val a: IC): IC_IC() + + @JvmInline + value class Second(val a: IC?): IC_IC() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.fir.kt new file mode 100644 index 0000000000000..ed8b11db1487b --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.fir.kt @@ -0,0 +1,29 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +interface Parent + +class Child: Parent + +@JvmInline +sealed value class Parent_Child { + @JvmInline + value class First(val a: Parent): Parent_Child() + + @JvmInline + value class Second(val a: Child): Parent_Child() +} + +@JvmInline +sealed value class String_Parent { + @JvmInline + value class First(val a: String): String_Parent() + + @JvmInline + value class Second(val a: Parent): String_Parent() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.kt new file mode 100644 index 0000000000000..22838e54348dd --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.kt @@ -0,0 +1,29 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +interface Parent + +class Child: Parent + +@JvmInline +sealed value class Parent_Child { + @JvmInline + value class First(val a: Parent): Parent_Child() + + @JvmInline + value class Second(val a: Child): Parent_Child() +} + +@JvmInline +sealed value class String_Parent { + @JvmInline + value class First(val a: String): String_Parent() + + @JvmInline + value class Second(val a: Parent): String_Parent() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.fir.kt new file mode 100644 index 0000000000000..edbe3720550e2 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.fir.kt @@ -0,0 +1,29 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +open class Parent + +class Child: Parent() + +@JvmInline +sealed value class Parent_Child { + @JvmInline + value class First(val a: Parent): Parent_Child() + + @JvmInline + value class Second(val a: Child): Parent_Child() +} + +@JvmInline +sealed value class String_Parent { + @JvmInline + value class First(val a: String): String_Parent() + + @JvmInline + value class Second(val a: Parent): String_Parent() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.kt new file mode 100644 index 0000000000000..deb4be4a10fd6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.kt @@ -0,0 +1,29 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +open class Parent + +class Child: Parent() + +@JvmInline +sealed value class Parent_Child { + @JvmInline + value class First(val a: Parent): Parent_Child() + + @JvmInline + value class Second(val a: Child): Parent_Child() +} + +@JvmInline +sealed value class String_Parent { + @JvmInline + value class First(val a: String): String_Parent() + + @JvmInline + value class Second(val a: Parent): String_Parent() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.fir.kt new file mode 100644 index 0000000000000..04f5e38a9ba9e --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.fir.kt @@ -0,0 +1,20 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +interface One + +interface Other + +@JvmInline +sealed value class One_Other { + @JvmInline + value class First(val a: One): One_Other() + + @JvmInline + value class Second(val a: Other): One_Other() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.kt new file mode 100644 index 0000000000000..7ec4e47136f10 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.kt @@ -0,0 +1,20 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +interface One + +interface Other + +@JvmInline +sealed value class One_Other { + @JvmInline + value class First(val a: One): One_Other() + + @JvmInline + value class Second(val a: Other): One_Other() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.fir.kt new file mode 100644 index 0000000000000..de41d80a30143 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.fir.kt @@ -0,0 +1,31 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +interface Parent + +open class Child: Parent + +open class Other + +@JvmInline +sealed value class Parent_Child { + @JvmInline + value class First(val a: Parent): Parent_Child() + + @JvmInline + value class Second(val a: Child): Parent_Child() +} + +@JvmInline +sealed value class Other_Parent { + @JvmInline + value class First(val a: Other): Other_Parent() + + @JvmInline + value class Second(val a: Parent): Other_Parent() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.kt new file mode 100644 index 0000000000000..21f98845655ce --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.kt @@ -0,0 +1,31 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +interface Parent + +open class Child: Parent + +open class Other + +@JvmInline +sealed value class Parent_Child { + @JvmInline + value class First(val a: Parent): Parent_Child() + + @JvmInline + value class Second(val a: Child): Parent_Child() +} + +@JvmInline +sealed value class Other_Parent { + @JvmInline + value class First(val a: Other): Other_Parent() + + @JvmInline + value class Second(val a: Parent): Other_Parent() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.fir.kt new file mode 100644 index 0000000000000..566eda65a1bea --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.fir.kt @@ -0,0 +1,31 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +open class Parent + +open class Child: Parent() + +open class Other + +@JvmInline +sealed value class Parent_Child { + @JvmInline + value class First(val a: Parent): Parent_Child() + + @JvmInline + value class Second(val a: Child): Parent_Child() +} + +@JvmInline +sealed value class Other_Parent { + @JvmInline + value class First(val a: Other): Other_Parent() + + @JvmInline + value class Second(val a: Parent): Other_Parent() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.kt new file mode 100644 index 0000000000000..97cc7507da643 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.kt @@ -0,0 +1,31 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +open class Parent + +open class Child: Parent() + +open class Other + +@JvmInline +sealed value class Parent_Child { + @JvmInline + value class First(val a: Parent): Parent_Child() + + @JvmInline + value class Second(val a: Child): Parent_Child() +} + +@JvmInline +sealed value class Other_Parent { + @JvmInline + value class First(val a: Other): Other_Parent() + + @JvmInline + value class Second(val a: Parent): Other_Parent() +} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.fir.kt new file mode 100644 index 0000000000000..6155f431c1749 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.fir.kt @@ -0,0 +1,15 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +@JvmInline +sealed value class Top { + @JvmInline + sealed value class Middle: Top() + @JvmInline + value class Child(val a: String): Top() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.kt new file mode 100644 index 0000000000000..adaf0dcb28af7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.kt @@ -0,0 +1,15 @@ +// LANGUAGE: +SealedInlineClasses +// SKIP_TXT +// !SKIP_JAVAC + +package kotlin.jvm + +annotation class JvmInline + +@JvmInline +sealed value class Top { + @JvmInline + sealed value class Middle: Top() + @JvmInline + value class Child(val a: String): Top() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-child.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-child.fir.kt index c6bc43568ffec..a5508bd19a401 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-child.fir.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-child.fir.kt @@ -49,37 +49,37 @@ abstract class AC @JvmInline -value class VC_SVC(val a: Int): SVC() +value class VC_SVC(val a: Int): SVC() @JvmInline value class VC_SI(val a: Any): SI @JvmInline value class VC_I(val a: Any): I @JvmInline -value class VC_VC(val b: Any): VC(b) +value class VC_VC(val b: Any): VC(b) @JvmInline -value class VC_IC(val b: Any): IC(b) +value class VC_IC(val b: Any): IC(b) @JvmInline -value class VC_OC(val a: Any): OC() +value class VC_OC(val a: Any): OC() @JvmInline -value class VC_SC(val a: Any): SC() +value class VC_SC(val a: Any): SC() @JvmInline -value class VC_AC(val a: Any): AC() +value class VC_AC(val a: Any): AC() -class C_SVC: SVC() -class C_VC: VC("") -class C_IC: IC("") +class C_SVC: SVC() +class C_VC: VC("") +class C_IC: IC("") inline class IC_SVC(val a: String): SVC() inline class IC_SI(val a: Any): SI inline class IC_I(val a: Any): I -inline class IC_VC(val b: Any): VC(b) -inline class IC_IC(val b: Any): IC(b) -inline class IC_OC(val a: Any): OC() -inline class IC_SC(val a: Any): SC() -inline class IC_AC(val a: Any): AC() +inline class IC_VC(val b: Any): VC(b) +inline class IC_IC(val b: Any): IC(b) +inline class IC_OC(val a: Any): OC() +inline class IC_SC(val a: Any): SC() +inline class IC_AC(val a: Any): AC() @JvmInline @@ -90,29 +90,29 @@ sealed value class SVC_SI: SI sealed value class SVC_I: I @JvmInline -sealed value class SVC_VC: VC("") +sealed value class SVC_VC: VC("") @JvmInline -sealed value class SVC_IC: IC("") +sealed value class SVC_IC: IC("") @JvmInline -sealed value class SVC_OC: OC() +sealed value class SVC_OC: OC() @JvmInline -sealed value class SVC_SC: SC() +sealed value class SVC_SC: SC() @JvmInline -sealed value class SVC_AC: AC() +sealed value class SVC_AC: AC() @JvmInline -open value class OVC_SVC: SVC() +open value class OVC_SVC: SVC() @JvmInline -open value class OVC_SI: SI +open value class OVC_SI: SI @JvmInline -open value class OVC_I: I +open value class OVC_I: I @JvmInline -open value class OVC_VC: VC("") +open value class OVC_VC: VC("") @JvmInline -open value class OVC_IC: IC("") +open value class OVC_IC: IC("") @JvmInline -open value class OVC_OC: OC() +open value class OVC_OC: OC() @JvmInline -open value class OVC_SC: SC() +open value class OVC_SC: SC() @JvmInline -open value class OVC_AC: AC() \ No newline at end of file +open value class OVC_AC: AC() diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-child.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-child.kt index dd14b8475668f..92accd614751d 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-child.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-child.kt @@ -49,7 +49,7 @@ abstract class AC @JvmInline -value class VC_SVC(val a: Int): SVC() +value class VC_SVC(val a: Int): SVC() @JvmInline value class VC_SI(val a: Any): SI @JvmInline diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-kind-children-forbidden.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-kind-children-forbidden.fir.kt index c55d4c8389349..94bf9cd993f0d 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-kind-children-forbidden.fir.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-kind-children-forbidden.fir.kt @@ -10,6 +10,6 @@ annotation class JvmInline @JvmInline sealed value class SVC -interface I : SVC() -enum class EC : SVC() -annotation class AC : SVC() \ No newline at end of file +interface I : SVC() +enum class EC : SVC() +annotation class AC : SVC() diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.kt deleted file mode 100644 index 8fb3331ff81e4..0000000000000 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.kt +++ /dev/null @@ -1,15 +0,0 @@ -// LANGUAGE: +SealedInlineClasses -// SKIP_TXT - -package kotlin.jvm - -annotation class JvmInline - -@JvmInline -sealed value class IC - -@JvmInline -sealed value class ICC: IC() - -@JvmInline -sealed value class ICC2: IC() diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/flat.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/flat.fir.kt index 24d8f0bcb7bc8..7141736164452 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/flat.fir.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/flat.fir.kt @@ -10,5 +10,5 @@ sealed value class Result @JvmInline value class Ok(val value: Any): Result() @JvmInline -value class FileNotFound(val value: Int): Result() +value class FileNotFound(val value: Int): Result() value class Error(val value: Throwable): Result() \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/flat.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/flat.kt index cdfcc568ce32b..479878da766ed 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/flat.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/flat.kt @@ -10,5 +10,5 @@ sealed value class Result @JvmInline value class Ok(val value: Any): Result() @JvmInline -value class FileNotFound(val value: Int): Result() -value class Error(val value: Throwable): Result() \ No newline at end of file +value class FileNotFound(val value: Int): Result() +value class Error(val value: Throwable): Result() diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/nested.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/nested.fir.kt index f3310d36be175..023e5d2162a4d 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/nested.fir.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/nested.fir.kt @@ -9,6 +9,6 @@ sealed value class Result { @JvmInline value class Ok(val value: Any): Result() @JvmInline - value class FileNotFound(val value: Int): Result() + value class FileNotFound(val value: Int): Result() value class Error(val value: Throwable): Result() } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/nested.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/nested.kt index 913bca901f6f7..1583864b7f916 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/nested.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/nested.kt @@ -9,6 +9,6 @@ sealed value class Result { @JvmInline value class Ok(val value: Any): Result() @JvmInline - value class FileNotFound(val value: Int): Result() + value class FileNotFound(val value: Int): Result() value class Error(val value: Throwable): Result() } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/object-child.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/object-child.fir.kt index feee787e75de0..c8411bed344d7 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/object-child.fir.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/object-child.fir.kt @@ -50,14 +50,14 @@ abstract class AC value object VO_SVC: SVC() -value object VO_VC: VC("") -value object VO_IC: IC("") -value object VO_SI: SI -value object VO_I: I -value object VO_OC: OC() -value object VO_SC: SC() -value object VO_AC: AC() - -object O_SVC: SVC() -object O_VC: VC("") -object O_IC: IC("") \ No newline at end of file +value object VO_VC: VC("") +value object VO_IC: IC("") +value object VO_SI: SI +value object VO_I: I +value object VO_OC: OC() +value object VO_SC: SC() +value object VO_AC: AC() + +object O_SVC: SVC() +object O_VC: VC("") +object O_IC: IC("") diff --git a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/unsupported-inline.fir.kt b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/unsupported-inline.fir.kt index e3bd01c3519e1..6489a2c436711 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/unsupported-inline.fir.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/unsupported-inline.fir.kt @@ -9,7 +9,7 @@ annotation class JvmInline sealed inline class SIC -inline object IO +inline object IO @JvmInline -value object JVO \ No newline at end of file +value object JVO diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt deleted file mode 100644 index 13c44ae164f4c..0000000000000 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt +++ /dev/null @@ -1,52 +0,0 @@ -// !SKIP_JAVAC -// !LANGUAGE: +InlineClasses -// !DIAGNOSTICS: -UNUSED_PARAMETER - -package kotlin.jvm - -annotation class JvmInline - -@JvmInline -value class A0(val x: Int) - -@JvmInline -value class A1 -@JvmInline -value class A2() -@JvmInline -value class A3(x: Int) -@JvmInline -value class A4(var x: Int) -@JvmInline -value class A5(val x: Int, val y: Int) -@JvmInline -value class A6(x: Int, val y: Int) -@JvmInline -value class A7(vararg val x: Int) -@JvmInline -value class A8(open val x: Int) -@JvmInline -value class A9(final val x: Int) - -class B1 { - companion object { - @JvmInline - value class C1(val x: Int) - } - - @JvmInline - value class C2(val x: Int) -} - -object B2 { - @JvmInline - value class C3(val x: Int) -} - -@JvmInline -final value class D0(val x: Int) -open value class D1(val x: Int) -abstract value class D2(val x: Int) -sealed value class D3(val x: Int) - -value data class D4(val x: String) diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt index 13c44ae164f4c..ecfec1b1f79a3 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER 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 f116d0cb33012..ee415695110e7 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 @@ -17863,12 +17863,6 @@ public void testClass_kind_children_forbidden() throws Exception { runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/class-kind-children-forbidden.kt"); } - @Test - @TestMetadata("doubleSealedChild.kt") - public void testDoubleSealedChild() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/doubleSealedChild.kt"); - } - @Test @TestMetadata("flat.kt") public void testFlat() throws Exception { @@ -17898,6 +17892,64 @@ public void testUnsupported_inline() throws Exception { public void testWith_value() throws Exception { runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/with-value.kt"); } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing") + @TestDataPath("$PROJECT_ROOT") + public class ChildrenDistinguishing { + @Test + public void testAllFilesPresentInChildrenDistinguishing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("doubleSealedChild.kt") + public void testDoubleSealedChild() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/doubleSealedChild.kt"); + } + + @Test + @TestMetadata("finalClassAndFinalClass.kt") + public void testFinalClassAndFinalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndFinalClass.kt"); + } + + @Test + @TestMetadata("finalClassAndInterface.kt") + public void testFinalClassAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndInterface.kt"); + } + + @Test + @TestMetadata("finalClassAndOpenClass.kt") + public void testFinalClassAndOpenClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/finalClassAndOpenClass.kt"); + } + + @Test + @TestMetadata("interfaceAndInterface.kt") + public void testInterfaceAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/interfaceAndInterface.kt"); + } + + @Test + @TestMetadata("openClassAndInterface.kt") + public void testOpenClassAndInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndInterface.kt"); + } + + @Test + @TestMetadata("openClassAndOpenClass.kt") + public void testOpenClassAndOpenClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/openClassAndOpenClass.kt"); + } + + @Test + @TestMetadata("sealedInlineClassChild.kt") + public void testSealedInlineClassChild() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/sealed-inline-class/childrenDistinguishing/sealedInlineClassChild.kt"); + } + } } } diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 65bc2972a0992..00dd4a5896a07 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -18319,6 +18319,16 @@ public void testWhenWithSubjectGeneric() throws Exception { @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class BoxReturnValueInLambda extends AbstractLightAnalysisModeTest { + @TestMetadata("boxAnySealed.kt") + public void ignoreBoxAnySealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("boxFunLiteralAnySealed.kt") + public void ignoreBoxFunLiteralAnySealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + private void runTest(String testDataFilePath) throws Exception { KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); } @@ -18341,11 +18351,6 @@ public void testBoxAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("boxAnySealed.kt") - public void testBoxAnySealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("boxFunLiteralAny.kt") public void testBoxFunLiteralAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18356,11 +18361,6 @@ public void testBoxFunLiteralAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("boxFunLiteralAnySealed.kt") - public void testBoxFunLiteralAnySealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("boxInt.kt") public void testBoxInt() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxInt.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18501,6 +18501,136 @@ public void ignoreBoxReturnValueInDefaultMethodSealed() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethodSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } + @TestMetadata("covariantOverrideChainErasedToAnySealed.kt") + public void ignoreCovariantOverrideChainErasedToAnySealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("covariantOverrideChainErasedToNullableAnySealed.kt") + public void ignoreCovariantOverrideChainErasedToNullableAnySealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("covariantOverrideErasedToAnySealed.kt") + public void ignoreCovariantOverrideErasedToAnySealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("covariantOverrideErasedToInterfaceSealed.kt") + public void ignoreCovariantOverrideErasedToInterfaceSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterfaceSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("covariantOverrideErasedToPrimitiveSealed.kt") + public void ignoreCovariantOverrideErasedToPrimitiveSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitiveSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("covariantOverrideListVsMutableListSealed.kt") + public void ignoreCovariantOverrideListVsMutableListSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableListSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("covariantOverrideUnrelatedInterfacesSealed.kt") + public void ignoreCovariantOverrideUnrelatedInterfacesSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfacesSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("genericOverrideSealed.kt") + public void ignoreGenericOverrideSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("genericOverrideSpecializedSealed.kt") + public void ignoreGenericOverrideSpecializedSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecializedSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("inlineClassInOverriddenReturnTypesSealed.kt") + public void ignoreInlineClassInOverriddenReturnTypesSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypesSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("kt28483Sealed.kt") + public void ignoreKt28483Sealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Sealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("kt31585Sealed.kt") + public void ignoreKt31585Sealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585Sealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("kt35234Sealed.kt") + public void ignoreKt35234Sealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234Sealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("overrideGenericWithInlineClassSealed.kt") + public void ignoreOverrideGenericWithInlineClassSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClassSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnySealed.kt") + public void ignoreOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAnySealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullSealed.kt") + public void ignoreOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnySealed.kt") + public void ignoreOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnySealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("overrideNullableInlineClassWithNonNullAnySealed.kt") + public void ignoreOverrideNullableInlineClassWithNonNullAnySealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNullSealed.kt") + public void ignoreOverrideNullableInlineClassWithNonNullNullableAnyNullSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnySealed.kt") + public void ignoreOverrideNullableInlineClassWithNonNullNullableAnySealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("relatedReturnTypes1aSealed.kt") + public void ignoreRelatedReturnTypes1aSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1aSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("relatedReturnTypes1bSealed.kt") + public void ignoreRelatedReturnTypes1bSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1bSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("relatedReturnTypes2aSealed.kt") + public void ignoreRelatedReturnTypes2aSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2aSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("relatedReturnTypes2bSealed.kt") + public void ignoreRelatedReturnTypes2bSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2bSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("uncastInlineClassToAnyAndBackSealed.kt") + public void ignoreUncastInlineClassToAnyAndBackSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBackSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @TestMetadata("unrelatedGenericsSealed.kt") + public void ignoreUnrelatedGenericsSealed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenericsSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + private void runTest(String testDataFilePath) throws Exception { KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); } @@ -18523,11 +18653,6 @@ public void testCovariantOverrideChainErasedToAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("covariantOverrideChainErasedToAnySealed.kt") - public void testCovariantOverrideChainErasedToAnySealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("covariantOverrideChainErasedToNullableAny.kt") public void testCovariantOverrideChainErasedToNullableAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18543,11 +18668,6 @@ public void testCovariantOverrideChainErasedToNullableAnyGeneric2() throws Excep runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnyGeneric2.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("covariantOverrideChainErasedToNullableAnySealed.kt") - public void testCovariantOverrideChainErasedToNullableAnySealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("covariantOverrideErasedToAny.kt") public void testCovariantOverrideErasedToAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18558,11 +18678,6 @@ public void testCovariantOverrideErasedToAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("covariantOverrideErasedToAnySealed.kt") - public void testCovariantOverrideErasedToAnySealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("covariantOverrideErasedToInterface.kt") public void testCovariantOverrideErasedToInterface() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterface.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18573,11 +18688,6 @@ public void testCovariantOverrideErasedToInterfaceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterfaceGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("covariantOverrideErasedToInterfaceSealed.kt") - public void testCovariantOverrideErasedToInterfaceSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterfaceSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("covariantOverrideErasedToPrimitive.kt") public void testCovariantOverrideErasedToPrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitive.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18588,11 +18698,6 @@ public void testCovariantOverrideErasedToPrimitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitiveGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("covariantOverrideErasedToPrimitiveSealed.kt") - public void testCovariantOverrideErasedToPrimitiveSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitiveSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("covariantOverrideListVsMutableList.kt") public void testCovariantOverrideListVsMutableList() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableList.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18603,11 +18708,6 @@ public void testCovariantOverrideListVsMutableListGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableListGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("covariantOverrideListVsMutableListSealed.kt") - public void testCovariantOverrideListVsMutableListSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableListSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("covariantOverrideUnrelatedInterfaces.kt") public void testCovariantOverrideUnrelatedInterfaces() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfaces.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18618,11 +18718,6 @@ public void testCovariantOverrideUnrelatedInterfacesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfacesGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("covariantOverrideUnrelatedInterfacesSealed.kt") - public void testCovariantOverrideUnrelatedInterfacesSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfacesSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("genericOverride.kt") public void testGenericOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverride.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18633,11 +18728,6 @@ public void testGenericOverrideGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("genericOverrideSealed.kt") - public void testGenericOverrideSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("genericOverrideSpecialized.kt") public void testGenericOverrideSpecialized() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecialized.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18648,11 +18738,6 @@ public void testGenericOverrideSpecializedGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecializedGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("genericOverrideSpecializedSealed.kt") - public void testGenericOverrideSpecializedSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecializedSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("inlineClassInOverriddenReturnTypes.kt") public void testInlineClassInOverriddenReturnTypes() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypes.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18663,11 +18748,6 @@ public void testInlineClassInOverriddenReturnTypesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypesGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("inlineClassInOverriddenReturnTypesSealed.kt") - public void testInlineClassInOverriddenReturnTypesSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypesSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("kt28483.kt") public void testKt28483() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18683,11 +18763,6 @@ public void testKt28483Generic2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Generic2.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("kt28483Sealed.kt") - public void testKt28483Sealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Sealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("kt31585.kt") public void testKt31585() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18698,11 +18773,6 @@ public void testKt31585Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("kt31585Sealed.kt") - public void testKt31585Sealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585Sealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("kt35234.kt") public void testKt35234() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18713,11 +18783,6 @@ public void testKt35234Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234Generic.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("kt35234Sealed.kt") - public void testKt35234Sealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234Sealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("kt35234a.kt") public void testKt35234a() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234a.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18733,11 +18798,6 @@ public void testOverrideGenericWithInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClassGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("overrideGenericWithInlineClassSealed.kt") - public void testOverrideGenericWithInlineClassSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClassSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18748,11 +18808,6 @@ public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGe runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnySealed.kt") - public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAnySealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18783,16 +18838,6 @@ public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNulla runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullSealed.kt") - public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNullSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - - @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnySealed.kt") - public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnySealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("overrideNullableInlineClassWithNonNullAny.kt") public void testOverrideNullableInlineClassWithNonNullAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18803,11 +18848,6 @@ public void testOverrideNullableInlineClassWithNonNullAnyGeneric() throws Except runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAnyGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("overrideNullableInlineClassWithNonNullAnySealed.kt") - public void testOverrideNullableInlineClassWithNonNullAnySealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("overrideNullableInlineClassWithNonNullNullableAny.kt") public void testOverrideNullableInlineClassWithNonNullNullableAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAny.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18838,16 +18878,6 @@ public void testOverrideNullableInlineClassWithNonNullNullableAnyNullGeneric2() runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullGeneric2.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNullSealed.kt") - public void testOverrideNullableInlineClassWithNonNullNullableAnyNullSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - - @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnySealed.kt") - public void testOverrideNullableInlineClassWithNonNullNullableAnySealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnySealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("relatedReturnTypes1a.kt") public void testRelatedReturnTypes1a() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1a.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18858,11 +18888,6 @@ public void testRelatedReturnTypes1aGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1aGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("relatedReturnTypes1aSealed.kt") - public void testRelatedReturnTypes1aSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1aSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("relatedReturnTypes1b.kt") public void testRelatedReturnTypes1b() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1b.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18873,11 +18898,6 @@ public void testRelatedReturnTypes1bGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1bGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("relatedReturnTypes1bSealed.kt") - public void testRelatedReturnTypes1bSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1bSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("relatedReturnTypes2a.kt") public void testRelatedReturnTypes2a() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2a.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18888,11 +18908,6 @@ public void testRelatedReturnTypes2aGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2aGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("relatedReturnTypes2aSealed.kt") - public void testRelatedReturnTypes2aSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2aSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("relatedReturnTypes2b.kt") public void testRelatedReturnTypes2b() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2b.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18903,11 +18918,6 @@ public void testRelatedReturnTypes2bGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2bGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("relatedReturnTypes2bSealed.kt") - public void testRelatedReturnTypes2bSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2bSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("uncastInlineClassToAnyAndBack.kt") public void testUncastInlineClassToAnyAndBack() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBack.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18918,11 +18928,6 @@ public void testUncastInlineClassToAnyAndBackGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBackGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - @TestMetadata("uncastInlineClassToAnyAndBackSealed.kt") - public void testUncastInlineClassToAnyAndBackSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBackSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } - @TestMetadata("unrelatedGenerics.kt") public void testUnrelatedGenerics() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenerics.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); @@ -18932,11 +18937,6 @@ public void testUnrelatedGenerics() throws Exception { public void testUnrelatedGenericsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenericsGeneric.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } - - @TestMetadata("unrelatedGenericsSealed.kt") - public void testUnrelatedGenericsSealed() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenericsSealed.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); - } } @TestMetadata("compiler/testData/codegen/box/inlineClasses/callableReferences")