diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt index 63fd2f20488..57f8ae0e693 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt @@ -20,11 +20,9 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor -import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor import org.jetbrains.kotlin.resolve.calls.components.hasDefaultValue import org.jetbrains.kotlin.resolve.calls.model.* import org.jetbrains.kotlin.resolve.descriptorUtil.overriddenTreeUniqueAsSequence -import org.jetbrains.kotlin.utils.DFS import org.jetbrains.kotlin.utils.mapToIndex class ArgumentAndDeclIndex(val arg: ResolvedValueArgument, val declIndex: Int) @@ -70,12 +68,8 @@ abstract class ArgumentGenerator { generateExpression(declIndex, argument) } is DefaultValueArgument -> { - if (calleeDescriptor?.defaultValueFromJava(declIndex) == true) { - generateDefaultJava(declIndex, argument) - } else { - defaultArgs.mark(declIndex) - generateDefault(declIndex, argument) - } + defaultArgs.mark(declIndex) + generateDefault(declIndex, argument) } is VarargValueArgument -> { generateVararg(declIndex, argument) @@ -103,10 +97,6 @@ abstract class ArgumentGenerator { throw UnsupportedOperationException("Unsupported vararg value argument #$i: $argument") } - protected open fun generateDefaultJava(i: Int, argument: DefaultValueArgument) { - throw UnsupportedOperationException("Unsupported default java argument #$i: $argument") - } - protected open fun generateOther(i: Int, argument: ResolvedValueArgument) { throw UnsupportedOperationException("Unsupported value argument #$i: $argument") } @@ -116,28 +106,6 @@ abstract class ArgumentGenerator { } } -private fun CallableDescriptor.defaultValueFromJava(index: Int): Boolean = DFS.ifAny( - listOf(this), - { current -> current.original.overriddenDescriptors.map { it.original } }, - { descriptor -> - descriptor.original.overriddenDescriptors.isEmpty() && - descriptor is JavaCallableMemberDescriptor && - descriptor.valueParameters[index].declaresDefaultValue() - } -) - -fun shouldInvokeDefaultArgumentsStub(resolvedCall: ResolvedCall<*>): Boolean { - val descriptor = resolvedCall.resultingDescriptor - val valueArgumentsByIndex = resolvedCall.valueArgumentsByIndex ?: return false - for (index in valueArgumentsByIndex.indices) { - val resolvedValueArgument = valueArgumentsByIndex[index] - if (resolvedValueArgument is DefaultValueArgument && !descriptor.defaultValueFromJava(index)) { - return true - } - } - return false -} - fun getFunctionWithDefaultArguments(functionDescriptor: FunctionDescriptor): FunctionDescriptor { if (functionDescriptor.containingDeclaration !is ClassDescriptor) return functionDescriptor if (functionDescriptor.overriddenDescriptors.isEmpty()) return functionDescriptor @@ -155,4 +123,4 @@ fun getFunctionWithDefaultArguments(functionDescriptor: FunctionDescriptor): Fun function.valueParameters.any { valueParameter -> valueParameter.hasDefaultValue() } } ?: functionDescriptor -} \ No newline at end of file +} diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.kt index c9918229723..2af03c53ab4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.kt @@ -72,12 +72,6 @@ class CallBasedArgumentGenerator( callGenerator.putValueIfNeeded(getJvmKotlinType(i), lazyVararg, ValueKind.GENERAL_VARARG, i) } - override fun generateDefaultJava(i: Int, argument: DefaultValueArgument) { - val argumentValue = valueParameters[i].findJavaDefaultArgumentValue(valueParameterTypes[i], codegen.typeMapper) - - callGenerator.putValueIfNeeded(getJvmKotlinType(i), argumentValue) - } - override fun reorderArgumentsIfNeeded(args: List) { callGenerator.reorderArgumentsIfNeeded(args, valueParameterTypes) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 974f617c47d..cb23cd5c181 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -74,7 +74,10 @@ import org.jetbrains.kotlin.resolve.constants.*; import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluatorKt; import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt; import org.jetbrains.kotlin.resolve.inline.InlineUtil; -import org.jetbrains.kotlin.resolve.jvm.*; +import org.jetbrains.kotlin.resolve.jvm.AsmTypes; +import org.jetbrains.kotlin.resolve.jvm.JvmBindingContextSlices; +import org.jetbrains.kotlin.resolve.jvm.JvmConstantsKt; +import org.jetbrains.kotlin.resolve.jvm.RuntimeAssertionInfo; import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature; @@ -2690,7 +2693,7 @@ public class ExpressionCodegen extends KtVisitor impleme } @NotNull - Callable resolveToCallable(@NotNull FunctionDescriptor fd, boolean superCall, @NotNull ResolvedCall resolvedCall) { + Callable resolveToCallable(@NotNull FunctionDescriptor fd, boolean superCall, @NotNull ResolvedCall resolvedCall) { IntrinsicMethod intrinsic = state.getIntrinsics().getIntrinsic(fd); if (intrinsic != null) { return intrinsic.toCallable(fd, superCall, resolvedCall, this); @@ -2698,7 +2701,8 @@ public class ExpressionCodegen extends KtVisitor impleme fd = SamCodegenUtil.resolveSamAdapter(fd); - if (ArgumentGeneratorKt.shouldInvokeDefaultArgumentsStub(resolvedCall)) { + List valueArguments = resolvedCall.getValueArgumentsByIndex(); + if (valueArguments != null && valueArguments.stream().anyMatch(it -> it instanceof DefaultValueArgument)) { // When we invoke a function with some arguments mapped as defaults, // we later reroute this call to an overridden function in a base class that processes the default arguments. // If the base class is generic, this overridden function can have a different Kotlin signature diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ObjectSuperCallArgumentGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/ObjectSuperCallArgumentGenerator.kt index 0b0f274db8a..165564ad61f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ObjectSuperCallArgumentGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ObjectSuperCallArgumentGenerator.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.descriptors.ConstructorDescriptor import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.resolve.calls.model.* import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature -import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter internal class ObjectSuperCallArgumentGenerator( @@ -65,12 +64,6 @@ internal class ObjectSuperCallArgumentGenerator( pushDefaultValueOnStack(type, iv) } - public override fun generateDefaultJava(i: Int, argument: DefaultValueArgument) { - val type = parameters[i].asmType - val value = superValueParameters[i].findJavaDefaultArgumentValue(type, typeMapper) - value.put(type, iv) - } - public override fun generateVararg(i: Int, argument: VarargValueArgument) { generateSuperCallArgument(i) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.kt index 72a1f5ac118..5053ed02192 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.kt @@ -5,18 +5,7 @@ package org.jetbrains.kotlin.codegen -import org.jetbrains.kotlin.codegen.AsmUtil.unboxPrimitiveTypeOrNull -import org.jetbrains.kotlin.codegen.StackValue.* -import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor -import org.jetbrains.kotlin.load.java.Constant -import org.jetbrains.kotlin.load.java.EnumEntry -import org.jetbrains.kotlin.load.java.descriptors.NullDefaultValue -import org.jetbrains.kotlin.load.java.descriptors.StringDefaultValue -import org.jetbrains.kotlin.load.java.descriptors.getDefaultValueFromAnnotation -import org.jetbrains.kotlin.load.java.lexicalCastFrom import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.utils.DFS import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter @@ -86,40 +75,3 @@ class FunctionCallStackValue( resultKotlinType: KotlinType?, lambda: (v: InstructionAdapter) -> Unit ) : OperationStackValue(resultType, resultKotlinType, lambda) - -fun ValueParameterDescriptor.findJavaDefaultArgumentValue(targetType: Type, typeMapper: KotlinTypeMapper): StackValue { - val descriptorWithDefaultValue = DFS.dfs( - listOf(this.original), - { it.original.overriddenDescriptors.map(ValueParameterDescriptor::getOriginal) }, - object : DFS.AbstractNodeHandler() { - var result: ValueParameterDescriptor? = null - - override fun beforeChildren(current: ValueParameterDescriptor?): Boolean { - if (current?.declaresDefaultValue() == true && current.getDefaultValueFromAnnotation() != null) { - result = current - return false - } - - return true - } - - override fun result(): ValueParameterDescriptor? = result - } - ) ?: error("Should be at least one descriptor with default value: $this") - - val defaultValue = descriptorWithDefaultValue.getDefaultValueFromAnnotation() - if (defaultValue is NullDefaultValue) { - return constant(null, targetType) - } - - val value = (defaultValue as StringDefaultValue).value - val castResult = type.lexicalCastFrom(value) ?: error("Should be checked in frontend") - - return when (castResult) { - is EnumEntry -> enumEntry(castResult.descriptor, typeMapper) - is Constant -> { - val unboxedType = unboxPrimitiveTypeOrNull(targetType) ?: targetType - return coercion(constant(castResult.value, unboxedType), targetType, null) - } - } -} diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt index f139b9ab77b..9359dd373bd 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt @@ -18,8 +18,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty import org.jetbrains.kotlin.fir.declarations.synthetic.buildSyntheticProperty -import org.jetbrains.kotlin.fir.expressions.FirExpression -import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack import org.jetbrains.kotlin.fir.java.declarations.* import org.jetbrains.kotlin.fir.render @@ -30,12 +28,9 @@ import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef import org.jetbrains.kotlin.load.java.AnnotationQualifierApplicabilityType -import org.jetbrains.kotlin.load.java.descriptors.NullDefaultValue -import org.jetbrains.kotlin.load.java.descriptors.StringDefaultValue import org.jetbrains.kotlin.load.java.typeEnhancement.* import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.utils.JavaTypeEnhancementState import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -185,27 +180,26 @@ class FirSignatureEnhancement( enhanceReturnType(firMethod, overriddenMembers, memberContext, predefinedEnhancementInfo) } - val newValueParameterInfo = mutableListOf() + val enhancedValueParameterTypes = mutableListOf() for ((index, valueParameter) in firMethod.valueParameters.withIndex()) { if (hasReceiver && index == 0) continue - newValueParameterInfo += enhanceValueParameter( + enhancedValueParameterTypes += enhanceValueParameterType( firMethod, overriddenMembers, hasReceiver, memberContext, predefinedEnhancementInfo, valueParameter as FirJavaValueParameter, if (hasReceiver) index - 1 else index ) } - val newValueParameters = firMethod.valueParameters.zip(newValueParameterInfo) { valueParameter, newInfo -> - val (newTypeRef, newDefaultValue) = newInfo + val newValueParameters = firMethod.valueParameters.zip(enhancedValueParameterTypes) { valueParameter, enhancedReturnType -> buildValueParameter { source = valueParameter.source session = this@FirSignatureEnhancement.session origin = FirDeclarationOrigin.Enhancement - returnTypeRef = newTypeRef + returnTypeRef = enhancedReturnType this.name = valueParameter.name symbol = FirVariableSymbol(this.name) - defaultValue = valueParameter.defaultValue ?: newDefaultValue + defaultValue = valueParameter.defaultValue isCrossinline = valueParameter.isCrossinline isNoinline = valueParameter.isNoinline isVararg = valueParameter.isVararg @@ -298,9 +292,7 @@ class FirSignatureEnhancement( return signatureParts.type } - private data class EnhanceValueParameterResult(val typeRef: FirResolvedTypeRef, val defaultValue: FirExpression?) - - private fun enhanceValueParameter( + private fun enhanceValueParameterType( ownerFunction: FirFunction<*>, overriddenMembers: List>, hasReceiver: Boolean, @@ -308,7 +300,7 @@ class FirSignatureEnhancement( predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo?, ownerParameter: FirJavaValueParameter, index: Int - ): EnhanceValueParameterResult { + ): FirResolvedTypeRef { val signatureParts = ownerFunction.partsForValueParameter( typeQualifierResolver, overriddenMembers, @@ -321,13 +313,7 @@ class FirSignatureEnhancement( predefinedEnhancementInfo?.parametersInfo?.getOrNull(index), forAnnotationMember = owner.classKind == ClassKind.ANNOTATION_CLASS ) - val firResolvedTypeRef = signatureParts.type - val defaultValueExpression = when (val defaultValue = ownerParameter.getDefaultValueFromAnnotation()) { - NullDefaultValue -> buildConstExpression(null, ConstantValueKind.Null, null) - is StringDefaultValue -> firResolvedTypeRef.type.lexicalCastFrom(session, defaultValue.value) - null -> null - } - return EnhanceValueParameterResult(firResolvedTypeRef, defaultValueExpression) + return signatureParts.type } private fun enhanceReturnType( diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt index e6cb0f6b97a..b25ce89fe98 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt @@ -13,11 +13,6 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression import org.jetbrains.kotlin.fir.expressions.builder.buildQualifiedAccessExpression -import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.FirValueParameter -import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.fir.expressions.FirConstExpression -import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass import org.jetbrains.kotlin.fir.java.declarations.FirJavaField import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference @@ -31,11 +26,6 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef import org.jetbrains.kotlin.load.java.JavaDefaultQualifiers -import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_NULL_FQ_NAME -import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_VALUE_FQ_NAME -import org.jetbrains.kotlin.load.java.descriptors.AnnotationDefaultValue -import org.jetbrains.kotlin.load.java.descriptors.NullDefaultValue -import org.jetbrains.kotlin.load.java.descriptors.StringDefaultValue import org.jetbrains.kotlin.load.java.structure.JavaClassifierType import org.jetbrains.kotlin.load.java.structure.JavaType import org.jetbrains.kotlin.load.java.typeEnhancement.* @@ -45,7 +35,6 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.AbstractStrictEqualityTypeChecker import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.RawType -import org.jetbrains.kotlin.utils.addToStdlib.safeAs import org.jetbrains.kotlin.utils.extractRadix internal class IndexedJavaTypeQualifiers(private val data: Array) { @@ -317,22 +306,6 @@ internal fun ConeKotlinType.lexicalCastFrom(session: FirSession, value: String): } } -internal fun FirValueParameter.getDefaultValueFromAnnotation(): AnnotationDefaultValue? { - annotations.find { it.classId == DEFAULT_VALUE_ID } - ?.arguments?.firstOrNull() - ?.safeAs>()?.value?.safeAs() - ?.let { return StringDefaultValue(it) } - - if (annotations.any { it.classId == DEFAULT_NULL_ID }) { - return NullDefaultValue - } - - return null -} - -private val DEFAULT_VALUE_ID = ClassId.topLevel(DEFAULT_VALUE_FQ_NAME) -private val DEFAULT_NULL_ID = ClassId.topLevel(DEFAULT_NULL_FQ_NAME) - internal fun List.computeTypeAttributesForJavaType(): ConeAttributes = computeTypeAttributes { classId -> when (classId) { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java index bb1f88ff226..2044df9624b 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java @@ -22,12 +22,10 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.kotlin.incremental.components.NoLookupLocation; import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor; -import org.jetbrains.kotlin.load.java.descriptors.UtilKt; import org.jetbrains.kotlin.load.java.structure.JavaMethod; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.resolve.DescriptorUtils; @@ -68,12 +66,10 @@ public class SignaturesPropagationData { JavaMethodDescriptor autoMethodDescriptor = createAutoMethodDescriptor(containingClass, method, autoReturnType, autoValueParameters, autoTypeParameters); - boolean hasStableParameterNames = autoValueParameters.stream().allMatch(it -> UtilKt.getParameterNameAnnotation(it) != null); - superFunctions = getSuperFunctionsForMethod(method, autoMethodDescriptor, containingClass); modifiedValueParameters = superFunctions.isEmpty() - ? new ValueParameters(null, autoValueParameters, hasStableParameterNames) - : modifyValueParametersAccordingToSuperMethods(autoValueParameters, hasStableParameterNames); + ? new ValueParameters(null, autoValueParameters, false) + : modifyValueParametersAccordingToSuperMethods(autoValueParameters); } @NotNull @@ -123,10 +119,7 @@ public class SignaturesPropagationData { signatureErrors.add(error); } - private ValueParameters modifyValueParametersAccordingToSuperMethods( - @NotNull List parameters, - boolean annotatedWithParameterName - ) { + private ValueParameters modifyValueParametersAccordingToSuperMethods(@NotNull List parameters) { KotlinType resultReceiverType = null; List resultParameters = new ArrayList<>(parameters.size()); @@ -167,15 +160,12 @@ public class SignaturesPropagationData { } } - AnnotationDescriptor currentName = UtilKt.getParameterNameAnnotation(originalParam); - boolean shouldTakeOldName = currentName == null && stableName != null; - resultParameters.add(new ValueParameterDescriptorImpl( originalParam.getContainingDeclaration(), null, shouldBeExtension ? originalIndex - 1 : originalIndex, originalParam.getAnnotations(), - shouldTakeOldName ? stableName : originalParam.getName(), + stableName != null ? stableName : originalParam.getName(), altType, originalParam.declaresDefaultValue(), originalParam.isCrossinline(), @@ -186,8 +176,7 @@ public class SignaturesPropagationData { } } - boolean hasStableParameterNames = - annotatedWithParameterName || CollectionsKt.any(superFunctions, CallableDescriptor::hasStableParameterNames); + boolean hasStableParameterNames = CollectionsKt.any(superFunctions, CallableDescriptor::hasStableParameterNames); return new ValueParameters(resultReceiverType, resultParameters, hasStableParameterNames); } diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java index f5897f1ba1a..e2420c17411 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java @@ -72,10 +72,6 @@ public final class JvmAnnotationNames { public static final FqName ENHANCED_NULLABILITY_ANNOTATION = new FqName("kotlin.jvm.internal.EnhancedNullability"); public static final FqName ENHANCED_MUTABILITY_ANNOTATION = new FqName("kotlin.jvm.internal.EnhancedMutability"); - public static final FqName PARAMETER_NAME_FQ_NAME = new FqName("kotlin.annotations.jvm.internal.ParameterName"); - public static final FqName DEFAULT_VALUE_FQ_NAME = new FqName("kotlin.annotations.jvm.internal.DefaultValue"); - public static final FqName DEFAULT_NULL_FQ_NAME = new FqName("kotlin.annotations.jvm.internal.DefaultNull"); - private JvmAnnotationNames() { } } diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/descriptors/AnnotationDefaultValue.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/descriptors/AnnotationDefaultValue.kt deleted file mode 100644 index c4abb83e5b7..00000000000 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/descriptors/AnnotationDefaultValue.kt +++ /dev/null @@ -1,12 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.load.java.descriptors - -sealed class AnnotationDefaultValue - -class StringDefaultValue(val value: String) : AnnotationDefaultValue() - -object NullDefaultValue : AnnotationDefaultValue() diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/util.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/util.kt index dc8501dcb4d..9a1cd490190 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/util.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/util.kt @@ -19,19 +19,14 @@ package org.jetbrains.kotlin.load.java.descriptors import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl -import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaStaticClassScope import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource -import org.jetbrains.kotlin.resolve.constants.StringValue -import org.jetbrains.kotlin.resolve.descriptorUtil.firstArgument import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.resolve.jvm.JvmClassName import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.utils.addToStdlib.safeAs class ValueParameterData(val type: KotlinType, val hasDefaultValue: Boolean) @@ -72,25 +67,3 @@ fun DescriptorWithContainerSource.getImplClassNameForDeserialized(): JvmClassNam fun DescriptorWithContainerSource.isFromJvmPackagePart(): Boolean = containerSource is JvmPackagePartSource - -fun ValueParameterDescriptor.getParameterNameAnnotation(): AnnotationDescriptor? { - val annotation = annotations.findAnnotation(JvmAnnotationNames.PARAMETER_NAME_FQ_NAME) ?: return null - if (annotation.firstArgument()?.safeAs()?.value?.isEmpty() != false) { - return null - } - - return annotation -} - -fun ValueParameterDescriptor.getDefaultValueFromAnnotation(): AnnotationDefaultValue? { - annotations.findAnnotation(JvmAnnotationNames.DEFAULT_VALUE_FQ_NAME) - ?.firstArgument() - ?.safeAs()?.value - ?.let { return StringDefaultValue(it) } - - if (annotations.hasAnnotation(JvmAnnotationNames.DEFAULT_NULL_FQ_NAME)) { - return NullDefaultValue - } - - return null -} diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt index e38a6004ec2..c124c7dc8e7 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.incremental.components.LookupLocation import org.jetbrains.kotlin.incremental.components.NoLookupLocation -import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.java.components.TypeUsage import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor @@ -39,8 +38,6 @@ import org.jetbrains.kotlin.load.java.toDescriptorVisibility import org.jetbrains.kotlin.load.kotlin.computeJvmDescriptor import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.* -import org.jetbrains.kotlin.resolve.constants.StringValue -import org.jetbrains.kotlin.resolve.descriptorUtil.firstArgument import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude.NonExtensions import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.scopes.MemberScope @@ -53,7 +50,6 @@ import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.utils.Printer import org.jetbrains.kotlin.utils.addIfNotNull -import org.jetbrains.kotlin.utils.addToStdlib.safeAs import java.util.* abstract class LazyJavaScope( @@ -212,15 +208,9 @@ abstract class LazyJavaScope( jValueParameters: List ): ResolvedValueParameters { var synthesizedNames = false - val usedNames = mutableSetOf() - val descriptors = jValueParameters.withIndex().map { (index, javaParameter) -> val annotations = c.resolveAnnotations(javaParameter) val typeUsage = TypeUsage.COMMON.toAttributes() - val parameterName = annotations - .findAnnotation(JvmAnnotationNames.PARAMETER_NAME_FQ_NAME) - ?.firstArgument() - ?.safeAs()?.value val (outType, varargElementType) = if (javaParameter.isVararg) { @@ -241,8 +231,6 @@ abstract class LazyJavaScope( // "other" in Any) // TODO: fix Java parameter name loading logic somehow (don't always load "p0", "p1", etc.) Name.identifier("other") - } else if (parameterName != null && parameterName.isNotEmpty() && usedNames.add(parameterName)) { - Name.identifier(parameterName) } else { // TODO: parameter names may be drawn from attached sources, which is slow; it's better to make them lazy val javaName = javaParameter.name diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 6e4a1f372ac..879d69b2925 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -195,14 +195,8 @@ class SignatureEnhancement( } val valueParameterEnhancements = annotationOwnerForMember.valueParameters.map { p -> - val enhancementResult = partsForValueParameter(p, memberContext) { it.valueParameters[p.index].type } + partsForValueParameter(p, memberContext) { it.valueParameters[p.index].type } .enhance(predefinedEnhancementInfo?.parametersInfo?.getOrNull(p.index)) - - val actualType = if (enhancementResult.wereChanges) enhancementResult.type else p.type - val hasDefaultValue = p.hasDefaultValueInAnnotation(actualType) - val wereChanges = enhancementResult.wereChanges || (hasDefaultValue != p.declaresDefaultValue()) - - ValueParameterEnhancementResult(enhancementResult.type, hasDefaultValue, wereChanges, enhancementResult.containsFunctionN) } val returnTypeEnhancement = @@ -231,7 +225,7 @@ class SignatureEnhancement( @Suppress("UNCHECKED_CAST") return this.enhance( receiverTypeEnhancement?.type, - valueParameterEnhancements.map { ValueParameterData(it.type, it.hasDefaultValue) }, + valueParameterEnhancements.map { ValueParameterData(it.type, false) }, returnTypeEnhancement.type, additionalUserData ) as D @@ -263,13 +257,6 @@ class SignatureEnhancement( fun enhanceSuperType(type: KotlinType, context: LazyJavaResolverContext) = SignatureParts(null, type, emptyList(), false, context, AnnotationQualifierApplicabilityType.TYPE_USE).enhance().type - private fun ValueParameterDescriptor.hasDefaultValueInAnnotation(type: KotlinType) = - when (val defaultValue = getDefaultValueFromAnnotation()) { - is StringDefaultValue -> type.lexicalCastFrom(defaultValue.value) != null - NullDefaultValue -> TypeUtils.acceptsNullable(type) - null -> declaresDefaultValue() - } && overriddenDescriptors.isEmpty() - private inner class SignatureParts( private val typeContainer: Annotated?, private val fromOverride: KotlinType, @@ -592,13 +579,6 @@ class SignatureEnhancement( val containsFunctionN: Boolean ) - private class ValueParameterEnhancementResult( - type: KotlinType, - val hasDefaultValue: Boolean, - wereChanges: Boolean, - containsFunctionN: Boolean - ) : PartEnhancementResult(type, wereChanges, containsFunctionN) - private fun CallableMemberDescriptor.partsForValueParameter( // TODO: investigate if it's really can be a null (check properties' with extension overrides in Java) parameterDescriptor: ValueParameterDescriptor?, diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/utils.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/utils.kt index 020f81b21ea..30a82002d09 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/utils.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/utils.kt @@ -16,53 +16,12 @@ package org.jetbrains.kotlin.load.java -import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.incremental.components.NoLookupLocation -import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.DescriptorVisibility +import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.resolve.deprecation.Deprecation import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.typeUtil.makeNotNullable -import org.jetbrains.kotlin.utils.extractRadix - -sealed class JavaDefaultValue -class EnumEntry(val descriptor: ClassDescriptor) : JavaDefaultValue() -class Constant(val value: Any) : JavaDefaultValue() - -fun KotlinType.lexicalCastFrom(value: String): JavaDefaultValue? { - val typeDescriptor = constructor.declarationDescriptor - if (typeDescriptor is ClassDescriptor && typeDescriptor.kind == ClassKind.ENUM_CLASS) { - val descriptor = typeDescriptor.unsubstitutedInnerClassesScope.getContributedClassifier( - Name.identifier(value), - NoLookupLocation.FROM_BACKEND - ) - - return if (descriptor is ClassDescriptor && descriptor.kind == ClassKind.ENUM_ENTRY) EnumEntry(descriptor) else null - } - - val type = this.makeNotNullable() - val (number, radix) = extractRadix(value) - val result: Any? = try { - when { - KotlinBuiltIns.isBoolean(type) -> value.toBoolean() - KotlinBuiltIns.isChar(type) -> value.singleOrNull() - KotlinBuiltIns.isByte(type) -> number.toByteOrNull(radix) - KotlinBuiltIns.isShort(type) -> number.toShortOrNull(radix) - KotlinBuiltIns.isInt(type) -> number.toIntOrNull(radix) - KotlinBuiltIns.isLong(type) -> number.toLongOrNull(radix) - KotlinBuiltIns.isFloat(type) -> value.toFloatOrNull() - KotlinBuiltIns.isDouble(type) -> value.toDoubleOrNull() - KotlinBuiltIns.isString(type) -> value - else -> null - } - } catch (e: IllegalArgumentException) { - null - } - - return if (result != null) Constant(result) else null -} class DeprecationCausedByFunctionN(override val target: DeclarationDescriptor) : Deprecation { override val deprecationLevel: DeprecationLevelValue