From 0570c05683c0445eaeb96e2827f95a9012229bed Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Mon, 3 Feb 2020 16:12:22 +0100 Subject: [PATCH] Rename `hasJvmDefaultAnnotation` method to `isCompiledToJvmDefaultIfNoAbstract` --- .../src/org/jetbrains/kotlin/codegen/AsmUtil.java | 5 +++-- .../jetbrains/kotlin/codegen/ClassBodyCodegen.java | 5 +++-- .../jetbrains/kotlin/codegen/FunctionCodegen.java | 8 ++++---- .../org/jetbrains/kotlin/codegen/JvmBridgesImpl.kt | 4 ++-- .../org/jetbrains/kotlin/codegen/JvmCodegenUtil.java | 4 ++-- .../org/jetbrains/kotlin/codegen/MemberCodegen.java | 12 +++++++----- .../kotlin/codegen/context/CodegenContext.java | 10 +++++----- .../kotlin/codegen/inline/SourceCompilerForInline.kt | 4 ++-- .../codegen/serialization/JvmSerializerExtension.kt | 4 ++-- .../kotlin/codegen/state/KotlinTypeMapper.kt | 12 ++++++------ .../kotlin/resolve/jvm/JvmDelegationFilter.kt | 3 +-- .../resolve/jvm/annotations/jvmAnnotationUtil.kt | 9 ++++++--- .../checkers/InterfaceDefaultMethodCallChecker.kt | 6 +++--- .../kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt | 6 +++--- .../jvm/platform/JvmDefaultSuperCallChecker.kt | 4 ++-- 15 files changed, 51 insertions(+), 45 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java index f6850fe0bc7..afec01d92df 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java @@ -43,6 +43,7 @@ import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker; import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver; import org.jetbrains.kotlin.resolve.inline.InlineUtil; import org.jetbrains.kotlin.resolve.jvm.*; +import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt; import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin; import org.jetbrains.kotlin.serialization.DescriptorSerializer; import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor; @@ -66,7 +67,6 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.*; import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode; import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineWithReified; import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*; -import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation; import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmSyntheticAnnotation; import static org.jetbrains.kotlin.types.TypeUtils.isNullableType; import static org.jetbrains.org.objectweb.asm.Opcodes.*; @@ -308,7 +308,8 @@ public class AsmUtil { public static boolean isAbstractMethod(FunctionDescriptor functionDescriptor, OwnerKind kind, JvmDefaultMode jvmDefaultMode) { return (functionDescriptor.getModality() == Modality.ABSTRACT || - (isJvmInterface(functionDescriptor.getContainingDeclaration()) && !hasJvmDefaultAnnotation(functionDescriptor, jvmDefaultMode))) + (isJvmInterface(functionDescriptor.getContainingDeclaration()) && !JvmAnnotationUtilKt + .isCompiledToJvmDefaultIfNoAbstract(functionDescriptor, jvmDefaultMode))) && !isStaticMethod(kind, functionDescriptor); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java index b4c690e7cb2..430c82aa9bf 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.psi.synthetics.SyntheticClassOrObjectDescriptorKt; import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt; +import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt; import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter; @@ -36,7 +37,6 @@ import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface; import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedSubclass; import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration; import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE; -import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation; import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL; public abstract class ClassBodyCodegen extends MemberCodegen { @@ -222,7 +222,8 @@ public abstract class ClassBodyCodegen extends MemberCodegen entry : CodegenUtil.getNonPrivateTraitMethods(descriptor).entrySet()) { FunctionDescriptor interfaceFun = entry.getKey(); //skip java 8 default methods - if (!CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) && !hasJvmDefaultAnnotation(interfaceFun, state.getJvmDefaultMode())) { + if (!CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) && !JvmAnnotationUtilKt + .isCompiledToJvmDefaultIfNoAbstract(interfaceFun, state.getJvmDefaultMode())) { generateDelegationToDefaultImpl(interfaceFun, entry.getValue()); } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index 474f279588c..2d8e898354d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -47,6 +47,7 @@ import org.jetbrains.kotlin.resolve.inline.InlineOnlyKt; import org.jetbrains.kotlin.resolve.inline.InlineUtil; import org.jetbrains.kotlin.resolve.jvm.AsmTypes; import org.jetbrains.kotlin.resolve.jvm.RuntimeAssertionInfo; +import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt; import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin; import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind; import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt; @@ -83,7 +84,6 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.*; import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode; import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE; import static org.jetbrains.kotlin.resolve.jvm.InlineClassManglingRulesKt.shouldHideConstructorDueToInlineClassTypeValueParameters; -import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation; import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.*; import static org.jetbrains.org.objectweb.asm.Opcodes.*; @@ -732,7 +732,7 @@ public class FunctionCodegen { @NotNull JvmDefaultMode jvmDefaultMode ) { return OwnerKind.DEFAULT_IMPLS == context.getContextKind() && - hasJvmDefaultAnnotation(functionDescriptor, jvmDefaultMode) && + JvmAnnotationUtilKt.isCompiledToJvmDefaultIfNoAbstract(functionDescriptor, jvmDefaultMode) && jvmDefaultMode.isCompatibility(); } @@ -1460,7 +1460,7 @@ public class FunctionCodegen { iv.invokespecial(parentInternalName, delegateTo.getName(), delegateTo.getDescriptor(), false); } else { - if (hasJvmDefaultAnnotation(descriptor, state.getJvmDefaultMode())) { + if (JvmAnnotationUtilKt.isCompiledToJvmDefaultIfNoAbstract(descriptor, state.getJvmDefaultMode())) { iv.invokeinterface(v.getThisName(), delegateTo.getName(), delegateTo.getDescriptor()); } else { @@ -1650,7 +1650,7 @@ public class FunctionCodegen { assert isInterface(containingDeclaration) : "'processInterfaceMethod' method should be called only for interfaces, but: " + containingDeclaration; - if (hasJvmDefaultAnnotation(memberDescriptor, mode)) { + if (JvmAnnotationUtilKt.isCompiledToJvmDefaultIfNoAbstract(memberDescriptor, mode)) { return (kind != OwnerKind.DEFAULT_IMPLS && !isSynthetic) || (kind == OwnerKind.DEFAULT_IMPLS && (isSynthetic || mode.isCompatibility())); } else { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmBridgesImpl.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmBridgesImpl.kt index f742e0e2945..e61141fc677 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmBridgesImpl.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmBridgesImpl.kt @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor import org.jetbrains.kotlin.load.java.descriptors.JavaForKotlinOverridePropertyDescriptor import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmDefaultAnnotation +import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefaultIfNoAbstract import org.jetbrains.kotlin.resolve.jvm.annotations.hasPlatformDependentAnnotation class DescriptorBasedFunctionHandleForJvm( @@ -67,7 +67,7 @@ private val FunctionDescriptor.isJavaForKotlinOverrideProperty: Boolean get() = this is PropertyAccessorDescriptor && correspondingProperty is JavaForKotlinOverridePropertyDescriptor private fun CallableMemberDescriptor.isJvmDefaultOrPlatformDependent(jvmDefaultMode: JvmDefaultMode) = - hasJvmDefaultAnnotation(jvmDefaultMode) || hasPlatformDependentAnnotation() + isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode) || hasPlatformDependentAnnotation() private fun needToGenerateDelegationToDefaultImpls(descriptor: FunctionDescriptor, jvmDefaultMode: JvmDefaultMode): Boolean { if (findInterfaceImplementation(descriptor) == null) return false diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java index 8489dddfdee..63a5844930e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java @@ -42,6 +42,7 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.resolve.inline.InlineUtil; +import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt; import org.jetbrains.kotlin.resolve.jvm.checkers.PolymorphicSignatureCallChecker; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver; @@ -60,7 +61,6 @@ import static org.jetbrains.kotlin.descriptors.Modality.FINAL; import static org.jetbrains.kotlin.resolve.BindingContext.DELEGATED_PROPERTY_RESOLVED_CALL; import static org.jetbrains.kotlin.resolve.DescriptorUtils.isCompanionObject; import static org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind.NO_EXPLICIT_RECEIVER; -import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation; import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmFieldAnnotation; public class JvmCodegenUtil { @@ -76,7 +76,7 @@ public class JvmCodegenUtil { return descriptor.getModality() == Modality.ABSTRACT; } - return !hasJvmDefaultAnnotation(descriptor, jvmDefaultMode); + return !JvmAnnotationUtilKt.isCompiledToJvmDefaultIfNoAbstract(descriptor, jvmDefaultMode); } public static boolean isJvmInterface(@Nullable DeclarationDescriptor descriptor) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java index 07f6e2abb07..affef4dc3ee 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java @@ -39,6 +39,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.resolve.constants.ConstantValue; import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt; import org.jetbrains.kotlin.resolve.jvm.AsmTypes; +import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt; import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt; @@ -63,7 +64,6 @@ import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYN import static org.jetbrains.kotlin.resolve.BindingContext.*; import static org.jetbrains.kotlin.resolve.DescriptorUtils.*; import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*; -import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation; import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN; import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt.Synthetic; import static org.jetbrains.org.objectweb.asm.Opcodes.*; @@ -402,7 +402,8 @@ public abstract class MemberCodegen accessor : ((CodegenContext) context).getAccessors()) { - boolean hasJvmDefaultAnnotation = hasJvmDefaultAnnotation(accessor.getCalleeDescriptor(), state.getJvmDefaultMode()); + boolean compiledToJvmDefault = + JvmAnnotationUtilKt.isCompiledToJvmDefaultIfNoAbstract(accessor.getCalleeDescriptor(), state.getJvmDefaultMode()); OwnerKind kind = context.getContextKind(); if (!isInterface(context.getContextDescriptor()) || - (hasJvmDefaultAnnotation && kind == OwnerKind.IMPLEMENTATION) || - (!hasJvmDefaultAnnotation && kind == OwnerKind.DEFAULT_IMPLS)) { + (compiledToJvmDefault && kind == OwnerKind.IMPLEMENTATION) || + (!compiledToJvmDefault && kind == OwnerKind.DEFAULT_IMPLS)) { generateSyntheticAccessor(accessor); } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java index 40ba5661b2d..ac8b78f5a47 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java @@ -18,6 +18,7 @@ import org.jetbrains.kotlin.load.java.sam.SamConstructorDescriptor; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.resolve.DescriptorUtils; +import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt; import org.jetbrains.kotlin.storage.LockBasedStorageManager; import org.jetbrains.kotlin.storage.NullableLazyValue; import org.jetbrains.kotlin.types.KotlinType; @@ -29,8 +30,7 @@ import static org.jetbrains.kotlin.codegen.AsmUtil.getVisibilityAccessFlag; import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isInSamePackage; import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isNonDefaultInterfaceMember; import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode; -import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation; -import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.isCallableMemberWithJvmDefaultAnnotation; +import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.isCallableMemberCompiledToJvmDefaultIfNoAbstract; import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PRIVATE; import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PROTECTED; @@ -593,8 +593,8 @@ public abstract class CodegenContext { CodegenContext properContext = getFirstCrossInlineOrNonInlineContext(); DeclarationDescriptor enclosing = descriptor.getContainingDeclaration(); boolean isInliningContext = properContext.isInlineMethodContext(); - boolean sameJvmDefault = hasJvmDefaultAnnotation(descriptor, getState().getJvmDefaultMode()) == - isCallableMemberWithJvmDefaultAnnotation(properContext.contextDescriptor, getState().getJvmDefaultMode()) || + boolean sameJvmDefault = JvmAnnotationUtilKt.isCompiledToJvmDefaultIfNoAbstract(descriptor, getState().getJvmDefaultMode()) == + isCallableMemberCompiledToJvmDefaultIfNoAbstract(properContext.contextDescriptor, getState().getJvmDefaultMode()) || properContext.contextDescriptor instanceof AccessorForCallableDescriptor; if (!isInliningContext && ( !properContext.hasThisDescriptor() || @@ -651,7 +651,7 @@ public abstract class CodegenContext { return descriptor; } - if (hasJvmDefaultAnnotation(descriptor, getState().getJvmDefaultMode()) && descriptorContext instanceof DefaultImplsClassContext) { + if (JvmAnnotationUtilKt.isCompiledToJvmDefaultIfNoAbstract(descriptor, getState().getJvmDefaultMode()) && descriptorContext instanceof DefaultImplsClassContext) { descriptorContext = ((DefaultImplsClassContext) descriptorContext).getInterfaceContext(); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt index 77b1f5c3acc..1165fd906a5 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert import org.jetbrains.kotlin.resolve.isInlineClass -import org.jetbrains.kotlin.resolve.jvm.annotations.isCallableMemberWithJvmDefaultAnnotation +import org.jetbrains.kotlin.resolve.jvm.annotations.isCallableMemberCompiledToJvmDefaultIfNoAbstract import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.kotlin.utils.addIfNotNull import org.jetbrains.org.objectweb.asm.Label @@ -408,7 +408,7 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid when { DescriptorUtils.isInterface(descriptor) && innerDescriptor !is ClassDescriptor && - !innerDescriptor.isCallableMemberWithJvmDefaultAnnotation(state.jvmDefaultMode) -> + !innerDescriptor.isCallableMemberCompiledToJvmDefaultIfNoAbstract(state.jvmDefaultMode) -> OwnerKind.DEFAULT_IMPLS else -> OwnerKind.IMPLEMENTATION diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt index 9a2d644be2a..0aedf4021f2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt @@ -30,7 +30,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils.isInterface import org.jetbrains.kotlin.resolve.descriptorUtil.classId import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyPrivateApi import org.jetbrains.kotlin.resolve.descriptorUtil.nonSourceAnnotations -import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmDefaultAnnotation +import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefaultIfNoAbstract import org.jetbrains.kotlin.serialization.DescriptorSerializer import org.jetbrains.kotlin.serialization.DescriptorSerializer.Companion.writeVersionRequirement import org.jetbrains.kotlin.serialization.SerializerExtension @@ -99,7 +99,7 @@ class JvmSerializerExtension @JvmOverloads constructor( if ( isInterface(classDescriptor) && classDescriptor.unsubstitutedMemberScope.getContributedDescriptors().any { - it is CallableMemberDescriptor && it.hasJvmDefaultAnnotation(jvmDefaultMode) //TODO: new requirements for new option + it is CallableMemberDescriptor && it.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode) //TODO: new requirements for new option } ) { builder.addVersionRequirement( 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 dc87400a459..dd0e2dd85ff 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt @@ -57,7 +57,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.resolve.jvm.AsmTypes.DEFAULT_CONSTRUCTOR_MARKER import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE import org.jetbrains.kotlin.resolve.jvm.JvmClassName -import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmDefaultAnnotation +import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefaultIfNoAbstract import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodGenericSignature import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature @@ -447,8 +447,8 @@ class KotlinTypeMapper @JvmOverloads constructor( baseMethodDescriptor = findBaseDeclaration(functionDescriptor).original val ownerForDefault = baseMethodDescriptor.containingDeclaration as ClassDescriptor - isDefaultMethodInInterface = isJvmInterface(ownerForDefault) && baseMethodDescriptor.hasJvmDefaultAnnotation(jvmDefaultMode) - ownerForDefaultImpl = if (isJvmInterface(ownerForDefault) && !baseMethodDescriptor.hasJvmDefaultAnnotation(jvmDefaultMode)) + isDefaultMethodInInterface = isJvmInterface(ownerForDefault) && baseMethodDescriptor.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode) + ownerForDefaultImpl = if (isJvmInterface(ownerForDefault) && !baseMethodDescriptor.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode)) mapDefaultImpls(ownerForDefault) else mapClass(ownerForDefault) @@ -456,7 +456,7 @@ class KotlinTypeMapper @JvmOverloads constructor( if (isInterface && (superCall || descriptor.visibility == Visibilities.PRIVATE || isAccessor(descriptor))) { thisClass = mapClass(functionParent) dispatchReceiverKotlinType = functionParent.defaultType - if (declarationOwner is JavaClassDescriptor || declarationFunctionDescriptor.hasJvmDefaultAnnotation(jvmDefaultMode)) { + if (declarationOwner is JavaClassDescriptor || declarationFunctionDescriptor.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode)) { invokeOpcode = INVOKESPECIAL signature = mapSignatureSkipGeneric(functionDescriptor) returnKotlinType = functionDescriptor.returnType @@ -467,7 +467,7 @@ class KotlinTypeMapper @JvmOverloads constructor( val originalDescriptor = descriptor.original signature = mapSignatureSkipGeneric(originalDescriptor, OwnerKind.DEFAULT_IMPLS) returnKotlinType = getReturnValueType(originalDescriptor) - if (descriptor is AccessorForCallableDescriptor<*> && descriptor.calleeDescriptor.hasJvmDefaultAnnotation(jvmDefaultMode)) { + if (descriptor is AccessorForCallableDescriptor<*> && descriptor.calleeDescriptor.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode)) { owner = mapClass(functionParent) isInterfaceMember = true } else { @@ -1517,7 +1517,7 @@ class KotlinTypeMapper @JvmOverloads constructor( current = classCallable continue } - if (isSuperCall && !current.hasJvmDefaultAnnotation(jvmDefaultMode) && !isInterface(current.containingDeclaration)) { + if (isSuperCall && !current.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode) && !isInterface(current.containingDeclaration)) { //Don't unwrap fake overrides from class to interface cause substituted override would be implicitly generated return current } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmDelegationFilter.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmDelegationFilter.kt index 64aadb0e1df..646c55ce014 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmDelegationFilter.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmDelegationFilter.kt @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.resolve.jvm import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.config.JvmAnalysisFlags import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor @@ -36,7 +35,7 @@ object JvmDelegationFilter : DelegationFilter { //We always have only one implementation otherwise it's an error in kotlin and java val realMember = DescriptorUtils.unwrapFakeOverride(interfaceMember) return !isJavaDefaultMethod(realMember) && - !realMember.hasJvmDefaultAnnotation(languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode)) && + !realMember.hasJvmDefaultAnnotation() && !isBuiltInMemberMappedToJavaDefault(realMember) } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt index 76acb45a583..e33465d15c3 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt @@ -41,12 +41,15 @@ fun DeclarationDescriptor.findJvmFieldAnnotation(): AnnotationDescriptor? = fun DeclarationDescriptor.hasJvmFieldAnnotation(): Boolean = findJvmFieldAnnotation() != null -fun DeclarationDescriptor.isCallableMemberWithJvmDefaultAnnotation(jvmDefault: JvmDefaultMode): Boolean = - this is CallableMemberDescriptor && hasJvmDefaultAnnotation(jvmDefault) +fun DeclarationDescriptor.isCallableMemberCompiledToJvmDefaultIfNoAbstract(jvmDefault: JvmDefaultMode): Boolean = + this is CallableMemberDescriptor && isCompiledToJvmDefaultIfNoAbstract(jvmDefault) -fun CallableMemberDescriptor.hasJvmDefaultAnnotation(jvmDefault: JvmDefaultMode): Boolean = +fun CallableMemberDescriptor.isCompiledToJvmDefaultIfNoAbstract(jvmDefault: JvmDefaultMode): Boolean = jvmDefault.forAllMehtodsWithBody || DescriptorUtils.getDirectMember(this).annotations.hasAnnotation(JVM_DEFAULT_FQ_NAME) +fun CallableMemberDescriptor.hasJvmDefaultAnnotation(): Boolean = + DescriptorUtils.getDirectMember(this).annotations.hasAnnotation(JVM_DEFAULT_FQ_NAME) + fun CallableMemberDescriptor.hasPlatformDependentAnnotation(): Boolean = DescriptorUtils.getDirectMember(this).annotations.hasAnnotation(PLATFORM_DEPENDENT_ANNOTATION_FQ_NAME) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt index bb819827787..68d688e01df 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt @@ -36,7 +36,7 @@ import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getSuperCallExpressio import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall -import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmDefaultAnnotation +import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefaultIfNoAbstract import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.* class InterfaceDefaultMethodCallChecker(val jvmTarget: JvmTarget) : CallChecker { @@ -63,13 +63,13 @@ class InterfaceDefaultMethodCallChecker(val jvmTarget: JvmTarget) : CallChecker val realDescriptorOwner = realDescriptor.containingDeclaration as? ClassDescriptor ?: return val jvmDefaultMode = context.languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) - if (isInterface(realDescriptorOwner) && (realDescriptor is JavaCallableMemberDescriptor || realDescriptor.hasJvmDefaultAnnotation(jvmDefaultMode))) { + if (isInterface(realDescriptorOwner) && (realDescriptor is JavaCallableMemberDescriptor || realDescriptor.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode))) { val bindingContext = context.trace.bindingContext val thisForSuperCall = getSuperCallLabelTarget(bindingContext, superCallExpression) if (thisForSuperCall != null && DescriptorUtils.isInterface(thisForSuperCall)) { val declarationWithCall = findInterfaceMember(thisForSuperCall, superCallExpression, bindingContext) - if (declarationWithCall?.hasJvmDefaultAnnotation(jvmDefaultMode) == false) { + if (declarationWithCall?.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode) == false) { context.trace.report(INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER.on(reportOn)) return } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt index 2175f5a2d08..21516b2de9d 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.resolve.OverridingUtil import org.jetbrains.kotlin.resolve.checkers.DeclarationChecker import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext import org.jetbrains.kotlin.resolve.jvm.annotations.JVM_DEFAULT_FQ_NAME -import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmDefaultAnnotation +import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefaultIfNoAbstract import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm class JvmDefaultChecker(val jvmTarget: JvmTarget) : DeclarationChecker { @@ -41,7 +41,7 @@ class JvmDefaultChecker(val jvmTarget: JvmTarget) : DeclarationChecker { if (descriptor is ClassDescriptor) { val hasDeclaredJvmDefaults = descriptor.unsubstitutedMemberScope.getContributedDescriptors().filterIsInstance().any { - it.kind.isReal && it.hasJvmDefaultAnnotation(jvmDefaultMode) + it.kind.isReal && it.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode) } if (!hasDeclaredJvmDefaults && !checkJvmDefaultsInHierarchy(descriptor, jvmDefaultMode)) { context.trace.report(ErrorsJvm.JVM_DEFAULT_THROUGH_INHERITANCE.on(declaration)) @@ -74,7 +74,7 @@ class JvmDefaultChecker(val jvmTarget: JvmTarget) : DeclarationChecker { return descriptor.unsubstitutedMemberScope.getContributedDescriptors().filterIsInstance() .all { memberDescriptor -> memberDescriptor.kind.isReal || OverridingUtil.filterOutOverridden(memberDescriptor.overriddenDescriptors.toSet()).all { - !isInterface(it.containingDeclaration) || !it.hasJvmDefaultAnnotation(jvmDefaultMode) || it.modality == Modality.ABSTRACT + !isInterface(it.containingDeclaration) || !it.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode) || it.modality == Modality.ABSTRACT } } } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmDefaultSuperCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmDefaultSuperCallChecker.kt index d56439db548..fa5e9078f12 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmDefaultSuperCallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmDefaultSuperCallChecker.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getSuperCallExpressio import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall -import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmDefaultAnnotation +import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefaultIfNoAbstract import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm class JvmDefaultSuperCallChecker : CallChecker { @@ -23,7 +23,7 @@ class JvmDefaultSuperCallChecker : CallChecker { if (getSuperCallExpression(resolvedCall.call) == null) return val resultingDescriptor = resolvedCall.resultingDescriptor as? CallableMemberDescriptor ?: return - if (!resultingDescriptor.hasJvmDefaultAnnotation(jvmDefaultMode)) return + if (!resultingDescriptor.isCompiledToJvmDefaultIfNoAbstract(jvmDefaultMode)) return if (DescriptorUtils.isInterface(resultingDescriptor.containingDeclaration)) { context.trace.report(ErrorsJvm.USAGE_OF_JVM_DEFAULT_THROUGH_SUPER_CALL.on(reportOn))