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

crazy bug with constructing object of the same class as calling class

Browse Source
This commit is contained in:
Alex Tkachman
2012-01-24 13:30:38 +02:00
parent 5613cb90f9
commit e61a9f62ba
9 changed files with 111 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/CompilationException.java
+1 -1
View File
@@ -36,7 +36,7 @@ public class CompilationException extends RuntimeException {
col = -1;
}
return "Internal error: (" + (line+1) + "," + col + ") " + (getCause().getMessage() != null ? getCause().getMessage() : getCause().toString());
return "Internal error: (" + (line+1) + "," + col + ") " + (getCause().getMessage() != null ? getCause().getMessage() : getCause().toString()) + "\n@" + getCause().getStackTrace()[0].getFileName() + ":" + getCause().getStackTrace()[0].getLineNumber();
}
@Override
compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+9
View File
@@ -782,6 +782,15 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
}
}
if(closureCodegen.superCall != null) {
ConstructorDescriptor superConstructor = (ConstructorDescriptor) bindingContext.get(BindingContext.REFERENCE_TARGET, ((JetDelegatorToSuperCall) closureCodegen.superCall).getCalleeExpression().getConstructorReferenceExpression());
CallableMethod superCallable = typeMapper.mapToCallableMethod(superConstructor, OwnerKind.IMPLEMENTATION);
Type[] argumentTypes = superCallable.getSignature().getAsmMethod().getArgumentTypes();
Collections.addAll(consArgTypes, argumentTypes);
ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, closureCodegen.superCall.getCalleeExpression());
pushMethodArguments(resolvedCall, Arrays.asList(argumentTypes));
}
Method cons = new Method("<init>", Type.VOID_TYPE, consArgTypes.toArray(new Type[consArgTypes.size()]));
v.invokespecial(closure.getClassname(), "<init>", cons.getDescriptor());
return StackValue.onStack(Type.getObjectType(closure.getClassname()));
compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+53 -24
View File
@@ -21,6 +21,8 @@ import org.objectweb.asm.commons.Method;
import java.util.*;
import static org.jetbrains.jet.codegen.JetTypeMapper.TYPE_OBJECT;
/**
* @author max
* @author yole
@@ -212,6 +214,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
try {
generatePrimaryConstructor();
}
catch (CompilationException e) {
throw e;
}
catch(RuntimeException e) {
throw new RuntimeException("Error generating primary constructor of class " + myClass.getName() + " with kind " + kind, e);
}
@@ -396,6 +401,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
}
ObjectOrClosureCodegen closure = context.closure;
int firstSuperArgument = -1;
if(closure != null) {
final LinkedList<JvmMethodParameterSignature> consArgTypes = new LinkedList<JvmMethodParameterSignature>(constructorMethod.getKotlinParameterTypes());
@@ -424,6 +430,18 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
}
}
if(myClass instanceof JetObjectDeclaration) {
if(superCall instanceof JetDelegatorToSuperCall) {
closure.superCall = (JetDelegatorToSuperCall) superCall;
ConstructorDescriptor superConstructor = (ConstructorDescriptor) bindingContext.get(BindingContext.REFERENCE_TARGET, ((JetDelegatorToSuperCall) superCall).getCalleeExpression().getConstructorReferenceExpression());
CallableMethod superCallable = typeMapper.mapToCallableMethod(superConstructor, OwnerKind.IMPLEMENTATION);
firstSuperArgument = insert;
for(Type t : superCallable.getSignature().getAsmMethod().getArgumentTypes()) {
consArgTypes.add(insert++, new JvmMethodParameterSignature(t, "", JvmMethodParameterKind.SHARED_VAR));
}
}
}
constructorMethod = JvmMethodSignature.simple("<init>", Type.VOID_TYPE, consArgTypes);
}
@@ -488,32 +506,31 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
}
}
if (superCall == null || superCall instanceof JetDelegatorToSuperClass) {
if (superCall == null) {
iv.load(0, Type.getType("L" + superClass + ";"));
if(superCall == null) {
iv.invokespecial(superClass, "<init>", "()V");
iv.invokespecial(superClass, "<init>", "()V");
}
else if (superCall instanceof JetDelegatorToSuperClass) {
iv.load(0, Type.getType("L" + superClass + ";"));
JetType superType = bindingContext.get(BindingContext.TYPE, superCall.getTypeReference());
List<Type> parameterTypes = new ArrayList<Type>();
assert superType != null;
ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
if (CodegenUtil.hasThis0(superClassDescriptor)) {
iv.load(1, JetTypeMapper.TYPE_OBJECT);
parameterTypes.add(typeMapper.mapType(CodegenUtil.getOuterClassDescriptor(descriptor).getDefaultType(), OwnerKind.IMPLEMENTATION));
}
else {
JetType superType = bindingContext.get(BindingContext.TYPE, superCall.getTypeReference());
List<Type> parameterTypes = new ArrayList<Type>();
assert superType != null;
ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
if (CodegenUtil.hasThis0(superClassDescriptor)) {
iv.load(1, JetTypeMapper.TYPE_OBJECT);
parameterTypes.add(typeMapper.mapType(CodegenUtil.getOuterClassDescriptor(descriptor).getDefaultType(), OwnerKind.IMPLEMENTATION));
}
for(TypeProjection typeParameterDescriptor : superType.getArguments()) {
codegen.generateTypeInfo(typeParameterDescriptor.getType(), null);
parameterTypes.add(JetTypeMapper.TYPE_TYPEINFO);
}
Method superCallMethod = new Method("<init>", Type.VOID_TYPE, parameterTypes.toArray(new Type[parameterTypes.size()]));
iv.invokespecial(typeMapper.mapType(superClassDescriptor.getDefaultType(), OwnerKind.IMPLEMENTATION).getInternalName(), "<init>", superCallMethod.getDescriptor());
for(TypeProjection typeParameterDescriptor : superType.getArguments()) {
codegen.generateTypeInfo(typeParameterDescriptor.getType(), null);
parameterTypes.add(JetTypeMapper.TYPE_TYPEINFO);
}
Method superCallMethod = new Method("<init>", Type.VOID_TYPE, parameterTypes.toArray(new Type[parameterTypes.size()]));
iv.invokespecial(typeMapper.mapType(superClassDescriptor.getDefaultType(), OwnerKind.IMPLEMENTATION).getInternalName(), "<init>", superCallMethod.getDescriptor());
}
else {
iv.load(0, classType);
ConstructorDescriptor constructorDescriptor1 = (ConstructorDescriptor) bindingContext.get(BindingContext.REFERENCE_TARGET, ((JetDelegatorToSuperCall) superCall).getCalleeExpression().getConstructorReferenceExpression());
generateDelegatorToConstructorCall(iv, codegen, (JetDelegatorToSuperCall) superCall, constructorDescriptor1, frameMap);
generateDelegatorToConstructorCall(iv, codegen, (JetDelegatorToSuperCall) superCall, constructorDescriptor1, frameMap, firstSuperArgument);
}
int n = 0;
@@ -685,10 +702,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
private void generateDelegatorToConstructorCall(InstructionAdapter iv, ExpressionCodegen codegen, JetCallElement constructorCall,
ConstructorDescriptor constructorDescriptor,
ConstructorFrameMap frameMap) {
ConstructorFrameMap frameMap, int firstSuperArgument) {
ClassDescriptor classDecl = constructorDescriptor.getContainingDeclaration();
Type type;
type = typeMapper.mapType(classDecl.getDefaultType(), OwnerKind.IMPLEMENTATION);
Type type = typeMapper.mapType(classDecl.getDefaultType(), OwnerKind.IMPLEMENTATION);
iv.load(0, type);
@@ -697,7 +713,20 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
}
CallableMethod method = typeMapper.mapToCallableMethod(constructorDescriptor, kind);
codegen.invokeMethodWithArguments(method, constructorCall, StackValue.none());
if(myClass instanceof JetObjectDeclaration && superCall instanceof JetDelegatorToSuperCall) {
iv.load(0, TYPE_OBJECT);
ConstructorDescriptor superConstructor = (ConstructorDescriptor) bindingContext.get(BindingContext.REFERENCE_TARGET, ((JetDelegatorToSuperCall) superCall).getCalleeExpression().getConstructorReferenceExpression());
CallableMethod superCallable = typeMapper.mapToCallableMethod(superConstructor, OwnerKind.IMPLEMENTATION);
int nextVar = firstSuperArgument+1;
for(Type t : superCallable.getSignature().getAsmMethod().getArgumentTypes()) {
iv.load(nextVar, t);
nextVar += t.getSize();
}
method.invoke(codegen.v);
}
else {
codegen.invokeMethodWithArguments(method, constructorCall, StackValue.none());
}
}
@Override
@@ -785,7 +814,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
if (!(thisDescriptor instanceof ConstructorDescriptor)) {
throw new UnsupportedOperationException("expected 'this' delegator to resolve to constructor");
}
generateDelegatorToConstructorCall(iv, codegen, thisCall, (ConstructorDescriptor) thisDescriptor, frameMap);
generateDelegatorToConstructorCall(iv, codegen, thisCall, (ConstructorDescriptor) thisDescriptor, frameMap, flags);
}
else {
throw new UnsupportedOperationException("unknown initializer type");
compiler/backend/src/org/jetbrains/jet/codegen/ObjectOrClosureCodegen.java
+2
View File
@@ -1,6 +1,7 @@
package org.jetbrains.jet.codegen;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.JetDelegatorToSuperCall;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
@@ -20,6 +21,7 @@ public class ObjectOrClosureCodegen {
protected ClassBuilder cv = null;
public String name = null;
protected Map<DeclarationDescriptor, EnclosedValueDescriptor> closure = new LinkedHashMap<DeclarationDescriptor, EnclosedValueDescriptor>();
public JetDelegatorToSuperCall superCall;
public ObjectOrClosureCodegen(ExpressionCodegen exprContext, CodegenContext context, GenerationState state) {
this.exprContext = exprContext;