azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Minor renames and refactorings related to JetTypeMapper

Browse Source
This commit is contained in:
Alexander Udalov
2013-12-24 20:57:38 +04:00
parent ace326f4cf
commit 49a4abbc9e
7 changed files with 143 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java
-1
View File
@@ -285,7 +285,6 @@ public class ClosureCodegen extends ParentCodegenAwareImpl {
JetType supertype = supertypes.iterator().next();
BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.CLASS);
typeMapper.writeFormalTypeParameters(Collections.<TypeParameterDescriptor>emptyList(), sw);
sw.writeSuperclass();
typeMapper.mapSupertype(supertype, sw);
sw.writeSuperclassEnd();
compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java
-28
View File
@@ -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();
}
compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+1 -1
View File
@@ -2411,7 +2411,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
@NotNull
public Type expressionType(JetExpression expr) {
return typeMapper.expressionType(expr);
return asmTypeOrVoid(bindingContext.get(EXPRESSION_TYPE, expr));
}
public int indexOfLocal(JetReferenceExpression lhs) {
compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java
+50 -52
View File
@@ -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<FunctionDescriptor> bfsQueue = new LinkedList<FunctionDescriptor>();
Set<FunctionDescriptor> visited = new HashSet<FunctionDescriptor>();
@@ -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);
}
}
compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+31 -41
View File
@@ -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<TypeParameterDescriptor> 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<String> superInterfaces = new LinkedHashSet<String>();
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<String> superInterfaces;
{ // superinterfaces
LinkedHashSet<String> superInterfacesLinkedHashSet = new LinkedHashSet<String>();
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<String>(superInterfacesLinkedHashSet);
}
return new JvmClassSignature(classAsmType.getInternalName(), superClassAsmType.getInternalName(), superInterfaces,
signatureVisitor.makeJavaGenericSignature());
return new JvmClassSignature(classAsmType.getInternalName(), superClassAsmType.getInternalName(),
new ArrayList<String>(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(
compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java
+61 -64
View File
@@ -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.<TypeParameterDescriptor>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<TypeParameterDescriptor> typeParameters, BothSignatureWriter signatureVisitor) {
if (signatureVisitor == null) return;
for (TypeParameterDescriptor typeParameterDescriptor : typeParameters) {
writeFormalTypeParameter(typeParameterDescriptor, signatureVisitor);
public void writeFormalTypeParameters(@NotNull List<TypeParameterDescriptor> 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 {
// <P:>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<ScriptDescriptor> importedScripts) {
BothSignatureWriter signatureWriter = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD);
writeFormalTypeParameters(Collections.<TypeParameterDescriptor>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");
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AsmTypeConstants.java
-1
View File
@@ -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");