diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt index 2e646cde807..8185851399f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt @@ -267,7 +267,7 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) { if (classDescriptor.kind != ClassKind.CLASS) return false if (classOrObject.isLocal) return false - if (classDescriptor.isInline) return false + if (classDescriptor.isInlineClass()) return false if (shouldHideConstructorDueToInlineClassTypeValueParameters(constructorDescriptor)) return false if (CodegenBinding.canHaveOuter(state.bindingContext, classDescriptor)) return false diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java index c1e84140240..2ab32eba3b0 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DescriptorAsmUtil.java @@ -216,7 +216,7 @@ public class DescriptorAsmUtil { private static boolean isInlineClassWrapperConstructor(@NotNull FunctionDescriptor functionDescriptor, @Nullable OwnerKind kind) { if (!(functionDescriptor instanceof ConstructorDescriptor)) return false; ClassDescriptor classDescriptor = ((ConstructorDescriptor) functionDescriptor).getConstructedClass(); - return classDescriptor.isInline() && kind == OwnerKind.IMPLEMENTATION; + return InlineClassesUtilsKt.isInlineClass(classDescriptor) && kind == OwnerKind.IMPLEMENTATION; } public static int getCommonCallableFlags(FunctionDescriptor functionDescriptor, @NotNull GenerationState state) { @@ -559,7 +559,7 @@ public class DescriptorAsmUtil { if (receiverKotlinType.isMarkedNullable()) return null; DeclarationDescriptor receiverTypeDescriptor = receiverKotlinType.getConstructor().getDeclarationDescriptor(); - assert receiverTypeDescriptor instanceof ClassDescriptor && ((ClassDescriptor) receiverTypeDescriptor).isInline() : + assert receiverTypeDescriptor != null && InlineClassesUtilsKt.isInlineClass(receiverTypeDescriptor) : "Inline class type expected: " + receiverKotlinType; ClassDescriptor receiverClassDescriptor = (ClassDescriptor) receiverTypeDescriptor; FunctionDescriptor toStringDescriptor = receiverClassDescriptor.getUnsubstitutedMemberScope() diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 67323b5949b..f2c109bf80d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -1190,7 +1190,7 @@ public class ExpressionCodegen extends KtVisitor impleme ClassDescriptor captureThis = closure.getCapturedOuterClassDescriptor(); if (captureThis != null) { StackValue thisOrOuter = generateThisOrOuter(captureThis, false); - assert !isPrimitive(thisOrOuter.type) || captureThis.isInline() : + assert !isPrimitive(thisOrOuter.type) || InlineClassesUtilsKt.isInlineClass(captureThis) : "This or outer for " + captureThis + " should be non-primitive: " + thisOrOuter.type; callGenerator.putCapturedValueOnStack(thisOrOuter, thisOrOuter.type, paramIndex++); } @@ -4830,7 +4830,7 @@ public class ExpressionCodegen extends KtVisitor impleme ReceiverParameterDescriptor dispatchReceiver = constructor.getDispatchReceiverParameter(); ClassDescriptor containingDeclaration = constructor.getContainingDeclaration(); - if (!containingDeclaration.isInline()) { + if (!InlineClassesUtilsKt.isInlineClass(containingDeclaration)) { v.anew(objectType); v.dup(); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index 3bc84e5c944..70e2d6844cf 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -1589,7 +1589,7 @@ public class FunctionCodegen { // When delegating to inline class, we invoke static implementation method // that takes inline class underlying value as 1st argument. - int toArgsShift = toClass.isInline() ? 1 : 0; + int toArgsShift = InlineClassesUtilsKt.isInlineClass(toClass) ? 1 : 0; int reg = 1; for (int i = 0; i < argTypes.length; ++i) { @@ -1609,7 +1609,7 @@ public class FunctionCodegen { if (toClass.getKind() == ClassKind.INTERFACE) { iv.invokeinterface(internalName, delegateToMethod.getName(), delegateToMethod.getDescriptor()); } - else if (toClass.isInline()) { + else if (InlineClassesUtilsKt.isInlineClass(toClass)) { iv.invokestatic(internalName, delegateToMethod.getName(), delegateToMethod.getDescriptor(), false); } else { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionsFromAnyGeneratorImpl.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionsFromAnyGeneratorImpl.java index b53fa912717..0d7dc837228 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionsFromAnyGeneratorImpl.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionsFromAnyGeneratorImpl.java @@ -84,7 +84,7 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator { String toStringMethodDesc = getToStringDesc(); MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), toStringMethodName, toStringMethodDesc, null, null); - if (!isInErasedInlineClass && classDescriptor.isInline()) { + if (!isInErasedInlineClass && InlineClassesUtilsKt.isInlineClass(classDescriptor)) { FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper); return; } @@ -161,7 +161,7 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator { String hashCodeMethodDesc = getHashCodeDesc(); MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), hashCodeMethodName, hashCodeMethodDesc, null, null); - if (!isInErasedInlineClass && classDescriptor.isInline()) { + if (!isInErasedInlineClass && InlineClassesUtilsKt.isInlineClass(classDescriptor)) { FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper); return; } @@ -233,7 +233,7 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator { String equalsMethodDesc = getEqualsDesc(); MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), equalsMethodName, equalsMethodDesc, null, null); - if (!isInErasedInlineClass && classDescriptor.isInline()) { + if (!isInErasedInlineClass && InlineClassesUtilsKt.isInlineClass(classDescriptor)) { FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper); return; } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index 2f0cf3eef55..c9c28a57deb 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -260,7 +260,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { @Override protected void generateErasedInlineClassIfNeeded() { if (!(myClass instanceof KtClass)) return; - if (!descriptor.isInline()) return; + if (!InlineClassesUtilsKt.isInlineClass(descriptor)) return; ClassContext erasedInlineClassContext = context.intoWrapperForErasedInlineClass(descriptor, state); new ErasedInlineClassBodyCodegen((KtClass) myClass, erasedInlineClassContext, v, state, this).generate(); @@ -269,7 +269,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { @Override protected void generateUnboxMethodForInlineClass() { if (!(myClass instanceof KtClass)) return; - if (!descriptor.isInline()) return; + if (!InlineClassesUtilsKt.isInlineClass(descriptor)) return; Type ownerType = typeMapper.mapClass(descriptor); ValueParameterDescriptor inlinedValue = InlineClassesUtilsKt.underlyingRepresentation(this.descriptor); @@ -450,7 +450,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { try { lookupConstructorExpressionsInClosureIfPresent(); constructorCodegen.generatePrimaryConstructor(delegationFieldsInfo, superClassAsmType); - if (!descriptor.isInline() && !(descriptor instanceof SyntheticClassOrObjectDescriptor)) { + if (!InlineClassesUtilsKt.isInlineClass(descriptor) && !(descriptor instanceof SyntheticClassOrObjectDescriptor)) { // Synthetic classes does not have declarations for secondary constructors for (ClassConstructorDescriptor secondaryConstructor : DescriptorUtilsKt.getSecondaryConstructors(descriptor)) { constructorCodegen.generateSecondaryConstructor(secondaryConstructor, superClassAsmType); @@ -552,7 +552,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } private void generateFunctionsFromAnyForInlineClasses() { - if (!descriptor.isInline()) return; + if (!InlineClassesUtilsKt.isInlineClass(descriptor)) return; if (!(myClass instanceof KtClassOrObject)) return; new FunctionsFromAnyGeneratorImpl( (KtClassOrObject) myClass, bindingContext, descriptor, classAsmType, context, v, state diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java index d72d53dc740..496f8940956 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java @@ -775,7 +775,8 @@ public abstract class StackValue { ) { // Coerce 'this' for the case when it is smart cast. // Do not coerce for other cases due to the 'protected' access issues (JVMS 7, 4.9.2 Structural Constraints). - boolean coerceType = descriptor.getKind() == ClassKind.INTERFACE || descriptor.isInline() || (castReceiver && !isSuper); + boolean coerceType = descriptor.getKind() == ClassKind.INTERFACE || InlineClassesUtilsKt.isInlineClass(descriptor) || + (castReceiver && !isSuper); return new ThisOuter(codegen, descriptor, isSuper, coerceType); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ConstructorContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ConstructorContext.java index e5ee4c4bc61..ecd6e4b3211 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ConstructorContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ConstructorContext.java @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.codegen.binding.MutableClosure; import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper; import org.jetbrains.kotlin.descriptors.ClassDescriptor; import org.jetbrains.kotlin.descriptors.ConstructorDescriptor; +import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt; import org.jetbrains.kotlin.resolve.jvm.AsmTypes; import org.jetbrains.kotlin.types.SimpleType; import org.jetbrains.org.objectweb.asm.Type; @@ -48,7 +49,7 @@ public class ConstructorContext extends MethodContext { ClassDescriptor capturedOuterClassDescriptor = closure != null ? closure.getCapturedOuterClassDescriptor() : null; StackValue stackValue; if (capturedOuterClassDescriptor != null) { - if (capturedOuterClassDescriptor.isInline()) { + if (InlineClassesUtilsKt.isInlineClass(capturedOuterClassDescriptor)) { SimpleType outerClassKotlinType = capturedOuterClassDescriptor.getDefaultType(); Type outerClassType = kotlinTypeMapper.mapType(capturedOuterClassDescriptor); stackValue = StackValue.local(1, outerClassType, outerClassKotlinType); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt index f4cd6573685..3224938157a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt @@ -20,6 +20,7 @@ import com.intellij.openapi.util.Pair import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.optimization.common.StrictBasicValue import org.jetbrains.kotlin.codegen.state.GenerationState +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.resolve.jvm.AsmTypes import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode @@ -119,7 +120,7 @@ fun getUnboxedType(boxedType: Type, state: GenerationState): Type { fun unboxedTypeOfInlineClass(boxedType: Type, state: GenerationState): Type? { val descriptor = - state.jvmBackendClassResolver.resolveToClassDescriptors(boxedType).singleOrNull()?.takeIf { it.isInline } ?: return null + state.jvmBackendClassResolver.resolveToClassDescriptors(boxedType).singleOrNull()?.takeIf { it.isInlineClass() } ?: return null return state.mapInlineClass(descriptor) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt index f02057dcf4d..d490572bc3c 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt @@ -445,7 +445,7 @@ class KotlinTypeMapper @JvmOverloads constructor( } } } else { - val toInlinedErasedClass = functionParent.isInline && + val toInlinedErasedClass = functionParent.isInlineClass() && (!isAccessor(functionDescriptor) || isInlineClassConstructorAccessor(functionDescriptor)) if (toInlinedErasedClass) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt index 0e787796758..7d8e309f1d0 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForParameterTypes import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType import org.jetbrains.kotlin.types.KotlinType @@ -111,7 +112,7 @@ fun getManglingSuffixBasedOnKotlinSignature( private fun getInfoForMangling(type: KotlinType): InfoForMangling? { val descriptor = type.constructor.declarationDescriptor ?: return null return when (descriptor) { - is ClassDescriptor -> InfoForMangling(descriptor.fqNameUnsafe, descriptor.isInline, type.isMarkedNullable) + is ClassDescriptor -> InfoForMangling(descriptor.fqNameUnsafe, descriptor.isInlineClass(), type.isMarkedNullable) is TypeParameterDescriptor -> { getInfoForMangling(descriptor.representativeUpperBound) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMapperUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMapperUtils.kt index f48cf6e9e26..1be180c7b03 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMapperUtils.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMapperUtils.kt @@ -23,6 +23,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.typeUtil.asTypeProjection @@ -93,4 +94,4 @@ fun KotlinType.removeExternalProjections(): KotlinType { fun isInlineClassConstructorAccessor(descriptor: FunctionDescriptor): Boolean = descriptor is AccessorForConstructorDescriptor && - descriptor.calleeDescriptor.constructedClass.isInline + descriptor.calleeDescriptor.constructedClass.isInlineClass() diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java index d1f3e3f6c53..7f464477a92 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java @@ -24968,6 +24968,129 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte } } + @TestMetadata("compiler/testData/diagnostics/tests/valueClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ValueClasses extends AbstractFirOldFrontendDiagnosticsTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInValueClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/valueClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @TestMetadata("basicValueClassDeclaration.kt") + public void testBasicValueClassDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt"); + } + + @TestMetadata("basicValueClassDeclarationDisabled.kt") + public void testBasicValueClassDeclarationDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt"); + } + + @TestMetadata("constructorsJvmSignaturesClash.kt") + public void testConstructorsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt"); + } + + @TestMetadata("delegatedPropertyInValueClass.kt") + public void testDelegatedPropertyInValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt"); + } + + @TestMetadata("functionsJvmSignaturesClash.kt") + public void testFunctionsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt"); + } + + @TestMetadata("functionsJvmSignaturesConflictOnInheritance.kt") + public void testFunctionsJvmSignaturesConflictOnInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt"); + } + + @TestMetadata("identityComparisonWithValueClasses.kt") + public void testIdentityComparisonWithValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt"); + } + + @TestMetadata("lateinitValueClasses.kt") + public void testLateinitValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt"); + } + + @TestMetadata("presenceOfInitializerBlockInsideValueClass.kt") + public void testPresenceOfInitializerBlockInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt"); + } + + @TestMetadata("presenceOfPublicPrimaryConstructorForValueClass.kt") + public void testPresenceOfPublicPrimaryConstructorForValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt"); + } + + @TestMetadata("propertiesWithBackingFieldsInsideValueClass.kt") + public void testPropertiesWithBackingFieldsInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt"); + } + + @TestMetadata("recursiveValueClasses.kt") + public void testRecursiveValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt"); + } + + @TestMetadata("reservedMembersAndConstructsInsideValueClass.kt") + public void testReservedMembersAndConstructsInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt"); + } + + @TestMetadata("unsignedLiteralsWithoutArtifactOnClasspath.kt") + public void testUnsignedLiteralsWithoutArtifactOnClasspath() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt"); + } + + @TestMetadata("valueClassCanOnlyImplementInterfaces.kt") + public void testValueClassCanOnlyImplementInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt"); + } + + @TestMetadata("valueClassCannotImplementInterfaceByDelegation.kt") + public void testValueClassCannotImplementInterfaceByDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt"); + } + + @TestMetadata("valueClassConstructorParameterWithDefaultValue.kt") + public void testValueClassConstructorParameterWithDefaultValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt"); + } + + @TestMetadata("valueClassDeclarationCheck.kt") + public void testValueClassDeclarationCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt"); + } + + @TestMetadata("valueClassImplementsCollection.kt") + public void testValueClassImplementsCollection() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt"); + } + + @TestMetadata("valueClassWithForbiddenUnderlyingType.kt") + public void testValueClassWithForbiddenUnderlyingType() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt"); + } + + @TestMetadata("valueClassesInsideAnnotations.kt") + public void testValueClassesInsideAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt"); + } + + @TestMetadata("varargsOnParametersOfValueClassType.kt") + public void testVarargsOnParametersOfValueClassType() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt"); + } + } + @TestMetadata("compiler/testData/diagnostics/tests/varargs") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 821a05c031e..61b37a840b8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -362,6 +362,7 @@ public interface Errors { DiagnosticFactory0 INLINE_CLASS_CANNOT_BE_RECURSIVE = DiagnosticFactory0.create(ERROR); DiagnosticFactory1 RESERVED_MEMBER_INSIDE_INLINE_CLASS = DiagnosticFactory1.create(ERROR); DiagnosticFactory0 SECONDARY_CONSTRUCTOR_WITH_BODY_INSIDE_INLINE_CLASS = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 VALUE_CLASS_WITHOUT_JVM_INLINE_ANNOTATION = DiagnosticFactory0.create(ERROR); // Result class diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index b67d915a45d..deb9aa147dd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -717,6 +717,7 @@ public class DefaultErrorMessages { MAP.put(INLINE_CLASS_CANNOT_BE_RECURSIVE, "Inline class cannot be recursive"); MAP.put(RESERVED_MEMBER_INSIDE_INLINE_CLASS, "Member with the name ''{0}'' is reserved for future releases", STRING); MAP.put(SECONDARY_CONSTRUCTOR_WITH_BODY_INSIDE_INLINE_CLASS, "Secondary constructors with bodies are reserved for for future releases"); + MAP.put(VALUE_CLASS_WITHOUT_JVM_INLINE_ANNOTATION, "Value classes without @JvmInline annotation are not supported yet"); MAP.put(RESULT_CLASS_IN_RETURN_TYPE, "'kotlin.Result' cannot be used as a return type"); MAP.put(RESULT_CLASS_WITH_NULLABLE_OPERATOR, "Expression of type 'kotlin.Result' cannot be used as a left operand of ''{0}''", STRING); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt index 42fea2834eb..f7220cd0efe 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt @@ -270,7 +270,7 @@ class DeclarationsChecker( if (declaration is KtPrimaryConstructor && !DescriptorUtils.isAnnotationClass(constructorDescriptor.constructedClass) && - !constructorDescriptor.constructedClass.isInline + !constructorDescriptor.constructedClass.isInlineClass() ) { for (parameter in declaration.valueParameters) { if (parameter.hasValOrVar()) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt index 33fda2c6791..cd212c74625 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt @@ -107,7 +107,8 @@ object ModifierCheckerCore { ANNOTATION_CLASS, TYPEALIAS ), - FUN_KEYWORD to EnumSet.of(INTERFACE) + FUN_KEYWORD to EnumSet.of(INTERFACE), + VALUE_KEYWORD to EnumSet.of(CLASS_ONLY) ) private val featureDependencies = mapOf( @@ -118,7 +119,8 @@ object ModifierCheckerCore { EXPECT_KEYWORD to listOf(LanguageFeature.MultiPlatformProjects), ACTUAL_KEYWORD to listOf(LanguageFeature.MultiPlatformProjects), LATEINIT_KEYWORD to listOf(LanguageFeature.LateinitTopLevelProperties, LanguageFeature.LateinitLocalVariables), - FUN_KEYWORD to listOf(LanguageFeature.FunctionalInterfaceConversion) + FUN_KEYWORD to listOf(LanguageFeature.FunctionalInterfaceConversion), + VALUE_KEYWORD to listOf(LanguageFeature.InlineClasses) ) private val featureDependenciesTargets = mapOf( @@ -185,12 +187,13 @@ object ModifierCheckerCore { result += incompatibilityRegister(PRIVATE_KEYWORD, PROTECTED_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD) // Abstract + open + final + sealed: incompatible result += incompatibilityRegister(ABSTRACT_KEYWORD, OPEN_KEYWORD, FINAL_KEYWORD, SEALED_KEYWORD) - // data + open, data + inner, data + abstract, data + sealed, data + inline + // data + open, data + inner, data + abstract, data + sealed, data + inline, data + value result += incompatibilityRegister(DATA_KEYWORD, OPEN_KEYWORD) result += incompatibilityRegister(DATA_KEYWORD, INNER_KEYWORD) result += incompatibilityRegister(DATA_KEYWORD, ABSTRACT_KEYWORD) result += incompatibilityRegister(DATA_KEYWORD, SEALED_KEYWORD) result += incompatibilityRegister(DATA_KEYWORD, INLINE_KEYWORD) + result += incompatibilityRegister(DATA_KEYWORD, VALUE_KEYWORD) // open is redundant to abstract & override result += redundantRegister(ABSTRACT_KEYWORD, OPEN_KEYWORD) // abstract is redundant to sealed diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt index b5f3decc39d..4d8bc1f6060 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt @@ -9,9 +9,9 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.modalityModifier -import org.jetbrains.kotlin.psi.psiUtil.visibilityModifier import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.typeUtil.isNothing @@ -22,15 +22,16 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs object InlineClassDeclarationChecker : DeclarationChecker { override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { if (declaration !is KtClass) return - if (descriptor !is ClassDescriptor || !descriptor.isInline) return + if (descriptor !is ClassDescriptor || !descriptor.isInline && !descriptor.isValue) return if (descriptor.kind != ClassKind.CLASS) return - val inlineKeyword = declaration.modifierList?.getModifier(KtTokens.INLINE_KEYWORD) - require(inlineKeyword != null) { "Declaration of inline class must have 'inline' keyword" } + val inlineOrValueKeyword = declaration.modifierList?.getModifier(KtTokens.INLINE_KEYWORD) + ?: declaration.modifierList?.getModifier(KtTokens.VALUE_KEYWORD) + require(inlineOrValueKeyword != null) { "Declaration of inline class must have 'inline' keyword" } val trace = context.trace if (!DescriptorUtils.isTopLevelDeclaration(descriptor)) { - trace.report(Errors.INLINE_CLASS_NOT_TOP_LEVEL.on(inlineKeyword)) + trace.report(Errors.INLINE_CLASS_NOT_TOP_LEVEL.on(inlineOrValueKeyword)) return } @@ -42,7 +43,7 @@ object InlineClassDeclarationChecker : DeclarationChecker { val primaryConstructor = declaration.primaryConstructor if (primaryConstructor == null) { - trace.report(Errors.ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_INLINE_CLASS.on(inlineKeyword)) + trace.report(Errors.ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_INLINE_CLASS.on(inlineOrValueKeyword)) return } @@ -87,6 +88,10 @@ object InlineClassDeclarationChecker : DeclarationChecker { } } } + + if (descriptor.isValue && !descriptor.annotations.hasAnnotation(JVM_INLINE_ANNOTATION)) { + trace.report(Errors.VALUE_CLASS_WITHOUT_JVM_INLINE_ANNOTATION.on(inlineOrValueKeyword)) + } } private fun KotlinType.isInapplicableParameterType() = diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt index c1b429f25d0..089a712515c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt @@ -258,7 +258,7 @@ open class LazyClassMemberScope( name: Name, fromSupertypes: List ) { - if (!thisDescriptor.isInline) return + if (!thisDescriptor.isInlineClass()) return addFunctionFromAnyIfNeeded(result, name, fromSupertypes) } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt index 2ee83228ff0..0ffed6b9f03 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt @@ -32,6 +32,7 @@ import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource @@ -274,7 +275,7 @@ class DeclarationStubGenerator( isInner = descriptor.isInner, isData = descriptor.isData, isExternal = descriptor.isEffectivelyExternal(), - isInline = descriptor.isInline, + isInline = descriptor.isInlineClass(), isExpect = descriptor.isExpect, isFun = descriptor.isFun, stubGenerator = this, diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorToIrUtil.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorToIrUtil.kt index bfd6370d3d6..006dfcbdd5a 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorToIrUtil.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorToIrUtil.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.ir.declarations.IrFactory import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.types.KotlinType val ParameterDescriptor.indexOrMinusOne: Int @@ -38,5 +39,5 @@ fun IrFactory.createIrClassFromDescriptor( ): IrClass = createClass( startOffset, endOffset, origin, symbol, name, descriptor.kind, visibility, modality, descriptor.isCompanionObject, descriptor.isInner, descriptor.isData, descriptor.isEffectivelyExternal(), - descriptor.isInline, descriptor.isExpect, descriptor.isFun, descriptor.source + descriptor.isInlineClass(), descriptor.isExpect, descriptor.isFun, descriptor.source ) diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtClass.kt b/compiler/psi/src/org/jetbrains/kotlin/psi/KtClass.kt index 7769c36d28d..9c88e1c59df 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtClass.kt +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtClass.kt @@ -33,6 +33,7 @@ open class KtClass : KtClassOrObject { fun isSealed(): Boolean = hasModifier(KtTokens.SEALED_KEYWORD) fun isInner(): Boolean = hasModifier(KtTokens.INNER_KEYWORD) fun isInline(): Boolean = hasModifier(KtTokens.INLINE_KEYWORD) + fun isValue(): Boolean = hasModifier(KtTokens.VALUE_KEYWORD) override fun getCompanionObjects(): List = body?.allCompanionObjects.orEmpty() diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt index e9bb36cf332..6ead2068679 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt @@ -23,10 +23,8 @@ import org.jetbrains.kotlin.metadata.serialization.MutableTypeTable import org.jetbrains.kotlin.metadata.serialization.MutableVersionRequirementTable import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry -import org.jetbrains.kotlin.resolve.MemberComparator -import org.jetbrains.kotlin.resolve.RequireKotlinConstants import org.jetbrains.kotlin.resolve.calls.components.isActualParameterWithAnyExpectedDefault import org.jetbrains.kotlin.resolve.constants.EnumValue import org.jetbrains.kotlin.resolve.constants.IntValue @@ -34,7 +32,6 @@ import org.jetbrains.kotlin.resolve.constants.NullValue import org.jetbrains.kotlin.resolve.constants.StringValue import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.descriptorUtil.nonSourceAnnotations -import org.jetbrains.kotlin.resolve.isInlineClassType import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility import org.jetbrains.kotlin.serialization.deserialization.memberKind @@ -74,7 +71,7 @@ class DescriptorSerializer private constructor( ProtoEnumFlags.modality(classDescriptor.modality), ProtoEnumFlags.classKind(classDescriptor.kind, classDescriptor.isCompanionObject), classDescriptor.isInner, classDescriptor.isData, classDescriptor.isExternal, classDescriptor.isExpect, - classDescriptor.isInline, classDescriptor.isFun + classDescriptor.isInlineClass(), classDescriptor.isFun ) if (flags != builder.flags) { builder.flags = flags @@ -173,7 +170,7 @@ class DescriptorSerializer private constructor( builder: ProtoBuf.Class.Builder, versionRequirementTable: MutableVersionRequirementTable ) { - if (!classDescriptor.isInline && !classDescriptor.hasInlineClassTypesInSignature()) return + if (!classDescriptor.isInlineClass() && !classDescriptor.hasInlineClassTypesInSignature()) return builder.addVersionRequirement( writeLanguageVersionRequirement(LanguageFeature.InlineClasses, versionRequirementTable) diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.fir.kt new file mode 100644 index 00000000000..2dee1eb7ee7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.fir.kt @@ -0,0 +1,13 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: Int) + +value interface InlineInterface +value annotation class InlineAnn +value object InlineObject +value enum class InlineEnum diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt new file mode 100644 index 00000000000..3bdc892c700 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt @@ -0,0 +1,13 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: Int) + +value interface InlineInterface +value annotation class InlineAnn +value object InlineObject +value enum class InlineEnum diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.txt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.txt new file mode 100644 index 00000000000..c98b37739ef --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.txt @@ -0,0 +1,56 @@ +package + +package kotlin { + + @kotlin.JvmInline public final value class Foo { + public constructor Foo(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final value annotation class InlineAnn : kotlin.Annotation { + public constructor InlineAnn() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final value enum class InlineEnum : kotlin.Enum { + private constructor InlineEnum() + public final override /*1*/ /*fake_override*/ val name: kotlin.String + public final override /*1*/ /*fake_override*/ val ordinal: kotlin.Int + protected final override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: kotlin.InlineEnum): kotlin.Int + public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + protected/*protected and package*/ final override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun finalize(): kotlin.Unit + public final override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun getDeclaringClass(): java.lang.Class! + public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): kotlin.InlineEnum + public final /*synthesized*/ fun values(): kotlin.Array + } + + public value interface InlineInterface { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public value object InlineObject { + private constructor InlineObject() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.fir.kt new file mode 100644 index 00000000000..161e5275090 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.fir.kt @@ -0,0 +1,15 @@ +// !LANGUAGE: -InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +value class Foo(val x: Int) + +value annotation class InlineAnn +value object InlineObject +value enum class InlineEnum + +@JvmInline +value class NotVal(x: Int) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt new file mode 100644 index 00000000000..e018281ab16 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt @@ -0,0 +1,15 @@ +// !LANGUAGE: -InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +value class Foo(val x: Int) + +value annotation class InlineAnn +value object InlineObject +value enum class InlineEnum + +@JvmInline +value class NotVal(x: Int) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.txt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.txt new file mode 100644 index 00000000000..3a25001d966 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.txt @@ -0,0 +1,57 @@ +package + +package kotlin { + + public final value class Foo { + public constructor Foo(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final value annotation class InlineAnn : kotlin.Annotation { + public constructor InlineAnn() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final value enum class InlineEnum : kotlin.Enum { + private constructor InlineEnum() + public final override /*1*/ /*fake_override*/ val name: kotlin.String + public final override /*1*/ /*fake_override*/ val ordinal: kotlin.Int + protected final override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: kotlin.InlineEnum): kotlin.Int + public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + protected/*protected and package*/ final override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun finalize(): kotlin.Unit + public final override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun getDeclaringClass(): java.lang.Class! + public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): kotlin.InlineEnum + public final /*synthesized*/ fun values(): kotlin.Array + } + + public value object InlineObject { + private constructor InlineObject() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class NotVal { + public constructor NotVal(/*0*/ x: kotlin.Int) + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.fir.kt new file mode 100644 index 00000000000..fbef2363032 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.fir.kt @@ -0,0 +1,24 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +@JvmInline +value class X(val x: Int) +@JvmInline +value class Z(val x: Int) + +class TestOk1(val a: Int, val b: Int) { + constructor(x: X) : this(x.x, 1) +} + +class TestErr1(val a: Int) { + constructor(x: X) : this(x.x) +} + +class TestErr2(val a: Int, val b: Int) { + constructor(x: X) : this(x.x, 1) + constructor(z: Z) : this(z.x, 2) +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt new file mode 100644 index 00000000000..96577da92e1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt @@ -0,0 +1,24 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +@JvmInline +value class X(val x: Int) +@JvmInline +value class Z(val x: Int) + +class TestOk1(val a: Int, val b: Int) { + constructor(x: X) : this(x.x, 1) +} + +class TestErr1(val a: Int) { + constructor(x: X) : this(x.x) +} + +class TestErr2(val a: Int, val b: Int) { + constructor(x: X) : this(x.x, 1) + constructor(z: Z) : this(z.x, 2) +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.txt b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.txt new file mode 100644 index 00000000000..6fc4c16ec8a --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.txt @@ -0,0 +1,57 @@ +package + +package kotlin { + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final class TestErr1 { + public constructor TestErr1(/*0*/ a: kotlin.Int) + public constructor TestErr1(/*0*/ x: kotlin.X) + public final val a: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final class TestErr2 { + public constructor TestErr2(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Int) + public constructor TestErr2(/*0*/ x: kotlin.X) + public constructor TestErr2(/*0*/ z: kotlin.Z) + public final val a: kotlin.Int + public final val b: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final class TestOk1 { + public constructor TestOk1(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Int) + public constructor TestOk1(/*0*/ x: kotlin.X) + public final val a: kotlin.Int + public final val b: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class X { + public constructor X(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Z { + public constructor Z(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.fir.kt new file mode 100644 index 00000000000..c1e7abba11b --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.fir.kt @@ -0,0 +1,33 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +class Val { + operator fun getValue(thisRef: Any?, kProp: Any?) = 1 +} + +class Var { + operator fun getValue(thisRef: Any?, kProp: Any?) = 2 + operator fun setValue(thisRef: Any?, kProp: Any?, value: Int) {} +} + + +object ValObject { + operator fun getValue(thisRef: Any?, kProp: Any?) = 1 +} + +object VarObject { + operator fun getValue(thisRef: Any?, kProp: Any?) = 2 + operator fun setValue(thisRef: Any?, kProp: Any?, value: Int) {} +} + +@JvmInline +value class Z(val data: Int) { + val testVal by Val() + var testVar by Var() + + val testValBySingleton by ValObject + var testVarBySingleton by VarObject +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt new file mode 100644 index 00000000000..5b9079fa89f --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt @@ -0,0 +1,33 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +class Val { + operator fun getValue(thisRef: Any?, kProp: Any?) = 1 +} + +class Var { + operator fun getValue(thisRef: Any?, kProp: Any?) = 2 + operator fun setValue(thisRef: Any?, kProp: Any?, value: Int) {} +} + + +object ValObject { + operator fun getValue(thisRef: Any?, kProp: Any?) = 1 +} + +object VarObject { + operator fun getValue(thisRef: Any?, kProp: Any?) = 2 + operator fun setValue(thisRef: Any?, kProp: Any?, value: Int) {} +} + +@JvmInline +value class Z(val data: Int) { + val testVal by Val() + var testVar by Var() + + val testValBySingleton by ValObject + var testVarBySingleton by VarObject +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.txt b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.txt new file mode 100644 index 00000000000..ebb31a9479f --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.txt @@ -0,0 +1,57 @@ +package + +package kotlin { + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final class Val { + public constructor Val() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final operator fun getValue(/*0*/ thisRef: kotlin.Any?, /*1*/ kProp: kotlin.Any?): kotlin.Int + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public object ValObject { + private constructor ValObject() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final operator fun getValue(/*0*/ thisRef: kotlin.Any?, /*1*/ kProp: kotlin.Any?): kotlin.Int + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final class Var { + public constructor Var() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final operator fun getValue(/*0*/ thisRef: kotlin.Any?, /*1*/ kProp: kotlin.Any?): kotlin.Int + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final operator fun setValue(/*0*/ thisRef: kotlin.Any?, /*1*/ kProp: kotlin.Any?, /*2*/ value: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public object VarObject { + private constructor VarObject() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final operator fun getValue(/*0*/ thisRef: kotlin.Any?, /*1*/ kProp: kotlin.Any?): kotlin.Int + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final operator fun setValue(/*0*/ thisRef: kotlin.Any?, /*1*/ kProp: kotlin.Any?, /*2*/ value: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Z { + public constructor Z(/*0*/ data: kotlin.Int) + public final val data: kotlin.Int + public final val testVal: kotlin.Int + public final val testValBySingleton: kotlin.Int + public final var testVar: kotlin.Int + public final var testVarBySingleton: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.fir.kt new file mode 100644 index 00000000000..dff6941bf0d --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.fir.kt @@ -0,0 +1,46 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +@JvmInline +value class X(val x: Int) +@JvmInline +value class Z(val x: Int) +@JvmInline +value class Str(val str: String) +@JvmInline +value class Name(val name: String) +@JvmInline +value class NStr(val str: String?) + +fun testSimple(x: X) {} +fun testSimple(z: Z) {} + +fun testMixed(x: Int, y: Int) {} +fun testMixed(x: X, y: Int) {} +fun testMixed(x: Int, y: X) {} +fun testMixed(x: X, y: X) {} + +fun testNewType(s: Str) {} +fun testNewType(name: Name) {} + +fun testNullableVsNonNull1(s: Str) {} +fun testNullableVsNonNull1(s: Str?) {} + +fun testNullableVsNonNull2(ns: NStr) {} +fun testNullableVsNonNull2(ns: NStr?) {} + +fun testFunVsExt(x: X) {} +fun X.testFunVsExt() {} + +fun testNonGenericVsGeneric(x: X, y: Number) {} +fun testNonGenericVsGeneric(x: X, y: T) {} + +class C { + fun testNonGenericVsGeneric(x: X, y: Number) {} + fun testNonGenericVsGeneric(x: X, y: T) {} + fun testNonGenericVsGeneric(x: X, y: TC) {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt new file mode 100644 index 00000000000..1222ff952f8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt @@ -0,0 +1,46 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +@JvmInline +value class X(val x: Int) +@JvmInline +value class Z(val x: Int) +@JvmInline +value class Str(val str: String) +@JvmInline +value class Name(val name: String) +@JvmInline +value class NStr(val str: String?) + +fun testSimple(x: X) {} +fun testSimple(z: Z) {} + +fun testMixed(x: Int, y: Int) {} +fun testMixed(x: X, y: Int) {} +fun testMixed(x: Int, y: X) {} +fun testMixed(x: X, y: X) {} + +fun testNewType(s: Str) {} +fun testNewType(name: Name) {} + +fun testNullableVsNonNull1(s: Str) {} +fun testNullableVsNonNull1(s: Str?) {} + +fun testNullableVsNonNull2(ns: NStr) {} +fun testNullableVsNonNull2(ns: NStr?) {} + +fun testFunVsExt(x: X) {} +fun X.testFunVsExt() {} + +fun testNonGenericVsGeneric(x: X, y: Number) {} +fun testNonGenericVsGeneric(x: X, y: T) {} + +class C { + fun testNonGenericVsGeneric(x: X, y: Number) {} + fun testNonGenericVsGeneric(x: X, y: T) {} + fun testNonGenericVsGeneric(x: X, y: TC) {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.txt b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.txt new file mode 100644 index 00000000000..d33a5eded5f --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.txt @@ -0,0 +1,77 @@ +package + +package kotlin { + public fun testFunVsExt(/*0*/ x: kotlin.X): kotlin.Unit + public fun testMixed(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int): kotlin.Unit + public fun testMixed(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.X): kotlin.Unit + public fun testMixed(/*0*/ x: kotlin.X, /*1*/ y: kotlin.Int): kotlin.Unit + public fun testMixed(/*0*/ x: kotlin.X, /*1*/ y: kotlin.X): kotlin.Unit + public fun testNewType(/*0*/ name: kotlin.Name): kotlin.Unit + public fun testNewType(/*0*/ s: kotlin.Str): kotlin.Unit + public fun testNonGenericVsGeneric(/*0*/ x: kotlin.X, /*1*/ y: T): kotlin.Unit + public fun testNonGenericVsGeneric(/*0*/ x: kotlin.X, /*1*/ y: kotlin.Number): kotlin.Unit + public fun testNullableVsNonNull1(/*0*/ s: kotlin.Str): kotlin.Unit + public fun testNullableVsNonNull1(/*0*/ s: kotlin.Str?): kotlin.Unit + public fun testNullableVsNonNull2(/*0*/ ns: kotlin.NStr): kotlin.Unit + public fun testNullableVsNonNull2(/*0*/ ns: kotlin.NStr?): kotlin.Unit + public fun testSimple(/*0*/ x: kotlin.X): kotlin.Unit + public fun testSimple(/*0*/ z: kotlin.Z): kotlin.Unit + public fun kotlin.X.testFunVsExt(): kotlin.Unit + + public final class C { + public constructor C() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final fun testNonGenericVsGeneric(/*0*/ x: kotlin.X, /*1*/ y: T): kotlin.Unit + public final fun testNonGenericVsGeneric(/*0*/ x: kotlin.X, /*1*/ y: TC): kotlin.Unit + public final fun testNonGenericVsGeneric(/*0*/ x: kotlin.X, /*1*/ y: kotlin.Number): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class NStr { + public constructor NStr(/*0*/ str: kotlin.String?) + public final val str: kotlin.String? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Name { + public constructor Name(/*0*/ name: kotlin.String) + public final val name: kotlin.String + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Str { + public constructor Str(/*0*/ str: kotlin.String) + public final val str: kotlin.String + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class X { + public constructor X(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Z { + public constructor Z(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt new file mode 100644 index 00000000000..d261567326b --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt @@ -0,0 +1,21 @@ +// FIR_IDENTICAL +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Name(val name: String) +@JvmInline +value class Password(val password: String) + +interface NameVerifier { + fun verify(name: Name) +} + +interface PasswordVerifier { + fun verify(password: Password) +} + +interface NameAndPasswordVerifier : NameVerifier, PasswordVerifier diff --git a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.txt b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.txt new file mode 100644 index 00000000000..cc538ec3809 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.txt @@ -0,0 +1,49 @@ +package + +package kotlin { + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Name { + public constructor Name(/*0*/ name: kotlin.String) + public final val name: kotlin.String + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public interface NameAndPasswordVerifier : kotlin.NameVerifier, kotlin.PasswordVerifier { + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + public abstract override /*1*/ /*fake_override*/ fun verify(/*0*/ name: kotlin.Name): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun verify(/*0*/ password: kotlin.Password): kotlin.Unit + } + + public interface NameVerifier { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public abstract fun verify(/*0*/ name: kotlin.Name): kotlin.Unit + } + + @kotlin.JvmInline public final value class Password { + public constructor Password(/*0*/ password: kotlin.String) + public final val password: kotlin.String + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public interface PasswordVerifier { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public abstract fun verify(/*0*/ password: kotlin.Password): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.fir.kt new file mode 100644 index 00000000000..a5f2b180bc4 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.fir.kt @@ -0,0 +1,21 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_VARIABLE + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: Int) +@JvmInline +value class Bar(val y: String) + +fun test(f1: Foo, f2: Foo, b1: Bar, fn1: Foo?, fn2: Foo?) { + val a1 = f1 === f2 || f1 !== f2 + val a2 = f1 === f1 + val a3 = f1 === b1 || f1 !== b1 + + val c1 = fn1 === fn2 || fn1 !== fn2 + val c2 = f1 === fn1 || f1 !== fn1 + val c3 = b1 === fn1 || b1 !== fn1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt new file mode 100644 index 00000000000..d9f52a94153 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt @@ -0,0 +1,21 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_VARIABLE + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: Int) +@JvmInline +value class Bar(val y: String) + +fun test(f1: Foo, f2: Foo, b1: Bar, fn1: Foo?, fn2: Foo?) { + val a1 = f1 === f2 || f1 !== f2 + val a2 = f1 === f1 + val a3 = f1 === b1 || f1 !== b1 + + val c1 = fn1 === fn2 || fn1 !== fn2 + val c2 = f1 === fn1 || f1 !== fn1 + val c3 = b1 === fn1 || b1 !== fn1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.txt b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.txt new file mode 100644 index 00000000000..545009b9063 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.txt @@ -0,0 +1,28 @@ +package + +package kotlin { + public fun test(/*0*/ f1: kotlin.Foo, /*1*/ f2: kotlin.Foo, /*2*/ b1: kotlin.Bar, /*3*/ fn1: kotlin.Foo?, /*4*/ fn2: kotlin.Foo?): kotlin.Unit + + @kotlin.JvmInline public final value class Bar { + public constructor Bar(/*0*/ y: kotlin.String) + public final val y: kotlin.String + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Foo { + public constructor Foo(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.fir.kt new file mode 100644 index 00000000000..87423ad5b0c --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.fir.kt @@ -0,0 +1,15 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_VARIABLE + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: Int) + +lateinit var a: Foo + +fun foo() { + lateinit var b: Foo +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt new file mode 100644 index 00000000000..ccf4cc8d6b8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt @@ -0,0 +1,15 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_VARIABLE + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: Int) + +lateinit var a: Foo + +fun foo() { + lateinit var b: Foo +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.txt b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.txt new file mode 100644 index 00000000000..dc071c62ae3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.txt @@ -0,0 +1,21 @@ +package + +package kotlin { + public lateinit var a: kotlin.Foo + public fun foo(): kotlin.Unit + + @kotlin.JvmInline public final value class Foo { + public constructor Foo(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt new file mode 100644 index 00000000000..f85a8c6367b --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt @@ -0,0 +1,16 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_VARIABLE +// FIR_IDENTICAL + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: Int) { + init {} + + init { + val f = 1 + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.txt b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.txt new file mode 100644 index 00000000000..d8feb9201fe --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.txt @@ -0,0 +1,19 @@ +package + +package kotlin { + + @kotlin.JvmInline public final value class Foo { + public constructor Foo(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt new file mode 100644 index 00000000000..f03ff14c317 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt @@ -0,0 +1,17 @@ +// !LANGUAGE: +InlineClasses +// FIR_IDENTICAL + +package kotlin + +annotation class JvmInline + +@JvmInline +value class ConstructorWithDefaultVisibility(val x: Int) +@JvmInline +value class PublicConstructor public constructor(val x: Int) +@JvmInline +value class InternalConstructor internal constructor(val x: Int) +@JvmInline +value class ProtectedConstructor protected constructor(val x: Int) +@JvmInline +value class PrivateConstructor private constructor(val x: Int) diff --git a/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.txt b/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.txt new file mode 100644 index 00000000000..b7859ca179b --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.txt @@ -0,0 +1,51 @@ +package + +package kotlin { + + @kotlin.JvmInline public final value class ConstructorWithDefaultVisibility { + public constructor ConstructorWithDefaultVisibility(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class InternalConstructor { + internal constructor InternalConstructor(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class PrivateConstructor { + private constructor PrivateConstructor(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class ProtectedConstructor { + protected constructor ProtectedConstructor(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class PublicConstructor { + public constructor PublicConstructor(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.fir.kt new file mode 100644 index 00000000000..8e53c287b85 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.fir.kt @@ -0,0 +1,39 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +interface A { + val goodSize: Int +} + +interface B { + val badSize: Int +} + +@JvmInline +value class Foo(val x: Int) : A, B { + val a0 + get() = 0 + + val a1 = 0 + + var a2: Int + get() = 1 + set(value) {} + + var a3: Int = 0 + get() = 1 + set(value) { + field = value + } + + override val goodSize: Int + get() = 0 + + override val badSize: Int = 0 + + lateinit var lateinitProperty: String +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt new file mode 100644 index 00000000000..721bbd69342 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt @@ -0,0 +1,39 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +interface A { + val goodSize: Int +} + +interface B { + val badSize: Int +} + +@JvmInline +value class Foo(val x: Int) : A, B { + val a0 + get() = 0 + + val a1 = 0 + + var a2: Int + get() = 1 + set(value) {} + + var a3: Int = 0 + get() = 1 + set(value) { + field = value + } + + override val goodSize: Int + get() = 0 + + override val badSize: Int = 0 + + lateinit var lateinitProperty: String +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.txt b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.txt new file mode 100644 index 00000000000..9540353f79b --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.txt @@ -0,0 +1,40 @@ +package + +package kotlin { + + public interface A { + public abstract val goodSize: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface B { + public abstract val badSize: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Foo : kotlin.A, kotlin.B { + public constructor Foo(/*0*/ x: kotlin.Int) + public final val a0: kotlin.Int + public final val a1: kotlin.Int = 0 + public final var a2: kotlin.Int + public final var a3: kotlin.Int + public open override /*1*/ val badSize: kotlin.Int = 0 + public open override /*1*/ val goodSize: kotlin.Int + public final lateinit var lateinitProperty: kotlin.String + public final val x: kotlin.Int + public open override /*2*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*2*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.fir.kt new file mode 100644 index 00000000000..c06db3a2dca --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.fir.kt @@ -0,0 +1,37 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Test1(val x: Test1) + +@JvmInline +value class Test2A(val x: Test2B) +@JvmInline +value class Test2B(val x: Test2A) + +@JvmInline +value class Test3A(val x: Test3B) +@JvmInline +value class Test3B(val x: Test3C) +@JvmInline +value class Test3C(val x: Test3A) + +@JvmInline +value class TestNullable(val x: TestNullable?) + +@JvmInline +value class TestRecursionInTypeArguments(val x: List) + +@JvmInline +value class TestRecursionInArray(val x: Array) + +@JvmInline +value class TestRecursionInUpperBounds>(val x: T) + +@JvmInline +value class Id(val x: T) +@JvmInline +value class TestRecursionThroughId(val x: Id) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt new file mode 100644 index 00000000000..e4c385fb711 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt @@ -0,0 +1,37 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Test1(val x: Test1) + +@JvmInline +value class Test2A(val x: Test2B) +@JvmInline +value class Test2B(val x: Test2A) + +@JvmInline +value class Test3A(val x: Test3B) +@JvmInline +value class Test3B(val x: Test3C) +@JvmInline +value class Test3C(val x: Test3A) + +@JvmInline +value class TestNullable(val x: TestNullable?) + +@JvmInline +value class TestRecursionInTypeArguments(val x: List) + +@JvmInline +value class TestRecursionInArray(val x: Array) + +@JvmInline +value class TestRecursionInUpperBounds>(val x: T) + +@JvmInline +value class Id(val x: T) +@JvmInline +value class TestRecursionThroughId(val x: Id) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.txt b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.txt new file mode 100644 index 00000000000..93f9a69949d --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.txt @@ -0,0 +1,107 @@ +package + +package kotlin { + + @kotlin.JvmInline public final value class Id { + public constructor Id(/*0*/ x: T) + public final val x: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Test1 { + public constructor Test1(/*0*/ x: kotlin.Test1) + public final val x: kotlin.Test1 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Test2A { + public constructor Test2A(/*0*/ x: kotlin.Test2B) + public final val x: kotlin.Test2B + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Test2B { + public constructor Test2B(/*0*/ x: kotlin.Test2A) + public final val x: kotlin.Test2A + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Test3A { + public constructor Test3A(/*0*/ x: kotlin.Test3B) + public final val x: kotlin.Test3B + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Test3B { + public constructor Test3B(/*0*/ x: kotlin.Test3C) + public final val x: kotlin.Test3C + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Test3C { + public constructor Test3C(/*0*/ x: kotlin.Test3A) + public final val x: kotlin.Test3A + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class TestNullable { + public constructor TestNullable(/*0*/ x: kotlin.TestNullable?) + public final val x: kotlin.TestNullable? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class TestRecursionInArray { + public constructor TestRecursionInArray(/*0*/ x: kotlin.Array) + public final val x: kotlin.Array + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class TestRecursionInTypeArguments { + public constructor TestRecursionInTypeArguments(/*0*/ x: kotlin.collections.List) + public final val x: kotlin.collections.List + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class TestRecursionInUpperBounds> { + public constructor TestRecursionInUpperBounds>(/*0*/ x: T) + public final val x: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class TestRecursionThroughId { + public constructor TestRecursionThroughId(/*0*/ x: kotlin.Id) + public final val x: kotlin.Id + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.fir.kt new file mode 100644 index 00000000000..c11e22f5d74 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.fir.kt @@ -0,0 +1,54 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +@JvmInline +value class IC1(val x: Any) { + fun box() {} + fun box(x: Any) {} + + fun unbox() {} + fun unbox(x: Any) {} + + override fun equals(other: Any?): Boolean = true + override fun hashCode(): Int = 0 +} + +@JvmInline +value class IC2(val x: Any) { + fun box(x: Any) {} + fun box(): Any = TODO() + + fun unbox(x: Any) {} + fun unbox(): Any = TODO() + + fun equals(my: Any, other: Any): Boolean = true + fun hashCode(a: Any): Int = 0 +} + +@JvmInline +value class IC3(val x: Any) { + fun box(x: Any): Any = TODO() + fun unbox(x: Any): Any = TODO() + + fun equals(): Boolean = true +} + +interface WithBox { + fun box(): String +} + +@JvmInline +value class IC4(val s: String) : WithBox { + override fun box(): String = "" +} + +@JvmInline +value class IC5(val a: String) { + constructor(i: Int) : this(i.toString()) { + TODO("something") + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt new file mode 100644 index 00000000000..2ed4dabb480 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt @@ -0,0 +1,54 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +annotation class JvmInline + +@JvmInline +value class IC1(val x: Any) { + fun box() {} + fun box(x: Any) {} + + fun unbox() {} + fun unbox(x: Any) {} + + override fun equals(other: Any?): Boolean = true + override fun hashCode(): Int = 0 +} + +@JvmInline +value class IC2(val x: Any) { + fun box(x: Any) {} + fun box(): Any = TODO() + + fun unbox(x: Any) {} + fun unbox(): Any = TODO() + + fun equals(my: Any, other: Any): Boolean = true + fun hashCode(a: Any): Int = 0 +} + +@JvmInline +value class IC3(val x: Any) { + fun box(x: Any): Any = TODO() + fun unbox(x: Any): Any = TODO() + + fun equals(): Boolean = true +} + +interface WithBox { + fun box(): String +} + +@JvmInline +value class IC4(val s: String) : WithBox { + override fun box(): String = "" +} + +@JvmInline +value class IC5(val a: String) { + constructor(i: Int) : this(i.toString()) { + TODO("something") + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.txt b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.txt new file mode 100644 index 00000000000..98b1db49c3e --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.txt @@ -0,0 +1,73 @@ +package + +package kotlin { + + @kotlin.JvmInline public final value class IC1 { + public constructor IC1(/*0*/ x: kotlin.Any) + public final val x: kotlin.Any + public final fun box(): kotlin.Unit + public final fun box(/*0*/ x: kotlin.Any): kotlin.Unit + public open override /*1*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + public final fun unbox(): kotlin.Unit + public final fun unbox(/*0*/ x: kotlin.Any): kotlin.Unit + } + + @kotlin.JvmInline public final value class IC2 { + public constructor IC2(/*0*/ x: kotlin.Any) + public final val x: kotlin.Any + public final fun box(): kotlin.Any + public final fun box(/*0*/ x: kotlin.Any): kotlin.Unit + public final fun equals(/*0*/ my: kotlin.Any, /*1*/ other: kotlin.Any): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public final fun hashCode(/*0*/ a: kotlin.Any): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + public final fun unbox(): kotlin.Any + public final fun unbox(/*0*/ x: kotlin.Any): kotlin.Unit + } + + @kotlin.JvmInline public final value class IC3 { + public constructor IC3(/*0*/ x: kotlin.Any) + public final val x: kotlin.Any + public final fun box(/*0*/ x: kotlin.Any): kotlin.Any + public final fun equals(): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + public final fun unbox(/*0*/ x: kotlin.Any): kotlin.Any + } + + @kotlin.JvmInline public final value class IC4 : kotlin.WithBox { + public constructor IC4(/*0*/ s: kotlin.String) + public final val s: kotlin.String + public open override /*1*/ fun box(): kotlin.String + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class IC5 { + public constructor IC5(/*0*/ i: kotlin.Int) + public constructor IC5(/*0*/ a: kotlin.String) + public final val a: kotlin.String + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface WithBox { + public abstract fun box(): kotlin.String + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.fir.kt new file mode 100644 index 00000000000..7fa08d2d9a9 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.fir.kt @@ -0,0 +1,3 @@ +val u1 = 1u +val u2 = 0xFu +val u3 = 0b1u \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt b/compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt new file mode 100644 index 00000000000..6cf80093333 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt @@ -0,0 +1,3 @@ +val u1 = 1u +val u2 = 0xFu +val u3 = 0b1u \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.txt b/compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.txt new file mode 100644 index 00000000000..1fd389d53fc --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.txt @@ -0,0 +1,5 @@ +package + +public val u1: [ERROR : Type cannot be resolved. Please make sure you have the required dependencies for unsigned types in the classpath] +public val u2: [ERROR : Type cannot be resolved. Please make sure you have the required dependencies for unsigned types in the classpath] +public val u3: [ERROR : Type cannot be resolved. Please make sure you have the required dependencies for unsigned types in the classpath] diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.fir.kt new file mode 100644 index 00000000000..ff6b14e35cc --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.fir.kt @@ -0,0 +1,20 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +abstract class AbstractBaseClass + +open class OpenBaseClass + +interface BaseInterface + +@JvmInline +value class TestExtendsAbstractClass(val x: Int) : AbstractBaseClass() + +@JvmInline +value class TestExtendsOpenClass(val x: Int) : OpenBaseClass() + +@JvmInline +value class TestImplementsInterface(val x: Int) : BaseInterface \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt new file mode 100644 index 00000000000..13ed4fd19ef --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt @@ -0,0 +1,20 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +abstract class AbstractBaseClass + +open class OpenBaseClass + +interface BaseInterface + +@JvmInline +value class TestExtendsAbstractClass(val x: Int) : AbstractBaseClass() + +@JvmInline +value class TestExtendsOpenClass(val x: Int) : OpenBaseClass() + +@JvmInline +value class TestImplementsInterface(val x: Int) : BaseInterface \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.txt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.txt new file mode 100644 index 00000000000..3181cf577a7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.txt @@ -0,0 +1,55 @@ +package + +package kotlin { + + public abstract class AbstractBaseClass { + public constructor AbstractBaseClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface BaseInterface { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class OpenBaseClass { + public constructor OpenBaseClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class TestExtendsAbstractClass : kotlin.AbstractBaseClass { + public constructor TestExtendsAbstractClass(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class TestExtendsOpenClass : kotlin.OpenBaseClass { + public constructor TestExtendsOpenClass(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class TestImplementsInterface : kotlin.BaseInterface { + public constructor TestImplementsInterface(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.fir.kt new file mode 100644 index 00000000000..d9de10fe6a5 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.fir.kt @@ -0,0 +1,15 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +interface IFoo + +object FooImpl : IFoo + +@JvmInline +value class Test1(val x: Any) : IFoo by FooImpl + +@JvmInline +value class Test2(val x: IFoo) : IFoo by x \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt new file mode 100644 index 00000000000..83112d8e629 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt @@ -0,0 +1,15 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +interface IFoo + +object FooImpl : IFoo + +@JvmInline +value class Test1(val x: Any) : IFoo by FooImpl + +@JvmInline +value class Test2(val x: IFoo) : IFoo by x \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.txt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.txt new file mode 100644 index 00000000000..5fae056825c --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.txt @@ -0,0 +1,40 @@ +package + +package kotlin { + + public object FooImpl : kotlin.IFoo { + private constructor FooImpl() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface IFoo { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Test1 : kotlin.IFoo { + public constructor Test1(/*0*/ x: kotlin.Any) + public final val x: kotlin.Any + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Test2 : kotlin.IFoo { + public constructor Test2(/*0*/ x: kotlin.IFoo) + public final val x: kotlin.IFoo + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt new file mode 100644 index 00000000000..7e47e5845c1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt @@ -0,0 +1,9 @@ +// FIR_IDENTICAL +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Test(val x: Int = 42) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.txt b/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.txt new file mode 100644 index 00000000000..53b09dfce5f --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.txt @@ -0,0 +1,19 @@ +package + +package kotlin { + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Test { + public constructor Test(/*0*/ x: kotlin.Int = ...) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt new file mode 100644 index 00000000000..9586d4bb74b --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt @@ -0,0 +1,51 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +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 new file mode 100644 index 00000000000..8a46844bd79 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt @@ -0,0 +1,51 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER + +package kotlin + +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.txt b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.txt new file mode 100644 index 00000000000..f0504130aaf --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.txt @@ -0,0 +1,176 @@ +package + +package kotlin { + + @kotlin.JvmInline public final value class A0 { + public constructor A0(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class A1 { + public constructor A1() + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class A2 { + public constructor A2() + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class A3 { + public constructor A3(/*0*/ x: kotlin.Int) + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class A4 { + public constructor A4(/*0*/ x: kotlin.Int) + public final var x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class A5 { + public constructor A5(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) + public final val x: kotlin.Int + public final val y: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class A6 { + public constructor A6(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) + public final val y: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class A7 { + public constructor A7(/*0*/ vararg x: kotlin.Int /*kotlin.IntArray*/) + public final val x: kotlin.IntArray + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class A8 { + public constructor A8(/*0*/ x: kotlin.Int) + public open val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class A9 { + public constructor A9(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final class B1 { + public constructor B1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + @kotlin.JvmInline public final value class C2 { + public constructor C2(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public companion object Companion { + private constructor Companion() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + @kotlin.JvmInline public final value class C1 { + public constructor C1(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + } + } + + public object B2 { + private constructor B2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + @kotlin.JvmInline public final value class C3 { + public constructor C3(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + } + + @kotlin.JvmInline public final value class D0 { + public constructor D0(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public open value class D1 { + public constructor D1(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public abstract value class D2 { + public constructor D2(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public sealed value class D3 { + private constructor D3(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final data value class D4 { + public constructor D4(/*0*/ x: kotlin.String) + public final val x: kotlin.String + public final operator /*synthesized*/ fun component1(): kotlin.String + public final /*synthesized*/ fun copy(/*0*/ x: kotlin.String = ...): kotlin.D4 + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt new file mode 100644 index 00000000000..3b6e1a34a79 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt @@ -0,0 +1,19 @@ +// FIR_IDENTICAL +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +@JvmInline +value class UInt(val x: Int) + +@JvmInline +value class UIntArray(private val storage: IntArray) : Collection { + public override val size: Int get() = storage.size + + override operator fun iterator() = TODO() + override fun contains(element: UInt): Boolean = TODO() + override fun containsAll(elements: Collection): Boolean = TODO() + override fun isEmpty(): Boolean = TODO() +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.txt b/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.txt new file mode 100644 index 00000000000..c5054c4d4f1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.txt @@ -0,0 +1,32 @@ +package + +package kotlin { + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class UInt { + public constructor UInt(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class UIntArray : kotlin.collections.Collection { + public constructor UIntArray(/*0*/ storage: kotlin.IntArray) + public open override /*1*/ val size: kotlin.Int + private final val storage: kotlin.IntArray + public open override /*1*/ fun contains(/*0*/ element: kotlin.UInt): kotlin.Boolean + public open override /*1*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ fun iterator(): kotlin.Nothing + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.fir.kt new file mode 100644 index 00000000000..8b21a794cb7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.fir.kt @@ -0,0 +1,30 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: T) +@JvmInline +value class FooNullable(val x: T?) + +@JvmInline +value class FooGenericArray(val x: Array) +@JvmInline +value class FooGenericArray2(val x: Array>) + +@JvmInline +value class FooStarProjectedArray(val x: Array<*>) +@JvmInline +value class FooStarProjectedArray2(val x: Array>) + +@JvmInline +value class Bar(val u: Unit) +@JvmInline +value class BarNullable(val u: Unit?) + +@JvmInline +value class Baz(val u: Nothing) +@JvmInline +value class BazNullable(val u: Nothing?) diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt new file mode 100644 index 00000000000..c29a59d547f --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt @@ -0,0 +1,30 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: T) +@JvmInline +value class FooNullable(val x: T?) + +@JvmInline +value class FooGenericArray(val x: Array) +@JvmInline +value class FooGenericArray2(val x: Array>) + +@JvmInline +value class FooStarProjectedArray(val x: Array<*>) +@JvmInline +value class FooStarProjectedArray2(val x: Array>) + +@JvmInline +value class Bar(val u: Unit) +@JvmInline +value class BarNullable(val u: Unit?) + +@JvmInline +value class Baz(val u: Nothing) +@JvmInline +value class BazNullable(val u: Nothing?) diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.txt b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.txt new file mode 100644 index 00000000000..22b80d4b1e2 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.txt @@ -0,0 +1,91 @@ +package + +package kotlin { + + @kotlin.JvmInline public final value class Bar { + public constructor Bar(/*0*/ u: kotlin.Unit) + public final val u: kotlin.Unit + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class BarNullable { + public constructor BarNullable(/*0*/ u: kotlin.Unit?) + public final val u: kotlin.Unit? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Baz { + public constructor Baz(/*0*/ u: kotlin.Nothing) + public final val u: kotlin.Nothing + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class BazNullable { + public constructor BazNullable(/*0*/ u: kotlin.Nothing?) + public final val u: kotlin.Nothing? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Foo { + public constructor Foo(/*0*/ x: T) + public final val x: T + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class FooGenericArray { + public constructor FooGenericArray(/*0*/ x: kotlin.Array) + public final val x: kotlin.Array + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class FooGenericArray2 { + public constructor FooGenericArray2(/*0*/ x: kotlin.Array>) + public final val x: kotlin.Array> + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class FooNullable { + public constructor FooNullable(/*0*/ x: T?) + public final val x: T? + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class FooStarProjectedArray { + public constructor FooStarProjectedArray(/*0*/ x: kotlin.Array<*>) + public final val x: kotlin.Array<*> + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class FooStarProjectedArray2 { + public constructor FooStarProjectedArray2(/*0*/ x: kotlin.Array>) + public final val x: kotlin.Array> + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.fir.kt new file mode 100644 index 00000000000..29a43c81ef1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.fir.kt @@ -0,0 +1,18 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +import kotlin.reflect.KClass + +annotation class JvmInline + +@JvmInline +value class MyInt(val x: Int) +@JvmInline +value class MyString(val x: String) + +annotation class Ann1(val a: MyInt) +annotation class Ann2(val a: Array) +annotation class Ann3(vararg val a: MyInt) + +annotation class Ann4(val a: KClass) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt new file mode 100644 index 00000000000..efcd653369d --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt @@ -0,0 +1,18 @@ +// !LANGUAGE: +InlineClasses + +package kotlin + +import kotlin.reflect.KClass + +annotation class JvmInline + +@JvmInline +value class MyInt(val x: Int) +@JvmInline +value class MyString(val x: String) + +annotation class Ann1(val a: MyInt) +annotation class Ann2(val a: Array) +annotation class Ann3(vararg val a: MyInt) + +annotation class Ann4(val a: KClass) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.txt b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.txt new file mode 100644 index 00000000000..3cf8b5549cb --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.txt @@ -0,0 +1,59 @@ +package + +package kotlin { + + public final annotation class Ann1 : kotlin.Annotation { + public constructor Ann1(/*0*/ a: kotlin.MyInt) + public final val a: kotlin.MyInt + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class Ann2 : kotlin.Annotation { + public constructor Ann2(/*0*/ a: kotlin.Array) + public final val a: kotlin.Array + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class Ann3 : kotlin.Annotation { + public constructor Ann3(/*0*/ vararg a: kotlin.MyInt /*kotlin.Array*/) + public final val a: kotlin.Array + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class Ann4 : kotlin.Annotation { + public constructor Ann4(/*0*/ a: kotlin.reflect.KClass) + public final val a: kotlin.reflect.KClass + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class MyInt { + public constructor MyInt(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class MyString { + public constructor MyString(/*0*/ x: kotlin.String) + public final val x: kotlin.String + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.fir.kt new file mode 100644 index 00000000000..8347b2f9779 --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.fir.kt @@ -0,0 +1,26 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE, -UNUSED_ANONYMOUS_PARAMETER + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: Int) + +fun f1(vararg a: Foo) {} +fun f2(vararg a: Foo?) {} + +class A { + fun f3(a0: Int, vararg a1: Foo) { + fun f4(vararg a: Foo) {} + + val g = fun (vararg v: Foo) {} + } +} + +class B(vararg val s: Foo) { + constructor(a: Int, vararg s: Foo) : this(*s) +} + +annotation class Ann(vararg val f: Foo) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt new file mode 100644 index 00000000000..56af413cbbd --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt @@ -0,0 +1,26 @@ +// !LANGUAGE: +InlineClasses +// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE, -UNUSED_ANONYMOUS_PARAMETER + +package kotlin + +annotation class JvmInline + +@JvmInline +value class Foo(val x: Int) + +fun f1(vararg a: Foo) {} +fun f2(vararg a: Foo?) {} + +class A { + fun f3(a0: Int, vararg a1: Foo) { + fun f4(vararg a: Foo) {} + + val g = fun (vararg v: Foo) {} + } +} + +class B(vararg val s: Foo) { + constructor(a: Int, vararg s: Foo) : this(*s) +} + +annotation class Ann(vararg val f: Foo) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.txt b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.txt new file mode 100644 index 00000000000..3577155821f --- /dev/null +++ b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.txt @@ -0,0 +1,46 @@ +package + +package kotlin { + public fun f1(/*0*/ vararg a: kotlin.Foo /*kotlin.Array*/): kotlin.Unit + public fun f2(/*0*/ vararg a: kotlin.Foo? /*kotlin.Array*/): kotlin.Unit + + public final class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun f3(/*0*/ a0: kotlin.Int, /*1*/ vararg a1: kotlin.Foo /*kotlin.Array*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final annotation class Ann : kotlin.Annotation { + public constructor Ann(/*0*/ vararg f: kotlin.Foo /*kotlin.Array*/) + public final val f: kotlin.Array + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final class B { + public constructor B(/*0*/ vararg s: kotlin.Foo /*kotlin.Array*/) + public constructor B(/*0*/ a: kotlin.Int, /*1*/ vararg s: kotlin.Foo /*kotlin.Array*/) + public final val s: kotlin.Array + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.JvmInline public final value class Foo { + public constructor Foo(/*0*/ x: kotlin.Int) + public final val x: kotlin.Int + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index 1da5d58a8a7..6123ea0f4dd 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -25050,6 +25050,129 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTestWithFirVali } } + @TestMetadata("compiler/testData/diagnostics/tests/valueClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ValueClasses extends AbstractDiagnosticsTestWithFirValidation { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInValueClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/valueClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @TestMetadata("basicValueClassDeclaration.kt") + public void testBasicValueClassDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt"); + } + + @TestMetadata("basicValueClassDeclarationDisabled.kt") + public void testBasicValueClassDeclarationDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt"); + } + + @TestMetadata("constructorsJvmSignaturesClash.kt") + public void testConstructorsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt"); + } + + @TestMetadata("delegatedPropertyInValueClass.kt") + public void testDelegatedPropertyInValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt"); + } + + @TestMetadata("functionsJvmSignaturesClash.kt") + public void testFunctionsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt"); + } + + @TestMetadata("functionsJvmSignaturesConflictOnInheritance.kt") + public void testFunctionsJvmSignaturesConflictOnInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt"); + } + + @TestMetadata("identityComparisonWithValueClasses.kt") + public void testIdentityComparisonWithValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt"); + } + + @TestMetadata("lateinitValueClasses.kt") + public void testLateinitValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt"); + } + + @TestMetadata("presenceOfInitializerBlockInsideValueClass.kt") + public void testPresenceOfInitializerBlockInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt"); + } + + @TestMetadata("presenceOfPublicPrimaryConstructorForValueClass.kt") + public void testPresenceOfPublicPrimaryConstructorForValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt"); + } + + @TestMetadata("propertiesWithBackingFieldsInsideValueClass.kt") + public void testPropertiesWithBackingFieldsInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt"); + } + + @TestMetadata("recursiveValueClasses.kt") + public void testRecursiveValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt"); + } + + @TestMetadata("reservedMembersAndConstructsInsideValueClass.kt") + public void testReservedMembersAndConstructsInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt"); + } + + @TestMetadata("unsignedLiteralsWithoutArtifactOnClasspath.kt") + public void testUnsignedLiteralsWithoutArtifactOnClasspath() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt"); + } + + @TestMetadata("valueClassCanOnlyImplementInterfaces.kt") + public void testValueClassCanOnlyImplementInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt"); + } + + @TestMetadata("valueClassCannotImplementInterfaceByDelegation.kt") + public void testValueClassCannotImplementInterfaceByDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt"); + } + + @TestMetadata("valueClassConstructorParameterWithDefaultValue.kt") + public void testValueClassConstructorParameterWithDefaultValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt"); + } + + @TestMetadata("valueClassDeclarationCheck.kt") + public void testValueClassDeclarationCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt"); + } + + @TestMetadata("valueClassImplementsCollection.kt") + public void testValueClassImplementsCollection() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt"); + } + + @TestMetadata("valueClassWithForbiddenUnderlyingType.kt") + public void testValueClassWithForbiddenUnderlyingType() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt"); + } + + @TestMetadata("valueClassesInsideAnnotations.kt") + public void testValueClassesInsideAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt"); + } + + @TestMetadata("varargsOnParametersOfValueClassType.kt") + public void testVarargsOnParametersOfValueClassType() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt"); + } + } + @TestMetadata("compiler/testData/diagnostics/tests/varargs") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index 2268109725c..31bdfd1493b 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -24970,6 +24970,129 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing } } + @TestMetadata("compiler/testData/diagnostics/tests/valueClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ValueClasses extends AbstractDiagnosticsUsingJavacTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInValueClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/valueClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @TestMetadata("basicValueClassDeclaration.kt") + public void testBasicValueClassDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt"); + } + + @TestMetadata("basicValueClassDeclarationDisabled.kt") + public void testBasicValueClassDeclarationDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt"); + } + + @TestMetadata("constructorsJvmSignaturesClash.kt") + public void testConstructorsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt"); + } + + @TestMetadata("delegatedPropertyInValueClass.kt") + public void testDelegatedPropertyInValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt"); + } + + @TestMetadata("functionsJvmSignaturesClash.kt") + public void testFunctionsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt"); + } + + @TestMetadata("functionsJvmSignaturesConflictOnInheritance.kt") + public void testFunctionsJvmSignaturesConflictOnInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt"); + } + + @TestMetadata("identityComparisonWithValueClasses.kt") + public void testIdentityComparisonWithValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt"); + } + + @TestMetadata("lateinitValueClasses.kt") + public void testLateinitValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt"); + } + + @TestMetadata("presenceOfInitializerBlockInsideValueClass.kt") + public void testPresenceOfInitializerBlockInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt"); + } + + @TestMetadata("presenceOfPublicPrimaryConstructorForValueClass.kt") + public void testPresenceOfPublicPrimaryConstructorForValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt"); + } + + @TestMetadata("propertiesWithBackingFieldsInsideValueClass.kt") + public void testPropertiesWithBackingFieldsInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt"); + } + + @TestMetadata("recursiveValueClasses.kt") + public void testRecursiveValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt"); + } + + @TestMetadata("reservedMembersAndConstructsInsideValueClass.kt") + public void testReservedMembersAndConstructsInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt"); + } + + @TestMetadata("unsignedLiteralsWithoutArtifactOnClasspath.kt") + public void testUnsignedLiteralsWithoutArtifactOnClasspath() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt"); + } + + @TestMetadata("valueClassCanOnlyImplementInterfaces.kt") + public void testValueClassCanOnlyImplementInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt"); + } + + @TestMetadata("valueClassCannotImplementInterfaceByDelegation.kt") + public void testValueClassCannotImplementInterfaceByDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt"); + } + + @TestMetadata("valueClassConstructorParameterWithDefaultValue.kt") + public void testValueClassConstructorParameterWithDefaultValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt"); + } + + @TestMetadata("valueClassDeclarationCheck.kt") + public void testValueClassDeclarationCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt"); + } + + @TestMetadata("valueClassImplementsCollection.kt") + public void testValueClassImplementsCollection() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt"); + } + + @TestMetadata("valueClassWithForbiddenUnderlyingType.kt") + public void testValueClassWithForbiddenUnderlyingType() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt"); + } + + @TestMetadata("valueClassesInsideAnnotations.kt") + public void testValueClassesInsideAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt"); + } + + @TestMetadata("varargsOnParametersOfValueClassType.kt") + public void testVarargsOnParametersOfValueClassType() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt"); + } + } + @TestMetadata("compiler/testData/diagnostics/tests/varargs") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/descriptorBasedTypeSignatureMapping.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/descriptorBasedTypeSignatureMapping.kt index fbb9379f43d..20ccce78da1 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/descriptorBasedTypeSignatureMapping.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/descriptorBasedTypeSignatureMapping.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.builtins.isSuspendFunctionType import org.jetbrains.kotlin.builtins.transformSuspendFunctionToRuntimeFunctionType import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.name.SpecialNames +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext import org.jetbrains.kotlin.types.typeUtil.replaceArgumentsWithStarProjections @@ -115,7 +116,7 @@ fun mapType( descriptor is ClassDescriptor -> { // NB if inline class is recursive, it's ok to map it as wrapped - if (descriptor.isInline && !mode.needInlineClassWrapping) { + if (descriptor.isInlineClass() && !mode.needInlineClassWrapping) { val expandedType = SimpleClassicTypeSystemContext.computeExpandedTypeForInlineClass(kotlinType) as KotlinType? if (expandedType != null) { return mapType( diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/resolve/jvm/inlineClassManglingRules.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/resolve/jvm/inlineClassManglingRules.kt index 5bcb0f201c7..eaa3b5c795f 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/resolve/jvm/inlineClassManglingRules.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/resolve/jvm/inlineClassManglingRules.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.types.typeUtil.representativeUpperBound fun shouldHideConstructorDueToInlineClassTypeValueParameters(descriptor: CallableMemberDescriptor): Boolean { val constructorDescriptor = descriptor as? ClassConstructorDescriptor ?: return false if (DescriptorVisibilities.isPrivate(constructorDescriptor.visibility)) return false - if (constructorDescriptor.constructedClass.isInline) return false + if (constructorDescriptor.constructedClass.isInlineClass()) return false if (DescriptorUtils.isSealedClass(constructorDescriptor.constructedClass)) return false // TODO inner class in inline class diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt index 8aa1898dd6b..d88800d8032 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.DescriptorUtils.getContainingClass import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.EnumValue +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.scopes.MemberScope import org.jetbrains.kotlin.types.KotlinType @@ -445,7 +446,7 @@ fun DeclarationDescriptor.isAnnotationConstructor(): Boolean = this is ConstructorDescriptor && DescriptorUtils.isAnnotationClass(this.constructedClass) fun DeclarationDescriptor.isPrimaryConstructorOfInlineClass(): Boolean = - this is ConstructorDescriptor && this.isPrimary && this.constructedClass.isInline + this is ConstructorDescriptor && this.isPrimary && this.constructedClass.isInlineClass() @TypeRefinement fun ModuleDescriptor.getKotlinTypeRefiner(): KotlinTypeRefiner = getCapability(REFINER_CAPABILITY)?.value ?: KotlinTypeRefiner.Default diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/inlineClassesUtils.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/inlineClassesUtils.kt index 2c3a5bf9ea6..fb2622039a3 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/inlineClassesUtils.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/inlineClassesUtils.kt @@ -6,18 +6,23 @@ package org.jetbrains.kotlin.resolve import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeSubstitutor import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.utils.addToStdlib.safeAs +val JVM_INLINE_ANNOTATION = FqName("kotlin.JvmInline") + fun ClassDescriptor.underlyingRepresentation(): ValueParameterDescriptor? { - if (!isInline) return null + if (!isInlineClass()) return null return unsubstitutedPrimaryConstructor?.valueParameters?.singleOrNull() } -fun DeclarationDescriptor.isInlineClass() = this is ClassDescriptor && this.isInline +// FIXME: DeserializedClassDescriptor in reflection do not have @JvmInline annotation, that we +// FIXME: would like to check as well. +fun DeclarationDescriptor.isInlineClass() = this is ClassDescriptor && (isInline || isValue) fun KotlinType.unsubstitutedUnderlyingParameter(): ValueParameterDescriptor? { return constructor.declarationDescriptor.safeAs()?.underlyingRepresentation() diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt index 3c213927a07..d424fe9d778 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.resolve.descriptorUtil.hasExactAnnotation import org.jetbrains.kotlin.resolve.descriptorUtil.hasNoInferAnnotation import org.jetbrains.kotlin.resolve.descriptorUtil.isExactAnnotation +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.resolve.substitutedUnderlyingType import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.model.* @@ -599,7 +600,7 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext, TypeSy override fun TypeConstructorMarker.isInlineClass(): Boolean { require(this is TypeConstructor, this::errorMessage) - return (declarationDescriptor as? ClassDescriptor)?.isInline == true + return (declarationDescriptor as? ClassDescriptor)?.isInlineClass() == true } override fun TypeConstructorMarker.isInnerClass(): Boolean { diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/calls/InlineClassAwareCaller.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/calls/InlineClassAwareCaller.kt index 6e3187ec6fa..b31061c7e97 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/calls/InlineClassAwareCaller.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/calls/InlineClassAwareCaller.kt @@ -90,7 +90,7 @@ internal class InlineClassAwareCaller( } } else { val containingDeclaration = descriptor.containingDeclaration - if (containingDeclaration is ClassDescriptor && containingDeclaration.isInline) { + if (containingDeclaration is ClassDescriptor && containingDeclaration.isInlineClass()) { kotlinParameterTypes.add(containingDeclaration.defaultType) } } @@ -180,7 +180,7 @@ internal fun KotlinType.toInlineClass(): Class<*>? = constructor.declarationDescriptor.toInlineClass() internal fun DeclarationDescriptor?.toInlineClass(): Class<*>? = - if (this is ClassDescriptor && isInline) + if (this is ClassDescriptor && isInlineClass()) toJavaClass() ?: throw KotlinReflectionInternalError("Class object for the class $name cannot be found (classId=$classId)") else null diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/TypeAccessibilityCheckerImpl.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/TypeAccessibilityCheckerImpl.kt index 41ef465cefd..c4289813b0a 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/TypeAccessibilityCheckerImpl.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/TypeAccessibilityCheckerImpl.kt @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtNamedDeclaration import org.jetbrains.kotlin.psi.KtTypeParameter import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameOrNull +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeProjection import org.jetbrains.kotlin.types.isError @@ -101,7 +102,7 @@ private fun DeclarationDescriptor.collectAllTypes(): Sequence { return when (this) { is ClassConstructorDescriptor -> valueParameters.asSequence().map(ValueParameterDescriptor::getType) .flatMap(KotlinType::collectAllTypes) - is ClassDescriptor -> if (isInline) unsubstitutedPrimaryConstructor?.collectAllTypes().orEmpty() else { + is ClassDescriptor -> if (isInlineClass()) unsubstitutedPrimaryConstructor?.collectAllTypes().orEmpty() else { emptySequence() } + declaredTypeParameters.asSequence().flatMap(DeclarationDescriptor::collectAllTypes) + sequenceOf(fqNameOrNull()) is CallableDescriptor -> { diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt index 50e487937e1..fa616c801f3 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt +++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt @@ -144,7 +144,7 @@ fun OverrideMemberChooserObject.generateMember( val renderer = baseRenderer.withOptions { if (descriptor is ClassConstructorDescriptor && descriptor.isPrimary) { val containingClass = descriptor.containingDeclaration - if (containingClass.kind == ClassKind.ANNOTATION_CLASS || containingClass.isInline) { + if (containingClass.kind == ClassKind.ANNOTATION_CLASS || containingClass.isInline || containingClass.isValue) { renderPrimaryConstructorParametersAsProperties = true } } diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt index 0729e666794..72bef5a1d29 100644 --- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt +++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt @@ -76,6 +76,7 @@ import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsExpression import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.resolve.isInlineClassType import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode import org.jetbrains.kotlin.util.findCallableMemberBySignature @@ -513,7 +514,7 @@ class UnusedSymbolInspection : AbstractKotlinInspection() { return when { descriptor is ConstructorDescriptor -> { val classDescriptor = descriptor.constructedClass - !classDescriptor.isInline && classDescriptor.visibility != DescriptorVisibilities.LOCAL + !classDescriptor.isInlineClass() && classDescriptor.visibility != DescriptorVisibilities.LOCAL } hasModifier(KtTokens.INTERNAL_KEYWORD) -> false descriptor !is FunctionDescriptor -> true diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsExternalChecker.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsExternalChecker.kt index fa85d32bb04..837a7de21b6 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsExternalChecker.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsExternalChecker.kt @@ -44,6 +44,7 @@ object JsExternalChecker : DeclarationChecker { descriptor.isData -> "data class" descriptor.isInner -> "inner class" descriptor.isInline -> "inline class" + descriptor.isValue -> "value class" descriptor.isFun -> "fun interface" DescriptorUtils.isAnnotationClass(descriptor) -> "annotation class" else -> null diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt index de0c9a7484b..8f3a1dfd252 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt @@ -131,7 +131,7 @@ class ClassTranslator private constructor( if (classDeclaration is KtClassOrObject) { when { descriptor.isData -> JsDataClassGenerator(classDeclaration, context).generate() - descriptor.isInline -> JsInlineClassGenerator(classDeclaration, context).generate() + descriptor.isInline || descriptor.isValue -> JsInlineClassGenerator(classDeclaration, context).generate() } } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassFactory.kt index 51757cf2e5f..29fb91d6889 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassFactory.kt @@ -16,6 +16,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirClassImpl import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.isInlineClass object CirClassFactory { fun create(source: ClassDescriptor): CirClass = create( @@ -28,7 +29,7 @@ object CirClassFactory { companion = source.companionObjectDescriptor?.name?.intern(), isCompanion = source.isCompanionObject, isData = source.isData, - isInline = source.isInline, + isInline = source.isInlineClass(), isInner = source.isInner, isExternal = source.isExternal ).apply { diff --git a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/utils/ComparingDeclarationsVisitor.kt b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/utils/ComparingDeclarationsVisitor.kt index ea06101a207..f3777515570 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/utils/ComparingDeclarationsVisitor.kt +++ b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/utils/ComparingDeclarationsVisitor.kt @@ -229,6 +229,7 @@ internal class ComparingDeclarationsVisitor( context.assertFieldsEqual(expected::isCompanionObject, actual::isCompanionObject) context.assertFieldsEqual(expected::isData, actual::isData) context.assertFieldsEqual(expected::isInline, actual::isInline) + context.assertFieldsEqual(expected::isValue, actual::isValue) context.assertFieldsEqual(expected::isInner, actual::isInner) context.assertFieldsEqual(expected::isExternal, actual::isExternal) context.assertFieldsEqual(expected::isExpect, actual::isExpect) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt index 40a2b4b9d33..378d047e290 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.resolve.hasBackingField +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.resolve.isInlineClassType import org.jetbrains.kotlin.resolve.jvm.annotations.TRANSIENT_ANNOTATION_FQ_NAME import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationDescriptor @@ -122,7 +123,7 @@ open class SerializationPluginDeclarationChecker : DeclarationChecker { return false } - if (descriptor.isInline) { + if (descriptor.isInlineClass()) { trace.reportOnSerializableAnnotation(descriptor, SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED) return false }