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

Merge remote branch 'origin/master'

Browse Source
This commit is contained in:
Andrey Breslav
2011-12-12 15:36:05 +04:00
parent 8e10536ef9 8f46153d39
commit cab2e9b192
100 changed files with 1073 additions and 315 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java
+13 -33
View File
@@ -57,26 +57,18 @@ public class CodegenUtil {
return (ClassDescriptor) outerDescriptor;
}
public static boolean hasOuterTypeInfo(ClassDescriptor descriptor) {
ClassDescriptor outerClassDescriptor = getOuterClassDescriptor(descriptor);
if(outerClassDescriptor == null)
return false;
if(outerClassDescriptor.getTypeConstructor().getParameters().size() > 0)
return true;
return hasOuterTypeInfo(outerClassDescriptor);
}
public static boolean hasDerivedTypeInfoField(JetType type, boolean exceptOwn) {
if(!exceptOwn) {
if(!isInterface(type))
if(hasTypeInfoField(type))
return true;
public static boolean hasDerivedTypeInfoField(JetType type) {
for (JetType jetType : type.getConstructor().getSupertypes()) {
if(hasTypeInfoField(jetType))
return true;
}
for (JetType jetType : type.getConstructor().getSupertypes()) {
if(hasDerivedTypeInfoField(jetType, false))
return false;
}
public static boolean requireTypeInfoConstructorArg(JetType type) {
for (TypeParameterDescriptor parameter : type.getConstructor().getParameters()) {
if(parameter.isReified())
return true;
}
@@ -87,22 +79,10 @@ public class CodegenUtil {
if(isInterface(type))
return false;
List<TypeParameterDescriptor> parameters = type.getConstructor().getParameters();
for (TypeParameterDescriptor parameter : parameters) {
if(parameter.isReified())
return true;
}
if(requireTypeInfoConstructorArg(type))
return true;
for (JetType jetType : type.getConstructor().getSupertypes()) {
if(hasTypeInfoField(jetType))
return true;
}
ClassDescriptor outerClassDescriptor = getOuterClassDescriptor(type.getConstructor().getDeclarationDescriptor());
if(outerClassDescriptor == null || isClassObject(type.getConstructor().getDeclarationDescriptor()))
return false;
return hasTypeInfoField(outerClassDescriptor.getDefaultType());
return hasDerivedTypeInfoField(type);
}
public static FunctionDescriptor createInvoke(ExpressionAsFunctionDescriptor fd) {
compiler/backend/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java
+6 -17
View File
@@ -12,11 +12,11 @@ import java.util.List;
/**
* @author yole
* @author alex.tkachman
*/
public class ConstructorFrameMap extends FrameMap {
private int myOuterThisIndex = -1;
private int myFirstTypeParameter = -1;
private int myTypeParameterCount = 0;
private int myTypeInfoIndex = -1;
public ConstructorFrameMap(CallableMethod callableMethod, @Nullable ConstructorDescriptor descriptor, ClassDescriptor classDescriptor, OwnerKind kind) {
enterTemp(); // this
@@ -27,15 +27,8 @@ public class ConstructorFrameMap extends FrameMap {
}
if (classDescriptor != null) {
List<TypeParameterDescriptor> parameters = classDescriptor.getTypeConstructor().getParameters();
for (TypeParameterDescriptor parameter : parameters) {
if(parameter.isReified()) {
int index = enterTemp();
myTypeParameterCount++;
if(myFirstTypeParameter == -1) {
myFirstTypeParameter = index;
}
}
if (CodegenUtil.requireTypeInfoConstructorArg(classDescriptor.getDefaultType())) {
myTypeInfoIndex = enterTemp();
}
}
@@ -54,11 +47,7 @@ public class ConstructorFrameMap extends FrameMap {
return myOuterThisIndex;
}
public int getFirstTypeParameter() {
return myFirstTypeParameter;
}
public int getTypeParameterCount() {
return myTypeParameterCount;
public int getTypeInfoIndex() {
return myTypeInfoIndex;
}
}
compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+44 -24
View File
@@ -979,7 +979,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
}
else if (descriptor instanceof TypeParameterDescriptor) {
TypeParameterDescriptor typeParameterDescriptor = (TypeParameterDescriptor) descriptor;
loadTypeParameterTypeInfo(typeParameterDescriptor);
loadTypeParameterTypeInfo(typeParameterDescriptor, null);
v.invokevirtual("jet/typeinfo/TypeInfo", "getClassObject", "()Ljava/lang/Object;");
v.checkcast(asmType(typeParameterDescriptor.getClassObjectType()));
@@ -2033,26 +2033,32 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
private void pushTypeArguments(ResolvedCall<? extends CallableDescriptor> resolvedCall) {
if(resolvedCall != null) {
Map<TypeParameterDescriptor, JetType> typeArguments = resolvedCall.getTypeArguments();
CallableDescriptor resultingDescriptor = resolvedCall.getCandidateDescriptor();
for (TypeParameterDescriptor typeParameterDescriptor : resultingDescriptor.getTypeParameters()) {
if(typeParameterDescriptor.isReified()) {
JetType jetType = typeArguments.get(typeParameterDescriptor);
generateTypeInfo(jetType);
if(resolvedCall.getResultingDescriptor() instanceof ConstructorDescriptor) {
ConstructorDescriptor constructorDescriptor = (ConstructorDescriptor) resolvedCall.getResultingDescriptor();
ClassDescriptor containingDeclaration = constructorDescriptor.getContainingDeclaration();
if(CodegenUtil.requireTypeInfoConstructorArg(containingDeclaration.getDefaultType())) {
generateTypeInfo(containingDeclaration.getDefaultType(), resolvedCall.getTypeArguments());
}
}
else {
Map<TypeParameterDescriptor, JetType> typeArguments = resolvedCall.getTypeArguments();
CallableDescriptor resultingDescriptor = resolvedCall.getCandidateDescriptor();
for (TypeParameterDescriptor typeParameterDescriptor : resultingDescriptor.getTypeParameters()) {
if(typeParameterDescriptor.isReified()) {
JetType jetType = typeArguments.get(typeParameterDescriptor);
generateTypeInfo(jetType, typeArguments);
}
}
}
}
else {
throw new UnsupportedOperationException();
// for (JetTypeProjection jetTypeArgument : expression.getTypeArguments()) {
// pushTypeArgument(jetTypeArgument);
// }
}
}
public void pushTypeArgument(JetTypeProjection jetTypeArgument) {
JetType typeArgument = bindingContext.get(BindingContext.TYPE, jetTypeArgument.getTypeReference());
generateTypeInfo(typeArgument);
generateTypeInfo(typeArgument, null);
}
private Type generateJavaConstructorCall(JetCallExpression expression) {
@@ -2091,7 +2097,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
if(isArray) {
JetType elementType = typeMapper.getGenericsElementType(arrayType);
if(elementType != null) {
generateTypeInfo(elementType);
generateTypeInfo(elementType, null);
gen(args.get(0).getArgumentExpression(), Type.INT_TYPE);
v.invokevirtual("jet/typeinfo/TypeInfo", "newArray", "(I)[Ljava/lang/Object;");
}
@@ -2195,7 +2201,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
}
for (TypeParameterDescriptor typeParameterDescriptor : getterDescriptor.getTypeParameters()) {
if(typeParameterDescriptor.isReified()) {
generateTypeInfo(resolvedGetCall.getTypeArguments().get(typeParameterDescriptor));
generateTypeInfo(resolvedGetCall.getTypeArguments().get(typeParameterDescriptor), null);
index++;
}
}
@@ -2215,7 +2221,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
}
for (TypeParameterDescriptor typeParameterDescriptor : setterDescriptor.getOriginal().getTypeParameters()) {
if(typeParameterDescriptor.isReified()) {
generateTypeInfo(resolvedSetCall.getTypeArguments().get(typeParameterDescriptor));
generateTypeInfo(resolvedSetCall.getTypeArguments().get(typeParameterDescriptor), null);
index++;
}
}
@@ -2503,7 +2509,7 @@ If finally block is present, its last expression is the value of try expression.
}
}
else {
generateTypeInfo(jetType);
generateTypeInfo(jetType, null);
expressionToGen.put(TYPE_OBJECT, v);
if (leaveExpressionOnStack) {
v.dupX1();
@@ -2512,7 +2518,7 @@ If finally block is present, its last expression is the value of try expression.
}
}
public void generateTypeInfo(JetType jetType) {
public void generateTypeInfo(JetType jetType, Map<TypeParameterDescriptor, JetType> typeArguments) {
String knownTypeInfo = typeMapper.isKnownTypeInfo(jetType);
if(knownTypeInfo != null) {
v.getstatic("jet/typeinfo/TypeInfo", knownTypeInfo, "Ljet/typeinfo/TypeInfo;");
@@ -2521,7 +2527,7 @@ If finally block is present, its last expression is the value of try expression.
DeclarationDescriptor declarationDescriptor = jetType.getConstructor().getDeclarationDescriptor();
if (declarationDescriptor instanceof TypeParameterDescriptor) {
loadTypeParameterTypeInfo((TypeParameterDescriptor) declarationDescriptor);
loadTypeParameterTypeInfo((TypeParameterDescriptor) declarationDescriptor, typeArguments);
return;
}
@@ -2551,7 +2557,7 @@ If finally block is present, its last expression is the value of try expression.
TypeProjection argument = arguments.get(i);
v.dup();
v.iconst(i);
generateTypeInfo(argument.getType());
generateTypeInfo(argument.getType(), typeArguments);
genTypeInfoToProjection(v, argument.getProjectionKind());
v.astore(TYPE_OBJECT);
}
@@ -2573,12 +2579,21 @@ If finally block is present, its last expression is the value of try expression.
throw new UnsupportedOperationException(variance.toString());
}
private void loadTypeParameterTypeInfo(TypeParameterDescriptor typeParameterDescriptor) {
private void loadTypeParameterTypeInfo(TypeParameterDescriptor typeParameterDescriptor, @Nullable Map<TypeParameterDescriptor, JetType> typeArguments) {
final StackValue value = typeParameterExpressions.get(typeParameterDescriptor);
if (value != null) {
value.put(TYPE_TYPEINFO, v);
return;
}
if(typeArguments != null) {
JetType jetType = typeArguments.get(typeParameterDescriptor);
if(jetType != null && !jetType.equals(typeParameterDescriptor.getDefaultType())) {
generateTypeInfo(jetType, typeArguments);
return;
}
}
DeclarationDescriptor containingDeclaration = typeParameterDescriptor.getContainingDeclaration();
if (context.getThisDescriptor() != null) {
ClassDescriptor descriptor = context.getThisDescriptor();
@@ -2589,8 +2604,13 @@ If finally block is present, its last expression is the value of try expression.
if (containingDeclaration == context.getThisDescriptor()) {
if(!CodegenUtil.isInterface(descriptor)) {
if (CodegenUtil.hasTypeInfoField(defaultType)) {
v.load(0, TYPE_OBJECT);
v.getfield(ownerType.getInternalName(), "$typeInfo", "Ljet/typeinfo/TypeInfo;");
if(!(context instanceof CodegenContext.ConstructorContext)) {
v.load(0, TYPE_OBJECT);
v.getfield(ownerType.getInternalName(), "$typeInfo", "Ljet/typeinfo/TypeInfo;");
}
else {
v.load(((ConstructorFrameMap)myFrameMap).getTypeInfoIndex(), TYPE_OBJECT);
}
}
else {
v.getstatic(ownerType.getInternalName(), "$typeInfo", "Ljet/typeinfo/TypeInfo;");
@@ -2603,11 +2623,11 @@ If finally block is present, its last expression is the value of try expression.
}
else {
v.load(0, TYPE_OBJECT);
v.invokeinterface("jet/JetObject", "getTypeInfo", "()Ljet/typeinfo/TypeInfo;");
while(descriptor != containingDeclaration) {
descriptor = CodegenUtil.getOuterClassDescriptor(descriptor);
v.invokevirtual("jet/typeinfo/TypeInfo", "getOuterTypeInfo", "()Ljet/typeinfo/TypeInfo;");
v.invokeinterface("jet/JetObject", "getOuterObject", "()Ljet/JetObject;");
}
v.invokeinterface("jet/JetObject", "getTypeInfo", "()Ljet/typeinfo/TypeInfo;");
}
v.aconst(ownerType);
v.iconst(typeParameterDescriptor.getIndex());
@@ -2737,7 +2757,7 @@ If finally block is present, its last expression is the value of try expression.
v.anew(tupleType);
v.dup();
generateTypeInfo(new ProjectionErasingJetType(bindingContext.get(BindingContext.EXPRESSION_TYPE, expression)));
generateTypeInfo(new ProjectionErasingJetType(bindingContext.get(BindingContext.EXPRESSION_TYPE, expression)), null);
for (JetExpression entry : entries) {
gen(entry, TYPE_OBJECT);
}
compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java
+8 -6
View File
@@ -8,17 +8,12 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.StdlibNames;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeProjection;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.InstructionAdapter;
import org.objectweb.asm.commons.Method;
import org.objectweb.asm.signature.SignatureVisitor;
import org.objectweb.asm.signature.SignatureWriter;
import org.objectweb.asm.util.CheckSignatureAdapter;
import java.util.List;
import java.util.Set;
@@ -66,6 +61,13 @@ public class FunctionCodegen {
List<TypeParameterDescriptor> typeParameters = (functionDescriptor instanceof PropertyAccessorDescriptor ? ((PropertyAccessorDescriptor)functionDescriptor).getCorrespondingProperty(): functionDescriptor).getTypeParameters();
int flags = ACC_PUBLIC; // TODO.
if (!functionDescriptor.getValueParameters().isEmpty()
&& functionDescriptor.getValueParameters().get(functionDescriptor.getValueParameters().size() - 1)
.getVarargElementType() != null)
{
flags |= ACC_VARARGS;
}
OwnerKind kind = context.getContextKind();
@@ -114,7 +116,7 @@ public class FunctionCodegen {
ValueParameterDescriptor parameterDescriptor = paramDescrs.get(i);
av.visit(StdlibNames.JET_PARAMETER_NAME_FIELD, parameterDescriptor.getName());
if(parameterDescriptor.hasDefaultValue()) {
av.visit(StdlibNames.JET_PARAMETER_HAS_DEFAULT_FIELD, true);
av.visit(StdlibNames.JET_PARAMETER_HAS_DEFAULT_VALUE_FIELD, true);
}
if(parameterDescriptor.getOutType().isNullable()) {
av.visit(StdlibNames.JET_PARAMETER_NULLABLE_FIELD, true);
compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+55 -65
View File
@@ -16,6 +16,9 @@ import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.InstructionAdapter;
import org.objectweb.asm.commons.Method;
import org.objectweb.asm.signature.SignatureVisitor;
import org.objectweb.asm.signature.SignatureWriter;
import org.objectweb.asm.util.CheckSignatureAdapter;
import java.util.*;
@@ -75,7 +78,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
? Opcodes.ACC_INTERFACE
: 0/*Opcodes.ACC_SUPER*/),
jvmName(),
null,
genericSignature(),
superClass,
interfaces.toArray(new String[interfaces.size()])
);
@@ -92,6 +95,31 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
}
}
@Nullable
private String genericSignature() {
List<TypeParameterDescriptor> typeParameters = descriptor.getTypeConstructor().getParameters();
SignatureWriter signatureWriter = new SignatureWriter();
SignatureVisitor signatureVisitor = JetTypeMapper.DEBUG_SIGNATURE_WRITER
? new CheckSignatureAdapter(CheckSignatureAdapter.CLASS_SIGNATURE, signatureWriter)
: signatureWriter;
for (TypeParameterDescriptor typeParameter : typeParameters) {
signatureVisitor.visitFormalTypeParameter(typeParameter.getName());
SignatureVisitor classBoundVisitor = signatureVisitor.visitClassBound();
// TODO: wrong
JetTypeMapper.visitAsmType(classBoundVisitor, JetTypeMapper.TYPE_OBJECT);
}
SignatureVisitor superclassSignatureVisitor = signatureVisitor.visitSuperclass();
// TODO: wrong
superclassSignatureVisitor.visitClassType("java/lang/Object");
// TODO: add interfaces
superclassSignatureVisitor.visitEnd();
// TODO: return null if class is not generic and does not have generic superclasses
return signatureWriter.toString();
}
private String jvmName() {
return typeMapper.mapType(descriptor.getDefaultType(), kind).getInternalName();
}
@@ -277,8 +305,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
parameterTypes.add(typeMapper.mapType(CodegenUtil.getOuterClassDescriptor(descriptor).getDefaultType(), OwnerKind.IMPLEMENTATION));
}
List<TypeParameterDescriptor> typeParameters = descriptor.getTypeConstructor().getParameters();
for (int n = typeParameters.size(); n > 0; n--) {
if (CodegenUtil.requireTypeInfoConstructorArg(descriptor.getDefaultType())) {
parameterTypes.add(JetTypeMapper.TYPE_TYPEINFO);
}
@@ -337,12 +364,12 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
final InstructionAdapter iv = new InstructionAdapter(mv);
ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, constructorContext, state);
for(int slot = 0; slot != frameMap.getTypeParameterCount(); ++slot) {
if(constructorDescriptor != null)
codegen.addTypeParameter(constructorDescriptor.getTypeParameters().get(slot), StackValue.local(frameMap.getFirstTypeParameter() + slot, JetTypeMapper.TYPE_TYPEINFO));
else
codegen.addTypeParameter(descriptor.getTypeConstructor().getParameters().get(slot), StackValue.local(frameMap.getFirstTypeParameter() + slot, JetTypeMapper.TYPE_TYPEINFO));
}
// for(int slot = 0; slot != frameMap.getTypeParameterCount(); ++slot) {
// if(constructorDescriptor != null)
// codegen.addTypeParameter(constructorDescriptor.getTypeParameters().get(slot), StackValue.local(frameMap.getFirstTypeParameter() + slot, JetTypeMapper.TYPE_TYPEINFO));
// else
// codegen.addTypeParameter(descriptor.getTypeConstructor().getParameters().get(slot), StackValue.local(frameMap.getFirstTypeParameter() + slot, JetTypeMapper.TYPE_TYPEINFO));
// }
String classname = typeMapper.mapType(descriptor.getDefaultType(), kind).getInternalName();
final Type classType = Type.getType("L" + classname + ";");
@@ -371,7 +398,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
parameterTypes.add(typeMapper.mapType(CodegenUtil.getOuterClassDescriptor(descriptor).getDefaultType(), OwnerKind.IMPLEMENTATION));
}
for(TypeProjection typeParameterDescriptor : superType.getArguments()) {
codegen.generateTypeInfo(typeParameterDescriptor.getType());
codegen.generateTypeInfo(typeParameterDescriptor.getType(), null);
parameterTypes.add(JetTypeMapper.TYPE_TYPEINFO);
}
Method superCallMethod = new Method("<init>", Type.VOID_TYPE, parameterTypes.toArray(new Type[parameterTypes.size()]));
@@ -419,10 +446,21 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
iv.load(0, classType);
iv.load(frameMap.getOuterThisIndex(), type);
iv.putfield(classname, fieldName, interfaceDesc);
Type outerType = typeMapper.mapType(outerDescriptor.getDefaultType());
MethodVisitor outer = v.newMethod(myClass, Opcodes.ACC_PUBLIC, "getOuterObject", "()Ljet/JetObject;", null, null);
outer.visitCode();
outer.visitVarInsn(Opcodes.ALOAD, 0);
outer.visitFieldInsn(Opcodes.GETFIELD, classname, "this$0", outerType.getDescriptor());
outer.visitInsn(Opcodes.ARETURN);
outer.visitMaxs(0, 0);
outer.visitEnd();
}
if (CodegenUtil.hasTypeInfoField(descriptor.getDefaultType()) && kind == OwnerKind.IMPLEMENTATION) {
generateTypeInfoInitializer(frameMap.getFirstTypeParameter(), frameMap.getTypeParameterCount(), iv);
if (CodegenUtil.requireTypeInfoConstructorArg(descriptor.getDefaultType()) && kind == OwnerKind.IMPLEMENTATION) {
iv.load(0, JetTypeMapper.TYPE_OBJECT);
iv.load(frameMap.getTypeInfoIndex(), JetTypeMapper.TYPE_OBJECT);
iv.invokevirtual(typeMapper.mapType(descriptor.getDefaultType(), OwnerKind.IMPLEMENTATION).getInternalName(), "$setTypeInfo", "(Ljet/typeinfo/TypeInfo;)V");
}
if(closure != null) {
@@ -663,46 +701,6 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
}
}
protected void generateTypeInfoInitializer(int firstTypeParameter, int typeParamCount, InstructionAdapter iv) {
iv.load(0, JetTypeMapper.TYPE_OBJECT);
iv.aconst(typeMapper.mapType(descriptor.getDefaultType(), OwnerKind.IMPLEMENTATION));
iv.iconst(0);
if(CodegenUtil.hasOuterTypeInfo(descriptor)) {
iv.load(1, JetTypeMapper.TYPE_OBJECT);
iv.invokeinterface("jet/JetObject", "getTypeInfo", "()Ljet/typeinfo/TypeInfo;");
}
if(typeParamCount != 0) {
iv.iconst(typeParamCount);
iv.newarray(JetTypeMapper.TYPE_TYPEINFOPROJECTION);
for (int i = 0; i < typeParamCount; i++) {
iv.dup();
iv.iconst(i);
iv.load(firstTypeParameter + i, JetTypeMapper.TYPE_OBJECT);
iv.checkcast(JetTypeMapper.TYPE_TYPEINFOPROJECTION);
iv.astore(JetTypeMapper.TYPE_OBJECT);
}
if(CodegenUtil.hasOuterTypeInfo(descriptor)) {
iv.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;ZLjet/typeinfo/TypeInfo;[Ljet/typeinfo/TypeInfoProjection;)Ljet/typeinfo/TypeInfo;");
}
else
iv.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z[Ljet/typeinfo/TypeInfoProjection;)Ljet/typeinfo/TypeInfo;");
}
else {
if(CodegenUtil.hasOuterTypeInfo(descriptor)) {
iv.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;ZLjet/typeinfo/TypeInfo;)Ljet/typeinfo/TypeInfo;");
}
else
iv.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z)Ljet/typeinfo/TypeInfo;");
}
iv.invokevirtual(typeMapper.mapType(descriptor.getDefaultType(), OwnerKind.IMPLEMENTATION).getInternalName(), "$setTypeInfo", "(Ljet/typeinfo/TypeInfo;)V");
}
protected void generateInitializers(ExpressionCodegen codegen, InstructionAdapter iv) {
for (JetDeclaration declaration : myClass.getDeclarations()) {
if (declaration instanceof JetProperty) {
@@ -799,15 +797,14 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
return;
JetType defaultType = descriptor.getDefaultType();
if(CodegenUtil.hasTypeInfoField(defaultType)) {
if(!CodegenUtil.hasDerivedTypeInfoField(defaultType, true)) {
if(CodegenUtil.requireTypeInfoConstructorArg(defaultType)) {
if(!CodegenUtil.hasDerivedTypeInfoField(defaultType)) {
v.newField(myClass, Opcodes.ACC_PROTECTED, "$typeInfo", "Ljet/typeinfo/TypeInfo;", null, null);
MethodVisitor mv = v.newMethod(myClass, Opcodes.ACC_PUBLIC, "getTypeInfo", "()Ljet/typeinfo/TypeInfo;", null, null);
InstructionAdapter iv = null;
if (v.generateCode()) {
mv.visitCode();
iv = new InstructionAdapter(mv);
InstructionAdapter iv = new InstructionAdapter(mv);
String owner = typeMapper.mapType(descriptor.getDefaultType(), OwnerKind.IMPLEMENTATION).getInternalName();
iv.load(0, JetTypeMapper.TYPE_OBJECT);
iv.getfield(owner, "$typeInfo", "Ljet/typeinfo/TypeInfo;");
@@ -819,7 +816,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
mv = v.newMethod(myClass, Opcodes.ACC_PROTECTED | Opcodes.ACC_FINAL, "$setTypeInfo", "(Ljet/typeinfo/TypeInfo;)V", null, null);
if (v.generateCode()) {
mv.visitCode();
iv = new InstructionAdapter(mv);
InstructionAdapter iv = new InstructionAdapter(mv);
String owner = typeMapper.mapType(descriptor.getDefaultType(), OwnerKind.IMPLEMENTATION).getInternalName();
iv.load(0, JetTypeMapper.TYPE_OBJECT);
iv.load(1, JetTypeMapper.TYPE_OBJECT);
@@ -856,14 +853,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
public void generate(InstructionAdapter v) {
v.aconst(typeMapper.mapType(descriptor.getDefaultType(), OwnerKind.IMPLEMENTATION));
v.iconst(0);
ClassDescriptor outerClassDescriptor = CodegenUtil.getOuterClassDescriptor(descriptor);
if(outerClassDescriptor == null || CodegenUtil.isClassObject(descriptor)) {
v.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z)Ljet/typeinfo/TypeInfo;");
}
else {
v.getstatic(typeMapper.mapType(outerClassDescriptor.getDefaultType(), OwnerKind.IMPLEMENTATION).getInternalName(), "$staticTypeInfo", "Ljet/typeinfo/TypeInfo;");
v.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;ZLjet/typeinfo/TypeInfo;)Ljet/typeinfo/TypeInfo;");
}
v.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z)Ljet/typeinfo/TypeInfo;");
v.putstatic(typeMapper.mapType(descriptor.getDefaultType(), kind).getInternalName(), "$staticTypeInfo", "Ljet/typeinfo/TypeInfo;");
}
});
compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java
+15 -11
View File
@@ -86,7 +86,11 @@ public class JetTypeMapper {
public static final Type TYPE_LONG_ITERATOR = Type.getObjectType("jet/LongIterator");
public static final Type TYPE_FLOAT_ITERATOR = Type.getObjectType("jet/FloatIterator");
public static final Type TYPE_DOUBLE_ITERATOR = Type.getObjectType("jet/DoubleIterator");
public JetStandardLibrary getStandardLibrary() {
return standardLibrary;
}
public JetTypeMapper(JetStandardLibrary standardLibrary, BindingContext bindingContext) {
this.standardLibrary = standardLibrary;
this.bindingContext = bindingContext;
@@ -234,10 +238,10 @@ public class JetTypeMapper {
return mapType(jetType, kind, signatureVisitor, false);
}
@NotNull private Type mapType(JetType jetType, OwnerKind kind, @Nullable SignatureVisitor signatureVisitor, boolean typeParameter) {
@NotNull private Type mapType(JetType jetType, OwnerKind kind, @Nullable SignatureVisitor signatureVisitor, boolean boxPrimitive) {
Type known = knowTypes.get(jetType);
if (known != null) {
return mapKnownAsmType(jetType, known, signatureVisitor, typeParameter);
return mapKnownAsmType(jetType, known, signatureVisitor, boxPrimitive);
}
DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
@@ -249,8 +253,7 @@ public class JetTypeMapper {
if (signatureVisitor != null) {
SignatureVisitor arraySignatureVisitor = signatureVisitor.visitArrayType();
// TODO: box
mapType(memberType, kind, arraySignatureVisitor);
mapType(memberType, kind, arraySignatureVisitor, true);
}
if (!isGenericsArray(jetType)) {
@@ -261,6 +264,9 @@ public class JetTypeMapper {
}
if (JetStandardClasses.getAny().equals(descriptor)) {
if (signatureVisitor != null) {
visitAsmType(signatureVisitor, TYPE_OBJECT);
}
return TYPE_OBJECT;
}
@@ -305,7 +311,7 @@ public class JetTypeMapper {
return asmType;
}
private void visitAsmType(SignatureVisitor visitor, Type asmType) {
public static void visitAsmType(SignatureVisitor visitor, Type asmType) {
switch (asmType.getSort()) {
case Type.OBJECT:
visitor.visitClassType(asmType.getInternalName());
@@ -377,7 +383,7 @@ public class JetTypeMapper {
return asmType;
}
private static final boolean DEBUG_SIGNATURE_WRITER = true;
public static final boolean DEBUG_SIGNATURE_WRITER = true;
public CallableMethod mapToCallableMethod(FunctionDescriptor functionDescriptor, boolean superCall, OwnerKind kind) {
if(functionDescriptor == null)
@@ -573,10 +579,8 @@ public class JetTypeMapper {
parameterTypes.add(mapType(CodegenUtil.getOuterClassDescriptor(classDescriptor).getDefaultType(), OwnerKind.IMPLEMENTATION));
}
List<TypeParameterDescriptor> typeParameters = classDescriptor.getTypeConstructor().getParameters();
for (TypeParameterDescriptor typeParameter : typeParameters) {
if(typeParameter.isReified())
parameterTypes.add(TYPE_TYPEINFO);
if (CodegenUtil.requireTypeInfoConstructorArg(classDescriptor.getDefaultType())) {
parameterTypes.add(TYPE_TYPEINFO);
}
for (ValueParameterDescriptor parameter : parameters) {
compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
+2 -1
View File
@@ -6,6 +6,7 @@ import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.JavaClassDescriptor;
import org.jetbrains.jet.lang.types.JetStandardClasses;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeProjection;
import org.jetbrains.jet.lang.types.TypeUtils;
@@ -145,7 +146,7 @@ public class NamespaceCodegen {
}
DeclarationDescriptor declarationDescriptor = jetType.getConstructor().getDeclarationDescriptor();
if(!jetType.equals(root) && jetType.getArguments().size() == 0 && !(declarationDescriptor instanceof JavaClassDescriptor)) {
if(!jetType.equals(root) && jetType.getArguments().size() == 0 && !(declarationDescriptor instanceof JavaClassDescriptor) && !JetStandardClasses.getAny().equals(declarationDescriptor)) {
// TODO: we need some better checks here
v.getstatic(typeMapper.mapType(jetType, OwnerKind.IMPLEMENTATION).getInternalName(), "$typeInfo", "Ljet/typeinfo/TypeInfo;");
return;
compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java
+4 -2
View File
@@ -7,6 +7,7 @@ import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lexer.JetTokens;
import org.objectweb.asm.Label;
import org.objectweb.asm.Opcodes;
@@ -629,7 +630,7 @@ public abstract class StackValue {
for (TypeParameterDescriptor typeParameterDescriptor : setterDescriptor.getOriginal().getTypeParameters()) {
if(typeParameterDescriptor.isReified()) {
codegen.generateTypeInfo(resolvedSetCall.getTypeArguments().get(typeParameterDescriptor));
codegen.generateTypeInfo(resolvedSetCall.getTypeArguments().get(typeParameterDescriptor), null);
}
}
@@ -1010,7 +1011,8 @@ public abstract class StackValue {
return codegen.typeMapper.mapType(callableMethod.getReceiverClass());
}
else {
return codegen.typeMapper.mapType(callableMethod.getThisType());
JetType thisType = callableMethod.getThisType();
return codegen.typeMapper.mapType(thisType);
}
}
else {
compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java
+1 -3
View File
@@ -5,14 +5,12 @@ import org.jetbrains.jet.codegen.ExpressionCodegen;
import org.jetbrains.jet.codegen.JetTypeMapper;
import org.jetbrains.jet.codegen.StackValue;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.psi.JetCallExpression;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.types.JetStandardLibrary;
import org.jetbrains.jet.lang.types.JetType;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.InstructionAdapter;
@@ -30,7 +28,7 @@ public class ArrayIterator implements IntrinsicMethod {
ClassDescriptor containingDeclaration = (ClassDescriptor) funDescriptor.getContainingDeclaration().getOriginal();
JetStandardLibrary standardLibrary = codegen.getState().getStandardLibrary();
if(containingDeclaration.equals(standardLibrary.getArray())) {
codegen.generateTypeInfo(funDescriptor.getReturnType().getArguments().get(0).getType());
codegen.generateTypeInfo(funDescriptor.getReturnType().getArguments().get(0).getType(), null);
v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Ljava/lang/Object;Ljet/typeinfo/TypeInfo;)Ljet/Iterator;");
return StackValue.onStack(JetTypeMapper.TYPE_ITERATOR);
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java
-2
View File
@@ -104,6 +104,4 @@ public class JavaPackageScope extends JetScopeImpl {
private String getQualifiedName(String name) {
return (packageFQN.isEmpty() ? "" : packageFQN + ".") + name;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableDescriptor.java
+2
View File
@@ -1,6 +1,7 @@
package org.jetbrains.jet.lang.descriptors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
@@ -24,6 +25,7 @@ public interface CallableDescriptor extends DeclarationDescriptor {
/**
* Method may return null for not yet fully initialized object or if error occurred.
*/
@Nullable
JetType getReturnType();
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptor.java
+1
View File
@@ -21,6 +21,7 @@ public interface DeclarationDescriptor extends Annotated, Named {
@Nullable
DeclarationDescriptor getContainingDeclaration();
@Nullable
DeclarationDescriptor substitute(TypeSubstitutor substitutor);
<R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java
+3 -1
View File
@@ -2,14 +2,16 @@ package org.jetbrains.jet.lang.resolve;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import java.util.Collection;
import java.util.List;
import java.util.Set;
/**
* Introduces a simple wrapper for internal scope.
*
* @author abreslav
*/
public abstract class AbstractScopeAdapter implements JetScope {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/StdlibNames.java
+1 -1
View File
@@ -12,7 +12,7 @@ public class StdlibNames {
public static final String JET_PARAMETER_DESCRIPTOR = "Ljet/typeinfo/JetParameter;";
public static final String JET_PARAMETER_NAME_FIELD = "name";
public static final String JET_PARAMETER_HAS_DEFAULT_FIELD = "hasDefault";
public static final String JET_PARAMETER_HAS_DEFAULT_VALUE_FIELD = "hasDefaultValue";
public static final String JET_PARAMETER_NULLABLE_FIELD = "nullable";
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
+8 -3
View File
@@ -86,7 +86,7 @@ public class CallResolver {
FunctionDescriptor functionDescriptor = resolveSimpleCallToFunctionDescriptor(trace, scope, call, expectedType);
return functionDescriptor == null ? null : functionDescriptor.getReturnType();
}
@Nullable
public ResolvedCall<FunctionDescriptor> resolveCallWithGivenName(
@NotNull BindingTrace trace,
@@ -95,7 +95,8 @@ public class CallResolver {
@NotNull final JetReferenceExpression functionReference,
@NotNull String name,
@NotNull JetType expectedType) {
List<ResolutionTask<FunctionDescriptor>> tasks = TaskPrioritizers.FUNCTION_TASK_PRIORITIZER.computePrioritizedTasks(scope, call, name, trace.getBindingContext(), dataFlowInfo);
List<ResolutionTask<FunctionDescriptor>> tasks = TaskPrioritizers.FUNCTION_TASK_PRIORITIZER.computePrioritizedTasks(
scope, call, name, trace.getBindingContext(), dataFlowInfo);
return doResolveCall(trace, scope, call, expectedType, tasks, functionReference);
}
@@ -406,7 +407,11 @@ public class CallResolver {
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@NotNull
private <D extends CallableDescriptor> OverloadResolutionResults<D> performResolution(@NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull JetType expectedType, @NotNull ResolutionTask<D> task, @NotNull TracingStrategy tracing) {
private <D extends CallableDescriptor> OverloadResolutionResults<D> performResolution(
@NotNull BindingTrace trace,
@NotNull JetScope scope, @NotNull JetType expectedType,
@NotNull ResolutionTask<D> task, @NotNull TracingStrategy tracing
) {
for (ResolvedCallImpl<D> candidateCall : task.getCandidates()) {
D candidate = candidateCall.getCandidateDescriptor();
TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java
+2
View File
@@ -9,6 +9,8 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
import java.util.Collection;
/**
* Stores candidates for call resolution.
*
* @author abreslav
*/
/*package*/ class ResolutionTask<D extends CallableDescriptor> {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java
+10 -5
View File
@@ -17,8 +17,8 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.NamespaceType;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import java.util.Collection;
import java.util.Collections;
@@ -32,8 +32,11 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
/*package*/ abstract class TaskPrioritizer<D extends CallableDescriptor> {
public static <D extends CallableDescriptor> void splitLexicallyLocalDescriptors(
Collection<ResolvedCallImpl<D>> allDescriptors, DeclarationDescriptor containerOfTheCurrentLocality, Collection<ResolvedCallImpl<D>> local, Collection<ResolvedCallImpl<D>> nonlocal) {
@NotNull Collection<ResolvedCallImpl<D>> allDescriptors,
@NotNull DeclarationDescriptor containerOfTheCurrentLocality,
@NotNull Collection<ResolvedCallImpl<D>> local,
@NotNull Collection<ResolvedCallImpl<D>> nonlocal
) {
for (ResolvedCallImpl<D> resolvedCall : allDescriptors) {
if (DescriptorUtils.isLocal(containerOfTheCurrentLocality, resolvedCall.getCandidateDescriptor())) {
local.add(resolvedCall);
@@ -56,7 +59,9 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
return null;
}
public List<ResolutionTask<D>> computePrioritizedTasks(@NotNull JetScope scope, @NotNull Call call, @NotNull String name, @NotNull BindingContext bindingContext, @NotNull DataFlowInfo dataFlowInfo) {
@NotNull
public List<ResolutionTask<D>> computePrioritizedTasks(@NotNull JetScope scope, @NotNull Call call, @NotNull String name,
@NotNull BindingContext bindingContext, @NotNull DataFlowInfo dataFlowInfo) {
List<ResolutionTask<D>> result = Lists.newArrayList();
ReceiverDescriptor explicitReceiver = call.getExplicitReceiver();
@@ -68,7 +73,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
return result;
}
private void doComputeTasks(JetScope scope, ReceiverDescriptor receiver, Call call, String name, List<ResolutionTask<D>> result, @NotNull AutoCastService autoCastService) {
DataFlowInfo dataFlowInfo = autoCastService.getDataFlowInfo();
List<ReceiverDescriptor> implicitReceivers = Lists.newArrayList();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java
+2 -15
View File
@@ -50,20 +50,17 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
JetReferenceExpression nameReference = valueArgument.getArgumentName().getReferenceExpression();
ValueParameterDescriptor valueParameterDescriptor = parameterByName.get(valueArgument.getArgumentName().getReferenceExpression().getReferencedName());
if (valueParameterDescriptor == null) {
// temporaryTrace.getErrorHandler().genericError(nameNode, "Cannot find a parameter with this name");
temporaryTrace.report(NAMED_PARAMETER_NOT_FOUND.on(nameReference));
error = true;
}
else {
if (!usedParameters.add(valueParameterDescriptor)) {
// temporaryTrace.getErrorHandler().genericError(nameNode, "An argument is already passed for this parameter");
temporaryTrace.report(ARGUMENT_PASSED_TWICE.on(nameReference));
}
temporaryTrace.record(REFERENCE_TARGET, nameReference, valueParameterDescriptor);
put(candidateCall, valueParameterDescriptor, valueArgument, varargs);
}
if (somePositioned) {
// temporaryTrace.getErrorHandler().genericError(nameNode, "Mixing named and positioned arguments in not allowed");
temporaryTrace.report(MIXING_NAMED_AND_POSITIONED_ARGUMENTS.on(nameReference));
error = true;
}
@@ -71,7 +68,6 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
else {
somePositioned = true;
if (someNamed) {
// temporaryTrace.getErrorHandler().genericError(valueArgument.asElement().getNode(), "Mixing named and positioned arguments in not allowed");
temporaryTrace.report(MIXING_NAMED_AND_POSITIONED_ARGUMENTS.on(valueArgument.asElement()));
error = true;
}
@@ -89,13 +85,11 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
usedParameters.add(valueParameterDescriptor);
}
else {
// temporaryTrace.getErrorHandler().genericError(valueArgument.asElement().getNode(), getTooManyArgumentsMessage(candidate));
temporaryTrace.report(TOO_MANY_ARGUMENTS.on(valueArgument.asElement(), candidate));
error = true;
}
}
else {
// temporaryTrace.getErrorHandler().genericError(valueArgument.asElement().getNode(), getTooManyArgumentsMessage(candidate));
temporaryTrace.report(TOO_MANY_ARGUMENTS.on(valueArgument.asElement(), candidate));
error = true;
}
@@ -108,7 +102,6 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
JetExpression possiblyLabeledFunctionLiteral = functionLiteralArguments.get(0);
if (valueParameters.isEmpty()) {
// temporaryTrace.getErrorHandler().genericError(possiblyLabeledFunctionLiteral.getNode(), getTooManyArgumentsMessage(candidate));
temporaryTrace.report(TOO_MANY_ARGUMENTS.on(possiblyLabeledFunctionLiteral, candidate));
error = true;
}
@@ -124,13 +117,11 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
ValueParameterDescriptor valueParameterDescriptor = valueParameters.get(valueParameters.size() - 1);
if (valueParameterDescriptor.getVarargElementType() != null) {
// temporaryTrace.getErrorHandler().genericError(possiblyLabeledFunctionLiteral.getNode(), "Passing value as a vararg is only allowed inside a parenthesized argument list");
temporaryTrace.report(VARARG_OUTSIDE_PARENTHESES.on(possiblyLabeledFunctionLiteral));
error = true;
}
else {
if (!usedParameters.add(valueParameterDescriptor)) {
// temporaryTrace.getErrorHandler().genericError(possiblyLabeledFunctionLiteral.getNode(), getTooManyArgumentsMessage(candidate));
temporaryTrace.report(TOO_MANY_ARGUMENTS.on(possiblyLabeledFunctionLiteral, candidate));
error = true;
}
@@ -142,7 +133,6 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
for (int i = 1; i < functionLiteralArguments.size(); i++) {
JetExpression argument = functionLiteralArguments.get(i);
// temporaryTrace.getErrorHandler().genericError(argument.getNode(), "Only one function literal is allowed outside a parenthesized argument list");
temporaryTrace.report(MANY_FUNCTION_LITERAL_ARGUMENTS.on(argument));
error = true;
}
@@ -176,7 +166,8 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
error = true;
}
assert candidateCall.getThisObject().exists() == candidateCall.getResultingDescriptor().getExpectedThisObject().exists() : "Shouldn't happen because of TaskPrioritizer: " + candidateCall.getCandidateDescriptor();
assert candidateCall.getThisObject().exists() == candidateCall.getResultingDescriptor().getExpectedThisObject().exists() :
"Shouldn't happen because of TaskPrioritizer: " + candidateCall.getCandidateDescriptor();
return error;
}
@@ -196,8 +187,4 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
candidateCall.recordValueArgument(valueParameterDescriptor, argument);
}
}
// private static <Descriptor extends CallableDescriptor> String getTooManyArgumentsMessage(Descriptor candidate) {
// return "Too many arguments for " + DescriptorRenderer.TEXT.render(candidate);
// }
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintResolutionListener.java
+22
View File
@@ -10,6 +10,28 @@ import java.util.Set;
*/
public interface ConstraintResolutionListener {
public static final ConstraintResolutionListener DO_NOTHING = new ConstraintResolutionListener() {
@Override
public void constraintsForUnknown(TypeParameterDescriptor typeParameterDescriptor, ConstraintSystemImpl.TypeValue typeValue) {
}
@Override
public void constraintsForKnownType(JetType type, ConstraintSystemImpl.TypeValue typeValue) {
}
@Override
public void done(ConstraintSystemSolution solution, Set<TypeParameterDescriptor> typeParameterDescriptors) {
}
@Override
public void log(Object message) {
}
@Override
public void error(Object message) {
}
};
void constraintsForUnknown(TypeParameterDescriptor typeParameterDescriptor, ConstraintSystemImpl.TypeValue typeValue);
void constraintsForKnownType(JetType type, ConstraintSystemImpl.TypeValue typeValue);
void done(ConstraintSystemSolution solution, Set<TypeParameterDescriptor> typeParameterDescriptors);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java
+5
View File
@@ -51,6 +51,11 @@ public interface JetScope {
@Nullable
PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName);
/**
* All visible descriptors from current scope.
*
* @return All visible descriptors from current scope.
*/
@NotNull
Collection<DeclarationDescriptor> getAllDescriptors();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeUtils.java
+54
View File
@@ -0,0 +1,54 @@
package org.jetbrains.jet.lang.resolve.scopes;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import java.util.Collection;
import java.util.List;
import java.util.Set;
/**
* @author Nikolay Krasko
*/
public final class JetScopeUtils {
private JetScopeUtils() {}
/**
* Get receivers in order of locality, so that the closest (the most local) receiver goes first
* A wrapper for {@link JetScope#getImplicitReceiversHierarchy(java.util.List)}
*
* @param scope Scope for getting receivers hierarchy.
* @return receivers hierarchy.
*/
@NotNull
public static Collection<ReceiverDescriptor> getImplicitReceiversHierarchy(@NotNull JetScope scope) {
List<ReceiverDescriptor> descriptors = Lists.newArrayList();
scope.getImplicitReceiversHierarchy(descriptors);
return descriptors;
}
/**
* Get all extension descriptors among visible descriptors for current scope.
*
* @param scope Scope for query extensions.
* @return extension descriptors.
*/
public static Collection<CallableDescriptor> getAllExtensions(@NotNull JetScope scope) {
final Set<CallableDescriptor> result = Sets.newHashSet();
for (DeclarationDescriptor descriptor : scope.getAllDescriptors()) {
if (descriptor instanceof CallableDescriptor) {
CallableDescriptor callDescriptor = (CallableDescriptor) descriptor;
if (callDescriptor.getReceiverParameter().exists()) {
result.add(callDescriptor);
}
}
}
return result;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java
+3 -2
View File
@@ -12,9 +12,9 @@ import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.resolve.TypeResolver;
import org.jetbrains.jet.lang.resolve.calls.CallMaker;
import org.jetbrains.jet.lang.resolve.calls.CallResolver;
import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults;
import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;
import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
@@ -40,7 +40,8 @@ import java.util.Map;
@NotNull JetType expectedType,
@NotNull JetType expectedReturnType,
boolean namespacesAllowed) {
return new ExpressionTypingContext(semanticServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, dataFlowInfo, expectedType, expectedReturnType, namespacesAllowed);
return new ExpressionTypingContext(semanticServices, patternsToDataFlowInfo, patternsToBoundVariableLists,
labelResolver, trace, scope, dataFlowInfo, expectedType, expectedReturnType, namespacesAllowed);
}
// @NotNull
compiler/testData/codegen/regressions/kt259.jet
+1 -2
View File
@@ -1,4 +1,5 @@
class A() {}
open class B<T>() {
fun isT (a : Any?) : Boolean {
return a is T
@@ -167,7 +168,6 @@ fun t26 () : Boolean {
}
fun box() : String {
/*
if(!t1()) {
return "t1 failed"
}
@@ -243,7 +243,6 @@ fun box() : String {
if(!t25()) {
return "t25 failed"
}
*/
if(!t26()) {
return "t26 failed"
}
compiler/testData/codegen/regressions/kt785.jet
+13
View File
@@ -0,0 +1,13 @@
class A() {
var x : Int = 0
var z = { () =>
x++
}
}
fun box() : String {
val a = A()
a.z() //problem is here
return if (a.x == 1) "OK" else "fail"
}
compiler/testData/codegen/regressions/kt789.jet
+12
View File
@@ -0,0 +1,12 @@
namespace foo
import java.util.*;
import std.util.*
fun box() : String {
val a = ArrayList<Int>();
a.add(1)
a.add(2)
return if((a.size == 2) && (a.get(1) == 2) && (a.get(0) == 1)) "OK" else "fail"
}
compiler/testData/codegen/typeInfo/inheritance.jet
+4 -2
View File
@@ -1,4 +1,4 @@
open class A<T> () {
open class A<out T> () {
fun plus(e: T) = B<T> (e)
}
@@ -6,4 +6,6 @@ class B<T> (val e: T) : A<T>() {
fun add() = B<T> (e)
}
fun box() = if( A<String>().plus("239").add().e == "239" ) "OK" else "fail"
fun box() : String {
return if(A<String>().plus("239").add().e == "239" ) "OK" else "fail"
}
compiler/testData/codegen/typeInfo/inner.jet
-1
View File
@@ -4,7 +4,6 @@ class Box<T>() {
}
class Inner2() : Inner() {
}
fun inner() = Inner2()
compiler/testData/compileJavaAgainstKotlin/IntArray.java
-6
View File
@@ -1,6 +0,0 @@
class IntArray {
{
int[] r = namespace.doNothing(new int[0]);
}
}
compiler/testData/compileJavaAgainstKotlin/IntArray.kt
-1
View File
@@ -1 +0,0 @@
fun doNothing(array: IntArray) = array
compiler/testData/compileJavaAgainstKotlin/class/Simple.java
+7
View File
@@ -0,0 +1,7 @@
class Simple {
{
jet.typeinfo.TypeInfo blabla = null;
new Impossible<String>(blabla);
}
}
compiler/testData/compileJavaAgainstKotlin/class/Simple.kt
+1
View File
@@ -0,0 +1 @@
class Impossible<P>()
compiler/testData/compileJavaAgainstKotlin/method/Any.java
+6
View File
@@ -0,0 +1,6 @@
class Any {
{
Object r = namespace.anyany(new Object(), null);
}
}
compiler/testData/compileJavaAgainstKotlin/method/Any.kt
+2
View File
@@ -0,0 +1,2 @@
// extra parameter is to preserve generic signature
fun anyany(a: Any, ignore: java.util.List<String>) = a
compiler/testData/compileJavaAgainstKotlin/method/ArrayOfIntArray.java
+7
View File
@@ -0,0 +1,7 @@
class ArrayOfIntArray {
{
int[][] a = new int[0][];
int[][] r = namespace.ohMy(a);
}
}
compiler/testData/compileJavaAgainstKotlin/method/ArrayOfIntArray.kt
+1
View File
@@ -0,0 +1 @@
fun ohMy(p: Array<IntArray>) = p
compiler/testData/compileJavaAgainstKotlin/method/ArrayOfIntegerArray.java
+7
View File
@@ -0,0 +1,7 @@
class ArrayOfIntArray {
{
Integer[][] a = new Integer[0][];
Integer[][] r = namespace.ohMy(a, null);
}
}
compiler/testData/compileJavaAgainstKotlin/method/ArrayOfIntegerArray.kt
+2
View File
@@ -0,0 +1,2 @@
// extra parameter is to make sure generic signature is generated
fun ohMy(p: Array<Array<Int>>, ignore: java.util.List<String>) = p
compiler/testData/compileJavaAgainstKotlin/GenericArray.java → compiler/testData/compileJavaAgainstKotlin/method/GenericArray.java
View File
compiler/testData/compileJavaAgainstKotlin/GenericArray.kt → compiler/testData/compileJavaAgainstKotlin/method/GenericArray.kt
View File
compiler/testData/compileJavaAgainstKotlin/Hello.java → compiler/testData/compileJavaAgainstKotlin/method/Hello.java
View File
compiler/testData/compileJavaAgainstKotlin/Hello.kt → compiler/testData/compileJavaAgainstKotlin/method/Hello.kt
View File
compiler/testData/compileJavaAgainstKotlin/Int.java → compiler/testData/compileJavaAgainstKotlin/method/Int.java
View File
compiler/testData/compileJavaAgainstKotlin/Int.kt → compiler/testData/compileJavaAgainstKotlin/method/Int.kt
View File
compiler/testData/compileJavaAgainstKotlin/method/IntArray.java
+6
View File
@@ -0,0 +1,6 @@
class IntArray {
{
int[] r = namespace.doNothing(new int[0], null);
}
}
compiler/testData/compileJavaAgainstKotlin/method/IntArray.kt
+2
View File
@@ -0,0 +1,2 @@
// extra parameter is to make sure generic signature is not erased
fun doNothing(array: IntArray, ignore: java.util.List<String>) = array
compiler/testData/compileJavaAgainstKotlin/IntWithDefault.java → compiler/testData/compileJavaAgainstKotlin/method/IntWithDefault.java
View File
compiler/testData/compileJavaAgainstKotlin/IntWithDefault.kt → compiler/testData/compileJavaAgainstKotlin/method/IntWithDefault.kt
View File
compiler/testData/compileJavaAgainstKotlin/method/IntegerArray.java
+6
View File
@@ -0,0 +1,6 @@
class IntArray {
{
Integer[] r = namespace.doNothing(new Integer[0], null);
}
}
compiler/testData/compileJavaAgainstKotlin/method/IntegerArray.kt
+2
View File
@@ -0,0 +1,2 @@
// extra parameter is to make sure generic signature is preserved
fun doNothing(array: Array<Int>, ignore: java.util.List<String>) = array
compiler/testData/compileJavaAgainstKotlin/ListOfInt.java → compiler/testData/compileJavaAgainstKotlin/method/ListOfInt.java
View File
compiler/testData/compileJavaAgainstKotlin/ListOfInt.kt → compiler/testData/compileJavaAgainstKotlin/method/ListOfInt.kt
View File
compiler/testData/compileJavaAgainstKotlin/ListOfString.java → compiler/testData/compileJavaAgainstKotlin/method/ListOfString.java
View File
compiler/testData/compileJavaAgainstKotlin/ListOfString.kt → compiler/testData/compileJavaAgainstKotlin/method/ListOfString.kt
View File
compiler/testData/compileJavaAgainstKotlin/ListOfT.java → compiler/testData/compileJavaAgainstKotlin/method/ListOfT.java
View File
compiler/testData/compileJavaAgainstKotlin/ListOfT.kt → compiler/testData/compileJavaAgainstKotlin/method/ListOfT.kt
View File
compiler/testData/compileJavaAgainstKotlin/MapOfKString.java → compiler/testData/compileJavaAgainstKotlin/method/MapOfKString.java
View File
compiler/testData/compileJavaAgainstKotlin/MapOfKString.kt → compiler/testData/compileJavaAgainstKotlin/method/MapOfKString.kt
View File
compiler/testData/compileJavaAgainstKotlin/MapOfStringIntQ.java → compiler/testData/compileJavaAgainstKotlin/method/MapOfStringIntQ.java
View File
compiler/testData/compileJavaAgainstKotlin/MapOfStringIntQ.kt → compiler/testData/compileJavaAgainstKotlin/method/MapOfStringIntQ.kt
View File
compiler/testData/compileJavaAgainstKotlin/method/Vararg.java
+9
View File
@@ -0,0 +1,9 @@
import java.util.List;
import java.util.ArrayList;
class Vararg {
{
List<String> list = new ArrayList<String>();
List<String> r = namespace.gg(list, 3, 4, 5, 6);
}
}
compiler/testData/compileJavaAgainstKotlin/method/Vararg.kt
+3
View File
@@ -0,0 +1,3 @@
import java.util.List;
fun gg(list: List<String>, vararg ints: Int) = list
compiler/testData/compileJavaAgainstKotlin/Void.java → compiler/testData/compileJavaAgainstKotlin/method/Void.java
View File
compiler/testData/compileJavaAgainstKotlin/Void.kt → compiler/testData/compileJavaAgainstKotlin/method/Void.kt
View File
compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java
+1 -1
View File
@@ -24,7 +24,7 @@ public class ClassGenTest extends CodegenTestCase {
public void testArrayListInheritance() throws Exception {
loadFile("classes/inheritingFromArrayList.jet");
System.out.println(generateToText());
final Class aClass = loadClass("Foo", generateClassesInFile());
assertInstanceOf(aClass.newInstance(), List.class);
}
compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java
+4
View File
@@ -81,6 +81,10 @@ public class FunctionGenTest extends CodegenTestCase {
blackBoxFile("regressions/kt395.jet");
}
public void testKt785 () {
// blackBoxFile("regressions/kt785.jet");
}
public void testFunction () throws InvocationTargetException, IllegalAccessException {
blackBoxFile("functions/functionExpression.jet");
}
compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java
+4
View File
@@ -80,6 +80,10 @@ public class StdlibTest extends CodegenTestCase {
blackBoxFile("regressions/kt528.kt");
}
public void testKt789 () {
// blackBoxFile("regressions/kt789.jet");
}
public void testCollectionSize () throws Exception {
loadText("import std.util.*; fun box() = if(java.util.Arrays.asList(0, 1, 2)?.size == 3) \"OK\" else \"fail\"");
// System.out.println(generateToText());
compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java
+1 -2
View File
@@ -140,7 +140,7 @@ public class TypeInfoTest extends CodegenTestCase {
public void testInner() throws Exception {
blackBoxFile("typeInfo/inner.jet");
// System.out.println(generateToText());
System.out.println(generateToText());
}
public void testInheritance() throws Exception {
@@ -148,4 +148,3 @@ public class TypeInfoTest extends CodegenTestCase {
System.out.println(generateToText());
}
}