diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java index 2fccd8fc91b..293ff771fa4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.codegen.binding.CalculatedClosure; import org.jetbrains.kotlin.codegen.context.ClosureContext; import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil; import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension; +import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter; import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; @@ -131,7 +132,7 @@ public class ClosureCodegen extends MemberCodegen { @Override protected void generateDeclaration() { - BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.CLASS); + JvmSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.CLASS); if (samType != null) { typeMapper.writeFormalTypeParameters(samType.getType().getConstructor().getParameters(), sw); } @@ -177,8 +178,8 @@ public class ClosureCodegen extends MemberCodegen { } generateBridge( - typeMapper.mapSignature(erasedInterfaceFunction).getAsmMethod(), - typeMapper.mapSignature(funDescriptor).getAsmMethod() + typeMapper.mapAsmMethod(erasedInterfaceFunction), + typeMapper.mapAsmMethod(funDescriptor) ); functionCodegen.generateMethod(JvmDeclarationOriginKt.OtherOrigin(element, funDescriptor), funDescriptor, strategy); @@ -334,7 +335,7 @@ public class ClosureCodegen extends MemberCodegen { if (generateBody) { mv.visitCode(); InstructionAdapter iv = new InstructionAdapter(mv); - Method method = typeMapper.mapSignature(descriptor.getOriginal()).getAsmMethod(); + Method method = typeMapper.mapAsmMethod(descriptor.getOriginal()); iv.aconst(method.getName() + method.getDescriptor()); iv.areturn(JAVA_STRING_TYPE); FunctionCodegen.endVisit(iv, "function reference getSignature", element); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt index 64b7d7f9f63..4a054dd91c4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.resolve.OverrideResolver import org.jetbrains.kotlin.resolve.OverridingStrategy import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin +import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodGenericSignature import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.checker.KotlinTypeChecker @@ -239,7 +240,7 @@ class CollectionStubMethodGenerator( return KotlinTypeImpl.create(Annotations.EMPTY, classDescriptor, false, typeArguments) } - private fun FunctionDescriptor.signature(): JvmMethodSignature = typeMapper.mapSignature(this) + private fun FunctionDescriptor.signature(): JvmMethodSignature = typeMapper.mapSignatureWithGeneric(this, OwnerKind.IMPLEMENTATION) private fun generateMethodStub(signature: JvmMethodSignature, synthetic: Boolean) { // TODO: investigate if it makes sense to generate abstract stubs in traits diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt index dde5a08be7d..e5a20782557 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt @@ -120,7 +120,7 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) { val isStatic = AsmUtil.isStaticMethod(contextKind, functionDescriptor) val flags = AsmUtil.getVisibilityAccessFlag(functionDescriptor) or (if (isStatic) Opcodes.ACC_STATIC else 0) val remainingParameters = getRemainingParameters(functionDescriptor.original, substituteCount) - val signature = typeMapper.mapSignature(functionDescriptor, contextKind, remainingParameters) + val signature = typeMapper.mapSignature(functionDescriptor, contextKind, remainingParameters, false) val mv = classBuilder.newMethod(OtherOrigin(methodElement, functionDescriptor), flags, signature.asmMethod.name, signature.asmMethod.descriptor, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 364d1f4976f..5d14fb99484 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -43,6 +43,7 @@ import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethod; import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods; import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicPropertyGetter; import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsnsKt; +import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter; import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; @@ -79,7 +80,6 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil; import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature; -import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; import org.jetbrains.kotlin.resolve.scopes.receivers.*; import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor; import org.jetbrains.kotlin.types.KotlinType; @@ -92,6 +92,7 @@ import org.jetbrains.org.objectweb.asm.MethodVisitor; import org.jetbrains.org.objectweb.asm.Opcodes; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; +import org.jetbrains.org.objectweb.asm.commons.Method; import java.util.*; @@ -1485,8 +1486,8 @@ public class ExpressionCodegen extends KtVisitor impleme assert constructors.size() == 1 : "Unexpected number of constructors for class: " + classDescriptor + " " + constructors; ConstructorDescriptor constructorDescriptor = CollectionsKt.single(constructors); - JvmMethodSignature constructor = typeMapper.mapSignature(SamCodegenUtil.resolveSamAdapter(constructorDescriptor)); - v.invokespecial(type.getInternalName(), "", constructor.getAsmMethod().getDescriptor(), false); + Method constructor = typeMapper.mapAsmMethod(SamCodegenUtil.resolveSamAdapter(constructorDescriptor)); + v.invokespecial(type.getInternalName(), "", constructor.getDescriptor(), false); return Unit.INSTANCE; } }); @@ -2520,7 +2521,7 @@ public class ExpressionCodegen extends KtVisitor impleme if (typeParameterAndReificationArgument == null) { KotlinType approximatedType = CapturedTypeApproximationKt.approximateCapturedTypes(entry.getValue()).getUpper(); // type is not generic - BothSignatureWriter signatureWriter = new BothSignatureWriter(BothSignatureWriter.Mode.TYPE); + JvmSignatureWriter signatureWriter = new BothSignatureWriter(BothSignatureWriter.Mode.TYPE); Type asmType = typeMapper.mapTypeParameter(approximatedType, signatureWriter); mappings.addParameterMappingToType( diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index a3484f12399..7ab1241774a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -152,7 +152,7 @@ public class FunctionCodegen { return; } - JvmMethodSignature jvmSignature = typeMapper.mapSignature(functionDescriptor, contextKind); + JvmMethodSignature jvmSignature = typeMapper.mapSignatureWithGeneric(functionDescriptor, contextKind); Method asmMethod = jvmSignature.getAsmMethod(); int flags = getMethodAsmFlags(functionDescriptor, contextKind); @@ -180,7 +180,7 @@ public class FunctionCodegen { generateMethodAnnotations(functionDescriptor, asmMethod, mv); - generateParameterAnnotations(functionDescriptor, mv, typeMapper.mapSignature(functionDescriptor)); + generateParameterAnnotations(functionDescriptor, mv, typeMapper.mapSignatureSkipGeneric(functionDescriptor)); generateBridges(functionDescriptor); @@ -212,10 +212,10 @@ public class FunctionCodegen { // native @JvmStatic foo() in companion object should delegate to the static native function moved to the outer class mv.visitCode(); FunctionDescriptor staticFunctionDescriptor = JvmStaticGenerator.createStaticFunctionDescriptor(functionDescriptor); - JvmMethodSignature jvmMethodSignature = - typeMapper.mapSignature(memberCodegen.getContext().accessibleDescriptor(staticFunctionDescriptor, null)); + Method accessorMethod = + typeMapper.mapAsmMethod(memberCodegen.getContext().accessibleDescriptor(staticFunctionDescriptor, null)); Type owningType = typeMapper.mapClass((ClassifierDescriptor) staticFunctionDescriptor.getContainingDeclaration()); - generateDelegateToMethodBody(false, mv, jvmMethodSignature.getAsmMethod(), owningType.getInternalName()); + generateDelegateToMethodBody(false, mv, accessorMethod, owningType.getInternalName()); } endVisit(mv, null, origin.getElement()); @@ -582,7 +582,7 @@ public class FunctionCodegen { CallableDescriptor overridden = SpecialBuiltinMembers.getOverriddenBuiltinReflectingJvmDescriptor(descriptor); assert overridden != null; - Method method = typeMapper.mapSignature(descriptor).getAsmMethod(); + Method method = typeMapper.mapAsmMethod(descriptor); int flags = ACC_ABSTRACT | getVisibilityAccessFlag(descriptor); v.newMethod(JvmDeclarationOriginKt.OtherOrigin(overridden), flags, method.getName(), method.getDescriptor(), null, null); } @@ -594,7 +594,7 @@ public class FunctionCodegen { return new Function1() { @Override public Method invoke(FunctionDescriptor descriptor) { - return typeMapper.mapSignature(descriptor).getAsmMethod(); + return typeMapper.mapAsmMethod(descriptor); } }; } @@ -708,7 +708,7 @@ public class FunctionCodegen { @NotNull Method defaultMethod ) { GenerationState state = parentCodegen.state; - JvmMethodSignature signature = state.getTypeMapper().mapSignature(functionDescriptor, methodContext.getContextKind()); + JvmMethodSignature signature = state.getTypeMapper().mapSignatureWithGeneric(functionDescriptor, methodContext.getContextKind()); boolean isStatic = isStaticMethod(methodContext.getContextKind(), functionDescriptor); FrameMap frameMap = createFrameMap(state, functionDescriptor, signature, isStatic); @@ -978,7 +978,7 @@ public class FunctionCodegen { @NotNull MemberCodegen parentCodegen ) { Method delegateToMethod = typeMapper.mapToCallableMethod(delegatedTo, /* superCall = */ false).getAsmMethod(); - Method delegateMethod = typeMapper.mapSignature(delegateFunction).getAsmMethod(); + Method delegateMethod = typeMapper.mapAsmMethod(delegateFunction); Type[] argTypes = delegateMethod.getArgumentTypes(); Type[] originalArgTypes = delegateToMethod.getArgumentTypes(); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index b5e70b2ae76..ae09bdafc46 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -36,6 +36,7 @@ import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension; import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil; import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension; import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter; +import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.incremental.components.NoLookupLocation; @@ -297,7 +298,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { @NotNull private JvmClassSignature signature() { - BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.CLASS); + JvmSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.CLASS); typeMapper.writeFormalTypeParameters(descriptor.getDeclaredTypeParameters(), sw); @@ -657,7 +658,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } else { //noinspection ConstantConditions - Method method = typeMapper.mapSignature(propertyDescriptor.getGetter()).getAsmMethod(); + Method method = typeMapper.mapAsmMethod(propertyDescriptor.getGetter()); iv.invokevirtual(classAsmType.getInternalName(), method.getName(), method.getDescriptor(), false); return method.getReturnType(); } @@ -726,7 +727,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { parameterIndex += type.getSize(); } - Method constructorAsmMethod = typeMapper.mapSignature(constructor).getAsmMethod(); + Method constructorAsmMethod = typeMapper.mapAsmMethod(constructor); iv.invokespecial(thisDescriptorType.getInternalName(), "", constructorAsmMethod.getDescriptor(), false); iv.areturn(thisDescriptorType); @@ -1342,7 +1343,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { ClassDescriptor containingTrait = (ClassDescriptor) containingDeclaration; Type traitImplType = typeMapper.mapDefaultImpls(containingTrait); - Method traitMethod = typeMapper.mapSignature(traitFun.getOriginal(), OwnerKind.DEFAULT_IMPLS).getAsmMethod(); + Method traitMethod = typeMapper.mapAsmMethod(traitFun.getOriginal(), OwnerKind.DEFAULT_IMPLS); Type[] argTypes = signature.getAsmMethod().getArgumentTypes(); Type[] originalArgTypes = traitMethod.getArgumentTypes(); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java index 73b6e9ad56b..f0f99b9ac6f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java @@ -318,7 +318,7 @@ public abstract class MemberCodegen")) { return method; } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt index 092accb4129..a993743ad88 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt @@ -174,7 +174,7 @@ class PropertyReferenceCodegen( initialize(property.type) } - val method = state.typeMapper.mapSignature(getter).asmMethod + val method = state.typeMapper.mapAsmMethod(getter) return method.name + method.descriptor } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java index 16bf5546e29..0ac24bdd662 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java @@ -116,7 +116,7 @@ public class InlineCodegen extends CallGenerator { PsiElement element = DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor); context = (MethodContext) getContext(functionDescriptor, state, element != null ? (KtFile) element.getContainingFile() : null); - jvmSignature = typeMapper.mapSignature(functionDescriptor, context.getContextKind()); + jvmSignature = typeMapper.mapSignatureWithGeneric(functionDescriptor, context.getContextKind()); // TODO: implement AS_FUNCTION inline strategy this.asFunctionInline = false; @@ -331,7 +331,7 @@ public class InlineCodegen extends CallGenerator { parentCodegen = ((FakeMemberCodegen) parentCodegen).delegate; } - JvmMethodSignature signature = typeMapper.mapSignature(context.getFunctionDescriptor(), context.getContextKind()); + JvmMethodSignature signature = typeMapper.mapSignatureSkipGeneric(context.getFunctionDescriptor(), context.getContextKind()); return new InlineCallSiteInfo(parentCodegen.getClassName(), signature.getAsmMethod().getName(), signature.getAsmMethod().getDescriptor()); } @@ -349,7 +349,7 @@ public class InlineCodegen extends CallGenerator { MethodContext context = parentContext.intoClosure(descriptor, codegen, typeMapper).intoInlinedLambda(descriptor, info.isCrossInline); - JvmMethodSignature jvmMethodSignature = typeMapper.mapSignature(descriptor); + JvmMethodSignature jvmMethodSignature = typeMapper.mapSignatureSkipGeneric(descriptor); Method asmMethod = jvmMethodSignature.getAsmMethod(); MethodNode methodNode = new MethodNode(InlineCodegenUtil.API, getMethodAsmFlags(descriptor, context.getContextKind()), asmMethod.getName(), asmMethod.getDescriptor(), jvmMethodSignature.getGenericsSignature(), null); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt index c64361e1d05..ea005197ab6 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt @@ -46,7 +46,7 @@ class InlineCodegenForDefaultBody( DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor)?.containingFile as? KtFile ) - private val jvmSignature = state.typeMapper.mapSignature(functionDescriptor, context.contextKind) + private val jvmSignature = state.typeMapper.mapSignatureWithGeneric(functionDescriptor, context.contextKind) init { assert(InlineUtil.isInline(function)) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java index 0984738c55f..34c35fcad9b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java @@ -30,6 +30,7 @@ import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.jvm.AsmTypes; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; import org.jetbrains.org.objectweb.asm.Type; +import org.jetbrains.org.objectweb.asm.commons.Method; import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode; import java.util.ArrayList; @@ -148,15 +149,15 @@ public class LambdaInfo implements CapturedParamOwner, LabelOwner { @NotNull public List getInvokeParamsWithoutCaptured() { - Type[] types = typeMapper.mapSignature(functionDescriptor).getAsmMethod().getArgumentTypes(); + Type[] types = typeMapper.mapAsmMethod(functionDescriptor).getArgumentTypes(); return Arrays.asList(types); } @NotNull public Parameters addAllParameters(FieldRemapper remapper) { - JvmMethodSignature signature = typeMapper.mapSignature(getFunctionDescriptor()); + Method asmMethod = typeMapper.mapAsmMethod(getFunctionDescriptor()); ParametersBuilder builder = - ParametersBuilder.initializeBuilderFrom(AsmTypes.OBJECT_TYPE, signature.getAsmMethod().getDescriptor(), this); + ParametersBuilder.initializeBuilderFrom(AsmTypes.OBJECT_TYPE, asmMethod.getDescriptor(), this); for (CapturedParamDesc info : getCapturedVars()) { CapturedParamInfo field = remapper.findField(new FieldInsnNode(0, info.getContainingLambdaName(), info.getFieldName(), "")); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java index aeb0bab3360..2f1d882237e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java @@ -260,8 +260,8 @@ public class MethodInliner { //return value boxing/unboxing Method bridge = - typeMapper.mapSignature(ClosureCodegen.getErasedInvokeFunction(info.getFunctionDescriptor())).getAsmMethod(); - Method delegate = typeMapper.mapSignature(info.getFunctionDescriptor()).getAsmMethod(); + typeMapper.mapAsmMethod(ClosureCodegen.getErasedInvokeFunction(info.getFunctionDescriptor())); + Method delegate = typeMapper.mapAsmMethod(info.getFunctionDescriptor()); StackValue.onStack(delegate.getReturnType()).put(bridge.getReturnType(), this); setLambdaInlining(false); addInlineMarker(this, false); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/BothSignatureWriter.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/BothSignatureWriter.java index 7952b3c02e3..4a198fa2e69 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/BothSignatureWriter.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/BothSignatureWriter.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2015 JetBrains s.r.o. + * Copyright 2010-2016 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,21 +19,15 @@ package org.jetbrains.kotlin.codegen.signature; import com.intellij.util.containers.Stack; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind; -import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature; -import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; +import org.jetbrains.kotlin.types.Variance; import org.jetbrains.org.objectweb.asm.Type; -import org.jetbrains.org.objectweb.asm.commons.Method; import org.jetbrains.org.objectweb.asm.signature.SignatureVisitor; import org.jetbrains.org.objectweb.asm.signature.SignatureWriter; import org.jetbrains.org.objectweb.asm.util.CheckSignatureAdapter; -import org.jetbrains.kotlin.name.Name; -import org.jetbrains.kotlin.types.Variance; -import java.util.ArrayList; -import java.util.List; - -public class BothSignatureWriter { +public class BothSignatureWriter extends JvmSignatureWriter { public enum Mode { METHOD(CheckSignatureAdapter.METHOD_SIGNATURE), CLASS(CheckSignatureAdapter.CLASS_SIGNATURE), @@ -49,18 +43,8 @@ public class BothSignatureWriter { private final SignatureWriter signatureWriter = new SignatureWriter(); private final SignatureVisitor signatureVisitor; - private final List kotlinParameterTypes = new ArrayList(); - - private int jvmCurrentTypeArrayLevel; - private Type jvmCurrentType; - private Type jvmReturnType; - - private JvmMethodParameterKind currentParameterKind; - private boolean generic = false; - private int currentSignatureSize = 0; - public BothSignatureWriter(@NotNull Mode mode) { this.signatureVisitor = new CheckSignatureAdapter(mode.asmType, signatureWriter); } @@ -82,64 +66,49 @@ public class BothSignatureWriter { /** * Shortcut */ + @Override public void writeAsmType(Type asmType) { - switch (asmType.getSort()) { - case Type.OBJECT: - writeClassBegin(asmType); - writeClassEnd(); - return; - case Type.ARRAY: - writeArrayType(); - writeAsmType(asmType.getElementType()); - writeArrayEnd(); - return; - default: - signatureVisitor().visitBaseType(asmType.getDescriptor().charAt(0)); - writeAsmType0(asmType); + if (asmType.getSort() != Type.OBJECT && asmType.getSort() != Type.ARRAY) { + signatureVisitor().visitBaseType(asmType.getDescriptor().charAt(0)); } + super.writeAsmType(asmType); } - private String makeArrayPrefix() { - StringBuilder sb = new StringBuilder(); - for (int i = 0; i < jvmCurrentTypeArrayLevel; ++i) { - sb.append('['); - } - return sb.toString(); - } - - private void writeAsmType0(Type type) { - if (jvmCurrentType == null) { - jvmCurrentType = Type.getType(makeArrayPrefix() + type.getDescriptor()); - } - } + @Override public void writeClassBegin(Type asmType) { signatureVisitor().visitClassType(asmType.getInternalName()); - writeAsmType0(asmType); + super.writeClassBegin(asmType); } + @Override public void writeOuterClassBegin(Type resultingAsmType, String outerInternalName) { signatureVisitor().visitClassType(outerInternalName); - writeAsmType0(resultingAsmType); + super.writeOuterClassBegin(resultingAsmType, outerInternalName); } + @Override public void writeInnerClass(String name) { signatureVisitor().visitInnerClassType(name); + super.writeInnerClass(name); } + @Override public void writeClassEnd() { signatureVisitor().visitEnd(); + super.writeClassEnd(); } + @Override public void writeArrayType() { push(signatureVisitor().visitArrayType()); - if (jvmCurrentType == null) { - ++jvmCurrentTypeArrayLevel; - } + super.writeArrayType(); } + @Override public void writeArrayEnd() { pop(); + super.writeArrayEnd(); } private static char toJvmVariance(@NotNull Variance variance) { @@ -151,56 +120,70 @@ public class BothSignatureWriter { } } + @Override public void writeTypeArgument(@NotNull Variance projectionKind) { push(signatureVisitor().visitTypeArgument(toJvmVariance(projectionKind))); - generic = true; + super.writeTypeArgument(projectionKind); } + @Override public void writeUnboundedWildcard() { signatureVisitor().visitTypeArgument(); - generic = true; + super.writeUnboundedWildcard(); } + @Override public void writeTypeArgumentEnd() { pop(); + super.writeTypeArgumentEnd(); } + @Override public void writeTypeVariable(Name name, Type asmType) { signatureVisitor().visitTypeVariable(name.asString()); generic = true; - writeAsmType0(asmType); + super.writeTypeVariable(name, asmType); } + @Override public void writeFormalTypeParameter(String name) { signatureVisitor().visitFormalTypeParameter(name); - generic = true; + super.writeFormalTypeParameter(name); } + @Override public void writeClassBound() { push(signatureVisitor().visitClassBound()); + super.writeClassBound(); } + @Override public void writeClassBoundEnd() { pop(); + super.writeClassBoundEnd(); } + @Override public void writeInterfaceBound() { push(signatureVisitor().visitInterfaceBound()); + super.writeInterfaceBound(); } + @Override public void writeInterfaceBoundEnd() { pop(); + super.writeInterfaceBoundEnd(); } + @Override public void writeParametersStart() { - // hacks - jvmCurrentType = null; - jvmCurrentTypeArrayLevel = 0; + super.writeParametersStart(); } + @Override public void writeParameterType(JvmMethodParameterKind parameterKind) { // This magic mimics the behavior of javac that enum constructor have these synthetic parameters in erased signature, but doesn't // have them in generic signature. IDEA, javac and their friends rely on this behavior. @@ -213,67 +196,60 @@ public class BothSignatureWriter { else { push(signatureVisitor().visitParameterType()); } - - this.currentParameterKind = parameterKind; + super.writeParameterType(parameterKind); } + @Override public void writeParameterTypeEnd() { pop(); - - kotlinParameterTypes.add(new JvmMethodParameterSignature(jvmCurrentType, currentParameterKind)); - currentSignatureSize += jvmCurrentType.getSize(); - - currentParameterKind = null; - jvmCurrentType = null; - jvmCurrentTypeArrayLevel = 0; + super.writeParameterTypeEnd(); } + @Override public void writeReturnType() { push(signatureVisitor().visitReturnType()); + super.writeReturnType(); } + @Override public void writeReturnTypeEnd() { pop(); - - jvmReturnType = jvmCurrentType; - jvmCurrentType = null; - jvmCurrentTypeArrayLevel = 0; + super.writeReturnTypeEnd(); } + @Override public void writeSuperclass() { push(signatureVisitor().visitSuperclass()); + super.writeSuperclass(); } + @Override public void writeSuperclassEnd() { pop(); + super.writeSuperclassEnd(); } + @Override public void writeInterface() { push(signatureVisitor().visitInterface()); + super.writeInterface(); } + @Override public void writeInterfaceEnd() { pop(); + super.writeInterfaceEnd(); } - + @Override @Nullable public String makeJavaGenericSignature() { return generic ? signatureWriter.toString() : null; } - @NotNull - public JvmMethodSignature makeJvmMethodSignature(@NotNull String name, boolean skipGenericSignature) { - List types = new ArrayList(kotlinParameterTypes.size()); - for (JvmMethodParameterSignature parameter : kotlinParameterTypes) { - types.add(parameter.getAsmType()); - } - Method asmMethod = new Method(name, jvmReturnType, types.toArray(new Type[types.size()])); - return new JvmMethodSignature(asmMethod, !skipGenericSignature ? makeJavaGenericSignature() : null, kotlinParameterTypes); - } - - public int getCurrentSignatureSize() { - return currentSignatureSize; + @Override + public boolean skipGenericSignature() { + return false; } @Override diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/JvmSignatureWriter.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/JvmSignatureWriter.java new file mode 100644 index 00000000000..6fb0ecd9b48 --- /dev/null +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/JvmSignatureWriter.java @@ -0,0 +1,196 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.codegen.signature; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.name.Name; +import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind; +import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature; +import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; +import org.jetbrains.kotlin.types.Variance; +import org.jetbrains.org.objectweb.asm.Type; +import org.jetbrains.org.objectweb.asm.commons.Method; + +import java.util.ArrayList; +import java.util.List; + +public class JvmSignatureWriter { + + private final List kotlinParameterTypes = new ArrayList(); + + private int jvmCurrentTypeArrayLevel; + private Type jvmCurrentType; + private Type jvmReturnType; + + private JvmMethodParameterKind currentParameterKind; + + private int currentSignatureSize = 0; + + /** + * Shortcut + */ + public void writeAsmType(Type asmType) { + switch (asmType.getSort()) { + case Type.OBJECT: + writeClassBegin(asmType); + writeClassEnd(); + return; + case Type.ARRAY: + writeArrayType(); + writeAsmType(asmType.getElementType()); + writeArrayEnd(); + return; + default: + writeAsmType0(asmType); + } + } + + private String makeArrayPrefix() { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < jvmCurrentTypeArrayLevel; ++i) { + sb.append('['); + } + return sb.toString(); + } + + protected void writeAsmType0(Type type) { + if (jvmCurrentType == null) { + jvmCurrentType = Type.getType(makeArrayPrefix() + type.getDescriptor()); + } + } + + public void writeClassBegin(Type asmType) { + writeAsmType0(asmType); + } + + public void writeOuterClassBegin(Type resultingAsmType, String outerInternalName) { + writeAsmType0(resultingAsmType); + } + + public void writeInnerClass(String name) { + } + + public void writeClassEnd() { + } + + public void writeArrayType() { + if (jvmCurrentType == null) { + ++jvmCurrentTypeArrayLevel; + } + } + + public void writeArrayEnd() { + } + + public void writeTypeArgument(@NotNull Variance projectionKind) { + } + + public void writeUnboundedWildcard() { + } + + public void writeTypeArgumentEnd() { + } + + public void writeTypeVariable(Name name, Type asmType) { + writeAsmType0(asmType); + } + + public void writeFormalTypeParameter(String name) { + } + + public void writeClassBound() { + } + + public void writeClassBoundEnd() { + } + + public void writeInterfaceBound() { + } + + public void writeInterfaceBoundEnd() { + } + + public void writeParametersStart() { + // hacks + jvmCurrentType = null; + jvmCurrentTypeArrayLevel = 0; + } + + public void writeParameterType(JvmMethodParameterKind parameterKind) { + currentParameterKind = parameterKind; + } + + public void writeParameterTypeEnd() { + kotlinParameterTypes.add(new JvmMethodParameterSignature(jvmCurrentType, currentParameterKind)); + currentSignatureSize += jvmCurrentType.getSize(); + + currentParameterKind = null; + jvmCurrentType = null; + jvmCurrentTypeArrayLevel = 0; + } + + public void writeReturnType() { + } + + public void writeReturnTypeEnd() { + jvmReturnType = jvmCurrentType; + jvmCurrentType = null; + jvmCurrentTypeArrayLevel = 0; + } + + public void writeSuperclass() { + } + + public void writeSuperclassEnd() { + } + + public void writeInterface() { + } + + public void writeInterfaceEnd() { + } + + @Nullable + public String makeJavaGenericSignature() { + return null; + } + + @NotNull + public JvmMethodSignature makeJvmMethodSignature(@NotNull String name) { + List types = new ArrayList(kotlinParameterTypes.size()); + for (JvmMethodParameterSignature parameter : kotlinParameterTypes) { + types.add(parameter.getAsmType()); + } + Method asmMethod = new Method(name, jvmReturnType, types.toArray(new Type[types.size()])); + return new JvmMethodSignature(asmMethod, makeJavaGenericSignature(), kotlinParameterTypes); + } + + public int getCurrentSignatureSize() { + return currentSignatureSize; + } + + public boolean skipGenericSignature() { + return true; + } + + @Override + public String toString() { + return "empty"; + } +} + diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt index 6b01f1f4bf0..2732a60cb25 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt @@ -30,5 +30,5 @@ class KotlinToJvmSignatureMapperImpl : KotlinToJvmSignatureMapper { private val typeMapper = JetTypeMapper(BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, NoResolveFileClassesProvider, null, IncompatibleClassTracker.DoNothing, JvmAbi.DEFAULT_MODULE_NAME) - override fun mapToJvmMethodSignature(function: FunctionDescriptor) = typeMapper.mapSignature(function) + override fun mapToJvmMethodSignature(function: FunctionDescriptor) = typeMapper.mapAsmMethod(function) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt index af844115f29..8eae8da0f59 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt @@ -192,8 +192,8 @@ class BuilderFactoryForDuplicateSignatureDiagnostics( } private fun FunctionDescriptor.asRawSignature() = - with(typeMapper.mapSignature(this)) { - RawSignature(asmMethod.name!!, asmMethod.descriptor!!, MemberKind.METHOD) + with(typeMapper.mapAsmMethod(this)) { + RawSignature(name, descriptor, MemberKind.METHOD) } private fun isOrOverridesSamAdapter(descriptor: CallableMemberDescriptor): Boolean { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java index 86ddc2cf0f2..072db1e96f5 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java @@ -31,6 +31,7 @@ import org.jetbrains.kotlin.codegen.binding.CodegenBinding; import org.jetbrains.kotlin.codegen.binding.MutableClosure; import org.jetbrains.kotlin.codegen.binding.PsiCodegenPredictor; import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter; +import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.fileClasses.FileClasses; import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil; @@ -322,7 +323,7 @@ public class JetTypeMapper { } @NotNull - private Type mapReturnType(@NotNull CallableDescriptor descriptor, @Nullable BothSignatureWriter sw) { + private Type mapReturnType(@NotNull CallableDescriptor descriptor, @Nullable JvmSignatureWriter sw) { KotlinType returnType = descriptor.getReturnType(); assert returnType != null : "Function has no return type: " + descriptor; @@ -346,8 +347,12 @@ public class JetTypeMapper { } @NotNull - private Type mapReturnType(@NotNull CallableDescriptor descriptor, @Nullable BothSignatureWriter sw, @NotNull KotlinType returnType) { + private Type mapReturnType(@NotNull CallableDescriptor descriptor, @Nullable JvmSignatureWriter sw, @NotNull KotlinType returnType) { boolean isAnnotationMethod = DescriptorUtils.isAnnotationClass(descriptor.getContainingDeclaration()); + if (sw == null || sw.skipGenericSignature()) { + return mapType(returnType, sw, TypeMappingMode.getModeForReturnTypeNoGeneric(isAnnotationMethod)); + } + TypeMappingMode typeMappingModeFromAnnotation = TypeMappingUtil.extractTypeMappingModeFromAnnotation(descriptor, returnType, isAnnotationMethod); if (typeMappingModeFromAnnotation != null) { @@ -367,12 +372,12 @@ public class JetTypeMapper { } @NotNull - public Type mapSupertype(@NotNull KotlinType jetType, @Nullable BothSignatureWriter signatureVisitor) { + public Type mapSupertype(@NotNull KotlinType jetType, @Nullable JvmSignatureWriter signatureVisitor) { return mapType(jetType, signatureVisitor, TypeMappingMode.SUPER_TYPE); } @NotNull - public Type mapTypeParameter(@NotNull KotlinType jetType, @Nullable BothSignatureWriter signatureVisitor) { + public Type mapTypeParameter(@NotNull KotlinType jetType, @Nullable JvmSignatureWriter signatureVisitor) { return mapType(jetType, signatureVisitor, TypeMappingMode.GENERIC_ARGUMENT); } @@ -394,11 +399,11 @@ public class JetTypeMapper { @NotNull public JvmMethodSignature mapAnnotationParameterSignature(@NotNull PropertyDescriptor descriptor) { - BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); + JvmSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); sw.writeReturnType(); mapType(descriptor.getType(), sw, TypeMappingMode.VALUE_FOR_ANNOTATION); sw.writeReturnTypeEnd(); - return sw.makeJvmMethodSignature(descriptor.getName().asString(), false); + return sw.makeJvmMethodSignature(descriptor.getName().asString()); } @NotNull @@ -409,7 +414,7 @@ public class JetTypeMapper { @NotNull private Type mapType( @NotNull KotlinType jetType, - @Nullable BothSignatureWriter signatureVisitor, + @Nullable JvmSignatureWriter signatureVisitor, @NotNull TypeMappingMode mode ) { Type builtinType = mapBuiltinType(jetType); @@ -595,7 +600,7 @@ public class JetTypeMapper { private void writeGenericType( @NotNull KotlinType type, @NotNull Type asmType, - @Nullable BothSignatureWriter signatureVisitor, + @Nullable JvmSignatureWriter signatureVisitor, @NotNull TypeMappingMode mode ) { if (signatureVisitor != null) { @@ -606,7 +611,7 @@ public class JetTypeMapper { // In == In<*, Foo> -> In // In -> In // Inv -> Inv - if (hasNothingInNonContravariantPosition(type) || type.getArguments().isEmpty()) { + if (signatureVisitor.skipGenericSignature() || hasNothingInNonContravariantPosition(type) || type.getArguments().isEmpty()) { signatureVisitor.writeAsmType(asmType); return; } @@ -654,7 +659,7 @@ public class JetTypeMapper { } private void writeGenericArguments( - @NotNull BothSignatureWriter signatureVisitor, + @NotNull JvmSignatureWriter signatureVisitor, @NotNull List arguments, @NotNull List parameters, @NotNull TypeMappingMode mode @@ -742,7 +747,7 @@ public class JetTypeMapper { @NotNull public CallableMethod mapToCallableMethod(@NotNull FunctionDescriptor descriptor, boolean superCall) { if (descriptor instanceof ConstructorDescriptor) { - JvmMethodSignature method = mapSignature(descriptor); + JvmMethodSignature method = mapSignatureSkipGeneric(descriptor); Type owner = mapClass(((ConstructorDescriptor) descriptor).getContainingDeclaration()); String defaultImplDesc = mapDefaultMethod(descriptor, OwnerKind.IMPLEMENTATION).getDescriptor(); return new CallableMethod(owner, owner, defaultImplDesc, method, INVOKESPECIAL, null, null, null); @@ -778,12 +783,12 @@ public class JetTypeMapper { thisClass = mapClass(currentOwner); if (declarationOwner instanceof JavaClassDescriptor) { invokeOpcode = INVOKESPECIAL; - signature = mapSignature(functionDescriptor); + signature = mapSignatureSkipGeneric(functionDescriptor); owner = thisClass; } else { invokeOpcode = INVOKESTATIC; - signature = mapSignature(descriptor.getOriginal(), OwnerKind.DEFAULT_IMPLS); + signature = mapSignatureSkipGeneric(descriptor.getOriginal(), OwnerKind.DEFAULT_IMPLS); owner = mapDefaultImpls(currentOwner); } } @@ -809,7 +814,7 @@ public class JetTypeMapper { ? overriddenSpecialBuiltinFunction.getOriginal() : functionDescriptor.getOriginal(); - signature = mapSignature(functionToCall); + signature = mapSignatureSkipGeneric(functionToCall); ClassDescriptor receiver = (currentIsInterface && !originalIsInterface) || currentOwner instanceof FunctionClassDescriptor ? declarationOwner @@ -819,7 +824,7 @@ public class JetTypeMapper { } } else { - signature = mapSignature(functionDescriptor.getOriginal()); + signature = mapSignatureSkipGeneric(functionDescriptor.getOriginal()); owner = mapOwner(functionDescriptor); ownerForDefaultImpl = owner; baseMethodDescriptor = functionDescriptor; @@ -975,39 +980,68 @@ public class JetTypeMapper { } @NotNull - public JvmMethodSignature mapSignature(@NotNull FunctionDescriptor descriptor) { - return mapSignature(descriptor, OwnerKind.IMPLEMENTATION); + public Method mapAsmMethod(@NotNull FunctionDescriptor descriptor) { + return mapSignature(descriptor, true).getAsmMethod(); } @NotNull - public JvmMethodSignature mapSignature(@NotNull FunctionDescriptor f, @NotNull OwnerKind kind) { + public Method mapAsmMethod(@NotNull FunctionDescriptor descriptor, @NotNull OwnerKind kind) { + return mapSignature(descriptor, kind, true).getAsmMethod(); + } + + @NotNull + private JvmMethodSignature mapSignature(@NotNull FunctionDescriptor f, boolean skipGenericSignature) { + return mapSignature(f, OwnerKind.IMPLEMENTATION, skipGenericSignature); + } + + @NotNull + public JvmMethodSignature mapSignatureSkipGeneric(@NotNull FunctionDescriptor f) { + return mapSignatureSkipGeneric(f, OwnerKind.IMPLEMENTATION); + } + + @NotNull + public JvmMethodSignature mapSignatureSkipGeneric(@NotNull FunctionDescriptor f, @NotNull OwnerKind kind) { + return mapSignature(f, kind, true); + } + + @NotNull + public JvmMethodSignature mapSignatureWithGeneric(@NotNull FunctionDescriptor f, @NotNull OwnerKind kind) { + return mapSignature(f, kind, false); + } + + @NotNull + private JvmMethodSignature mapSignature(@NotNull FunctionDescriptor f, @NotNull OwnerKind kind, boolean skipGenericSignature) { if (f.getInitialSignatureDescriptor() != null && f != f.getInitialSignatureDescriptor()) { // Overrides of special builtin in Kotlin classes always have special signature if (SpecialBuiltinMembers.getOverriddenBuiltinReflectingJvmDescriptor(f) == null || f.getContainingDeclaration().getOriginal() instanceof JavaClassDescriptor) { - return mapSignature(f.getInitialSignatureDescriptor(), kind); + return mapSignature(f.getInitialSignatureDescriptor(), kind, skipGenericSignature); } } if (f instanceof ConstructorDescriptor) { - return mapSignature(f, kind, f.getOriginal().getValueParameters()); + return mapSignature(f, kind, f.getOriginal().getValueParameters(), skipGenericSignature); } - return mapSignature(f, kind, f.getValueParameters()); + + return mapSignature(f, kind, f.getValueParameters(), skipGenericSignature); } @NotNull public JvmMethodSignature mapSignature( @NotNull FunctionDescriptor f, @NotNull OwnerKind kind, - @NotNull List valueParameters + @NotNull List valueParameters, + boolean skipGenericSignature ) { if (f instanceof FunctionImportedFromObject) { - return mapSignature(((FunctionImportedFromObject) f).getCallableFromObject()); + return mapSignature(((FunctionImportedFromObject) f).getCallableFromObject(), kind, skipGenericSignature); } checkOwnerCompatibility(f); - BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); + JvmSignatureWriter sw = skipGenericSignature || f instanceof AccessorForCallableDescriptor + ? new JvmSignatureWriter() + : new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); if (f instanceof ConstructorDescriptor) { sw.writeParametersStart(); @@ -1044,7 +1078,7 @@ public class JetTypeMapper { sw.writeReturnTypeEnd(); } - JvmMethodSignature signature = sw.makeJvmMethodSignature(mapFunctionName(f), f instanceof AccessorForCallableDescriptor); + JvmMethodSignature signature = sw.makeJvmMethodSignature(mapFunctionName(f)); if (kind != OwnerKind.DEFAULT_IMPLS) { SpecialSignatureInfo specialSignatureInfo = BuiltinMethodsWithSpecialGenericSignature.getSpecialSignatureInfo(f); @@ -1089,7 +1123,7 @@ public class JetTypeMapper { private boolean writeCustomParameter( @NotNull FunctionDescriptor f, @NotNull ValueParameterDescriptor parameter, - @NotNull BothSignatureWriter sw + @NotNull JvmSignatureWriter sw ) { FunctionDescriptor overridden = BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(f); @@ -1131,7 +1165,7 @@ public class JetTypeMapper { @NotNull public Method mapDefaultMethod(@NotNull FunctionDescriptor functionDescriptor, @NotNull OwnerKind kind) { - Method jvmSignature = mapSignature(functionDescriptor, kind).getAsmMethod(); + Method jvmSignature = mapAsmMethod(functionDescriptor, kind); Type ownerType = mapOwner(functionDescriptor); boolean isConstructor = isConstructor(jvmSignature); String descriptor = getDefaultDescriptor( @@ -1161,7 +1195,7 @@ public class JetTypeMapper { return false; } - private static void writeVoidReturn(@NotNull BothSignatureWriter sw) { + private static void writeVoidReturn(@NotNull JvmSignatureWriter sw) { sw.writeReturnType(); sw.writeAsmType(Type.VOID_TYPE); sw.writeReturnTypeEnd(); @@ -1169,7 +1203,7 @@ public class JetTypeMapper { @Nullable public String mapFieldSignature(@NotNull KotlinType backingFieldType, @NotNull PropertyDescriptor propertyDescriptor) { - BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.TYPE); + JvmSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.TYPE); if (!propertyDescriptor.isVar()) { mapReturnType(propertyDescriptor, sw, backingFieldType); @@ -1184,7 +1218,7 @@ public class JetTypeMapper { private void writeThisIfNeeded( @NotNull CallableMemberDescriptor descriptor, @NotNull OwnerKind kind, - @NotNull BothSignatureWriter sw + @NotNull JvmSignatureWriter sw ) { ClassDescriptor thisType; if (kind == OwnerKind.DEFAULT_IMPLS) { @@ -1208,13 +1242,14 @@ public class JetTypeMapper { return traitDescriptor; } - public void writeFormalTypeParameters(@NotNull List typeParameters, @NotNull BothSignatureWriter sw) { + public void writeFormalTypeParameters(@NotNull List typeParameters, @NotNull JvmSignatureWriter sw) { + if (sw.skipGenericSignature()) return; for (TypeParameterDescriptor typeParameter : typeParameters) { writeFormalTypeParameter(typeParameter, sw); } } - private void writeFormalTypeParameter(@NotNull TypeParameterDescriptor typeParameterDescriptor, @NotNull BothSignatureWriter sw) { + private void writeFormalTypeParameter(@NotNull TypeParameterDescriptor typeParameterDescriptor, @NotNull JvmSignatureWriter sw) { if (classBuilderMode == ClassBuilderMode.LIGHT_CLASSES && typeParameterDescriptor.getName().isSpecial()) { // If a type parameter has no name, the code below fails, but it should recover in case of light classes return; @@ -1263,7 +1298,7 @@ public class JetTypeMapper { } private void writeParameter( - @NotNull BothSignatureWriter sw, + @NotNull JvmSignatureWriter sw, @NotNull KotlinType type, @Nullable CallableDescriptor callableDescriptor ) { @@ -1271,7 +1306,7 @@ public class JetTypeMapper { } private void writeParameter( - @NotNull BothSignatureWriter sw, + @NotNull JvmSignatureWriter sw, @NotNull JvmMethodParameterKind kind, @NotNull KotlinType type, @Nullable CallableDescriptor callableDescriptor @@ -1284,10 +1319,15 @@ public class JetTypeMapper { } private void writeParameterType( - @NotNull BothSignatureWriter sw, + @NotNull JvmSignatureWriter sw, @NotNull KotlinType type, @Nullable CallableDescriptor callableDescriptor ) { + if (sw.skipGenericSignature()) { + mapType(type, sw, TypeMappingMode.DEFAULT); + return; + } + TypeMappingMode typeMappingMode; TypeMappingMode typeMappingModeFromAnnotation = @@ -1306,13 +1346,13 @@ public class JetTypeMapper { mapType(type, sw, typeMappingMode); } - private static void writeParameter(@NotNull BothSignatureWriter sw, @NotNull JvmMethodParameterKind kind, @NotNull Type type) { + private static void writeParameter(@NotNull JvmSignatureWriter sw, @NotNull JvmMethodParameterKind kind, @NotNull Type type) { sw.writeParameterType(kind); sw.writeAsmType(type); sw.writeParameterTypeEnd(); } - private void writeAdditionalConstructorParameters(@NotNull ConstructorDescriptor descriptor, @NotNull BothSignatureWriter sw) { + private void writeAdditionalConstructorParameters(@NotNull ConstructorDescriptor descriptor, @NotNull JvmSignatureWriter sw) { MutableClosure closure = bindingContext.get(CodegenBinding.CLOSURE, descriptor.getContainingDeclaration()); ClassDescriptor captureThis = getDispatchReceiverParameterForConstructorCall(descriptor, closure); @@ -1368,7 +1408,7 @@ public class JetTypeMapper { } private void writeSuperConstructorCallParameters( - @NotNull BothSignatureWriter sw, + @NotNull JvmSignatureWriter sw, @NotNull ConstructorDescriptor descriptor, @NotNull ResolvedCall superCall, boolean hasOuter @@ -1377,7 +1417,7 @@ public class JetTypeMapper { List valueArguments = superCall.getValueArgumentsByIndex(); assert valueArguments != null : "Failed to arrange value arguments by index: " + superDescriptor; - List parameters = mapSignature(superDescriptor).getValueParameters(); + List parameters = mapSignatureSkipGeneric(superDescriptor).getValueParameters(); int params = parameters.size(); int args = valueArguments.size(); @@ -1421,7 +1461,7 @@ public class JetTypeMapper { @NotNull public JvmMethodSignature mapScriptSignature(@NotNull ScriptDescriptor script, @NotNull List importedScripts) { - BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); + JvmSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); sw.writeParametersStart(); @@ -1435,7 +1475,7 @@ public class JetTypeMapper { writeVoidReturn(sw); - return sw.makeJvmMethodSignature("", false); + return sw.makeJvmMethodSignature(""); } public Type getSharedVarType(DeclarationDescriptor descriptor) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/TypeMappingMode.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/TypeMappingMode.kt index 9a1a8ee2ef9..e2941939f02 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/TypeMappingMode.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/TypeMappingMode.kt @@ -60,6 +60,11 @@ internal class TypeMappingMode private constructor( genericArgumentMode = TypeMappingMode(isForAnnotationParameter = true, genericArgumentMode = GENERIC_ARGUMENT)) + @JvmStatic + fun getModeForReturnTypeNoGeneric( + isAnnotationMethod: Boolean + ) = if (isAnnotationMethod) VALUE_FOR_ANNOTATION else DEFAULT + @JvmStatic fun getOptimalModeForValueParameter( type: KotlinType diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt index c6bece60f03..d0f1027a6b5 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt @@ -17,19 +17,13 @@ package org.jetbrains.kotlin.resolve.jvm.jvmSignature import org.jetbrains.kotlin.descriptors.FunctionDescriptor +import org.jetbrains.org.objectweb.asm.commons.Method interface KotlinToJvmSignatureMapper { - fun mapToJvmMethodSignature(function: FunctionDescriptor): JvmMethodSignature + fun mapToJvmMethodSignature(function: FunctionDescriptor): Method } -fun erasedSignaturesEqualIgnoringReturnTypes(subFunction: JvmMethodSignature, superFunction: JvmMethodSignature): Boolean { - val subParams = subFunction.valueParameters - val superParams = superFunction.valueParameters +fun erasedSignaturesEqualIgnoringReturnTypes(subFunction: Method, superFunction: Method) = + subFunction.parametersDescriptor() == superFunction.parametersDescriptor() - if (subParams.size != superParams.size) return false - - return subParams.zip(superParams).all { - p -> val (subParam, superParam) = p - subParam.asmType == superParam.asmType - } -} +private fun Method.parametersDescriptor() = descriptor.substring(1, descriptor.lastIndexOf(")")) 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 a20412b3827..b4b0ea5a516 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 @@ -39,6 +39,7 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.KotlinToJvmSignatureMapper; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.KotlinToJvmSignatureMapperKt; import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.kotlin.types.TypeUtils; +import org.jetbrains.org.objectweb.asm.commons.Method; import java.util.*; @@ -197,11 +198,11 @@ public class SignaturesPropagationData { // TODO: Add propagation for other kotlin descriptors (KT-3621) Name name = method.getName(); - JvmMethodSignature autoSignature = SIGNATURE_MAPPER.mapToJvmMethodSignature(autoMethodDescriptor); + Method autoSignature = SIGNATURE_MAPPER.mapToJvmMethodSignature(autoMethodDescriptor); for (KotlinType supertype : containingClass.getTypeConstructor().getSupertypes()) { Collection superFunctionCandidates = supertype.getMemberScope().getContributedFunctions(name, NoLookupLocation.WHEN_GET_SUPER_MEMBERS); for (FunctionDescriptor candidate : superFunctionCandidates) { - JvmMethodSignature candidateSignature = SIGNATURE_MAPPER.mapToJvmMethodSignature(candidate); + Method candidateSignature = SIGNATURE_MAPPER.mapToJvmMethodSignature(candidate); if (KotlinToJvmSignatureMapperKt.erasedSignaturesEqualIgnoringReturnTypes(autoSignature, candidateSignature)) { superFunctions.add(candidate); }