From 23eb6daae9b21bba225438ecce5d8ad11ace63a8 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 23 Aug 2019 18:53:34 +0200 Subject: [PATCH] JVM IR: remove MethodSignatureMapper.mapImplementationOwner --- .../backend/jvm/codegen/ExpressionCodegen.kt | 19 +++++++++---------- .../jvm/codegen/MethodSignatureMapper.kt | 3 --- .../kotlin/backend/jvm/intrinsics/BinaryOp.kt | 6 ++++-- 3 files changed, 13 insertions(+), 15 deletions(-) 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 afcce5fd10b..d2b4f6849e5 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 @@ -438,23 +438,24 @@ class ExpressionCodegen( } override fun visitFieldAccess(expression: IrFieldAccessExpression, data: BlockInfo): PromisedValue { - expression.symbol.owner.constantValue()?.let { + val callee = expression.symbol.owner + callee.constantValue()?.let { // Handling const reads before codegen is important for constant folding. - assert(expression is IrSetField) { "read of const val ${expression.symbol.owner.name} not inlined by ConstLowering" } + assert(expression is IrSetField) { "read of const val ${callee.name} not inlined by ConstLowering" } // This can only be the field's initializer; JVM implementations are required // to generate those for ConstantValue-marked fields automatically, so this is redundant. return defaultValue(expression.type) } - val realField = expression.symbol.owner.resolveFakeOverride()!! + val realField = callee.resolveFakeOverride()!! val fieldType = typeMapper.mapType(realField.type) - val ownerType = methodSignatureMapper.mapImplementationOwner(expression.symbol.owner).internalName + val ownerType = typeMapper.mapClass(callee.parentAsClass).internalName val fieldName = realField.name.asString() val isStatic = expression.receiver == null expression.markLineNumber(startOffset = true) expression.receiver?.accept(this, data)?.materialize() return if (expression is IrSetField) { - expression.value.accept(this, data).coerce(fieldType, expression.symbol.owner.type).materialize() + expression.value.accept(this, data).coerce(fieldType, callee.type).materialize() when { isStatic -> mv.putstatic(ownerType, fieldName, fieldType.descriptor) else -> mv.putfield(ownerType, fieldName, fieldType.descriptor) @@ -462,12 +463,10 @@ class ExpressionCodegen( defaultValue(expression.type) } else { when { - isStatic -> - mv.getstatic(ownerType, fieldName, fieldType.descriptor) - else -> - mv.getfield(ownerType, fieldName, fieldType.descriptor) + isStatic -> mv.getstatic(ownerType, fieldName, fieldType.descriptor) + else -> mv.getfield(ownerType, fieldName, fieldType.descriptor) } - MaterialValue(this, fieldType, expression.symbol.owner.type).coerce(expression.type) + MaterialValue(this, fieldType, callee.type).coerce(expression.type) } } 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 1a14d556cdc..b6333632f59 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 @@ -41,9 +41,6 @@ class MethodSignatureMapper(context: JvmBackendContext) { 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) 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 f40f0c27670..f3a7cb05a77 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,6 +20,9 @@ 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.types.isChar +import org.jetbrains.kotlin.ir.util.defaultType +import org.jetbrains.kotlin.ir.util.parentAsClass import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Opcodes.* import org.jetbrains.org.objectweb.asm.Type @@ -33,10 +36,9 @@ class BinaryOp(private val opcode: Int) : IntrinsicMethod() { signature: JvmMethodSignature, context: JvmBackendContext ): IrIntrinsicFunction { - val owner = context.methodSignatureMapper.mapImplementationOwner(expression.symbol.owner) val returnType = signature.returnType val intermediateResultType = numberFunctionOperandType(returnType) - val argTypes = if (owner != Type.CHAR_TYPE) { + val argTypes = if (!expression.symbol.owner.parentAsClass.defaultType.isChar()) { listOf(intermediateResultType, if (shift()) Type.INT_TYPE else intermediateResultType) } else { listOf(Type.CHAR_TYPE, signature.valueParameters[0].asmType)