From 14a6a06166fdb7b82b5f39b3b50fb2760ba4880c Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 7 Aug 2019 07:20:49 +0200 Subject: [PATCH] JVM IR: do not use GenerationState.typeMapper The only remaining usages are in IrTypeMapper, MethodSignatureMapper and in InterfaceDelegationLowering.generateDelegationToDefaultImpl --- .../kotlin/backend/jvm/JvmBackendContext.kt | 6 +-- .../backend/jvm/codegen/AnnotationCodegen.kt | 42 ++++++++----------- .../backend/jvm/codegen/ClassCodegen.kt | 4 +- .../backend/jvm/codegen/ExpressionCodegen.kt | 4 +- .../backend/jvm/codegen/FunctionCodegen.kt | 31 ++++++-------- .../jvm/codegen/IrSourceCompilerForInline.kt | 2 +- .../jvm/codegen/MethodSignatureMapper.kt | 13 ++++-- .../backend/jvm/codegen/irCodegenUtils.kt | 7 +++- .../jvm/descriptors/JvmDeclarationFactory.kt | 7 ++-- .../backend/jvm/intrinsics/ArrayIterator.kt | 4 +- .../kotlin/backend/jvm/intrinsics/BinaryOp.kt | 16 +++---- .../backend/jvm/intrinsics/IntrinsicMethod.kt | 5 +-- .../backend/jvm/intrinsics/IrEnumValueOf.kt | 6 +-- .../jvm/intrinsics/IrIntrinsicFunction.kt | 4 +- .../backend/jvm/intrinsics/IsArrayOf.kt | 30 ++++--------- .../AdditionalClassAnnotationLowering.kt | 7 ++-- .../backend/jvm/lower/BridgeLowering.kt | 9 ++-- .../jvm/lower/CollectionStubMethodLowering.kt | 17 ++++---- .../jvm/lower/JvmStaticAnnotationLowering.kt | 2 +- .../jvm/lower/PropertyReferenceLowering.kt | 4 +- .../jvm/lower/SyntheticAccessorLowering.kt | 5 +-- .../backend/jvm/lower/ToArrayLowering.kt | 2 +- 22 files changed, 104 insertions(+), 123 deletions(-) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt index ac836f97d7a..afb792d4a19 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt @@ -41,12 +41,12 @@ class JvmBackendContext( private val firMode: Boolean ) : CommonBackendContext { override val builtIns = state.module.builtIns - override val declarationFactory: JvmDeclarationFactory = JvmDeclarationFactory(state) - override val sharedVariablesManager = JvmSharedVariablesManager(state.module, builtIns, irBuiltIns) - val typeMapper = IrTypeMapper(this) val methodSignatureMapper = MethodSignatureMapper(this) + override val declarationFactory: JvmDeclarationFactory = JvmDeclarationFactory(methodSignatureMapper) + override val sharedVariablesManager = JvmSharedVariablesManager(state.module, builtIns, irBuiltIns) + private val symbolTable = symbolTable.lazyWrapper override val ir = JvmIr(irModuleFragment, this.symbolTable) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt index b134230018e..ad218748e01 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt @@ -19,16 +19,19 @@ package org.jetbrains.kotlin.backend.jvm.codegen import org.jetbrains.annotations.NotNull import org.jetbrains.annotations.Nullable import org.jetbrains.kotlin.backend.common.ir.ir2string +import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.codegen.AsmUtil -import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.* -import org.jetbrains.kotlin.ir.types.* +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.classifierOrNull +import org.jetbrains.kotlin.ir.types.isMarkedNullable +import org.jetbrains.kotlin.ir.types.isNullable import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable import org.jetbrains.kotlin.ir.util.getAnnotation import org.jetbrains.kotlin.ir.util.isAnnotationClass @@ -42,11 +45,11 @@ import java.lang.annotation.RetentionPolicy class AnnotationCodegen( private val innerClassConsumer: InnerClassConsumer, - state: GenerationState, + context: JvmBackendContext, private val visitAnnotation: (descriptor: String, visible: Boolean) -> AnnotationVisitor ) { - - private val typeMapper = state.typeMapper + private val typeMapper = context.typeMapper + private val methodSignatureMapper = context.methodSignatureMapper /** * @param returnType can be null if not applicable (e.g. [annotated] is a class) @@ -153,15 +156,13 @@ class AnnotationCodegen( private fun genAnnotation(annotation: IrConstructorCall): String? { val annotationClass = annotation.annotationClass - val rp = getRetentionPolicy(annotationClass) - if (rp == RetentionPolicy.SOURCE && !typeMapper.classBuilderMode.generateSourceRetentionAnnotations) { - return null - } + val retentionPolicy = getRetentionPolicy(annotationClass) + if (retentionPolicy == RetentionPolicy.SOURCE) return null innerClassConsumer.addInnerClassInfoFromAnnotation(annotationClass) - val asmTypeDescriptor = typeMapper.mapType(annotation.type.toKotlinType()).descriptor - val annotationVisitor = visitAnnotation(asmTypeDescriptor, rp == RetentionPolicy.RUNTIME) + val asmTypeDescriptor = typeMapper.mapType(annotation.type).descriptor + val annotationVisitor = visitAnnotation(asmTypeDescriptor, retentionPolicy == RetentionPolicy.RUNTIME) genAnnotationArguments(annotation, annotationVisitor) annotationVisitor.visitEnd() @@ -188,7 +189,7 @@ class AnnotationCodegen( annotationClass.declarations.filterIsInstance().singleOrNull { it.name == parameterName } ?: return parameterName.asString() - return typeMapper.mapAnnotationParameterName(field.descriptor) + return methodSignatureMapper.mapAnnotationParameterName(field) } private fun genCompileTimeValue( @@ -196,20 +197,13 @@ class AnnotationCodegen( value: IrExpression, annotationVisitor: AnnotationVisitor ) { - fun visitUnsupportedValue(value: IrExpression) { - val mode = typeMapper.classBuilderMode - if (mode.generateBodies) { - throw IllegalStateException("Don't know how to compile annotation value ${ir2string(value)}") - } - } - when (value) { is IrConst<*> -> annotationVisitor.visit(name, value.value) is IrConstructorCall -> { val callee = value.symbol.owner when { callee.parentAsClass.isAnnotationClass -> { - val internalAnnName = typeMapper.mapType(callee.returnType.toKotlinType()).descriptor + val internalAnnName = typeMapper.mapType(callee.returnType).descriptor val visitor = annotationVisitor.visitAnnotation(name, internalAnnName) genAnnotationArguments(value, visitor) visitor.visitEnd() @@ -218,7 +212,7 @@ class AnnotationCodegen( } } is IrGetEnumValue -> { - val enumClassInternalName = typeMapper.mapClass(value.symbol.owner.parentAsClass.descriptor).descriptor + val enumClassInternalName = typeMapper.mapClass(value.symbol.owner.parentAsClass).descriptor val enumEntryName = value.symbol.owner.name annotationVisitor.visitEnum(name, enumClassInternalName, enumEntryName.asString()) } @@ -230,10 +224,10 @@ class AnnotationCodegen( visitor.visitEnd() } is IrClassReference -> { - annotationVisitor.visit(name, typeMapper.mapType(value.classType.toKotlinType())) + annotationVisitor.visit(name, typeMapper.mapType(value.classType)) } - is IrErrorExpression -> visitUnsupportedValue(value) - else -> error("Unsupported compiletime value ${ir2string(value)}") + is IrErrorExpression -> error("Don't know how to compile annotation value ${ir2string(value)}") + else -> error("Unsupported compile-time value ${ir2string(value)}") } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt index a568e5375f6..3398dbcb07e 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt @@ -91,7 +91,7 @@ open class ClassCodegen protected constructor( signature.superclassName, signature.interfaces.toTypedArray() ) - AnnotationCodegen(this, context.state, visitor.visitor::visitAnnotation).genAnnotations(irClass, null) + AnnotationCodegen(this, context, visitor.visitor::visitAnnotation).genAnnotations(irClass, null) val nestedClasses = irClass.declarations.mapNotNull { declaration -> if (declaration is IrClass) { @@ -258,7 +258,7 @@ open class ClassCodegen protected constructor( fieldSignature, field.constantValue(implicitConst)?.value ) - AnnotationCodegen(this, state, fv::visitAnnotation).genAnnotations(field, fieldType) + AnnotationCodegen(this, context, fv::visitAnnotation).genAnnotations(field, fieldType) val descriptor = field.metadata?.descriptor if (descriptor != null) { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index 077bfaf4eca..5c4a30ee61a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt @@ -321,7 +321,7 @@ class ExpressionCodegen( ?.invoke(expression, this, data)?.let { return it.coerce(expression.type) } val isSuperCall = (expression as? IrCall)?.superQualifier != null - val callable = resolveToCallable(expression, isSuperCall) + val callable = methodSignatureMapper.mapToCallableMethod(expression, isSuperCall) val callee = expression.symbol.owner val callGenerator = getOrCreateCallGenerator(expression, data) val asmType = if (expression is IrConstructorCall) typeMapper.mapTypeAsDeclaration(expression.type) else expression.asmType @@ -985,7 +985,7 @@ class ExpressionCodegen( } private fun resolveToCallable(irCall: IrFunctionAccessExpression, isSuper: Boolean): IrCallableMethod = - methodSignatureMapper.mapToCallableMethod(irCall.symbol.owner, isSuper) + methodSignatureMapper.mapToCallableMethod(irCall, isSuper) private fun getOrCreateCallGenerator(element: IrFunctionAccessExpression, data: BlockInfo): IrCallGenerator { if (!element.symbol.owner.isInlineFunctionCall(context) || diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt index 6883a47b8a5..9e5865ba1eb 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt @@ -5,12 +5,12 @@ package org.jetbrains.kotlin.backend.jvm.codegen +import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.builtins.KotlinBuiltIns.FQ_NAMES import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.ClassBuilderMode import org.jetbrains.kotlin.codegen.OwnerKind -import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.codegen.visitAnnotableParameterCount import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.declarations.* @@ -34,7 +34,7 @@ open class FunctionCodegen( private val classCodegen: ClassCodegen, private val isInlineLambda: Boolean = false ) { - + val context = classCodegen.context val state = classCodegen.state fun generate(): JvmMethodGenericSignature = @@ -58,26 +58,26 @@ open class FunctionCodegen( //TODO: investigate this case: annotation here is generated twice in lowered function and in interface method overload irFunction.origin == JvmLoweredDeclarationOrigin.GENERATED_SAM_IMPLEMENTATION ) { - AnnotationCodegen(classCodegen, state, methodVisitor::visitAnnotation).genAnnotations( + AnnotationCodegen(classCodegen, context, methodVisitor::visitAnnotation).genAnnotations( irFunction, signature.asmMethod.returnType ) - generateParameterAnnotations(irFunction, methodVisitor, signature, classCodegen, state) + generateParameterAnnotations(irFunction, methodVisitor, signature, classCodegen, context) } if (!state.classBuilderMode.generateBodies || flags.and(Opcodes.ACC_ABSTRACT) != 0 || irFunction.isExternal) { generateAnnotationDefaultValueIfNeeded(methodVisitor) } else { val frameMap = createFrameMapWithReceivers(signature) - val irClass = classCodegen.context.suspendFunctionContinuations[irFunction] + val irClass = context.suspendFunctionContinuations[irFunction] val element = (irFunction.symbol.descriptor.psiElement - ?: classCodegen.context.suspendLambdaToOriginalFunctionMap[irFunction.parent]?.symbol?.descriptor?.psiElement) as? KtElement - val continuationClassBuilder = classCodegen.context.continuationClassBuilders[irClass] + ?: context.suspendLambdaToOriginalFunctionMap[irFunction.parent]?.symbol?.descriptor?.psiElement) as? KtElement + val continuationClassBuilder = context.continuationClassBuilders[irClass] methodVisitor = when { irFunction.isSuspend -> generateStateMachineForNamedFunction( irFunction, classCodegen, methodVisitor, flags, signature, continuationClassBuilder, element!! ) - irFunction.isInvokeSuspendOfLambda(classCodegen.context) -> generateStateMachineForLambda( + irFunction.isInvokeSuspendOfLambda(context) -> generateStateMachineForLambda( classCodegen, methodVisitor, flags, signature, element!! ) else -> methodVisitor @@ -149,7 +149,7 @@ open class FunctionCodegen( private fun generateAnnotationDefaultValueIfNeeded(methodVisitor: MethodVisitor) { getAnnotationDefaultValueExpression()?.let { defaultValueExpression -> - val annotationCodegen = AnnotationCodegen(classCodegen, state) { _, _ -> methodVisitor.visitAnnotationDefault() } + val annotationCodegen = AnnotationCodegen(classCodegen, context) { _, _ -> methodVisitor.visitAnnotationDefault() } annotationCodegen.generateAnnotationDefaultValue(defaultValueExpression) } } @@ -208,7 +208,7 @@ fun generateParameterAnnotations( mv: MethodVisitor, jvmSignature: JvmMethodSignature, innerClassConsumer: InnerClassConsumer, - state: GenerationState + context: JvmBackendContext ) { val iterator = irFunction.valueParameters.iterator() val kotlinParameterTypes = jvmSignature.valueParameters @@ -217,7 +217,7 @@ fun generateParameterAnnotations( val kind = parameterSignature.kind if (kind.isSkippedInGenericSignature) { if (AsmUtil.IS_BUILT_WITH_ASM6) { - markEnumOrInnerConstructorParameterAsSynthetic(mv, i, state.classBuilderMode) + markEnumOrInnerConstructorParameterAsSynthetic(mv, i, ClassBuilderMode.FULL) } else { syntheticParameterCount++ } @@ -238,18 +238,13 @@ fun generateParameterAnnotations( } if (annotated != null) { - - AnnotationCodegen( - innerClassConsumer, - state - ) { descriptor, visible -> + AnnotationCodegen(innerClassConsumer, context) { descriptor, visible -> mv.visitParameterAnnotation( if (AsmUtil.IS_BUILT_WITH_ASM6) i else i - syntheticParameterCount, descriptor, visible ) - } - .genAnnotations(annotated, parameterSignature.asmType) + }.genAnnotations(annotated, parameterSignature.asmType) } } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt index f566476e50d..13c4f991180 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt @@ -107,7 +107,7 @@ class IrSourceCompilerForInline( irClass.declarations.filterIsInstance().single { it.descriptor.name.asString() == jvmSignature.asmMethod.name + JvmAbi.DEFAULT_PARAMS_IMPL_SUFFIX && - state.typeMapper.mapSignatureSkipGeneric(callableDescriptor).asmMethod.descriptor.startsWith( + codegen.context.methodSignatureMapper.mapSignatureSkipGeneric(callElement.symbol.owner).asmMethod.descriptor.startsWith( jvmSignature.asmMethod.descriptor.substringBeforeLast(')') ) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/MethodSignatureMapper.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/MethodSignatureMapper.kt index f563fa036d1..69d1b5ef1e8 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/MethodSignatureMapper.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/MethodSignatureMapper.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper import org.jetbrains.kotlin.ir.declarations.IrDeclaration import org.jetbrains.kotlin.ir.declarations.IrField import org.jetbrains.kotlin.ir.declarations.IrFunction +import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.ir.types.toKotlinType import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodGenericSignature import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature @@ -26,12 +27,18 @@ class MethodSignatureMapper(context: JvmBackendContext) { fun mapFieldSignature(irField: IrField): String? = kotlinTypeMapper.mapFieldSignature(irField.type.toKotlinType(), irField.descriptor) - fun mapFunctionName(irFunction: IrFunction, ownerKind: OwnerKind): String = + fun mapFunctionName(irFunction: IrFunction, ownerKind: OwnerKind?): String = kotlinTypeMapper.mapFunctionName(irFunction.descriptor, ownerKind) + fun mapAnnotationParameterName(field: IrField): String = + kotlinTypeMapper.mapAnnotationParameterName(field.descriptor) + fun mapImplementationOwner(irDeclaration: IrDeclaration): Type = kotlinTypeMapper.mapImplementationOwner(irDeclaration.descriptor) + fun mapReturnType(irField: IrField): Type = + kotlinTypeMapper.mapReturnType(irField.descriptor) + fun mapReturnType(irFunction: IrFunction): Type = kotlinTypeMapper.mapReturnType(irFunction.descriptor) @@ -41,8 +48,8 @@ class MethodSignatureMapper(context: JvmBackendContext) { fun mapSignatureWithGeneric(f: IrFunction, kind: OwnerKind): JvmMethodGenericSignature = kotlinTypeMapper.mapSignatureWithGeneric(f.descriptor, kind) - fun mapToCallableMethod(f: IrFunction, superCall: Boolean): IrCallableMethod = - with(kotlinTypeMapper.mapToCallableMethod(f.descriptor, superCall)) { + fun mapToCallableMethod(expression: IrFunctionAccessExpression, superCall: Boolean): IrCallableMethod = + with(kotlinTypeMapper.mapToCallableMethod(expression.descriptor, superCall)) { IrCallableMethod( owner, valueParameterTypes, invokeOpcode, getAsmMethod(), dispatchReceiverType, extensionReceiverType, isInterfaceMethod ) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt index 04fe4d739af..f5ff788023a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt @@ -19,7 +19,10 @@ import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings -import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithSource +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrSymbol @@ -94,7 +97,7 @@ fun JvmBackendContext.getSourceMapper(declaration: IrClass): DefaultSourceMapper return DefaultSourceMapper( SourceInfo.createInfoForIr( endLineNumber + 1, - this.state.typeMapper.mapType(declaration.descriptor).internalName, + typeMapper.mapClass(declaration).internalName, declaration.fileParent.name ) ) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt index 174325b5b91..c7ac94809d0 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt @@ -5,15 +5,14 @@ package org.jetbrains.kotlin.backend.jvm.descriptors -import org.jetbrains.kotlin.backend.common.deepCopyWithWrappedDescriptors import org.jetbrains.kotlin.backend.common.descriptors.WrappedClassConstructorDescriptor import org.jetbrains.kotlin.backend.common.descriptors.WrappedClassDescriptor import org.jetbrains.kotlin.backend.common.descriptors.WrappedValueParameterDescriptor import org.jetbrains.kotlin.backend.common.ir.* import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin +import org.jetbrains.kotlin.backend.jvm.codegen.MethodSignatureMapper import org.jetbrains.kotlin.builtins.CompanionObjectMapping.isMappedIntrinsicCompanionObject import org.jetbrains.kotlin.codegen.OwnerKind -import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities @@ -35,7 +34,7 @@ import org.jetbrains.kotlin.name.Name import java.util.* class JvmDeclarationFactory( - private val state: GenerationState + private val methodSignatureMapper: MethodSignatureMapper ) : DeclarationFactory { private val singletonFieldDeclarations = HashMap() private val outerThisDeclarations = HashMap() @@ -136,7 +135,7 @@ class JvmDeclarationFactory( return defaultImplsMethods.getOrPut(interfaceFun) { val defaultImpls = getDefaultImplsClass(interfaceFun.parentAsClass) - val name = Name.identifier(state.typeMapper.mapFunctionName(interfaceFun.descriptor.original, OwnerKind.IMPLEMENTATION)) + val name = Name.identifier(methodSignatureMapper.mapFunctionName(interfaceFun, OwnerKind.IMPLEMENTATION)) createStaticFunctionWithReceivers( defaultImpls, name, interfaceFun, dispatchReceiverType = parent.defaultType, diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt index 7ef48314d01..1fca3d8bccd 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt @@ -27,9 +27,9 @@ object ArrayIterator : IntrinsicMethod() { signature: JvmMethodSignature, context: JvmBackendContext ): IrIntrinsicFunction { - val method = context.state.typeMapper.mapToCallableMethod(expression.descriptor, false) + val method = context.methodSignatureMapper.mapToCallableMethod(expression, false) return IrIntrinsicFunction.create(expression, signature, context, method.owner) { - val methodSignature = "(${method.owner.descriptor})${method.returnType.descriptor}" + val methodSignature = "(${method.owner.descriptor})${method.asmMethod.returnType.descriptor}" val intrinsicOwner = if (AsmUtil.isPrimitive(method.owner.elementType)) "kotlin/jvm/internal/ArrayIteratorsKt" diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt index 7c891aad245..f40f0c27670 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt @@ -20,23 +20,25 @@ import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.codegen.AsmUtil.numberFunctionOperandType import org.jetbrains.kotlin.codegen.StackValue import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Opcodes.* import org.jetbrains.org.objectweb.asm.Type class BinaryOp(private val opcode: Int) : IntrinsicMethod() { private fun shift(): Boolean = - opcode == ISHL || opcode == ISHR || opcode == IUSHR + opcode == ISHL || opcode == ISHR || opcode == IUSHR - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - val owner = context.state.typeMapper.mapOwner(expression.descriptor) + override fun toCallable( + expression: IrFunctionAccessExpression, + signature: JvmMethodSignature, + context: JvmBackendContext + ): IrIntrinsicFunction { + val owner = context.methodSignatureMapper.mapImplementationOwner(expression.symbol.owner) val returnType = signature.returnType - val intermediateResultType: Type = numberFunctionOperandType(returnType) + val intermediateResultType = numberFunctionOperandType(returnType) val argTypes = if (owner != Type.CHAR_TYPE) { listOf(intermediateResultType, if (shift()) Type.INT_TYPE else intermediateResultType) - } - else { + } else { listOf(Type.CHAR_TYPE, signature.valueParameters[0].asmType) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt index 97609f3921d..6321074d0cc 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt @@ -12,7 +12,6 @@ import org.jetbrains.kotlin.backend.jvm.codegen.PromisedValue import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression -import org.jetbrains.kotlin.ir.types.toKotlinType import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.Method @@ -35,11 +34,11 @@ abstract class IntrinsicMethod { companion object { fun calcReceiverType(call: IrMemberAccessExpression, context: JvmBackendContext): Type { - return context.state.typeMapper.mapType((call.dispatchReceiver?.type ?: call.extensionReceiver!!.type).toKotlinType()) + return context.typeMapper.mapType(call.dispatchReceiver?.type ?: call.extensionReceiver!!.type) } fun expressionType(expression: IrExpression, context: JvmBackendContext): Type { - return context.state.typeMapper.mapType(expression.type.toKotlinType()) + return context.typeMapper.mapType(expression.type) } fun JvmMethodSignature.newReturnType(type: Type): JvmMethodSignature { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrEnumValueOf.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrEnumValueOf.kt index 04313f06a10..21c3e0311e0 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrEnumValueOf.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrEnumValueOf.kt @@ -32,8 +32,8 @@ object IrEnumValueOf : IntrinsicMethod() { signature: JvmMethodSignature, context: JvmBackendContext ): IrIntrinsicFunction { - val enumType = context.state.typeMapper.mapType(expression.descriptor.returnType!!) - val newSignature = context.state.typeMapper.mapSignatureSkipGeneric(expression.descriptor, OwnerKind.IMPLEMENTATION) + val enumType = context.typeMapper.mapType(expression.type) + val newSignature = context.methodSignatureMapper.mapSignatureSkipGeneric(expression.symbol.owner, OwnerKind.IMPLEMENTATION) val stringType = AsmTypes.JAVA_STRING_TYPE return object : IrIntrinsicFunction(expression, newSignature, context, listOf(stringType)) { @@ -46,4 +46,4 @@ object IrEnumValueOf : IntrinsicMethod() { } } } -} \ No newline at end of file +} diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt index f5d0ef3e34b..89c8d314afa 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt @@ -138,10 +138,10 @@ open class IrIntrinsicFunction( } fun IrFunctionAccessExpression.argTypes(context: JvmBackendContext): ArrayList { - val callableMethod = context.state.typeMapper.mapToCallableMethod(descriptor, false) + val callableMethod = context.methodSignatureMapper.mapToCallableMethod(this, false) return arrayListOf().apply { callableMethod.dispatchReceiverType?.let { add(it) } - addAll(callableMethod.getAsmMethod().argumentTypes) + addAll(callableMethod.asmMethod.argumentTypes) } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt index ece6fb90f19..ff5a9e42992 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt @@ -7,28 +7,16 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression -import org.jetbrains.kotlin.ir.types.toKotlinType -import org.jetbrains.kotlin.resolve.descriptorUtil.module +import org.jetbrains.kotlin.ir.types.typeWith import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature -import org.jetbrains.kotlin.types.Variance object IsArrayOf : IntrinsicMethod() { - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - val typeMapper = context.state.typeMapper - - val descriptor = expression.descriptor - val builtIns = descriptor.module.builtIns - assert(descriptor.typeParameters.size == 1) { - "Expected only one type parameter for Any?.isArrayOf(), got: ${descriptor.typeParameters}" - } - /*TODO original?*/ - val elementType = expression.getTypeArgument(descriptor.original.typeParameters.first().index)!! - val arrayKtType = builtIns.getArrayType(Variance.INVARIANT, elementType.toKotlinType()) - val arrayType = typeMapper.mapType(arrayKtType) - - return IrIntrinsicFunction.create(expression, signature, context) { - it.instanceOf(arrayType) - } + override fun toCallable( + expression: IrFunctionAccessExpression, + signature: JvmMethodSignature, + context: JvmBackendContext + ): IrIntrinsicFunction = IrIntrinsicFunction.create(expression, signature, context) { v -> + val arrayType = context.irBuiltIns.arrayClass.typeWith(expression.getTypeArgument(0)!!) + v.instanceOf(context.typeMapper.mapType(arrayType)) } -} \ No newline at end of file +} diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt index 9e250b9583a..88ceff8a440 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt @@ -50,8 +50,7 @@ internal val additionalClassAnnotationPhase = makeIrFilePhase( ) private class AdditionalClassAnnotationLowering(private val context: JvmBackendContext) : ClassLoweringPass { - - val typeMapper = context.state.typeMapper + private val jvmTarget = context.state.target // TODO: import IR structures from the library? @@ -210,8 +209,8 @@ private class AdditionalClassAnnotationLowering(private val context: JvmBackendC private fun generateTargetAnnotation(irClass: IrClass) { if (irClass.hasAnnotation(FqName("java.lang.annotation.Target"))) return - val annotationTargetMap = annotationTargetMaps[typeMapper.jvmTarget] - ?: throw AssertionError("No annotation target map for JVM target ${typeMapper.jvmTarget}") + val annotationTargetMap = annotationTargetMaps[jvmTarget] + ?: throw AssertionError("No annotation target map for JVM target $jvmTarget") val targets = irClass.applicableTargetSet() ?: return val javaTargets = targets.mapNotNull { annotationTargetMap[it] } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt index 0d8c9211b53..9b507c2f11d 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt @@ -51,10 +51,7 @@ internal val bridgePhase = makeIrFilePhase( ) private class BridgeLowering(val context: JvmBackendContext) : ClassLoweringPass { - - private val state = context.state - - private val typeMapper = state.typeMapper + private val methodSignatureMapper = context.methodSignatureMapper private val specialBridgeMethods = SpecialBridgeMethods(context) @@ -383,8 +380,8 @@ private class BridgeLowering(val context: JvmBackendContext) : ClassLoweringPass return findConcreteSuperDeclaration(FunctionHandleForIrFunction(this))?.irFunction } - private fun IrFunction.getJvmSignature() = typeMapper.mapAsmMethod(descriptor) - private fun IrFunction.getJvmName() = getJvmSignature().name + private fun IrFunction.getJvmSignature(): Method = methodSignatureMapper.mapAsmMethod(this) + private fun IrFunction.getJvmName(): String = getJvmSignature().name } private data class SignatureWithSource(val signature: Method, val source: IrSimpleFunction) { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt index c6ac2b83562..30757c4bba7 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt @@ -17,7 +17,10 @@ import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.builders.irBlockBody import org.jetbrains.kotlin.ir.builders.irCall import org.jetbrains.kotlin.ir.builders.irString -import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin +import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction +import org.jetbrains.kotlin.ir.declarations.IrValueParameter import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol @@ -33,10 +36,7 @@ internal val collectionStubMethodLowering = makeIrFilePhase( ) private class CollectionStubMethodLowering(val context: JvmBackendContext) : ClassLoweringPass { - - private val state = context.state - - private val typeMapper = state.typeMapper + private val methodSignatureMapper = context.methodSignatureMapper override fun lower(irClass: IrClass) { if (irClass.isInterface) { @@ -65,10 +65,11 @@ private class CollectionStubMethodLowering(val context: JvmBackendContext) : Cla } } - //TODO: replace with new typeMapper using no descriptor - private fun IrSimpleFunction.toSignature() = typeMapper.mapAsmMethod(this.descriptor).toString() + private fun IrSimpleFunction.toSignature(): String = methodSignatureMapper.mapAsmMethod(this).toString() - private fun createStubMethod(function: IrSimpleFunction, irClass: IrClass, substitutionMap: Map): IrSimpleFunction { + private fun createStubMethod( + function: IrSimpleFunction, irClass: IrClass, substitutionMap: Map + ): IrSimpleFunction { return buildFun { name = function.name returnType = function.returnType.substitute(substitutionMap) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt index 6c2c90826e3..6f318c0adf6 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt @@ -64,7 +64,7 @@ private class CompanionObjectJvmStaticLowering(val context: JvmBackendContext) : companion?.declarations?.filter(::isJvmStaticFunction)?.forEach { val jvmStaticFunction = it as IrSimpleFunction - val newName = Name.identifier(context.state.typeMapper.mapFunctionName(jvmStaticFunction.symbol.descriptor, null)) + val newName = Name.identifier(context.methodSignatureMapper.mapFunctionName(jvmStaticFunction, null)) if (!jvmStaticFunction.visibility.isPublicAPI) { // TODO: Synthetic accessor creation logic should be supported in SyntheticAccessorLowering in the future. val accessorName = Name.identifier("access\$$newName") diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt index 1ce5d902d0f..d8a90211f8d 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt @@ -55,12 +55,12 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class get() = (this as? IrPropertyReference)?.field private val IrSimpleFunction.signature: String - get() = context.state.typeMapper.mapSignatureSkipGeneric(collectRealOverrides().first().descriptor).toString() + get() = context.methodSignatureMapper.mapSignatureSkipGeneric(collectRealOverrides().first()).toString() // Plain Java fields do not have a getter, but can be referenced nonetheless. The signature should be the one // that a getter would have, if it existed. private val IrField.signature: String - get() = "${JvmAbi.getterName(name.asString())}()${context.state.typeMapper.mapReturnType(descriptor)}" + get() = "${JvmAbi.getterName(name.asString())}()${context.methodSignatureMapper.mapReturnType(this)}" private val IrMemberAccessExpression.signature: String get() = getter?.let { getter -> diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt index e0205c5be89..6c10b3f217f 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt @@ -416,10 +416,7 @@ private class SyntheticAccessorLowering(val context: JvmBackendContext) : IrElem private var nameCounter = 0 private fun IrFunction.accessorName(): Name { - val jvmName = context.state.typeMapper.mapFunctionName( - descriptor, - OwnerKind.getMemberOwnerKind(parentAsClass.descriptor) - ) + val jvmName = context.methodSignatureMapper.mapFunctionName(this, OwnerKind.IMPLEMENTATION) return Name.identifier("access\$$jvmName\$${nameCounter++}") } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt index 53de5be8f3e..2c719826d38 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt @@ -190,7 +190,7 @@ private class ToArrayLowering(private val context: JvmBackendContext) : ClassLow private fun IrDeclaration.isGenericToArray(): Boolean { if (this !is IrSimpleFunction) return false - val signature = context.state.typeMapper.mapAsmMethod(descriptor) + val signature = context.methodSignatureMapper.mapAsmMethod(this) return signature.toString() == "toArray([Ljava/lang/Object;)[Ljava/lang/Object;" }