From 49a4abbc9e56ada6eacda3067efc8991a2f98c95 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 24 Dec 2013 20:57:38 +0400 Subject: [PATCH] Minor renames and refactorings related to JetTypeMapper --- .../jetbrains/jet/codegen/ClosureCodegen.java | 1 - .../jetbrains/jet/codegen/CodegenUtil.java | 28 ---- .../jet/codegen/ExpressionCodegen.java | 2 +- .../jet/codegen/FunctionCodegen.java | 102 +++++++------- .../codegen/ImplementationBodyCodegen.java | 72 +++++----- .../jet/codegen/state/JetTypeMapper.java | 125 +++++++++--------- .../lang/resolve/java/AsmTypeConstants.java | 1 - 7 files changed, 143 insertions(+), 188 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java index 02b9ace57e7..136d2209e74 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java @@ -285,7 +285,6 @@ public class ClosureCodegen extends ParentCodegenAwareImpl { JetType supertype = supertypes.iterator().next(); BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.CLASS); - typeMapper.writeFormalTypeParameters(Collections.emptyList(), sw); sw.writeSuperclass(); typeMapper.mapSupertype(supertype, sw); sw.writeSuperclassEnd(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java index 99733227c85..71438a80aa2 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java @@ -26,9 +26,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.codegen.binding.CalculatedClosure; import org.jetbrains.jet.codegen.context.CodegenContext; import org.jetbrains.jet.codegen.context.PackageContext; -import org.jetbrains.jet.codegen.signature.BothSignatureWriter; -import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind; -import org.jetbrains.jet.codegen.signature.JvmMethodSignature; import org.jetbrains.jet.codegen.state.JetTypeMapper; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; @@ -47,7 +44,6 @@ import java.util.Collections; import java.util.List; import static org.jetbrains.jet.lang.descriptors.Modality.ABSTRACT; -import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE; public class CodegenUtil { @@ -86,30 +82,6 @@ public class CodegenUtil { return invokeDescriptor; } - public static JvmMethodSignature erasedInvokeSignature(FunctionDescriptor fd) { - BothSignatureWriter signatureWriter = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); - - boolean isExtensionFunction = fd.getReceiverParameter() != null; - int paramCount = fd.getValueParameters().size(); - if (isExtensionFunction) { - paramCount++; - } - - signatureWriter.writeParametersStart(); - - for (int i = 0; i < paramCount; ++i) { - signatureWriter.writeParameterType(JvmMethodParameterKind.VALUE); - signatureWriter.writeAsmType(OBJECT_TYPE); - signatureWriter.writeParameterTypeEnd(); - } - - signatureWriter.writeReturnType(); - signatureWriter.writeAsmType(OBJECT_TYPE); - signatureWriter.writeReturnTypeEnd(); - - return signatureWriter.makeJvmMethodSignature("invoke"); - } - public static boolean isConst(@NotNull CalculatedClosure closure) { return closure.getCaptureThis() == null && closure.getCaptureReceiverType() == null && closure.getCaptureVariables().isEmpty(); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 8d62904815a..bc78184ed66 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -2411,7 +2411,7 @@ public class ExpressionCodegen extends JetVisitor implem @NotNull public Type expressionType(JetExpression expr) { - return typeMapper.expressionType(expr); + return asmTypeOrVoid(bindingContext.get(EXPRESSION_TYPE, expr)); } public int indexOfLocal(JetReferenceExpression lhs) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 0074b63abfd..82f0341e625 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -145,7 +145,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { endVisit(mv, null, origin); - generateBridgeIfNeeded(owner, state, v, jvmSignature.getAsmMethod(), functionDescriptor); + generateBridgeIfNeeded(owner, state, v, functionDescriptor); methodContext.recordSyntheticAccessorIfNeeded(functionDescriptor, typeMapper); } @@ -408,15 +408,13 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { CodegenContext owner, GenerationState state, ClassBuilder v, - Method jvmSignature, FunctionDescriptor functionDescriptor ) { if (owner.getContextKind() == OwnerKind.TRAIT_IMPL) { return; } - Method method = - state.getTypeMapper().mapSignature(functionDescriptor).getAsmMethod(); + Method method = state.getTypeMapper().mapSignature(functionDescriptor).getAsmMethod(); Queue bfsQueue = new LinkedList(); Set visited = new HashSet(); @@ -435,8 +433,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { while (!bfsQueue.isEmpty()) { FunctionDescriptor descriptor = bfsQueue.poll(); if (descriptor.getKind() == CallableMemberDescriptor.Kind.DECLARATION) { - Method overridden = - state.getTypeMapper().mapSignature(descriptor.getOriginal()).getAsmMethod(); + Method overridden = state.getTypeMapper().mapSignature(descriptor.getOriginal()).getAsmMethod(); if (differentMethods(method, overridden)) { bridgesToGenerate.add(overridden); } @@ -453,7 +450,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { } for (Method overridden : bridgesToGenerate) { - generateBridge(state, v, jvmSignature, functionDescriptor, overridden); + generateBridge(state, v, functionDescriptor, overridden); } } @@ -701,34 +698,35 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { private static void generateBridge( GenerationState state, ClassBuilder v, - Method jvmSignature, FunctionDescriptor functionDescriptor, Method overridden ) { + Method jvmSignature = state.getTypeMapper().mapSignature(functionDescriptor).getAsmMethod(); + int flags = ACC_PUBLIC | ACC_BRIDGE | ACC_SYNTHETIC; // TODO. MethodVisitor mv = v.newMethod(null, flags, jvmSignature.getName(), overridden.getDescriptor(), null, null); - if (state.getClassBuilderMode() == ClassBuilderMode.FULL) { - mv.visitCode(); + if (state.getClassBuilderMode() != ClassBuilderMode.FULL) return; - Type[] argTypes = overridden.getArgumentTypes(); - Type[] originalArgTypes = jvmSignature.getArgumentTypes(); + mv.visitCode(); - InstructionAdapter iv = new InstructionAdapter(mv); - iv.load(0, OBJECT_TYPE); - for (int i = 0, reg = 1; i < argTypes.length; i++) { - StackValue.local(reg, argTypes[i]).put(originalArgTypes[i], iv); - //noinspection AssignmentToForLoopParameter - reg += argTypes[i].getSize(); - } + Type[] argTypes = overridden.getArgumentTypes(); + Type[] originalArgTypes = jvmSignature.getArgumentTypes(); - iv.invokevirtual(v.getThisName(), jvmSignature.getName(), jvmSignature.getDescriptor()); - - StackValue.onStack(jvmSignature.getReturnType()).put(overridden.getReturnType(), iv); - - iv.areturn(overridden.getReturnType()); - endVisit(mv, "bridge method", callableDescriptorToDeclaration(state.getBindingContext(), functionDescriptor)); + InstructionAdapter iv = new InstructionAdapter(mv); + iv.load(0, OBJECT_TYPE); + for (int i = 0, reg = 1; i < argTypes.length; i++) { + StackValue.local(reg, argTypes[i]).put(originalArgTypes[i], iv); + //noinspection AssignmentToForLoopParameter + reg += argTypes[i].getSize(); } + + iv.invokevirtual(v.getThisName(), jvmSignature.getName(), jvmSignature.getDescriptor()); + + StackValue.coerce(jvmSignature.getReturnType(), overridden.getReturnType(), iv); + iv.areturn(overridden.getReturnType()); + + endVisit(mv, "bridge method", callableDescriptorToDeclaration(state.getBindingContext(), functionDescriptor)); } public void genDelegate(FunctionDescriptor functionDescriptor, FunctionDescriptor overriddenDescriptor, StackValue field) { @@ -751,36 +749,36 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { int flags = ACC_PUBLIC | ACC_SYNTHETIC; // TODO. MethodVisitor mv = v.newMethod(null, flags, delegateMethod.getName(), delegateMethod.getDescriptor(), null, null); - if (state.getClassBuilderMode() == ClassBuilderMode.FULL) { - mv.visitCode(); + if (state.getClassBuilderMode() != ClassBuilderMode.FULL) return; - Type[] argTypes = delegateMethod.getArgumentTypes(); - Type[] originalArgTypes = overriddenMethod.getArgumentTypes(); + mv.visitCode(); - InstructionAdapter iv = new InstructionAdapter(mv); - iv.load(0, OBJECT_TYPE); - field.put(field.type, iv); - for (int i = 0, reg = 1; i < argTypes.length; i++) { - StackValue.local(reg, argTypes[i]).put(originalArgTypes[i], iv); - //noinspection AssignmentToForLoopParameter - reg += argTypes[i].getSize(); - } + Type[] argTypes = delegateMethod.getArgumentTypes(); + Type[] originalArgTypes = overriddenMethod.getArgumentTypes(); - String internalName = typeMapper.mapType(toClass).getInternalName(); - if (toClass.getKind() == ClassKind.TRAIT) { - iv.invokeinterface(internalName, overriddenMethod.getName(), overriddenMethod.getDescriptor()); - } - else { - iv.invokevirtual(internalName, overriddenMethod.getName(), overriddenMethod.getDescriptor()); - } - - StackValue.onStack(overriddenMethod.getReturnType()).put(delegateMethod.getReturnType(), iv); - - iv.areturn(delegateMethod.getReturnType()); - endVisit(mv, "Delegate method " + functionDescriptor + " to " + jvmOverriddenMethodSignature, - descriptorToDeclaration(bindingContext, functionDescriptor.getContainingDeclaration())); - - generateBridgeIfNeeded(owner, state, v, jvmDelegateMethodSignature.getAsmMethod(), functionDescriptor); + InstructionAdapter iv = new InstructionAdapter(mv); + iv.load(0, OBJECT_TYPE); + field.put(field.type, iv); + for (int i = 0, reg = 1; i < argTypes.length; i++) { + StackValue.local(reg, argTypes[i]).put(originalArgTypes[i], iv); + //noinspection AssignmentToForLoopParameter + reg += argTypes[i].getSize(); } + + String internalName = typeMapper.mapType(toClass).getInternalName(); + if (toClass.getKind() == ClassKind.TRAIT) { + iv.invokeinterface(internalName, overriddenMethod.getName(), overriddenMethod.getDescriptor()); + } + else { + iv.invokevirtual(internalName, overriddenMethod.getName(), overriddenMethod.getDescriptor()); + } + + StackValue.onStack(overriddenMethod.getReturnType()).put(delegateMethod.getReturnType(), iv); + + iv.areturn(delegateMethod.getReturnType()); + endVisit(mv, "Delegate method " + functionDescriptor + " to " + jvmOverriddenMethodSignature, + descriptorToDeclaration(bindingContext, functionDescriptor.getContainingDeclaration())); + + generateBridgeIfNeeded(owner, state, v, functionDescriptor); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index d0a313ea52e..40471f0583b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -333,50 +333,40 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { return typeMapper.mapClass(descriptor).getInternalName(); } + @NotNull private JvmClassSignature signature() { - BothSignatureWriter signatureVisitor = new BothSignatureWriter(BothSignatureWriter.Mode.CLASS); + BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.CLASS); - { // type parameters - List typeParameters = descriptor.getTypeConstructor().getParameters(); - typeMapper.writeFormalTypeParameters(typeParameters, signatureVisitor); + typeMapper.writeFormalTypeParameters(descriptor.getTypeConstructor().getParameters(), sw); + + sw.writeSuperclass(); + if (superClassType == null) { + sw.writeClassBegin(superClassAsmType); + sw.writeClassEnd(); + } + else { + typeMapper.mapSupertype(superClassType, sw); + } + sw.writeSuperclassEnd(); + + LinkedHashSet superInterfaces = new LinkedHashSet(); + superInterfaces.add(JvmAbi.JET_OBJECT.getInternalName()); + + for (JetDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) { + JetType superType = bindingContext.get(BindingContext.TYPE, specifier.getTypeReference()); + assert superType != null : "No supertype for class: " + myClass.getText(); + ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor(); + if (isInterface(superClassDescriptor)) { + sw.writeInterface(); + Type jvmName = typeMapper.mapSupertype(superType, sw); + sw.writeInterfaceEnd(); + superInterfaces.add(jvmName.getInternalName()); + } } - { // superclass - signatureVisitor.writeSuperclass(); - if (superClassType == null) { - signatureVisitor.writeClassBegin(superClassAsmType); - signatureVisitor.writeClassEnd(); - } - else { - typeMapper.mapSupertype(superClassType, signatureVisitor); - } - signatureVisitor.writeSuperclassEnd(); - } - - - List superInterfaces; - { // superinterfaces - LinkedHashSet superInterfacesLinkedHashSet = new LinkedHashSet(); - - superInterfacesLinkedHashSet.add(JvmAbi.JET_OBJECT.getInternalName()); - - for (JetDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) { - JetType superType = bindingContext.get(BindingContext.TYPE, specifier.getTypeReference()); - assert superType != null; - ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor(); - if (isInterface(superClassDescriptor)) { - signatureVisitor.writeInterface(); - Type jvmName = typeMapper.mapSupertype(superType, signatureVisitor); - signatureVisitor.writeInterfaceEnd(); - superInterfacesLinkedHashSet.add(jvmName.getInternalName()); - } - } - - superInterfaces = new ArrayList(superInterfacesLinkedHashSet); - } - - return new JvmClassSignature(classAsmType.getInternalName(), superClassAsmType.getInternalName(), superInterfaces, - signatureVisitor.makeJavaGenericSignature()); + return new JvmClassSignature(classAsmType.getInternalName(), superClassAsmType.getInternalName(), + new ArrayList(superInterfaces), + sw.makeJavaGenericSignature()); } protected void getSuperClass() { @@ -1479,7 +1469,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { FunctionCodegen.endVisit(iv, "trait method", callableDescriptorToDeclaration(bindingContext, fun)); } - FunctionCodegen.generateBridgeIfNeeded(context, state, v, methodToGenerate, fun); + FunctionCodegen.generateBridgeIfNeeded(context, state, v, fun); } private void generateDelegatorToConstructorCall( diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java index 1fb6b380986..a9108b353ed 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java @@ -46,7 +46,6 @@ import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.ArrayList; -import java.util.Collections; import java.util.List; import static org.jetbrains.asm4.Opcodes.*; @@ -57,6 +56,7 @@ import static org.jetbrains.jet.codegen.FunctionTypesUtil.getFunctionTraitClassN import static org.jetbrains.jet.codegen.binding.CodegenBinding.*; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isAnnotationClass; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isAnonymousObject; +import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE; import static org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor.Kind.CLASS_STATICS; public class JetTypeMapper extends BindingTraceAware { @@ -194,7 +194,7 @@ public class JetTypeMapper extends BindingTraceAware { } @NotNull - public Type mapType( + private Type mapType( @NotNull JetType jetType, @Nullable BothSignatureWriter signatureVisitor, @NotNull JetTypeMapperMode kind, @@ -262,14 +262,11 @@ public class JetTypeMapper extends BindingTraceAware { signatureVisitor.writeArrayEnd(); } - Type r; - if (!isGenericsArray(jetType)) { - r = Type.getType("[" + boxType(mapType(memberType, kind)).getDescriptor()); + if (memberType.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) { + return AsmTypeConstants.getType(Object[].class); } - else { - r = AsmTypeConstants.JAVA_ARRAY_GENERIC_TYPE; - } - return r; + + return Type.getType("[" + boxType(mapType(memberType, kind)).getDescriptor()); } if (descriptor instanceof ClassDescriptor) { @@ -580,9 +577,6 @@ public class JetTypeMapper extends BindingTraceAware { BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); if (f instanceof ConstructorDescriptor) { - // constructor type parameters are fake - writeFormalTypeParameters(Collections.emptyList(), sw); - sw.writeParametersStart(); writeAdditionalConstructorParameters((ConstructorDescriptor) f, sw); @@ -623,10 +617,10 @@ public class JetTypeMapper extends BindingTraceAware { return sw.makeJvmMethodSignature(mapFunctionName(f)); } - private static void writeVoidReturn(@NotNull BothSignatureWriter signatureVisitor) { - signatureVisitor.writeReturnType(); - signatureVisitor.writeAsmType(Type.VOID_TYPE); - signatureVisitor.writeReturnTypeEnd(); + private static void writeVoidReturn(@NotNull BothSignatureWriter sw) { + sw.writeReturnType(); + sw.writeAsmType(Type.VOID_TYPE); + sw.writeReturnTypeEnd(); } @Nullable @@ -639,43 +633,41 @@ public class JetTypeMapper extends BindingTraceAware { private void writeThisIfNeeded( @NotNull CallableMemberDescriptor descriptor, @NotNull OwnerKind kind, - @NotNull BothSignatureWriter signatureVisitor + @NotNull BothSignatureWriter sw ) { if (kind == OwnerKind.TRAIT_IMPL) { ClassDescriptor containingDeclaration = (ClassDescriptor) descriptor.getContainingDeclaration(); Type type = getTraitImplThisParameterType(containingDeclaration, this); - signatureVisitor.writeParameterType(JvmMethodParameterKind.THIS); - signatureVisitor.writeAsmType(type); - signatureVisitor.writeParameterTypeEnd(); + sw.writeParameterType(JvmMethodParameterKind.THIS); + sw.writeAsmType(type); + sw.writeParameterTypeEnd(); } else if (isAccessor(descriptor) && descriptor.getExpectedThisObject() != null) { - signatureVisitor.writeParameterType(JvmMethodParameterKind.THIS); - mapType(((ClassifierDescriptor) descriptor.getContainingDeclaration()).getDefaultType(), signatureVisitor, JetTypeMapperMode.VALUE); - signatureVisitor.writeParameterTypeEnd(); + sw.writeParameterType(JvmMethodParameterKind.THIS); + mapType(((ClassifierDescriptor) descriptor.getContainingDeclaration()).getDefaultType(), sw, JetTypeMapperMode.VALUE); + sw.writeParameterTypeEnd(); } } - public void writeFormalTypeParameters(List typeParameters, BothSignatureWriter signatureVisitor) { - if (signatureVisitor == null) return; - - for (TypeParameterDescriptor typeParameterDescriptor : typeParameters) { - writeFormalTypeParameter(typeParameterDescriptor, signatureVisitor); + public void writeFormalTypeParameters(@NotNull List typeParameters, @NotNull BothSignatureWriter sw) { + for (TypeParameterDescriptor typeParameter : typeParameters) { + writeFormalTypeParameter(typeParameter, sw); } } - private void writeFormalTypeParameter(TypeParameterDescriptor typeParameterDescriptor, BothSignatureWriter signatureVisitor) { - signatureVisitor.writeFormalTypeParameter(typeParameterDescriptor.getName().asString()); + private void writeFormalTypeParameter(@NotNull TypeParameterDescriptor typeParameterDescriptor, @NotNull BothSignatureWriter sw) { + sw.writeFormalTypeParameter(typeParameterDescriptor.getName().asString()); classBound: { - signatureVisitor.writeClassBound(); + sw.writeClassBound(); for (JetType jetType : typeParameterDescriptor.getUpperBounds()) { if (jetType.getConstructor().getDeclarationDescriptor() instanceof ClassDescriptor) { if (!isInterface(jetType)) { - mapType(jetType, signatureVisitor, JetTypeMapperMode.TYPE_PARAMETER); + mapType(jetType, sw, JetTypeMapperMode.TYPE_PARAMETER); break classBound; } } @@ -686,36 +678,36 @@ public class JetTypeMapper extends BindingTraceAware { // Ljava/lang/Object; // TODO: avoid writing java/lang/Object if interface list is not empty } - signatureVisitor.writeClassBoundEnd(); + sw.writeClassBoundEnd(); for (JetType jetType : typeParameterDescriptor.getUpperBounds()) { if (jetType.getConstructor().getDeclarationDescriptor() instanceof ClassDescriptor) { if (isInterface(jetType)) { - signatureVisitor.writeInterfaceBound(); - mapType(jetType, signatureVisitor, JetTypeMapperMode.TYPE_PARAMETER); - signatureVisitor.writeInterfaceBoundEnd(); + sw.writeInterfaceBound(); + mapType(jetType, sw, JetTypeMapperMode.TYPE_PARAMETER); + sw.writeInterfaceBoundEnd(); } } if (jetType.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) { - signatureVisitor.writeInterfaceBound(); - mapType(jetType, signatureVisitor, JetTypeMapperMode.TYPE_PARAMETER); - signatureVisitor.writeInterfaceBoundEnd(); + sw.writeInterfaceBound(); + mapType(jetType, sw, JetTypeMapperMode.TYPE_PARAMETER); + sw.writeInterfaceBoundEnd(); } } } - private void writeReceiverIfNeeded(@Nullable ReceiverParameterDescriptor receiver, BothSignatureWriter signatureWriter) { + private void writeReceiverIfNeeded(@Nullable ReceiverParameterDescriptor receiver, @NotNull BothSignatureWriter sw) { if (receiver != null) { - signatureWriter.writeParameterType(JvmMethodParameterKind.RECEIVER); - mapType(receiver.getType(), signatureWriter, JetTypeMapperMode.VALUE); - signatureWriter.writeParameterTypeEnd(); + sw.writeParameterType(JvmMethodParameterKind.RECEIVER); + mapType(receiver.getType(), sw, JetTypeMapperMode.VALUE); + sw.writeParameterTypeEnd(); } } - private void writeParameter(@NotNull BothSignatureWriter signatureWriter, @NotNull JetType outType) { - signatureWriter.writeParameterType(JvmMethodParameterKind.VALUE); - mapType(outType, signatureWriter, JetTypeMapperMode.VALUE); - signatureWriter.writeParameterTypeEnd(); + private void writeParameter(@NotNull BothSignatureWriter sw, @NotNull JetType type) { + sw.writeParameterType(JvmMethodParameterKind.VALUE); + mapType(type, sw, JetTypeMapperMode.VALUE); + sw.writeParameterTypeEnd(); } private void writeAdditionalConstructorParameters( @@ -793,8 +785,6 @@ public class JetTypeMapper extends BindingTraceAware { public JvmMethodSignature mapScriptSignature(@NotNull ScriptDescriptor script, @NotNull List importedScripts) { BothSignatureWriter signatureWriter = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); - writeFormalTypeParameters(Collections.emptyList(), signatureWriter); - signatureWriter.writeParametersStart(); for (ScriptDescriptor importedScript : importedScripts) { @@ -825,12 +815,6 @@ public class JetTypeMapper extends BindingTraceAware { return new CallableMethod(owner, owner, owner, method, INVOKESPECIAL, null, null, null); } - - private static boolean isGenericsArray(JetType type) { - return KotlinBuiltIns.getInstance().isArray(type) && - type.getArguments().get(0).getType().getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor; - } - public Type getSharedVarType(DeclarationDescriptor descriptor) { if (descriptor instanceof PropertyDescriptor) { return StackValue.sharedTypeForType(mapType(((PropertyDescriptor) descriptor).getReceiverParameter().getType())); @@ -850,7 +834,7 @@ public class JetTypeMapper extends BindingTraceAware { @NotNull public CallableMethod mapToFunctionInvokeCallableMethod(@NotNull FunctionDescriptor fd) { - JvmMethodSignature descriptor = erasedInvokeSignature(fd); + JvmMethodSignature signature = erasedInvokeSignature(fd); Type owner = getFunctionTraitClassName(fd); Type receiverParameterType; ReceiverParameterDescriptor receiverParameter = fd.getOriginal().getReceiverParameter(); @@ -860,17 +844,30 @@ public class JetTypeMapper extends BindingTraceAware { else { receiverParameterType = null; } - return new CallableMethod(owner, null, null, descriptor, INVOKEINTERFACE, owner, receiverParameterType, owner); + return new CallableMethod(owner, null, null, signature, INVOKEINTERFACE, owner, receiverParameterType, owner); } @NotNull - public Type expressionType(JetExpression expr) { - JetType type = bindingContext.get(BindingContext.EXPRESSION_TYPE, expr); - return asmTypeOrVoid(type); - } + private static JvmMethodSignature erasedInvokeSignature(@NotNull FunctionDescriptor descriptor) { + BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); - @NotNull - private Type asmTypeOrVoid(@Nullable JetType type) { - return type == null ? Type.VOID_TYPE : mapType(type); + int paramCount = descriptor.getValueParameters().size(); + if (descriptor.getReceiverParameter() != null) { + paramCount++; + } + + sw.writeParametersStart(); + + for (int i = 0; i < paramCount; ++i) { + sw.writeParameterType(JvmMethodParameterKind.VALUE); + sw.writeAsmType(OBJECT_TYPE); + sw.writeParameterTypeEnd(); + } + + sw.writeReturnType(); + sw.writeAsmType(OBJECT_TYPE); + sw.writeReturnTypeEnd(); + + return sw.makeJvmMethodSignature("invoke"); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AsmTypeConstants.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AsmTypeConstants.java index c265f451b95..f673729c050 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AsmTypeConstants.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AsmTypeConstants.java @@ -28,7 +28,6 @@ public class AsmTypeConstants { public static final Type OBJECT_TYPE = getType(Object.class); public static final Type JAVA_STRING_TYPE = getType(String.class); public static final Type JAVA_THROWABLE_TYPE = getType(Throwable.class); - public static final Type JAVA_ARRAY_GENERIC_TYPE = getType(Object[].class); public static final Type JET_UNIT_TYPE = Type.getObjectType("jet/Unit"); public static final Type JET_FUNCTION0_TYPE = Type.getObjectType("jet/Function0");