diff --git a/.idea/modules.xml b/.idea/modules.xml index 4959db82cd6..463eb8bb67f 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -5,6 +5,7 @@ + diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java b/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java index 01b0d082f3b..9b5888566d1 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java @@ -2,6 +2,8 @@ package org.jetbrains.jet.codegen; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; import org.objectweb.asm.commons.InstructionAdapter; import org.objectweb.asm.commons.Method; @@ -17,9 +19,9 @@ public class CallableMethod implements Callable { private final int invokeOpcode; private final List valueParameterTypes; private boolean acceptsTypeArguments = false; - private boolean needsReceiverOnStack = false; private boolean ownerFromCall = false; - private ClassDescriptor receiverClass = null; + private DeclarationDescriptor thisClass = null; + private DeclarationDescriptor receiverClass = null; private Type generateCalleeType = null; public CallableMethod(String owner, Method signature, int invokeOpcode, List valueParameterTypes) { @@ -57,13 +59,12 @@ public class CallableMethod implements Callable { this.acceptsTypeArguments = acceptsTypeArguments; } - public void setNeedsReceiver(@Nullable ClassDescriptor receiverClass) { - needsReceiverOnStack = true; + public void setNeedsReceiver(@Nullable DeclarationDescriptor receiverClass) { this.receiverClass = receiverClass; } - public boolean needsReceiverOnStack() { - return needsReceiverOnStack; + public void setNeedsThis(@Nullable DeclarationDescriptor receiverClass) { + this.thisClass = receiverClass; } public boolean isOwnerFromCall() { @@ -74,10 +75,6 @@ public class CallableMethod implements Callable { this.ownerFromCall = ownerFromCall; } - public ClassDescriptor getReceiverClass() { - return receiverClass; - } - void invoke(InstructionAdapter v) { v.visitMethodInsn(getInvokeOpcode(), getOwner(), getSignature().getName(), getSignature().getDescriptor()); } @@ -89,4 +86,25 @@ public class CallableMethod implements Callable { public Type getGenerateCalleeType() { return generateCalleeType; } + + public void invokeWithDefault(InstructionAdapter v, int mask) { + v.iconst(mask); + String desc = getSignature().getDescriptor().replace(")", "I)"); + if(getInvokeOpcode() != Opcodes.INVOKESTATIC) + desc = desc.replace("(", "(L" + getOwner() + ";"); + v.visitMethodInsn(Opcodes.INVOKESTATIC, getInvokeOpcode() == Opcodes.INVOKEINTERFACE ? getOwner() + "$$TImpl" : getOwner(), getSignature().getName() + "$default", desc); + } + + public boolean isNeedsThis() { + return thisClass != null; + } + + public boolean isNeedsReceiver() { + return receiverClass != null; + } + + public DeclarationDescriptor getThisClass() { + return thisClass; + } + } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java index 8e507409cb9..b062a56f417 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java @@ -4,19 +4,13 @@ package org.jetbrains.jet.codegen; import com.intellij.openapi.util.Pair; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetFunctionLiteral; import org.jetbrains.jet.lang.psi.JetFunctionLiteralExpression; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import org.objectweb.asm.Type; +import org.objectweb.asm.*; import org.objectweb.asm.commons.InstructionAdapter; import org.objectweb.asm.commons.Method; import org.objectweb.asm.signature.SignatureWriter; @@ -26,6 +20,8 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import static org.objectweb.asm.Opcodes.*; + public class ClosureCodegen extends FunctionOrClosureCodegen { public ClosureCodegen(GenerationState state, ExpressionCodegen exprContext, ClassContext context) { @@ -68,8 +64,8 @@ public class ClosureCodegen extends FunctionOrClosureCodegen { appendType(signatureWriter, funDescriptor.getReturnType(), '='); signatureWriter.visitEnd(); - cv.visit(Opcodes.V1_6, - Opcodes.ACC_PUBLIC, + cv.visit(V1_6, + ACC_PUBLIC, name, null, funClass, @@ -79,7 +75,7 @@ public class ClosureCodegen extends FunctionOrClosureCodegen { generateBridge(name, funDescriptor, cv); - boolean captureThis = generateBody(funDescriptor, cv, fun.getFunctionLiteral()); + captureThis = generateBody(funDescriptor, cv, fun.getFunctionLiteral()); final Type enclosingType = context.enclosingClassType(state.getTypeMapper()); if (enclosingType == null) captureThis = false; @@ -89,6 +85,10 @@ public class ClosureCodegen extends FunctionOrClosureCodegen { cv.visitField(0, "this$0", enclosingType.getDescriptor(), null, null); } + if(isConst()) { + generateConstInstance(); + } + cv.visitEnd(); final GeneratedAnonymousClassDescriptor answer = new GeneratedAnonymousClassDescriptor(name, constructor, captureThis); @@ -99,6 +99,48 @@ public class ClosureCodegen extends FunctionOrClosureCodegen { return answer; } + private void generateConstInstance() { + cv.visitField(ACC_PRIVATE| ACC_STATIC, "$instance", "Ljava/lang/ref/SoftReference;", null, null); + + MethodVisitor mv = cv.visitMethod(ACC_PUBLIC | ACC_STATIC, "$getInstance", "()L" + name + ";", null, new String[0]); + mv.visitCode(); + mv.visitFieldInsn(GETSTATIC, name, "$instance", "Ljava/lang/ref/SoftReference;"); + mv.visitInsn(DUP); + Label makeNew = new Label(); + mv.visitJumpInsn(IFNULL, makeNew); + + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/ref/SoftReference", "get", "()Ljava/lang/Object;"); + mv.visitInsn(DUP); + + Label ret = new Label(); + mv.visitJumpInsn(IFNULL, makeNew); + mv.visitTypeInsn(CHECKCAST, name); + mv.visitJumpInsn(GOTO, ret); + + mv.visitLabel(makeNew); + mv.visitInsn(POP); + + mv.visitTypeInsn(NEW, "java/lang/ref/SoftReference"); + mv.visitInsn(DUP); + + mv.visitTypeInsn(NEW, name); + mv.visitInsn(DUP); + mv.visitVarInsn(ASTORE, 0); + + mv.visitInsn(DUP); + mv.visitMethodInsn(INVOKESPECIAL, name, "", "()V"); + + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/ref/SoftReference", "", "(Ljava/lang/Object;)V"); + mv.visitFieldInsn(PUTSTATIC, name, "$instance", "Ljava/lang/ref/SoftReference;"); + + mv.visitVarInsn(ALOAD, 0); + + mv.visitLabel(ret); + mv.visitInsn(ARETURN); + mv.visitMaxs(0,0); + mv.visitEnd(); + } + private boolean generateBody(FunctionDescriptor funDescriptor, ClassVisitor cv, JetFunctionLiteral body) { final ClassContext closureContext = context.intoClosure(name, this); FunctionCodegen fc = new FunctionCodegen(closureContext, cv, state); @@ -110,7 +152,7 @@ public class ClosureCodegen extends FunctionOrClosureCodegen { final Method bridge = erasedInvokeSignature(funDescriptor); final Method delegate = invokeSignature(funDescriptor); - final MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC, "invoke", bridge.getDescriptor(), state.getTypeMapper().genericSignature(funDescriptor), new String[0]); + final MethodVisitor mv = cv.visitMethod(ACC_PUBLIC, "invoke", bridge.getDescriptor(), state.getTypeMapper().genericSignature(funDescriptor), new String[0]); mv.visitCode(); InstructionAdapter iv = new InstructionAdapter(mv); @@ -164,7 +206,7 @@ public class ClosureCodegen extends FunctionOrClosureCodegen { } final Method constructor = new Method("", Type.VOID_TYPE, argTypes); - final MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC, "", constructor.getDescriptor(), null, new String[0]); + final MethodVisitor mv = cv.visitMethod(ACC_PUBLIC, "", constructor.getDescriptor(), null, new String[0]); mv.visitCode(); InstructionAdapter iv = new InstructionAdapter(mv); ExpressionCodegen expressionCodegen = new ExpressionCodegen(mv, null, Type.VOID_TYPE, context, state); @@ -190,7 +232,7 @@ public class ClosureCodegen extends FunctionOrClosureCodegen { StackValue.field(type, name, fieldName, false).store(iv); } - iv.visitInsn(Opcodes.RETURN); + iv.visitInsn(RETURN); mv.visitMaxs(0, 0); mv.visitEnd(); @@ -215,15 +257,4 @@ public class ClosureCodegen extends FunctionOrClosureCodegen { signatureWriter.visitClassType(rawRetType.getInternalName()); signatureWriter.visitEnd(); } - - public static CallableMethod asCallableMethod(FunctionDescriptor fd) { - Method descriptor = erasedInvokeSignature(fd); - String owner = getInternalClassName(fd); - final CallableMethod result = new CallableMethod(owner, descriptor, Opcodes.INVOKEVIRTUAL, Arrays.asList(descriptor.getArgumentTypes())); - if (fd.getReceiverParameter().exists()) { - result.setNeedsReceiver(null); - } - result.requestGenerateCallee(Type.getObjectType(getInternalClassName(fd))); - return result; - } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 782ec25c56a..0b577fedb1c 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -13,6 +13,7 @@ import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; +import org.jetbrains.jet.lang.resolve.calls.*; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.JavaClassDescriptor; import org.jetbrains.jet.lang.types.*; @@ -26,6 +27,8 @@ import org.objectweb.asm.commons.Method; import java.util.*; +import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL; + /** * @author max * @author yole @@ -76,6 +79,17 @@ public class ExpressionCodegen extends JetVisitor { this.intrinsics = state.getIntrinsics(); } + private CallableMethod asCallableMethod(FunctionDescriptor fd) { + Method descriptor = ClosureCodegen.erasedInvokeSignature(fd); + String owner = ClosureCodegen.getInternalClassName(fd); + final CallableMethod result = new CallableMethod(owner, descriptor, INVOKEVIRTUAL, Arrays.asList(descriptor.getArgumentTypes())); + if (fd.getReceiverParameter().exists()) { + result.setNeedsReceiver(fd.getReceiverParameter().getType().getConstructor().getDeclarationDescriptor()); + } + result.requestGenerateCallee(Type.getObjectType(ClosureCodegen.getInternalClassName(fd))); + return result; + } + public GenerationState getState() { return state; } @@ -428,9 +442,9 @@ public class ExpressionCodegen extends JetVisitor { gen(expression.getLoopRange(), loopRangeType); v.dup(); - v.invokevirtual("jet/IntRange", "getStartValue", "()I"); + v.invokevirtual("jet/IntRange", "getStart", "()I"); v.store(lookupLocal(parameterDescriptor), Type.INT_TYPE); - v.invokevirtual("jet/IntRange", "getEndValue", "()I"); + v.invokevirtual("jet/IntRange", "getEnd", "()I"); v.store(myEndVar, Type.INT_TYPE); } } @@ -543,23 +557,29 @@ public class ExpressionCodegen extends JetVisitor { return generateBlock(expression.getFunctionLiteral().getBodyExpression().getStatements()); } else { - final GeneratedAnonymousClassDescriptor closure = new ClosureCodegen(state, this, context).gen(expression); + ClosureCodegen closureCodegen = new ClosureCodegen(state, this, context); + final GeneratedAnonymousClassDescriptor closure = closureCodegen.gen(expression); - v.anew(Type.getObjectType(closure.getClassname())); - v.dup(); - - final Method cons = closure.getConstructor(); - - if (closure.isCaptureThis()) { - v.load(0, JetTypeMapper.TYPE_OBJECT); + if(closureCodegen.isConst()) { + v.invokestatic(closure.getClassname(), "$getInstance", "()L" + closure.getClassname() + ";"); } + else { + v.anew(Type.getObjectType(closure.getClassname())); + v.dup(); - for (int i = 0; i < closure.getArgs().size(); i++) { - StackValue arg = closure.getArgs().get(i); - arg.put(cons.getArgumentTypes()[i], v); + final Method cons = closure.getConstructor(); + + if (closure.isCaptureThis()) { + v.load(0, JetTypeMapper.TYPE_OBJECT); + } + + for (int i = 0; i < closure.getArgs().size(); i++) { + StackValue arg = closure.getArgs().get(i); + arg.put(cons.getArgumentTypes()[i], v); + } + + v.invokespecial(closure.getClassname(), "", cons.getDescriptor()); } - - v.invokespecial(closure.getClassname(), "", cons.getDescriptor()); return StackValue.onStack(Type.getObjectType(closure.getClassname())); } } @@ -976,7 +996,7 @@ public class ExpressionCodegen extends JetVisitor { callableMethod = typeMapper.mapToCallableMethod((PsiNamedElement) declarationPsiElement, null); } else if (fd instanceof VariableAsFunctionDescriptor) { - callableMethod = ClosureCodegen.asCallableMethod((FunctionDescriptor) fd); + callableMethod = asCallableMethod((FunctionDescriptor) fd); } else if (fd instanceof FunctionDescriptor) { callableMethod = typeMapper.mapToCallableMethod((FunctionDescriptor) fd, null); @@ -1011,18 +1031,35 @@ public class ExpressionCodegen extends JetVisitor { if (callableMethod.isOwnerFromCall()) { setOwnerFromCall(callableMethod, expression); } - if (callableMethod.needsReceiverOnStack()) { - if (receiver == StackValue.none()) { - ClassDescriptor receiverClass = callableMethod.getReceiverClass(); - receiver = receiverClass == null ? thisExpression() : generateThisOrOuter(receiverClass); + + if (callableMethod.isNeedsThis()) { + if(callableMethod.isNeedsReceiver()) { + generateThisOrOuter((ClassDescriptor) callableMethod.getThisClass()).put(JetTypeMapper.TYPE_OBJECT, v); + receiver.put(JetTypeMapper.TYPE_OBJECT, v); + } + else { + if (receiver == StackValue.none()) { + generateThisOrOuter((ClassDescriptor) callableMethod.getThisClass()).put(JetTypeMapper.TYPE_OBJECT, v);; + } + else { + receiver.put(JetTypeMapper.TYPE_OBJECT, v); + } } - receiver.put(JetTypeMapper.TYPE_OBJECT, v); } - pushMethodArguments(expression, callableMethod.getValueParameterTypes()); + else { + if (callableMethod.isNeedsReceiver()) { + receiver.put(JetTypeMapper.TYPE_OBJECT, v); + } + } + + int mask = pushMethodArguments(expression, callableMethod.getValueParameterTypes()); if (callableMethod.acceptsTypeArguments()) { pushTypeArguments(expression); } - callableMethod.invoke(v); + if(mask == 0) + callableMethod.invoke(v); + else + callableMethod.invokeWithDefault(v, mask); } private void setOwnerFromCall(CallableMethod callableMethod, JetCallElement expression) { @@ -1118,11 +1155,52 @@ public class ExpressionCodegen extends JetVisitor { return false; } - private void pushMethodArguments(JetCallElement expression, List valueParameterTypes) { + private int pushMethodArguments(JetCallElement expression, List valueParameterTypes) { + ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression()); List args = expression.getValueArguments(); - for (int i = 0, argsSize = args.size(); i < argsSize; i++) { - ValueArgument arg = args.get(i); - gen(arg.getArgumentExpression(), valueParameterTypes.get(i)); + if(resolvedCall != null) { + Map valueArguments = resolvedCall.getValueArguments(); + CallableDescriptor fd = resolvedCall.getResultingDescriptor(); + + int index = 0; + int mask = 0; + for (ValueParameterDescriptor valueParameterDescriptor : fd.getValueParameters()) { + ResolvedValueArgument resolvedValueArgument = valueArguments.get(valueParameterDescriptor); + if(resolvedValueArgument instanceof ExpressionValueArgument) { + ExpressionValueArgument valueArgument = (ExpressionValueArgument) resolvedValueArgument; + gen(valueArgument.getExpression(), valueParameterTypes.get(index)); + } + else if(resolvedValueArgument instanceof DefaultValueArgument) { + Type type = valueParameterTypes.get(index); + if(type.getSort() == Type.OBJECT||type.getSort() == Type.ARRAY) + v.aconst(null); + else if(type.getSort() == Type.FLOAT) { + v.aconst(0f); + } + else if(type.getSort() == Type.DOUBLE) { + v.aconst(0d); + } + else { + v.iconst(0); + } + mask |= (1 << index); + } + else if(resolvedValueArgument instanceof VarargValueArgument) { + throw new UnsupportedOperationException("Varargs are not supported yet"); + } + else { + throw new UnsupportedOperationException(); + } + index++; + } + return mask; + } + else { + for (int i = 0, argsSize = args.size(); i < argsSize; i++) { + ValueArgument arg = args.get(i); + gen(arg.getArgumentExpression(), valueParameterTypes.get(i)); + } + return 0; } } @@ -1739,8 +1817,19 @@ public class ExpressionCodegen extends JetVisitor { } private void pushTypeArguments(JetCallElement expression) { - for (JetTypeProjection jetTypeArgument : expression.getTypeArguments()) { - pushTypeArgument(jetTypeArgument); + ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression()); + if(resolvedCall != null) { + Map typeArguments = resolvedCall.getTypeArguments(); + CallableDescriptor resultingDescriptor = resolvedCall.getCandidateDescriptor(); + for (TypeParameterDescriptor typeParameterDescriptor : resultingDescriptor.getTypeParameters()) { + JetType jetType = typeArguments.get(typeParameterDescriptor); + generateTypeInfo(jetType); + } + } + else { + for (JetTypeProjection jetTypeArgument : expression.getTypeArguments()) { + pushTypeArgument(jetTypeArgument); + } } } @@ -1754,7 +1843,7 @@ public class ExpressionCodegen extends JetVisitor { Type type = JetTypeMapper.psiClassType(javaClass); v.anew(type); v.dup(); - final CallableMethod callableMethod = JetTypeMapper.mapToCallableMethod(constructor); + final CallableMethod callableMethod = typeMapper.mapToCallableMethod(constructor); invokeMethodWithArguments(callableMethod, expression); return type; } @@ -1850,7 +1939,7 @@ public class ExpressionCodegen extends JetVisitor { assert declaration != null : "No declaration found for " + expression.getText(); final CallableMethod accessor; if (declaration instanceof PsiMethod) { - accessor = JetTypeMapper.mapToCallableMethod((PsiMethod) declaration); + accessor = typeMapper.mapToCallableMethod((PsiMethod) declaration); } else if (declaration instanceof JetNamedFunction) { accessor = typeMapper.mapToCallableMethod((JetNamedFunction) declaration, null); @@ -1922,7 +2011,7 @@ public class ExpressionCodegen extends JetVisitor { @Override public StackValue visitThisExpression(JetThisExpression expression, StackValue receiver) { - final DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getThisReference()); + final DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getInstanceReference()); if (descriptor instanceof ClassDescriptor) { return generateThisOrOuter((ClassDescriptor) descriptor); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 1fcd98e320c..a7724378b36 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -1,26 +1,22 @@ package org.jetbrains.jet.codegen; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.psi.JetDeclarationWithBody; -import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.psi.JetNamedFunction; +import com.intellij.psi.PsiElement; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import org.objectweb.asm.Type; +import org.objectweb.asm.*; import org.objectweb.asm.commons.InstructionAdapter; import org.objectweb.asm.commons.Method; import java.util.List; import java.util.Set; +import static org.objectweb.asm.Opcodes.*; + /** * @author max * @author yole + * @author alex.tkachman */ public class FunctionCodegen { private final ClassContext owner; @@ -54,74 +50,89 @@ public class FunctionCodegen { List paramDescrs = functionDescriptor.getValueParameters(); List typeParameters = functionDescriptor.getTypeParameters(); - int flags = Opcodes.ACC_PUBLIC; // TODO. + int flags = ACC_PUBLIC; // TODO. OwnerKind kind = context.getContextKind(); - if(kind == OwnerKind.TRAIT_IMPL && bodyExpressions == null) - return; + if (kind != OwnerKind.TRAIT_IMPL || bodyExpressions != null) { - boolean isStatic = kind == OwnerKind.NAMESPACE || kind == OwnerKind.TRAIT_IMPL; - if (isStatic) flags |= Opcodes.ACC_STATIC; + boolean isStatic = kind == OwnerKind.NAMESPACE || kind == OwnerKind.TRAIT_IMPL; + if (isStatic) flags |= ACC_STATIC; - boolean isAbstract = !isStatic && (bodyExpressions == null || CodegenUtil.isInterface(functionDescriptor.getContainingDeclaration())); - if (isAbstract) flags |= Opcodes.ACC_ABSTRACT; + boolean isAbstract = !isStatic && (bodyExpressions == null || CodegenUtil.isInterface(functionDescriptor.getContainingDeclaration())); + if (isAbstract) flags |= ACC_ABSTRACT; - final MethodVisitor mv = v.visitMethod(flags, jvmSignature.getName(), jvmSignature.getDescriptor(), null, null); - if (!isAbstract) { - mv.visitCode(); - FrameMap frameMap = context.prepareFrame(); - - ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, jvmSignature.getReturnType(), context, state); - - Type[] argTypes = jvmSignature.getArgumentTypes(); - for (int i = 0; i < paramDescrs.size(); i++) { - ValueParameterDescriptor parameter = paramDescrs.get(i); - frameMap.enter(parameter, argTypes[i].getSize()); - } - - for (final TypeParameterDescriptor typeParameterDescriptor : typeParameters) { - int slot = frameMap.enterTemp(); - codegen.addTypeParameter(typeParameterDescriptor, StackValue.local(slot, JetTypeMapper.TYPE_TYPEINFO)); - } - - if (kind instanceof OwnerKind.DelegateKind) { - OwnerKind.DelegateKind dk = (OwnerKind.DelegateKind) kind; - InstructionAdapter iv = new InstructionAdapter(mv); - iv.load(0, JetTypeMapper.TYPE_OBJECT); - dk.getDelegate().put(JetTypeMapper.TYPE_OBJECT, iv); - for (int i = 0; i < argTypes.length; i++) { - Type argType = argTypes[i]; - iv.load(i + 1, argType); + final MethodVisitor mv = v.visitMethod(flags, jvmSignature.getName(), jvmSignature.getDescriptor(), null, null); + if(kind != OwnerKind.TRAIT_IMPL) { + int start = functionDescriptor.getReceiverParameter().exists() ? 1 : 0; + for(int i = 0; i != paramDescrs.size(); ++i) { + AnnotationVisitor annotationVisitor = mv.visitParameterAnnotation(i + start, "jet/typeinfo/JetParameterName", true); + annotationVisitor.visit("value", paramDescrs.get(i).getName()); + annotationVisitor.visitEnd(); } - iv.invokeinterface(dk.getOwnerClass(), jvmSignature.getName(), jvmSignature.getDescriptor()); - iv.areturn(jvmSignature.getReturnType()); } - else { + if (!isAbstract) { + mv.visitCode(); + FrameMap frameMap = context.prepareFrame(); + + ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, jvmSignature.getReturnType(), context, state); + + Type[] argTypes = jvmSignature.getArgumentTypes(); for (int i = 0; i < paramDescrs.size(); i++) { ValueParameterDescriptor parameter = paramDescrs.get(i); - - Type sharedVarType = codegen.getSharedVarType(parameter); - Type localVarType = state.getTypeMapper().mapType(parameter.getOutType()); - if(sharedVarType != null) { - int index = frameMap.getIndex(parameter); - mv.visitTypeInsn(Opcodes.NEW, sharedVarType.getInternalName()); - mv.visitInsn(Opcodes.DUP); - mv.visitInsn(Opcodes.DUP); - mv.visitMethodInsn(Opcodes.INVOKESPECIAL, sharedVarType.getInternalName(), "", "()V"); - mv.visitVarInsn(localVarType.getOpcode(Opcodes.ILOAD), index); - mv.visitFieldInsn(Opcodes.PUTFIELD, sharedVarType.getInternalName(), "ref", StackValue.refType(localVarType).getDescriptor()); - mv.visitVarInsn(sharedVarType.getOpcode(Opcodes.ISTORE), index); - } + frameMap.enter(parameter, argTypes[i].getSize()); } - codegen.returnExpression(bodyExpressions); - } - mv.visitMaxs(0, 0); - mv.visitEnd(); + for (final TypeParameterDescriptor typeParameterDescriptor : typeParameters) { + int slot = frameMap.enterTemp(); + codegen.addTypeParameter(typeParameterDescriptor, StackValue.local(slot, JetTypeMapper.TYPE_TYPEINFO)); + } - generateBridgeIfNeeded(owner, state, v, jvmSignature, functionDescriptor, kind); + if (kind instanceof OwnerKind.DelegateKind) { + OwnerKind.DelegateKind dk = (OwnerKind.DelegateKind) kind; + InstructionAdapter iv = new InstructionAdapter(mv); + iv.load(0, JetTypeMapper.TYPE_OBJECT); + dk.getDelegate().put(JetTypeMapper.TYPE_OBJECT, iv); + for (int i = 0; i < argTypes.length; i++) { + Type argType = argTypes[i]; + iv.load(i + 1, argType); + } + iv.invokeinterface(dk.getOwnerClass(), jvmSignature.getName(), jvmSignature.getDescriptor()); + iv.areturn(jvmSignature.getReturnType()); + } + else { + for (int i = 0; i < paramDescrs.size(); i++) { + ValueParameterDescriptor parameter = paramDescrs.get(i); + + Type sharedVarType = codegen.getSharedVarType(parameter); + Type localVarType = state.getTypeMapper().mapType(parameter.getOutType()); + if (sharedVarType != null) { + int index = frameMap.getIndex(parameter); + mv.visitTypeInsn(NEW, sharedVarType.getInternalName()); + mv.visitInsn(DUP); + mv.visitInsn(DUP); + mv.visitMethodInsn(INVOKESPECIAL, sharedVarType.getInternalName(), "", "()V"); + mv.visitVarInsn(localVarType.getOpcode(ILOAD), index); + mv.visitFieldInsn(PUTFIELD, sharedVarType.getInternalName(), "ref", StackValue.refType(localVarType).getDescriptor()); + mv.visitVarInsn(sharedVarType.getOpcode(ISTORE), index); + } + } + + codegen.returnExpression(bodyExpressions); + } + try { + mv.visitMaxs(0, 0); + } + catch (Throwable t) { + System.out.println(t); + } + mv.visitEnd(); + + generateBridgeIfNeeded(owner, state, v, jvmSignature, functionDescriptor, kind); + } } + + generateDefaultIfNeeded(context, state, v, jvmSignature, functionDescriptor, kind); } static void generateBridgeIfNeeded(ClassContext owner, GenerationState state, ClassVisitor v, Method jvmSignature, FunctionDescriptor functionDescriptor, OwnerKind kind) { @@ -135,12 +146,153 @@ public class FunctionCodegen { } } + static void generateDefaultIfNeeded(ClassContext owner, GenerationState state, ClassVisitor v, Method jvmSignature, FunctionDescriptor functionDescriptor, OwnerKind kind) { + DeclarationDescriptor contextClass = owner.getContextClass(); + + if(kind != OwnerKind.TRAIT_IMPL) { + // we don't generate defaults for traits but do for traitImpl + if(contextClass instanceof ClassDescriptor) { + PsiElement psiElement = state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, contextClass); + if(psiElement instanceof JetClass) { + JetClass element = (JetClass) psiElement; + if(element.isTrait()) + return; + } + } + } + + boolean needed = false; + for (ValueParameterDescriptor parameterDescriptor : functionDescriptor.getValueParameters()) { + if(parameterDescriptor.hasDefaultValue()) { + needed = true; + break; + } + } + + if(needed) { + boolean hasReceiver = functionDescriptor.getReceiverParameter().exists(); + boolean isStatic = kind == OwnerKind.NAMESPACE; + + if(kind == OwnerKind.TRAIT_IMPL) { + String correctedDescr = "(" + jvmSignature.getDescriptor().substring(jvmSignature.getDescriptor().indexOf(";") + 1); + jvmSignature = new Method(jvmSignature.getName(), correctedDescr); + } + + int flags = ACC_PUBLIC; // TODO. + + String ownerInternalName = contextClass instanceof NamespaceDescriptor ? + JetTypeMapper.jvmName((NamespaceDescriptor) contextClass) : + state.getTypeMapper().jvmName((ClassDescriptor) contextClass, OwnerKind.IMPLEMENTATION); + + String descriptor = jvmSignature.getDescriptor().replace(")","I)"); + if(!isStatic) + descriptor = descriptor.replace("(","(L" + ownerInternalName + ";"); + final MethodVisitor mv = v.visitMethod(flags| ACC_STATIC, jvmSignature.getName() + "$default", descriptor, null, null); + InstructionAdapter iv = new InstructionAdapter(mv); + mv.visitCode(); + + FrameMap frameMap = owner.prepareFrame(); + + ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, jvmSignature.getReturnType(), owner, state); + + int var = 0; + if(!isStatic) { + frameMap.enterTemp(); + var++; + } + + if(hasReceiver) { + frameMap.enterTemp(); + var++; + } + + Type[] argTypes = jvmSignature.getArgumentTypes(); + List paramDescrs = functionDescriptor.getValueParameters(); + for (int i = 0; i < paramDescrs.size(); i++) { + ValueParameterDescriptor parameter = paramDescrs.get(i); + int size = argTypes[i + (hasReceiver ? 1 : 0)].getSize(); + var += size; + frameMap.enter(parameter, size); + } + + List typeParameters = functionDescriptor.getTypeParameters(); + for (final TypeParameterDescriptor typeParameterDescriptor : typeParameters) { + int slot = frameMap.enterTemp(); + codegen.addTypeParameter(typeParameterDescriptor, StackValue.local(slot, JetTypeMapper.TYPE_TYPEINFO)); + var++; + } + + frameMap.enterTemp(); + + int maskIndex = var; + + var = 0; + if(!isStatic) { + mv.visitVarInsn(ALOAD, var++); + } + + if(hasReceiver) { + mv.visitVarInsn(ALOAD, var++); + } + + Type[] argumentTypes = jvmSignature.getArgumentTypes(); + for (int index = 0; index < paramDescrs.size(); index++) { + ValueParameterDescriptor parameterDescriptor = paramDescrs.get(index); + + Type t = argumentTypes[(hasReceiver ? 1 : 0) + index]; + Label endArg = null; + if (parameterDescriptor.hasDefaultValue()) { + iv.load(maskIndex, Type.INT_TYPE); + iv.iconst(1 << index); + iv.and(Type.INT_TYPE); + Label loadArg = new Label(); + iv.ifeq(loadArg); + + JetParameter jetParameter = (JetParameter) state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, parameterDescriptor); + codegen.gen(jetParameter.getDefaultValue(), t); + + endArg = new Label(); + iv.goTo(endArg); + + iv.mark(loadArg); + } + + iv.load(var, t); + var += t.getSize(); + + if (parameterDescriptor.hasDefaultValue()) { + iv.mark(endArg); + } + } + + for (final TypeParameterDescriptor typeParameterDescriptor : typeParameters) { + iv.load(var++, JetTypeMapper.TYPE_OBJECT); + } + + if(!isStatic) { + if(kind == OwnerKind.TRAIT_IMPL) { + iv.invokeinterface(ownerInternalName, jvmSignature.getName(), jvmSignature.getDescriptor()); + } + else + iv.invokevirtual(ownerInternalName, jvmSignature.getName(), jvmSignature.getDescriptor()); + } + else { + iv.invokestatic(ownerInternalName, jvmSignature.getName(), jvmSignature.getDescriptor()); + } + + iv.areturn(jvmSignature.getReturnType()); + + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + } + private static void checkOverride(ClassContext owner, GenerationState state, ClassVisitor v, Method jvmSignature, FunctionDescriptor functionDescriptor, FunctionDescriptor overriddenFunction) { Type type1 = state.getTypeMapper().mapType(overriddenFunction.getOriginal().getReturnType()); Type type2 = state.getTypeMapper().mapType(functionDescriptor.getReturnType()); if(!type1.equals(type2)) { Method overriden = state.getTypeMapper().mapSignature(overriddenFunction.getName(), overriddenFunction.getOriginal()); - int flags = Opcodes.ACC_PUBLIC; // TODO. + int flags = ACC_PUBLIC; // TODO. final MethodVisitor mv = v.visitMethod(flags, jvmSignature.getName(), overriden.getDescriptor(), null, null); mv.visitCode(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionOrClosureCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionOrClosureCodegen.java index a6a57ece6b5..a9834ed153d 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionOrClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionOrClosureCodegen.java @@ -13,6 +13,8 @@ import java.util.Map; * @author alex.tkachman */ public class FunctionOrClosureCodegen { + protected boolean captureThis; + public final GenerationState state; protected final ExpressionCodegen exprContext; protected final ClassContext context; @@ -54,4 +56,12 @@ public class FunctionOrClosureCodegen { return null; } + + public boolean isCaptureThis() { + return captureThis; + } + + public boolean isConst () { + return !captureThis && closure.isEmpty(); + } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 9cf08cd2482..926b496e243 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -162,40 +162,6 @@ public class JetTypeMapper { return new Method(method.isConstructor() ? "" : method.getName(), Type.getMethodDescriptor(returnType, parameterTypes)); } - static CallableMethod mapToCallableMethod(PsiMethod method) { - final PsiClass containingClass = method.getContainingClass(); - String owner = jvmName(containingClass); - Method signature = getMethodDescriptor(method); - List valueParameterTypes = new ArrayList(); - Collections.addAll(valueParameterTypes, signature.getArgumentTypes()); - int opcode; - boolean needsReceiver = false; - boolean ownerFromCall = false; - if (method.isConstructor()) { - opcode = Opcodes.INVOKESPECIAL; - } - else if (method.hasModifierProperty(PsiModifier.STATIC)) { - opcode = Opcodes.INVOKESTATIC; - } - else { - needsReceiver = true; - assert containingClass != null; - if (containingClass.isInterface()) { - opcode = Opcodes.INVOKEINTERFACE; - } - else { - opcode = Opcodes.INVOKEVIRTUAL; - } - ownerFromCall = true; - } - final CallableMethod result = new CallableMethod(owner, signature, opcode, valueParameterTypes); - if (needsReceiver) { - result.setNeedsReceiver(null); - } - result.setOwnerFromCall(ownerFromCall); - return result; - } - public static Type getBoxedType(final Type type) { switch (type.getSort()) { case Type.BYTE: @@ -518,18 +484,49 @@ public class JetTypeMapper { return mapToCallableMethod(functionDescriptor, kind); } + CallableMethod mapToCallableMethod(PsiMethod method) { + final PsiClass containingClass = method.getContainingClass(); + String owner = jvmName(containingClass); + Method signature = getMethodDescriptor(method); + List valueParameterTypes = new ArrayList(); + Collections.addAll(valueParameterTypes, signature.getArgumentTypes()); + int opcode; + boolean ownerFromCall = false; + DeclarationDescriptor thisClass = null; + if (method.isConstructor()) { + opcode = Opcodes.INVOKESPECIAL; + } + else if (method.hasModifierProperty(PsiModifier.STATIC)) { + opcode = Opcodes.INVOKESTATIC; + } + else { + assert containingClass != null; + if (containingClass.isInterface()) { + opcode = Opcodes.INVOKEINTERFACE; + } + else { + opcode = Opcodes.INVOKEVIRTUAL; + } + ownerFromCall = true; + thisClass = JetStandardClasses.getAny(); // todo - this is hack, correct descriptor needed + } + final CallableMethod result = new CallableMethod(owner, signature, opcode, valueParameterTypes); + result.setNeedsThis(thisClass); + result.setOwnerFromCall(ownerFromCall); + return result; + } + public CallableMethod mapToCallableMethod(FunctionDescriptor functionDescriptor, OwnerKind kind) { final DeclarationDescriptor functionParent = functionDescriptor.getContainingDeclaration(); final List valueParameterTypes = new ArrayList(); Method descriptor = mapSignature(functionDescriptor.getOriginal(), valueParameterTypes, kind); String owner; int invokeOpcode; - boolean needsReceiver; - ClassDescriptor receiverClass = null; + ClassDescriptor thisClass; if (functionParent instanceof NamespaceDescriptor) { owner = NamespaceCodegen.getJVMClassName(DescriptorRenderer.getFQName(functionParent)); invokeOpcode = Opcodes.INVOKESTATIC; - needsReceiver = functionDescriptor.getReceiverParameter().exists(); + thisClass = null; } else if (functionParent instanceof ClassDescriptor) { ClassDescriptor containingClass = (ClassDescriptor) functionParent; @@ -537,8 +534,7 @@ public class JetTypeMapper { invokeOpcode = CodegenUtil.isInterface(containingClass) ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL; - needsReceiver = true; - receiverClass = containingClass; + thisClass = containingClass; } else { throw new UnsupportedOperationException("unknown function parent"); @@ -546,9 +542,11 @@ public class JetTypeMapper { final CallableMethod result = new CallableMethod(owner, descriptor, invokeOpcode, valueParameterTypes); result.setAcceptsTypeArguments(true); - if (needsReceiver) { - result.setNeedsReceiver(receiverClass); + result.setNeedsThis(thisClass); + if(functionDescriptor.getReceiverParameter().exists()) { + result.setNeedsReceiver(functionDescriptor.getReceiverParameter().getType().getConstructor().getDeclarationDescriptor()); } + return result; } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java index e41fcdddb7c..9d943679e2b 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java @@ -22,6 +22,8 @@ import org.jetbrains.jet.plugin.JetFileType; import java.io.File; import java.io.IOException; +import java.net.URL; +import java.net.URLClassLoader; import java.util.List; /** @@ -34,16 +36,6 @@ public class KotlinCompiler { System.out.println("Usage: KotlinCompiler "); return; } - String javaHome = System.getenv("JAVA_HOME"); - if (javaHome == null) { - System.out.println("JAVA_HOME environment variable needs to be defined"); - return; - } - File rtJar = findRtJar(javaHome); - if (rtJar == null || !rtJar.exists()) { - System.out.print("No rt.jar found under JAVA_HOME"); - return; - } Disposable root = new Disposable() { @Override @@ -51,9 +43,45 @@ public class KotlinCompiler { } }; JavaCoreEnvironment environment = new JavaCoreEnvironment(root); + + String javaHome = System.getenv("JAVA_HOME"); + File rtJar = null; + if (javaHome == null) { + ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); + if(systemClassLoader instanceof URLClassLoader) { + URLClassLoader loader = (URLClassLoader) systemClassLoader; + for(URL url: loader.getURLs()) { + if("file".equals(url.getProtocol())) { + if(url.getFile().endsWith("/lib/rt.jar")) { + rtJar = new File(url.getFile()); + break; + } + if(url.getFile().endsWith("/Classes/classes.jar")) { + rtJar = new File(url.getFile()).getAbsoluteFile(); + break; + } + } + } + } + + if(rtJar == null) { + System.out.println("JAVA_HOME environment variable needs to be defined"); + return; + } + } + else { + rtJar = findRtJar(javaHome); + } + + if (rtJar == null || !rtJar.exists()) { + System.out.print("No rt.jar found under JAVA_HOME=" + javaHome); + return; + } + environment.addToClasspath(rtJar); environment.registerFileType(JetFileType.INSTANCE, "kt"); + environment.registerFileType(JetFileType.INSTANCE, "jet"); environment.registerParserDefinition(new JetParserDefinition()); VirtualFile vFile = environment.getLocalFileSystem().findFileByPath(args [0]); if (vFile == null) { diff --git a/idea/src/org/jetbrains/jet/plugin/AnalyzerFacade.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java similarity index 89% rename from idea/src/org/jetbrains/jet/plugin/AnalyzerFacade.java rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java index ec376a187b8..e0772dbcd28 100644 --- a/idea/src/org/jetbrains/jet/plugin/AnalyzerFacade.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java @@ -1,4 +1,4 @@ -package org.jetbrains.jet.plugin; +package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; @@ -6,7 +6,6 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamespace; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.java.JavaDefaultImports; /** * @author abreslav diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java index ab02a9d9d42..c46e086ab25 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java @@ -51,11 +51,6 @@ public class JavaClassMembersScope implements JetScope { return null; } - @Override - public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { - throw new UnsupportedOperationException(); - } - @Override public ClassifierDescriptor getClassifier(@NotNull String name) { ClassifierDescriptor classifierDescriptor = classifiers.get(name); diff --git a/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java b/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java index 9656239e4a2..e26d14c12dc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java +++ b/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java @@ -109,6 +109,7 @@ public interface JetNodeTypes { JetNodeType LABEL_QUALIFIER = new JetNodeType("LABEL_QUALIFIER", JetContainerNode.class); JetNodeType THIS_EXPRESSION = new JetNodeType("THIS_EXPRESSION", JetThisExpression.class); + JetNodeType SUPER_EXPRESSION = new JetNodeType("SUPER_EXPRESSION", JetSuperExpression.class); JetNodeType BINARY_EXPRESSION = new JetNodeType("BINARY_EXPRESSION", JetBinaryExpression.class); JetNodeType BINARY_WITH_TYPE = new JetNodeType("BINARY_WITH_TYPE", JetBinaryExpressionWithTypeRHS.class); JetNodeType BINARY_WITH_PATTERN = new JetNodeType("BINARY_WITH_PATTERN", JetIsExpression.class); // TODO: diff --git a/idea/src/org/jetbrains/jet/checkers/CheckerTestUtil.java b/compiler/frontend/src/org/jetbrains/jet/checkers/CheckerTestUtil.java similarity index 100% rename from idea/src/org/jetbrains/jet/checkers/CheckerTestUtil.java rename to compiler/frontend/src/org/jetbrains/jet/checkers/CheckerTestUtil.java diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java index 1b7057a76d4..cf468bee683 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java @@ -14,7 +14,7 @@ import java.util.Set; /** * @author abreslav */ -public interface ClassDescriptor extends ClassifierDescriptor { +public interface ClassDescriptor extends ClassifierDescriptor, MemberDescriptor { @NotNull JetScope getMemberScope(List typeArguments); @@ -53,9 +53,11 @@ public interface ClassDescriptor extends ClassifierDescriptor { @NotNull ClassKind getKind(); + @Override @NotNull Modality getModality(); - + + @Override @NotNull Visibility getVisibility(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorWithVisibility.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorWithVisibility.java new file mode 100644 index 00000000000..eab9e41ff5d --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorWithVisibility.java @@ -0,0 +1,11 @@ +package org.jetbrains.jet.lang.descriptors; + +import org.jetbrains.annotations.NotNull; + +/** + * @author abreslav + */ +public interface DeclarationDescriptorWithVisibility extends DeclarationDescriptor { + @NotNull + Visibility getVisibility(); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java index 5327b981133..29940086e89 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java @@ -5,10 +5,11 @@ import org.jetbrains.annotations.NotNull; /** * @author abreslav */ -public interface MemberDescriptor { +public interface MemberDescriptor extends DeclarationDescriptor, DeclarationDescriptorWithVisibility { @NotNull Modality getModality(); - + + @Override @NotNull Visibility getVisibility(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java index e2c5364dfe3..4b6e70e2e77 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java @@ -1,5 +1,7 @@ package org.jetbrains.jet.lang.descriptors; +import java.util.EnumSet; + /** * @author svtk */ @@ -11,6 +13,8 @@ public enum Visibility { INTERNAL_PROTECTED(false), LOCAL(false); + public static final EnumSet INTERNAL_VISIBILITIES = EnumSet.of(PRIVATE, INTERNAL, INTERNAL_PROTECTED, LOCAL); + private final boolean isAPI; private Visibility(boolean visibleOutside) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java index b9d4050f915..23126722df9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java @@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.diagnostics; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; import org.jetbrains.jet.resolve.DescriptorRenderer; import java.util.Collection; @@ -10,7 +10,7 @@ import java.util.Collection; /** * @author abreslav */ -public class AmbiguousDescriptorDiagnosticFactory extends ParameterizedDiagnosticFactory1>> { +public class AmbiguousDescriptorDiagnosticFactory extends ParameterizedDiagnosticFactory1>> { public static AmbiguousDescriptorDiagnosticFactory create(String messageTemplate) { return new AmbiguousDescriptorDiagnosticFactory(messageTemplate); } @@ -20,9 +20,9 @@ public class AmbiguousDescriptorDiagnosticFactory extends ParameterizedDiagnosti } @Override - protected String makeMessageFor(@NotNull Collection> argument) { + protected String makeMessageFor(@NotNull Collection> argument) { StringBuilder stringBuilder = new StringBuilder("\n"); - for (ResolvedCall call : argument) { + for (ResolvedCallImpl call : argument) { stringBuilder.append(DescriptorRenderer.TEXT.render(call.getResultingDescriptor())).append("\n"); } return stringBuilder.toString(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index 4d01f8cbeea..4f4cfb16e36 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -162,12 +162,16 @@ public interface Errors { SimpleDiagnosticFactory EQUALS_MISSING = SimpleDiagnosticFactory.create(ERROR, "No method 'equals(Any?) : Boolean' available"); SimpleDiagnosticFactory ASSIGNMENT_IN_EXPRESSION_CONTEXT = SimpleDiagnosticFactory.create(ERROR, "Assignments are not expressions, and only expressions are allowed in this context"); - SimpleDiagnosticFactory NAMESPACE_IS_NOT_AN_EXPRESSION = SimpleDiagnosticFactory.create(ERROR, "'namespace' is not an expression"); + SimpleDiagnosticFactory NAMESPACE_IS_NOT_AN_EXPRESSION = SimpleDiagnosticFactory.create(ERROR, "'namespace' is not an expression, it can only be used on the left-hand side of a dot ('.')"); + ParameterizedDiagnosticFactory1 SUPER_IS_NOT_AN_EXPRESSION = ParameterizedDiagnosticFactory1.create(ERROR, "{0} is not an expression, it can only be used on the left-hand side of a dot ('.')"); SimpleDiagnosticFactory DECLARATION_IN_ILLEGAL_CONTEXT = SimpleDiagnosticFactory.create(ERROR, "Declarations are not allowed in this position"); SimpleDiagnosticFactory REF_SETTER_PARAMETER = SimpleDiagnosticFactory.create(ERROR, "Setter parameters can not be 'ref'"); SimpleDiagnosticFactory SETTER_PARAMETER_WITH_DEFAULT_VALUE = SimpleDiagnosticFactory.create(ERROR, "Setter parameters can not have default values"); SimpleDiagnosticFactory NO_THIS = SimpleDiagnosticFactory.create(ERROR, "'this' is not defined in this context"); + SimpleDiagnosticFactory SUPER_NOT_AVAILABLE = SimpleDiagnosticFactory.create(ERROR, "No supertypes are accessible in this context"); + SimpleDiagnosticFactory AMBIGUOUS_SUPER = SimpleDiagnosticFactory.create(ERROR, "Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super'"); SimpleDiagnosticFactory NOT_A_SUPERTYPE = SimpleDiagnosticFactory.create(ERROR, "Not a supertype"); + SimpleDiagnosticFactory TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER = SimpleDiagnosticFactory.create(WARNING, "Type arguments do not need to be specified in a 'super' qualifier"); SimpleDiagnosticFactory NO_WHEN_ENTRIES = SimpleDiagnosticFactory.create(ERROR, "Entries are required for when-expression"); // TODO : Scope, and maybe this should not be an error SimplePsiElementOnlyDiagnosticFactory USELESS_CAST_STATIC_ASSERT_IS_FINE = SimplePsiElementOnlyDiagnosticFactory.create(WARNING, "No cast needed, use ':' instead"); SimplePsiElementOnlyDiagnosticFactory USELESS_CAST = SimplePsiElementOnlyDiagnosticFactory.create(WARNING, "No cast needed"); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java index 2da63a0e2d6..d5b8b5a8760 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java @@ -49,6 +49,7 @@ public class JetExpressionParsing extends AbstractJetParsing { LPAR, // tuple THIS_KEYWORD, // this + SUPER_KEYWORD, // super IF_KEYWORD, // if WHEN_KEYWORD, // when @@ -464,7 +465,8 @@ public class JetExpressionParsing extends AbstractJetParsing { /* * atomicExpression * : tupleLiteral // or parenthesized element - * : "this" getEntryPoint? ("<" type ">")? + * : "this" label? + * : "super" ("<" type ">")? label? * : objectLiteral * : jump * : if @@ -490,6 +492,9 @@ public class JetExpressionParsing extends AbstractJetParsing { else if (at(THIS_KEYWORD)) { parseThisExpression(); } + else if (at(SUPER_KEYWORD)) { + parseSuperExpression(); + } else if (at(OBJECT_KEYWORD)) { parseObjectLiteral(); } @@ -1593,7 +1598,7 @@ public class JetExpressionParsing extends AbstractJetParsing { } /* - * "this" getEntryPoint? ("<" type ">")? + * "this" label? */ private void parseThisExpression() { assert _at(THIS_KEYWORD); @@ -1605,8 +1610,22 @@ public class JetExpressionParsing extends AbstractJetParsing { parseLabel(); + mark.done(THIS_EXPRESSION); + } + + /* + * "this" ("<" type ">")? label? + */ + private void parseSuperExpression() { + assert _at(SUPER_KEYWORD); + PsiBuilder.Marker mark = mark(); + + PsiBuilder.Marker superReference = mark(); + advance(); // SUPER_KEYWORD + superReference.done(REFERENCE_EXPRESSION); + if (at(LT)) { - // This may be "this < foo" or "this", thus the backtracking + // This may be "super < foo" or "super", thus the backtracking PsiBuilder.Marker supertype = mark(); myBuilder.disableNewlines(); @@ -1623,7 +1642,9 @@ public class JetExpressionParsing extends AbstractJetParsing { } myBuilder.restoreNewlinesState(); } - mark.done(THIS_EXPRESSION); + parseLabel(); + + mark.done(SUPER_EXPRESSION); } /* diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetLabelQualifiedInstanceExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetLabelQualifiedInstanceExpression.java new file mode 100644 index 00000000000..297830432d7 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetLabelQualifiedInstanceExpression.java @@ -0,0 +1,20 @@ +package org.jetbrains.jet.lang.psi; + +import com.intellij.lang.ASTNode; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.JetNodeTypes; + +/** + * @author abreslav + */ +public abstract class JetLabelQualifiedInstanceExpression extends JetLabelQualifiedExpression { + + public JetLabelQualifiedInstanceExpression(@NotNull ASTNode node) { + super(node); + } + + @NotNull + public JetReferenceExpression getInstanceReference() { + return (JetReferenceExpression) findChildByType(JetNodeTypes.REFERENCE_EXPRESSION); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java index c40c07518a3..4ef04645259 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java @@ -10,13 +10,14 @@ import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.parsing.JetExpressionParsing; -import org.jetbrains.jet.lexer.JetTokens; + +import static org.jetbrains.jet.lexer.JetTokens.*; /** * @author max */ public class JetSimpleNameExpression extends JetReferenceExpression { - public static final TokenSet REFERENCE_TOKENS = TokenSet.orSet(JetTokens.LABELS, TokenSet.create(JetTokens.IDENTIFIER, JetTokens.FIELD_IDENTIFIER, JetTokens.THIS_KEYWORD)); + public static final TokenSet REFERENCE_TOKENS = TokenSet.orSet(LABELS, TokenSet.create(IDENTIFIER, FIELD_IDENTIFIER, THIS_KEYWORD, SUPER_KEYWORD)); public JetSimpleNameExpression(@NotNull ASTNode node) { super(node); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSuperExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSuperExpression.java new file mode 100644 index 00000000000..1eaa7bcf08d --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSuperExpression.java @@ -0,0 +1,39 @@ +package org.jetbrains.jet.lang.psi; + +import com.intellij.lang.ASTNode; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.JetNodeTypes; + +/** + * @author max + */ +public class JetSuperExpression extends JetLabelQualifiedInstanceExpression { + + public JetSuperExpression(@NotNull ASTNode node) { + super(node); + } + + @Override + public void accept(@NotNull JetVisitorVoid visitor) { + visitor.visitSuperExpression(this); + } + + @Override + public R accept(@NotNull JetVisitor visitor, D data) { + return visitor.visitSuperExpression(this, data); + } + + /** + * class A : B, C { + * override fun foo() { + * super.foo() + * super.foo() + * } + * } + */ + @Nullable + public JetTypeReference getSuperTypeQualifier() { + return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThisExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThisExpression.java index eb176aa19bd..ac42c897c7b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThisExpression.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThisExpression.java @@ -2,13 +2,11 @@ package org.jetbrains.jet.lang.psi; import com.intellij.lang.ASTNode; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.JetNodeTypes; /** * @author max */ -public class JetThisExpression extends JetLabelQualifiedExpression { +public class JetThisExpression extends JetLabelQualifiedInstanceExpression { public JetThisExpression(@NotNull ASTNode node) { super(node); @@ -23,23 +21,4 @@ public class JetThisExpression extends JetLabelQualifiedExpression { public R accept(@NotNull JetVisitor visitor, D data) { return visitor.visitThisExpression(this, data); } - - /** - * class A : B, C { - * override fun foo() { - * this.foo() - * this.foo() - * } - * } - */ - @Nullable - public JetTypeReference getSuperTypeQualifier() { - return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE); - } - - @NotNull - public JetReferenceExpression getThisReference() { - return (JetReferenceExpression) findChildByType(JetNodeTypes.REFERENCE_EXPRESSION); - } - } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTreeVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTreeVisitor.java index d343f8bccf8..d48dc9a4d31 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTreeVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTreeVisitor.java @@ -511,7 +511,15 @@ public class JetTreeVisitor extends JetVisitor { @Override public Void visitThisExpression(JetThisExpression expression, D data) { - JetReferenceExpression thisReference = expression.getThisReference(); + JetReferenceExpression thisReference = expression.getInstanceReference(); + thisReference.accept(this, data); + visitLabelQualifiedExpression(expression, data); + return null; + } + + @Override + public Void visitSuperExpression(JetSuperExpression expression, D data) { + JetReferenceExpression thisReference = expression.getInstanceReference(); thisReference.accept(this, data); JetTypeReference superTypeQualifier = expression.getSuperTypeQualifier(); if (superTypeQualifier != null) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java index 9c5787cda2c..4817657f54c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java @@ -280,6 +280,10 @@ public class JetVisitor extends PsiElementVisitor { return visitLabelQualifiedExpression(expression, data); } + public R visitSuperExpression(JetSuperExpression expression, D data) { + return visitLabelQualifiedExpression(expression, data); + } + public R visitParenthesizedExpression(JetParenthesizedExpression expression, D data) { return visitExpression(expression, data); } @@ -419,4 +423,5 @@ public class JetVisitor extends PsiElementVisitor { public R visitEscapeStringTemplateEntry(JetEscapeStringTemplateEntry entry, D data) { return visitStringTemplateEntry(entry, data); } + } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java index 8fc840217da..e62e607a705 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java @@ -278,6 +278,10 @@ public class JetVisitorVoid extends PsiElementVisitor { visitLabelQualifiedExpression(expression); } + public void visitSuperExpression(JetSuperExpression expression) { + visitLabelQualifiedExpression(expression); + } + public void visitParenthesizedExpression(JetParenthesizedExpression expression) { visitExpression(expression); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java index 2d5218a40a3..fec39dc6493 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java @@ -65,11 +65,6 @@ public abstract class AbstractScopeAdapter implements JetScope { return getWorkerScope().getPropertyByFieldReference(fieldName); } - @Override - public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { - return getWorkerScope().getDeclarationDescriptorForUnqualifiedThis(); - } - @NotNull @Override public Collection getAllDescriptors() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java index c7ebed1f1e9..f05397f66a5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java @@ -10,7 +10,7 @@ import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetModifierList; import org.jetbrains.jet.lang.resolve.calls.CallMaker; import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; @@ -36,7 +36,7 @@ public class AnnotationResolver { this.trace = trace; // this.typeInferrer = new JetTypeInferrer(JetFlowInformationProvider.THROW_EXCEPTION, semanticServices); // this.services = typeInferrer.getServices(this.trace); - this.callResolver = new CallResolver(semanticServices, DataFlowInfo.getEmpty()); + this.callResolver = new CallResolver(semanticServices, DataFlowInfo.EMPTY); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java index e5d49d0c837..8d012378264 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java @@ -7,6 +7,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.DeferredType; @@ -29,7 +30,7 @@ public interface BindingContext { WritableSlice REFERENCE_TARGET = new BasicWritableSlice("REFERENCE_TARGET", RewritePolicy.DO_NOTHING); WritableSlice> RESOLVED_CALL = new BasicWritableSlice>("RESOLVED_CALL", RewritePolicy.DO_NOTHING); - WritableSlice>> AMBIGUOUS_REFERENCE_TARGET = new BasicWritableSlice>>("AMBIGUOUS_REFERENCE_TARGET", RewritePolicy.DO_NOTHING); + WritableSlice>> AMBIGUOUS_REFERENCE_TARGET = new BasicWritableSlice>>("AMBIGUOUS_REFERENCE_TARGET", RewritePolicy.DO_NOTHING); WritableSlice LOOP_RANGE_ITERATOR = Slices.createSimpleSlice("LOOP_RANGE_ITERATOR"); WritableSlice LOOP_RANGE_HAS_NEXT = Slices.createSimpleSlice("LOOP_RANGE_HAS_NEXT"); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index 1eba532f34c..7bc2afd02c8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -10,7 +10,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.CallMaker; import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; @@ -176,7 +176,7 @@ public class BodyResolver { JetTypeReference typeReference = call.getTypeReference(); if (typeReference != null) { if (descriptor.getUnsubstitutedPrimaryConstructor() != null) { - JetType supertype = new CallResolver(context.getSemanticServices(), DataFlowInfo.getEmpty()).resolveCall( + JetType supertype = new CallResolver(context.getSemanticServices(), DataFlowInfo.EMPTY).resolveCall( context.getTrace(), scopeForConstructor, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE); if (supertype != null) { @@ -322,7 +322,7 @@ public class BodyResolver { private void resolveSecondaryConstructorBody(JetConstructor declaration, final ConstructorDescriptor descriptor, final JetScope declaringScope) { final JetScope functionInnerScope = getInnerScopeForConstructor(descriptor, declaringScope, false); - final CallResolver callResolver = new CallResolver(context.getSemanticServices(), DataFlowInfo.getEmpty()); // TODO: dataFlowInfo + final CallResolver callResolver = new CallResolver(context.getSemanticServices(), DataFlowInfo.EMPTY); // TODO: dataFlowInfo JetClass containingClass = PsiTreeUtil.getParentOfType(declaration, JetClass.class); assert containingClass != null : "This must be guaranteed by the parser"; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java index c01f2934b82..76c23ca970d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -20,6 +20,7 @@ import java.util.List; import static org.jetbrains.jet.lang.diagnostics.Errors.UNRESOLVED_REFERENCE; import static org.jetbrains.jet.lang.diagnostics.Errors.WRONG_NUMBER_OF_TYPE_ARGUMENTS; +import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; /** * @author abreslav @@ -240,6 +241,9 @@ public class TypeResolver { if (classifierDescriptor == null) { trace.report(UNRESOLVED_REFERENCE.on(userType.getReferenceExpression())); } + else { + trace.record(REFERENCE_TARGET, userType.getReferenceExpression(), classifierDescriptor); + } return classifierDescriptor; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastUtils.java deleted file mode 100644 index 63d47a2746f..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastUtils.java +++ /dev/null @@ -1,135 +0,0 @@ -package org.jetbrains.jet.lang.resolve.calls; - -import com.google.common.collect.Lists; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.psi.JetPsiUtil; -import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; -import org.jetbrains.jet.lang.psi.JetThisExpression; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.scopes.receivers.*; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.JetTypeChecker; - -import java.util.Collections; -import java.util.List; - -import static org.jetbrains.jet.lang.diagnostics.Errors.AUTOCAST_IMPOSSIBLE; -import static org.jetbrains.jet.lang.resolve.BindingContext.AUTOCAST; -import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; - -/** - * @author abreslav - */ -public class AutoCastUtils { - - private AutoCastUtils() {} - - public static List getAutoCastVariants(@NotNull final BindingContext bindingContext, @NotNull final DataFlowInfo dataFlowInfo, @NotNull ReceiverDescriptor receiverToCast) { - return receiverToCast.accept(new ReceiverDescriptorVisitor, Object>() { - @Override - public List visitNoReceiver(ReceiverDescriptor noReceiver, Object data) { - return Collections.emptyList(); - } - - @Override - public List visitTransientReceiver(TransientReceiver receiver, Object data) { - return Collections.emptyList(); - } - - @Override - public List visitExtensionReceiver(ExtensionReceiver receiver, Object data) { - return castThis(dataFlowInfo, receiver); - } - - @Override - public List visitClassReceiver(ClassReceiver receiver, Object data) { - return castThis(dataFlowInfo, receiver); - } - - @Override - public List visitExpressionReceiver(ExpressionReceiver receiver, Object data) { - JetExpression expression = receiver.getExpression(); - VariableDescriptor variableDescriptor = getVariableDescriptorFromSimpleName(bindingContext, expression); - if (variableDescriptor != null) { - List result = Lists.newArrayList(); - for (JetType possibleType : dataFlowInfo.getPossibleTypesForVariable(variableDescriptor)) { - result.add(new AutoCastReceiver(receiver, possibleType, isAutoCastable(variableDescriptor))); - } - return result; - } - else if (expression instanceof JetThisExpression) { - return castThis(dataFlowInfo, receiver); - } - return Collections.emptyList(); - } - }, null); - } - - private static List castThis(@NotNull DataFlowInfo dataFlowInfo, @NotNull ReceiverDescriptor receiver) { - assert receiver.exists(); - List result = Lists.newArrayList(); - for (JetType possibleType : dataFlowInfo.getPossibleTypesForReceiver(receiver)) { - result.add(new AutoCastReceiver(receiver, possibleType, true)); - } - return result; - } - - @Nullable - public static JetType castExpression(@NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, @NotNull BindingTrace trace) { - JetTypeChecker typeChecker = JetTypeChecker.INSTANCE; - VariableDescriptor variableDescriptor = getVariableDescriptorFromSimpleName(trace.getBindingContext(), expression); - if (variableDescriptor != null) { - List possibleTypes = Lists.newArrayList(dataFlowInfo.getPossibleTypesForVariable(variableDescriptor)); - Collections.reverse(possibleTypes); - for (JetType possibleType : possibleTypes) { - if (typeChecker.isSubtypeOf(possibleType, expectedType)) { - if (isAutoCastable(variableDescriptor)) { - trace.record(AUTOCAST, expression, possibleType); - } - else { - trace.report(AUTOCAST_IMPOSSIBLE.on(expression, possibleType, expression.getText())); - } - return possibleType; - } - } - } - return null; - } - - @Nullable - public static VariableDescriptor getVariableDescriptorFromSimpleName(@NotNull BindingContext bindingContext, @NotNull JetExpression expression) { - JetExpression receiver = JetPsiUtil.deparenthesize(expression); - VariableDescriptor variableDescriptor = null; - if (receiver instanceof JetSimpleNameExpression) { - JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) receiver; - DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, nameExpression); - if (declarationDescriptor instanceof VariableDescriptor) { - variableDescriptor = (VariableDescriptor) declarationDescriptor; - } - } - return variableDescriptor; - } - - public static boolean isAutoCastable(@NotNull VariableDescriptor variableDescriptor) { - if (variableDescriptor.isVar()) return false; - if (variableDescriptor instanceof PropertyDescriptor) { - PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variableDescriptor; - DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration(); - if (containingDeclaration instanceof ClassDescriptor) { - ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; - if (classDescriptor.getModality().isOverridable() && propertyDescriptor.getModality().isOverridable()) return false; - } - else { - assert !propertyDescriptor.getModality().isOverridable() : "Property outside a class must not be overridable"; - } - PropertyGetterDescriptor getter = propertyDescriptor.getGetter(); - if (getter == null || !getter.isDefault()) return false; - } - return true; - } - -} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 4395382f451..3840d59e444 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -11,6 +11,8 @@ import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastServiceImpl; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; 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; @@ -25,8 +27,8 @@ import java.util.*; import static org.jetbrains.jet.lang.diagnostics.Errors.*; import static org.jetbrains.jet.lang.resolve.BindingContext.*; import static org.jetbrains.jet.lang.resolve.calls.ResolutionStatus.*; -import static org.jetbrains.jet.lang.resolve.calls.ResolvedCall.MAP_TO_CANDIDATE; -import static org.jetbrains.jet.lang.resolve.calls.ResolvedCall.MAP_TO_RESULT; +import static org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl.MAP_TO_CANDIDATE; +import static org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl.MAP_TO_RESULT; import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER; import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; @@ -149,7 +151,7 @@ public class CallResolver { trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn)); return checkArgumentTypesAndFail(trace, scope, call); } - prioritizedTasks.add(new ResolutionTask(TaskPrioritizer.convertWithImpliedThis(scope, Collections.singletonList(NO_RECEIVER), constructors), call, DataFlowInfo.getEmpty())); + prioritizedTasks.add(new ResolutionTask(TaskPrioritizer.convertWithImpliedThis(scope, Collections.singletonList(NO_RECEIVER), constructors), call, DataFlowInfo.EMPTY)); } else { // trace.getErrorHandler().genericError(calleeExpression.getNode(), "Not a class"); @@ -169,7 +171,7 @@ public class CallResolver { trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn)); return checkArgumentTypesAndFail(trace, scope, call); } - prioritizedTasks = Collections.singletonList(new ResolutionTask(ResolvedCall.convertCollection(constructors), call, DataFlowInfo.getEmpty())); + prioritizedTasks = Collections.singletonList(new ResolutionTask(ResolvedCallImpl.convertCollection(constructors), call, DataFlowInfo.EMPTY)); } else { throw new UnsupportedOperationException("Type argument inference not implemented for " + call); @@ -192,12 +194,12 @@ public class CallResolver { @NotNull JetType expectedType, @NotNull final List> prioritizedTasks, // high to low priority @NotNull final JetReferenceExpression reference) { - ResolvedCall resolvedCall = doResolveCall(trace, scope, call, expectedType, prioritizedTasks, reference); + ResolvedCallImpl resolvedCall = doResolveCall(trace, scope, call, expectedType, prioritizedTasks, reference); return resolvedCall == null ? null : resolvedCall.getResultingDescriptor(); } @Nullable - private ResolvedCall doResolveCall( + private ResolvedCallImpl doResolveCall( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull final Call call, @@ -208,7 +210,7 @@ public class CallResolver { OverloadResolutionResults resultsForFirstNonemptyCandidateSet = null; TracingStrategy tracing = new TracingStrategy() { @Override - public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCall resolvedCall) { + public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall) { D descriptor = resolvedCall.getCandidateDescriptor(); // if (descriptor instanceof VariableAsFunctionDescriptor) { // VariableAsFunctionDescriptor variableAsFunctionDescriptor = (VariableAsFunctionDescriptor) descriptor; @@ -221,7 +223,7 @@ public class CallResolver { } @Override - public void recordAmbiguity(BindingTrace trace, Collection> candidates) { + public void recordAmbiguity(BindingTrace trace, Collection> candidates) { trace.record(AMBIGUOUS_REFERENCE_TARGET, reference, candidates); } @@ -270,12 +272,12 @@ public class CallResolver { } @Override - public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) { + public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) { trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(call.getCallNode(), descriptors)); } @Override - public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) { + public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) { trace.report(NONE_APPLICABLE.on(reference, descriptors)); } @@ -301,7 +303,10 @@ public class CallResolver { JetBinaryExpression binaryExpression = (JetBinaryExpression) callElement; JetSimpleNameExpression operationReference = binaryExpression.getOperationReference(); String operationString = operationReference.getReferencedNameElementType() == JetTokens.IDENTIFIER ? operationReference.getText() : OperatorConventions.getNameForOperationSymbol(operationReference.getReferencedNameElementType()); - trace.report(UNSAFE_INFIX_CALL.on(reference, binaryExpression.getLeft().getText(), operationString, binaryExpression.getRight().getText())); + JetExpression right = binaryExpression.getRight(); + if (right != null) { + trace.report(UNSAFE_INFIX_CALL.on(reference, binaryExpression.getLeft().getText(), operationString, right.getText())); + } } else { trace.report(UNSAFE_CALL.on(reference, type)); @@ -347,7 +352,7 @@ public class CallResolver { @NotNull private OverloadResolutionResults performResolution(@NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull JetType expectedType, @NotNull ResolutionTask task, @NotNull TracingStrategy tracing) { - for (ResolvedCall candidateCall : task.getCandidates()) { + for (ResolvedCallImpl candidateCall : task.getCandidates()) { D candidate = candidateCall.getCandidateDescriptor(); TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); candidateCall.setTrace(temporaryTrace); @@ -415,6 +420,9 @@ public class CallResolver { assert substitute != null; replaceValueParametersWithSubstitutedOnes(candidateCall, substitute); candidateCall.setResultingDescriptor(substitute); + for (TypeParameterDescriptor typeParameterDescriptor : candidateCall.getCandidateDescriptor().getTypeParameters()) { + candidateCall.recordTypeArgument(typeParameterDescriptor, solution.getValue(typeParameterDescriptor)); + } candidateCall.setStatus(SUCCESS); } else { @@ -454,6 +462,12 @@ public class CallResolver { candidateCall.setResultingDescriptor(substitutedDescriptor); replaceValueParametersWithSubstitutedOnes(candidateCall, substitutedDescriptor); + + List typeParameters = candidateCall.getCandidateDescriptor().getTypeParameters(); + for (int i = 0; i < typeParameters.size(); i++) { + TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i); + candidateCall.recordTypeArgument(typeParameterDescriptor, typeArguments.get(i)); + } candidateCall.setStatus(checkAllValueArguments(scope, tracing, task, candidateCall)); } else { @@ -469,9 +483,9 @@ public class CallResolver { recordAutoCastIfNecessary(candidateCall.getThisObject(), candidateCall.getTrace()); } - Set> successfulCandidates = Sets.newLinkedHashSet(); - Set> failedCandidates = Sets.newLinkedHashSet(); - for (ResolvedCall candidateCall : task.getCandidates()) { + Set> successfulCandidates = Sets.newLinkedHashSet(); + Set> failedCandidates = Sets.newLinkedHashSet(); + for (ResolvedCallImpl candidateCall : task.getCandidates()) { ResolutionStatus status = candidateCall.getStatus(); if (status.isSuccess()) { successfulCandidates.add(candidateCall); @@ -541,7 +555,7 @@ public class CallResolver { // }; // } - private void replaceValueParametersWithSubstitutedOnes(ResolvedCall candidateCall, @NotNull D substitutedDescriptor) { + private void replaceValueParametersWithSubstitutedOnes(ResolvedCallImpl candidateCall, @NotNull D substitutedDescriptor) { Map parameterMap = Maps.newHashMap(); for (ValueParameterDescriptor valueParameterDescriptor : substitutedDescriptor.getValueParameters()) { parameterMap.put(valueParameterDescriptor.getOriginal(), valueParameterDescriptor); @@ -557,14 +571,14 @@ public class CallResolver { } } - private ResolutionStatus checkAllValueArguments(JetScope scope, TracingStrategy tracing, ResolutionTask task, ResolvedCall candidateCall) { + private ResolutionStatus checkAllValueArguments(JetScope scope, TracingStrategy tracing, ResolutionTask task, ResolvedCallImpl candidateCall) { ResolutionStatus result = checkValueArgumentTypes(scope, candidateCall); result = result.combine(checkReceiver(tracing, candidateCall, candidateCall.getResultingDescriptor().getReceiverParameter(), candidateCall.getReceiverArgument(), task)); result = result.combine(checkReceiver(tracing, candidateCall, candidateCall.getResultingDescriptor().getExpectedThisObject(), candidateCall.getThisObject(), task)); return result; } - private ResolutionStatus checkReceiver(TracingStrategy tracing, ResolvedCall candidateCall, ReceiverDescriptor receiverParameter, ReceiverDescriptor receiverArgument, ResolutionTask task) { + private ResolutionStatus checkReceiver(TracingStrategy tracing, ResolvedCallImpl candidateCall, ReceiverDescriptor receiverParameter, ReceiverDescriptor receiverArgument, ResolutionTask task) { ResolutionStatus result = SUCCESS; if (receiverParameter.exists() && receiverArgument.exists()) { ASTNode callOperationNode = task.getCall().getCallOperationNode(); @@ -592,7 +606,7 @@ public class CallResolver { return result; } - private ResolutionStatus checkValueArgumentTypes(JetScope scope, ResolvedCall candidateCall) { + private ResolutionStatus checkValueArgumentTypes(JetScope scope, ResolvedCallImpl candidateCall) { ResolutionStatus result = SUCCESS; for (Map.Entry entry : candidateCall.getValueArguments().entrySet()) { ValueParameterDescriptor parameterDescriptor = entry.getKey(); @@ -618,7 +632,7 @@ public class CallResolver { // } // } // if (autoCastType != null) { -// if (AutoCastUtils.isAutoCastable(variableDescriptor)) { +// if (AutoCastUtils.isStableVariable(variableDescriptor)) { // temporaryTrace.record(AUTOCAST, argumentExpression, autoCastType); // } // else { @@ -639,16 +653,16 @@ public class CallResolver { private OverloadResolutionResults computeResultAndReportErrors( BindingTrace trace, TracingStrategy tracing, - Set> successfulCandidates, - Set> failedCandidates) { + Set> successfulCandidates, + Set> failedCandidates) { // TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific if (successfulCandidates.size() > 0) { return chooseAndReportMaximallySpecific(trace, tracing, successfulCandidates); } else if (!failedCandidates.isEmpty()) { if (failedCandidates.size() != 1) { - Set> weakErrors = Sets.newLinkedHashSet(); - for (ResolvedCall candidate : failedCandidates) { + Set> weakErrors = Sets.newLinkedHashSet(); + for (ResolvedCallImpl candidate : failedCandidates) { if (candidate.getStatus().isWeakError()) { weakErrors.add(candidate); } @@ -662,7 +676,7 @@ public class CallResolver { return OverloadResolutionResults.manyFailedCandidates(results.getResults()); } - Set> noOverrides = OverridingUtil.filterOverrides(failedCandidates, MAP_TO_CANDIDATE); + Set> noOverrides = OverridingUtil.filterOverrides(failedCandidates, MAP_TO_CANDIDATE); if (noOverrides.size() != 1) { // tracing.reportOverallResolutionError(trace, "None of the following functions can be called with the arguments supplied: " // + makeErrorMessageForMultipleDescriptors(noOverrides)); @@ -672,7 +686,7 @@ public class CallResolver { } failedCandidates = noOverrides; } - ResolvedCall failed = failedCandidates.iterator().next(); + ResolvedCallImpl failed = failedCandidates.iterator().next(); failed.getTrace().commit(); return OverloadResolutionResults.singleFailedCandidate(failed); } @@ -682,12 +696,12 @@ public class CallResolver { } } - private OverloadResolutionResults chooseAndReportMaximallySpecific(BindingTrace trace, TracingStrategy tracing, Set> candidates) { + private OverloadResolutionResults chooseAndReportMaximallySpecific(BindingTrace trace, TracingStrategy tracing, Set> candidates) { if (candidates.size() != 1) { - Set> cleanCandidates = Sets.newLinkedHashSet(candidates); + Set> cleanCandidates = Sets.newLinkedHashSet(candidates); boolean allClean = true; - for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { - ResolvedCall candidate = iterator.next(); + for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { + ResolvedCallImpl candidate = iterator.next(); if (candidate.isDirty()) { iterator.remove(); allClean = false; @@ -697,17 +711,17 @@ public class CallResolver { if (cleanCandidates.isEmpty()) { cleanCandidates = candidates; } - ResolvedCall maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false); + ResolvedCallImpl maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false); if (maximallySpecific != null) { return OverloadResolutionResults.success(maximallySpecific); } - ResolvedCall maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true); + ResolvedCallImpl maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true); if (maximallySpecificGenericsDiscriminated != null) { return OverloadResolutionResults.success(maximallySpecificGenericsDiscriminated); } - Set> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT); + Set> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT); if (allClean) { // tracing.reportOverallResolutionError(trace, "Overload resolution ambiguity: " // + makeErrorMessageForMultipleDescriptors(noOverrides)); @@ -719,7 +733,7 @@ public class CallResolver { return OverloadResolutionResults.ambiguity(noOverrides); } else { - ResolvedCall result = candidates.iterator().next(); + ResolvedCallImpl result = candidates.iterator().next(); TemporaryBindingTrace temporaryTrace = result.getTrace(); temporaryTrace.commit(); @@ -748,24 +762,24 @@ public class CallResolver { @NotNull public OverloadResolutionResults resolveExactSignature(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { - List> result = findCandidatesByExactSignature(scope, receiver, name, parameterTypes); + List> result = findCandidatesByExactSignature(scope, receiver, name, parameterTypes); BindingTraceContext trace = new BindingTraceContext(); TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create(trace); - Set> candidates = Sets.newLinkedHashSet(); - for (ResolvedCall call : result) { + Set> candidates = Sets.newLinkedHashSet(); + for (ResolvedCallImpl call : result) { call.setTrace(temporaryBindingTrace); candidates.add(call); } - return computeResultAndReportErrors(trace, TracingStrategy.EMPTY, candidates, Collections.>emptySet()); + return computeResultAndReportErrors(trace, TracingStrategy.EMPTY, candidates, Collections.>emptySet()); } - private List> findCandidatesByExactSignature(JetScope scope, ReceiverDescriptor receiver, String name, List parameterTypes) { - List> result = Lists.newArrayList(); + private List> findCandidatesByExactSignature(JetScope scope, ReceiverDescriptor receiver, String name, List parameterTypes) { + List> result = Lists.newArrayList(); if (receiver.exists()) { - Collection> extensionFunctionDescriptors = ResolvedCall.convertCollection(scope.getFunctions(name)); - List> nonlocal = Lists.newArrayList(); - List> local = Lists.newArrayList(); + Collection> extensionFunctionDescriptors = ResolvedCallImpl.convertCollection(scope.getFunctions(name)); + List> nonlocal = Lists.newArrayList(); + List> local = Lists.newArrayList(); TaskPrioritizer.splitLexicallyLocalDescriptors(extensionFunctionDescriptors, scope.getContainingDeclaration(), local, nonlocal); @@ -773,7 +787,7 @@ public class CallResolver { return result; } - Collection> functionDescriptors = ResolvedCall.convertCollection(receiver.getType().getMemberScope().getFunctions(name)); + Collection> functionDescriptors = ResolvedCallImpl.convertCollection(receiver.getType().getMemberScope().getFunctions(name)); if (lookupExactSignature(functionDescriptors, parameterTypes, result)) { return result; @@ -782,14 +796,14 @@ public class CallResolver { return result; } else { - lookupExactSignature(ResolvedCall.convertCollection(scope.getFunctions(name)), parameterTypes, result); + lookupExactSignature(ResolvedCallImpl.convertCollection(scope.getFunctions(name)), parameterTypes, result); return result; } } - private boolean lookupExactSignature(Collection> candidates, List parameterTypes, List> result) { + private boolean lookupExactSignature(Collection> candidates, List parameterTypes, List> result) { boolean found = false; - for (ResolvedCall resolvedCall : candidates) { + for (ResolvedCallImpl resolvedCall : candidates) { FunctionDescriptor functionDescriptor = resolvedCall.getResultingDescriptor(); if (functionDescriptor.getReceiverParameter().exists()) continue; if (!functionDescriptor.getTypeParameters().isEmpty()) continue; @@ -800,9 +814,9 @@ public class CallResolver { return found; } - private boolean findExtensionFunctions(Collection> candidates, ReceiverDescriptor receiver, List parameterTypes, List> result) { + private boolean findExtensionFunctions(Collection> candidates, ReceiverDescriptor receiver, List parameterTypes, List> result) { boolean found = false; - for (ResolvedCall resolvedCall : candidates) { + for (ResolvedCallImpl resolvedCall : candidates) { FunctionDescriptor functionDescriptor = resolvedCall.getResultingDescriptor(); ReceiverDescriptor functionReceiver = functionDescriptor.getReceiverParameter(); if (!functionReceiver.exists()) continue; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/DataFlowInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/DataFlowInfo.java deleted file mode 100644 index 0b91738ee7f..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/DataFlowInfo.java +++ /dev/null @@ -1,224 +0,0 @@ -package org.jetbrains.jet.lang.resolve.calls; - -import com.google.common.collect.*; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; -import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.util.CommonSuppliers; - -import java.util.*; - -/** - * @author abreslav - */ -public class DataFlowInfo { - - public static abstract class CompositionOperator { - - public abstract DataFlowInfo compose(DataFlowInfo a, DataFlowInfo b); - } - public static final CompositionOperator AND = new CompositionOperator() { - @Override - public DataFlowInfo compose(DataFlowInfo a, DataFlowInfo b) { - return a.and(b); - } - }; - - public static final CompositionOperator OR = new CompositionOperator() { - @Override - public DataFlowInfo compose(DataFlowInfo a, DataFlowInfo b) { - return a.or(b); - } - }; - - private static DataFlowInfo EMPTY = new DataFlowInfo(ImmutableMap.of(), Multimaps.newListMultimap(Collections.>emptyMap(), CommonSuppliers.getArrayListSupplier())); - - public static DataFlowInfo getEmpty() { - return EMPTY; - } - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - - private final ImmutableMap nullabilityInfo; - - private final ListMultimap typeInfo; - - private DataFlowInfo(ImmutableMap nullabilityInfo, ListMultimap typeInfo) { - this.nullabilityInfo = nullabilityInfo; - this.typeInfo = typeInfo; - } - - @Nullable - public JetType getOutType(@NotNull VariableDescriptor variableDescriptor) { - JetType outType = variableDescriptor.getOutType(); - if (outType == null) return null; - if (!outType.isNullable()) return outType; - NullabilityFlags nullabilityFlags = nullabilityInfo.get(variableDescriptor); - if (nullabilityFlags != null && !nullabilityFlags.canBeNull()) { - return TypeUtils.makeNotNullable(outType); - } - return outType; - } - - @NotNull - private List getPossibleTypes(Object key, @NotNull JetType originalType) { - List types = typeInfo.get(key); - NullabilityFlags nullabilityFlags = nullabilityInfo.get(key); - if (nullabilityFlags == null || nullabilityFlags.canBeNull()) { - return types; - } - List enrichedTypes = Lists.newArrayListWithCapacity(types.size()); - if (originalType.isNullable()) { - enrichedTypes.add(TypeUtils.makeNotNullable(originalType)); - } - for (JetType type: types) { - if (type.isNullable()) { - enrichedTypes.add(TypeUtils.makeNotNullable(type)); - } - else { - enrichedTypes.add(type); - } - } - return enrichedTypes; - } - - @NotNull - public List getPossibleTypesForVariable(@NotNull VariableDescriptor variableDescriptor) { - return getPossibleTypes(variableDescriptor, variableDescriptor.getOutType()); - } - - public List getPossibleTypesForReceiver(@NotNull ReceiverDescriptor receiver) { - return getPossibleTypes(receiver, receiver.getType()); - } - - public DataFlowInfo equalsToNull(@NotNull VariableDescriptor variableDescriptor, boolean notNull) { - return new DataFlowInfo(getEqualsToNullMap(variableDescriptor, notNull), typeInfo); - } - - private ImmutableMap getEqualsToNullMap(VariableDescriptor variableDescriptor, boolean notNull) { - Map builder = Maps.newHashMap(nullabilityInfo); - NullabilityFlags nullabilityFlags = nullabilityInfo.get(variableDescriptor); - boolean varNotNull = notNull || (nullabilityFlags != null && !nullabilityFlags.canBeNull); - builder.put(variableDescriptor, new NullabilityFlags(!varNotNull, varNotNull)); - return ImmutableMap.copyOf(builder); - } - - private ImmutableMap getEqualsToNullMap(VariableDescriptor[] variableDescriptors, boolean notNull) { - if (variableDescriptors.length == 0) return nullabilityInfo; - Map builder = Maps.newHashMap(nullabilityInfo); - for (VariableDescriptor variableDescriptor : variableDescriptors) { - if (variableDescriptor != null) { - NullabilityFlags nullabilityFlags = nullabilityInfo.get(variableDescriptor); - boolean varNotNull = notNull || (nullabilityFlags != null && !nullabilityFlags.canBeNull); - builder.put(variableDescriptor, new NullabilityFlags(!varNotNull, varNotNull)); - } - } - return ImmutableMap.copyOf(builder); - } - - public DataFlowInfo isInstanceOf(@NotNull VariableDescriptor variableDescriptor, @NotNull JetType type) { - ListMultimap newTypeInfo = copyTypeInfo(); - newTypeInfo.put(variableDescriptor, type); - return new DataFlowInfo(getEqualsToNullMap(variableDescriptor, !type.isNullable()), newTypeInfo); - } - - public DataFlowInfo isInstanceOf(@NotNull VariableDescriptor[] variableDescriptors, @NotNull JetType type) { - if (variableDescriptors.length == 0) return this; - ListMultimap newTypeInfo = copyTypeInfo(); - for (VariableDescriptor variableDescriptor : variableDescriptors) { - if (variableDescriptor != null) { - newTypeInfo.put(variableDescriptor, type); - } - } - return new DataFlowInfo(getEqualsToNullMap(variableDescriptors, !type.isNullable()), newTypeInfo); - } - - public DataFlowInfo and(DataFlowInfo other) { - Map nullabilityMapBuilder = Maps.newHashMap(); - nullabilityMapBuilder.putAll(nullabilityInfo); - for (Map.Entry entry : other.nullabilityInfo.entrySet()) { - Object key = entry.getKey(); - NullabilityFlags otherFlags = entry.getValue(); - NullabilityFlags thisFlags = nullabilityInfo.get(key); - if (thisFlags != null) { - nullabilityMapBuilder.put(key, thisFlags.and(otherFlags)); - } - else { - nullabilityMapBuilder.put(key, otherFlags); - } - } - - ListMultimap newTypeInfo = copyTypeInfo(); - newTypeInfo.putAll(other.typeInfo); - return new DataFlowInfo(ImmutableMap.copyOf(nullabilityMapBuilder), newTypeInfo); - } - - private ListMultimap copyTypeInfo() { - ListMultimap newTypeInfo = Multimaps.newListMultimap(Maps.>newHashMap(), CommonSuppliers.getArrayListSupplier()); - newTypeInfo.putAll(typeInfo); - return newTypeInfo; - } - - public DataFlowInfo or(DataFlowInfo other) { - Map builder = Maps.newHashMap(nullabilityInfo); - builder.keySet().retainAll(other.nullabilityInfo.keySet()); - for (Map.Entry entry : builder.entrySet()) { - Object key = entry.getKey(); - NullabilityFlags thisFlags = entry.getValue(); - NullabilityFlags otherFlags = other.nullabilityInfo.get(key); - assert (otherFlags != null); - builder.put(key, thisFlags.or(otherFlags)); - } - - ListMultimap newTypeInfo = Multimaps.newListMultimap(Maps.>newHashMap(), CommonSuppliers.getArrayListSupplier()); - - Set keys = newTypeInfo.keySet(); - keys.retainAll(other.typeInfo.keySet()); - - for (Object key : keys) { - Collection thisTypes = typeInfo.get(key); - Collection otherTypes = other.typeInfo.get(key); - - Collection newTypes = Sets.newHashSet(thisTypes); - newTypes.retainAll(otherTypes); - - newTypeInfo.putAll(key, newTypes); - } - - return new DataFlowInfo(ImmutableMap.copyOf(builder), newTypeInfo); - } - - public DataFlowInfo nullabilityOnly() { - return new DataFlowInfo(nullabilityInfo, EMPTY.copyTypeInfo()); - } - - private static class NullabilityFlags { - private final boolean canBeNull; - private final boolean canBeNonNull; - - private NullabilityFlags(boolean canBeNull, boolean canBeNonNull) { - this.canBeNull = canBeNull; - this.canBeNonNull = canBeNonNull; - } - - public boolean canBeNull() { - return canBeNull; - } - - public boolean canBeNonNull() { - return canBeNonNull; - } - - public NullabilityFlags and(NullabilityFlags other) { - return new NullabilityFlags(this.canBeNull && other.canBeNull, this.canBeNonNull && other.canBeNonNull); - } - - public NullabilityFlags or(NullabilityFlags other) { - return new NullabilityFlags(this.canBeNull || other.canBeNull, this.canBeNonNull || other.canBeNonNull); - } - - } -} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java index e93b7a0a2db..dfe84f5f26c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java @@ -29,40 +29,40 @@ public class OverloadResolutionResults { } - public static OverloadResolutionResults success(@NotNull ResolvedCall descriptor) { + public static OverloadResolutionResults success(@NotNull ResolvedCallImpl descriptor) { return new OverloadResolutionResults(Code.SUCCESS, Collections.singleton(descriptor)); } public static OverloadResolutionResults nameNotFound() { - return new OverloadResolutionResults(Code.NAME_NOT_FOUND, Collections.>emptyList()); + return new OverloadResolutionResults(Code.NAME_NOT_FOUND, Collections.>emptyList()); } - public static OverloadResolutionResults singleFailedCandidate(ResolvedCall candidate) { + public static OverloadResolutionResults singleFailedCandidate(ResolvedCallImpl candidate) { return new OverloadResolutionResults(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate)); } - public static OverloadResolutionResults manyFailedCandidates(Collection> failedCandidates) { + public static OverloadResolutionResults manyFailedCandidates(Collection> failedCandidates) { return new OverloadResolutionResults(Code.MANY_FAILED_CANDIDATES, failedCandidates); } - public static OverloadResolutionResults ambiguity(Collection> descriptors) { + public static OverloadResolutionResults ambiguity(Collection> descriptors) { return new OverloadResolutionResults(Code.AMBIGUITY, descriptors); } - private final Collection> results; + private final Collection> results; private final Code resultCode; - private OverloadResolutionResults(@NotNull Code resultCode, @NotNull Collection> results) { + private OverloadResolutionResults(@NotNull Code resultCode, @NotNull Collection> results) { this.results = results; this.resultCode = resultCode; } @NotNull - public Collection> getResults() { + public Collection> getResults() { return results; } @NotNull - public ResolvedCall getResult() { + public ResolvedCallImpl getResult() { assert singleDescriptor(); return results.iterator().next(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java index dc12c9ab9bc..4758dfd54af 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java @@ -28,23 +28,23 @@ public class OverloadingConflictResolver { } @Nullable - public ResolvedCall findMaximallySpecific(Set> candidates, boolean discriminateGenericDescriptors) { - // Different autocasts may lead to the same candidate descriptor wrapped into different ResolvedCall objects - Set> maximallySpecific = new THashSet>(new TObjectHashingStrategy>() { + public ResolvedCallImpl findMaximallySpecific(Set> candidates, boolean discriminateGenericDescriptors) { + // Different autocasts may lead to the same candidate descriptor wrapped into different ResolvedCallImpl objects + Set> maximallySpecific = new THashSet>(new TObjectHashingStrategy>() { @Override - public boolean equals(ResolvedCall o1, ResolvedCall o2) { + public boolean equals(ResolvedCallImpl o1, ResolvedCallImpl o2) { return o1 == null ? o2 == null : o1.getResultingDescriptor().equals(o2.getResultingDescriptor()); } @Override - public int computeHashCode(ResolvedCall object) { + public int computeHashCode(ResolvedCallImpl object) { return object == null ? 0 : object.getResultingDescriptor().hashCode(); } }); meLoop: - for (ResolvedCall candidateCall : candidates) { + for (ResolvedCallImpl candidateCall : candidates) { D me = candidateCall.getResultingDescriptor(); - for (ResolvedCall otherCall : candidates) { + for (ResolvedCallImpl otherCall : candidates) { D other = otherCall.getResultingDescriptor(); if (other == me) continue; if (!moreSpecific(me, other, discriminateGenericDescriptors) || moreSpecific(other, me, discriminateGenericDescriptors)) { @@ -54,7 +54,7 @@ public class OverloadingConflictResolver { maximallySpecific.add(candidateCall); } if (maximallySpecific.size() == 1) { - ResolvedCall result = maximallySpecific.iterator().next(); + ResolvedCallImpl result = maximallySpecific.iterator().next(); result.getTrace().commit(); return result; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java index 189a2550d0d..ecde91cc4ed 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java @@ -4,6 +4,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.psi.Call; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import java.util.Collection; @@ -12,13 +13,13 @@ import java.util.Collection; */ /*package*/ class ResolutionTask { private final Call call; - private final Collection> candidates; + private final Collection> candidates; private final DataFlowInfo dataFlowInfo; private DescriptorCheckStrategy checkingStrategy; public ResolutionTask( - @NotNull Collection> candidates, + @NotNull Collection> candidates, @NotNull Call call, @NotNull DataFlowInfo dataFlowInfo ) { @@ -33,7 +34,7 @@ import java.util.Collection; } @NotNull - public Collection> getCandidates() { + public Collection> getCandidates() { return candidates; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCall.java index 73021e8890f..521e7063eba 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCall.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCall.java @@ -1,147 +1,39 @@ package org.jetbrains.jet.lang.resolve.calls; -import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; -import java.util.Collection; -import java.util.List; import java.util.Map; -import static org.jetbrains.jet.lang.resolve.calls.ResolutionStatus.UNKNOWN_STATUS; -import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER; - /** * @author abreslav */ -public class ResolvedCall { - - public static final Function, CallableDescriptor> MAP_TO_CANDIDATE = new Function, CallableDescriptor>() { - @Override - public CallableDescriptor fun(ResolvedCall resolvedCall) { - return resolvedCall.getCandidateDescriptor(); - } - }; - - public static final Function, CallableDescriptor> MAP_TO_RESULT = new Function, CallableDescriptor>() { - @Override - public CallableDescriptor fun(ResolvedCall resolvedCall) { - return resolvedCall.getResultingDescriptor(); - } - }; - +public interface ResolvedCall { + /** A target callable descriptor as it was accessible in the corresponding scope, i.e. with type parameters not substituted */ @NotNull - public static ResolvedCall create(@NotNull D descriptor) { - return new ResolvedCall(descriptor); - } + D getCandidateDescriptor(); + /** Type parameters are substituted */ @NotNull - public static List> convertCollection(@NotNull Collection descriptors) { - List> result = Lists.newArrayList(); - for (D descriptor : descriptors) { - result.add(create(descriptor)); - } - return result; - } - - private final D candidateDescriptor; - private D resultingDescriptor; // Probably substituted - private ReceiverDescriptor thisObject = NO_RECEIVER; // receiver object of a method - private ReceiverDescriptor receiverArgument = NO_RECEIVER; // receiver of an extension function - private final Map typeArguments = Maps.newLinkedHashMap(); - private final Map autoCasts = Maps.newHashMap(); - private final Map valueArguments = Maps.newHashMap(); - private boolean someArgumentHasNoType = false; - private TemporaryBindingTrace trace; - private ResolutionStatus status = UNKNOWN_STATUS; - - private ResolvedCall(@NotNull D candidateDescriptor) { - this.candidateDescriptor = candidateDescriptor; - } + D getResultingDescriptor(); + /** If the target was an extension function or property, this is the value for its receiver parameter */ @NotNull - public ResolutionStatus getStatus() { - return status; - } - - public void setStatus(@NotNull ResolutionStatus status) { - this.status = status; - } + ReceiverDescriptor getReceiverArgument(); + /** If the target was a member of a class, this is the object of that class to call it on */ @NotNull - public TemporaryBindingTrace getTrace() { - return trace; - } - - public void setTrace(@NotNull TemporaryBindingTrace trace) { - this.trace = trace; - } + ReceiverDescriptor getThisObject(); + /** Values (arguments) for value parameters */ @NotNull - public D getCandidateDescriptor() { - return candidateDescriptor; - } + Map getValueArguments(); + /** What's substituted for type parameters */ @NotNull - public D getResultingDescriptor() { - return resultingDescriptor == null ? candidateDescriptor : resultingDescriptor; - } - - public ResolvedCall setResultingDescriptor(@NotNull D resultingDescriptor) { - this.resultingDescriptor = resultingDescriptor; - return this; - } - - public void recordTypeArgument(@NotNull TypeParameterDescriptor typeParameter, @NotNull JetType typeArgument) { - assert !typeArguments.containsKey(typeParameter); - typeArguments.put(typeParameter, typeArgument); - } - - public void recordValueArgument(@NotNull ValueParameterDescriptor valueParameter, @NotNull ResolvedValueArgument valueArgument) { - assert !valueArguments.containsKey(valueParameter); - valueArguments.put(valueParameter, valueArgument); - } - - public void autoCastValueArgument(@NotNull ValueParameterDescriptor parameter, @NotNull JetType target) { - assert !autoCasts.containsKey(parameter); - autoCasts.put(parameter, target); - } - - @NotNull - public ReceiverDescriptor getReceiverArgument() { - return receiverArgument; - } - - public void setReceiverArgument(@NotNull ReceiverDescriptor receiverParameter) { - this.receiverArgument = receiverParameter; - } - - @NotNull - public ReceiverDescriptor getThisObject() { - return thisObject; - } - - public void setThisObject(@NotNull ReceiverDescriptor thisObject) { - this.thisObject = thisObject; - } - - @NotNull - public Map getValueArguments() { - return valueArguments; - } - - public void argumentHasNoType() { - this.someArgumentHasNoType = true; - } - - public boolean isDirty() { - return someArgumentHasNoType; - } + Map getTypeArguments(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java new file mode 100644 index 00000000000..bf95a59a1c1 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java @@ -0,0 +1,159 @@ +package org.jetbrains.jet.lang.resolve.calls; + +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.intellij.util.Function; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Collection; +import java.util.List; +import java.util.Map; + +import static org.jetbrains.jet.lang.resolve.calls.ResolutionStatus.UNKNOWN_STATUS; +import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER; + +/** + * @author abreslav + */ +public class ResolvedCallImpl implements ResolvedCall { + + public static final Function, CallableDescriptor> MAP_TO_CANDIDATE = new Function, CallableDescriptor>() { + @Override + public CallableDescriptor fun(ResolvedCallImpl resolvedCall) { + return resolvedCall.getCandidateDescriptor(); + } + }; + + public static final Function, CallableDescriptor> MAP_TO_RESULT = new Function, CallableDescriptor>() { + @Override + public CallableDescriptor fun(ResolvedCallImpl resolvedCall) { + return resolvedCall.getResultingDescriptor(); + } + }; + + @NotNull + public static ResolvedCallImpl create(@NotNull D descriptor) { + return new ResolvedCallImpl(descriptor); + } + + @NotNull + public static List> convertCollection(@NotNull Collection descriptors) { + List> result = Lists.newArrayList(); + for (D descriptor : descriptors) { + result.add(create(descriptor)); + } + return result; + } + + private final D candidateDescriptor; + private D resultingDescriptor; // Probably substituted + private ReceiverDescriptor thisObject = NO_RECEIVER; // receiver object of a method + private ReceiverDescriptor receiverArgument = NO_RECEIVER; // receiver of an extension function + + private final Map typeArguments = Maps.newLinkedHashMap(); + private final Map autoCasts = Maps.newHashMap(); + private final Map valueArguments = Maps.newHashMap(); + private boolean someArgumentHasNoType = false; + private TemporaryBindingTrace trace; + private ResolutionStatus status = UNKNOWN_STATUS; + + private ResolvedCallImpl(@NotNull D candidateDescriptor) { + this.candidateDescriptor = candidateDescriptor; + } + + @NotNull + public ResolutionStatus getStatus() { + return status; + } + + public void setStatus(@NotNull ResolutionStatus status) { + this.status = status; + } + + @NotNull + public TemporaryBindingTrace getTrace() { + return trace; + } + + public void setTrace(@NotNull TemporaryBindingTrace trace) { + this.trace = trace; + } + + @Override + @NotNull + public D getCandidateDescriptor() { + return candidateDescriptor; + } + + @Override + @NotNull + public D getResultingDescriptor() { + return resultingDescriptor == null ? candidateDescriptor : resultingDescriptor; + } + + public ResolvedCallImpl setResultingDescriptor(@NotNull D resultingDescriptor) { + this.resultingDescriptor = resultingDescriptor; + return this; + } + + public void recordTypeArgument(@NotNull TypeParameterDescriptor typeParameter, @NotNull JetType typeArgument) { + assert !typeArguments.containsKey(typeParameter); + typeArguments.put(typeParameter, typeArgument); + } + + public void recordValueArgument(@NotNull ValueParameterDescriptor valueParameter, @NotNull ResolvedValueArgument valueArgument) { + assert !valueArguments.containsKey(valueParameter); + valueArguments.put(valueParameter, valueArgument); + } + + public void autoCastValueArgument(@NotNull ValueParameterDescriptor parameter, @NotNull JetType target) { + assert !autoCasts.containsKey(parameter); + autoCasts.put(parameter, target); + } + + @Override + @NotNull + public ReceiverDescriptor getReceiverArgument() { + return receiverArgument; + } + + public void setReceiverArgument(@NotNull ReceiverDescriptor receiverParameter) { + this.receiverArgument = receiverParameter; + } + + @Override + @NotNull + public ReceiverDescriptor getThisObject() { + return thisObject; + } + + public void setThisObject(@NotNull ReceiverDescriptor thisObject) { + this.thisObject = thisObject; + } + + @Override + @NotNull + public Map getValueArguments() { + return valueArguments; + } + + public void argumentHasNoType() { + this.someArgumentHasNoType = true; + } + + public boolean isDirty() { + return someArgumentHasNoType; + } + + @NotNull + @Override + public Map getTypeArguments() { + return typeArguments; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java index 581d5251e68..5bfc0947a8e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java @@ -8,6 +8,9 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.psi.Call; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastService; +import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastServiceImpl; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; @@ -26,9 +29,9 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor /*package*/ abstract class TaskPrioritizer { public static void splitLexicallyLocalDescriptors( - Collection> allDescriptors, DeclarationDescriptor containerOfTheCurrentLocality, Collection> local, Collection> nonlocal) { + Collection> allDescriptors, DeclarationDescriptor containerOfTheCurrentLocality, Collection> local, Collection> nonlocal) { - for (ResolvedCall resolvedCall : allDescriptors) { + for (ResolvedCallImpl resolvedCall : allDescriptors) { if (isLocal(containerOfTheCurrentLocality, resolvedCall.getCandidateDescriptor())) { local.add(resolvedCall); } @@ -93,13 +96,13 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor if (receiver.exists()) { List variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver); - Collection> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, getExtensionsByName(scope, name)); - List> nonlocals = Lists.newArrayList(); - List> locals = Lists.newArrayList(); + Collection> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, getExtensionsByName(scope, name)); + List> nonlocals = Lists.newArrayList(); + List> locals = Lists.newArrayList(); //noinspection unchecked,RedundantTypeArguments TaskPrioritizer.splitLexicallyLocalDescriptors(extensionFunctions, scope.getContainingDeclaration(), locals, nonlocals); - Collection> members = Lists.newArrayList(); + Collection> members = Lists.newArrayList(); for (ReceiverDescriptor variant : variantsForExplicitReceiver) { Collection membersForThisVariant = getMembersByName(variant.getType(), name); convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), Collections.singletonList(NO_RECEIVER), members); @@ -117,10 +120,10 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor addTask(result, call, nonlocals, dataFlowInfo); } else { - Collection> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), getNonExtensionsByName(scope, name)); + Collection> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), getNonExtensionsByName(scope, name)); - List> nonlocals = Lists.newArrayList(); - List> locals = Lists.newArrayList(); + List> nonlocals = Lists.newArrayList(); + List> locals = Lists.newArrayList(); //noinspection unchecked,RedundantTypeArguments TaskPrioritizer.splitLexicallyLocalDescriptors(functions, scope.getContainingDeclaration(), locals, nonlocals); @@ -134,18 +137,18 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor } } - private Collection> convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters) { - Collection> result = Lists.newArrayList(); + private Collection> convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters) { + Collection> result = Lists.newArrayList(); convertWithReceivers(descriptors, thisObjects, receiverParameters, result); return result; } - private void convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters, Collection> result) { -// Collection> result = Lists.newArrayList(); + private void convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters, Collection> result) { +// Collection> result = Lists.newArrayList(); for (ReceiverDescriptor thisObject : thisObjects) { for (ReceiverDescriptor receiverParameter : receiverParameters) { for (D extension : descriptors) { - ResolvedCall resolvedCall = ResolvedCall.create(extension); + ResolvedCallImpl resolvedCall = ResolvedCallImpl.create(extension); resolvedCall.setThisObject(thisObject); resolvedCall.setReceiverArgument(receiverParameter); result.add(resolvedCall); @@ -155,11 +158,11 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor // return result; } - public static Collection> convertWithImpliedThis(JetScope scope, Iterable receiverParameters, Collection descriptors) { - Collection> result = Lists.newArrayList(); + public static Collection> convertWithImpliedThis(JetScope scope, Iterable receiverParameters, Collection descriptors) { + Collection> result = Lists.newArrayList(); for (ReceiverDescriptor receiverParameter : receiverParameters) { for (D extension : descriptors) { - ResolvedCall resolvedCall = ResolvedCall.create(extension); + ResolvedCallImpl resolvedCall = ResolvedCallImpl.create(extension); resolvedCall.setReceiverArgument(receiverParameter); if (setImpliedThis(scope, resolvedCall)) { result.add(resolvedCall); @@ -169,7 +172,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor return result; } - private static boolean setImpliedThis(@NotNull JetScope scope, ResolvedCall resolvedCall) { + private static boolean setImpliedThis(@NotNull JetScope scope, ResolvedCallImpl resolvedCall) { ReceiverDescriptor expectedThisObject = resolvedCall.getCandidateDescriptor().getExpectedThisObject(); if (!expectedThisObject.exists()) return true; List receivers = Lists.newArrayList(); @@ -184,7 +187,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor return false; } - private void addTask(@NotNull List> result, @NotNull Call call, @NotNull Collection> candidates, @NotNull DataFlowInfo dataFlowInfo) { + private void addTask(@NotNull List> result, @NotNull Call call, @NotNull Collection> candidates, @NotNull DataFlowInfo dataFlowInfo) { if (candidates.isEmpty()) return; result.add(new ResolutionTask(candidates, call, dataFlowInfo)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java index a7e7096b2de..6284ccb5b0d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java @@ -16,13 +16,13 @@ import java.util.Set; /*package*/ interface TracingStrategy { TracingStrategy EMPTY = new TracingStrategy() { @Override - public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCall resolvedCall) {} + public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall) {} @Override public void unresolvedReference(@NotNull BindingTrace trace) {} @Override - public void recordAmbiguity(BindingTrace trace, Collection> candidates) {} + public void recordAmbiguity(BindingTrace trace, Collection> candidates) {} @Override public void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver) {} @@ -40,10 +40,10 @@ import java.util.Set; public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) {} @Override - public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} + public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} @Override - public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} + public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} @Override public void instantiationOfAbstractClass(@NotNull BindingTrace trace) {} @@ -58,11 +58,11 @@ import java.util.Set; public void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull JetType type) {} }; - void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCall resolvedCall); + void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall); void unresolvedReference(@NotNull BindingTrace trace); - void recordAmbiguity(BindingTrace trace, Collection> candidates); + void recordAmbiguity(BindingTrace trace, Collection> candidates); void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver); @@ -74,9 +74,9 @@ import java.util.Set; void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount); - void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors); + void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors); - void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors); + void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors); void instantiationOfAbstractClass(@NotNull BindingTrace trace); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java index 8338f750b11..402b3f1aa62 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java @@ -23,7 +23,7 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; public static boolean mapValueArgumentsToParameters( @NotNull ResolutionTask task, @NotNull TracingStrategy tracing, - @NotNull ResolvedCall candidateCall + @NotNull ResolvedCallImpl candidateCall ) { TemporaryBindingTrace temporaryTrace = candidateCall.getTrace(); @@ -181,7 +181,7 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; return error; } - private static void put(ResolvedCall candidateCall, ValueParameterDescriptor valueParameterDescriptor, ValueArgument valueArgument, Map varargs) { + private static void put(ResolvedCallImpl candidateCall, ValueParameterDescriptor valueParameterDescriptor, ValueArgument valueArgument, Map varargs) { if (valueParameterDescriptor.isVararg()) { VarargValueArgument vararg = varargs.get(valueParameterDescriptor); if (vararg == null) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastService.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastService.java similarity index 90% rename from compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastService.java rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastService.java index 60fbb920eac..4c0de1c1ca5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastService.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastService.java @@ -1,4 +1,4 @@ -package org.jetbrains.jet.lang.resolve.calls; +package org.jetbrains.jet.lang.resolve.calls.autocasts; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; @@ -13,7 +13,7 @@ public interface AutoCastService { AutoCastService NO_AUTO_CASTS = new AutoCastService() { @Override public DataFlowInfo getDataFlowInfo() { - return DataFlowInfo.getEmpty(); + return DataFlowInfo.EMPTY; } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastServiceImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastServiceImpl.java similarity index 95% rename from compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastServiceImpl.java rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastServiceImpl.java index d0f8c6f102d..c5cf125e80a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastServiceImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastServiceImpl.java @@ -1,4 +1,4 @@ -package org.jetbrains.jet.lang.resolve.calls; +package org.jetbrains.jet.lang.resolve.calls.autocasts; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.resolve.BindingContext; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastUtils.java new file mode 100644 index 00000000000..e1b62313964 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastUtils.java @@ -0,0 +1,109 @@ +package org.jetbrains.jet.lang.resolve.calls.autocasts; + +import com.google.common.collect.Lists; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.calls.AutoCastReceiver; +import org.jetbrains.jet.lang.resolve.scopes.receivers.*; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Collections; +import java.util.List; + +/** + * @author abreslav + */ +public class AutoCastUtils { + + private AutoCastUtils() {} + + public static List getAutoCastVariants(@NotNull final BindingContext bindingContext, @NotNull final DataFlowInfo dataFlowInfo, @NotNull ReceiverDescriptor receiverToCast) { + return receiverToCast.accept(new ReceiverDescriptorVisitor, Object>() { + @Override + public List visitNoReceiver(ReceiverDescriptor noReceiver, Object data) { + return Collections.emptyList(); + } + + @Override + public List visitTransientReceiver(TransientReceiver receiver, Object data) { + return Collections.emptyList(); + } + + @Override + public List visitExtensionReceiver(ExtensionReceiver receiver, Object data) { + return castThis(dataFlowInfo, receiver); + } + + @Override + public List visitClassReceiver(ClassReceiver receiver, Object data) { + return castThis(dataFlowInfo, receiver); + } + + @Override + public List visitExpressionReceiver(ExpressionReceiver receiver, Object data) { +// JetExpression expression = receiver.getExpression(); +// VariableDescriptor variableDescriptor = DataFlowValueFactory.getVariableDescriptorFromSimpleName(bindingContext, expression); +// if (variableDescriptor != null) { +// List result = Lists.newArrayList(); +// for (JetType possibleType : dataFlowInfo.getPossibleTypesForVariable(variableDescriptor)) { +// result.add(new AutoCastReceiver(receiver, possibleType, DataFlowValueFactory.isStableVariable(variableDescriptor))); +// } +// return result; +// } +// else if (expression instanceof JetThisExpression) { +// return castThis(dataFlowInfo, receiver); +// } + DataFlowValue dataFlowValue = DataFlowValueFactory.INSTANCE.createDataFlowValue(receiver.getExpression(),receiver.getType(), bindingContext); + List result = Lists.newArrayList(); + for (JetType possibleType : dataFlowInfo.getPossibleTypes(dataFlowValue)) { + result.add(new AutoCastReceiver(receiver, possibleType, dataFlowValue.isStableIdentifier())); + } + return result; + } + }, null); + } + + private static List castThis(@NotNull DataFlowInfo dataFlowInfo, @NotNull ThisReceiverDescriptor receiver) { + assert receiver.exists(); + List result = Lists.newArrayList(); + for (JetType possibleType : dataFlowInfo.getPossibleTypes(DataFlowValueFactory.INSTANCE.createDataFlowValue(receiver))) { + result.add(new AutoCastReceiver(receiver, possibleType, true)); + } + return result; + } + +// @Nullable +// public static JetType castExpression(@NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, @NotNull BindingTrace trace) { +// JetTypeChecker typeChecker = JetTypeChecker.INSTANCE; +// DataFlowValue dataFlowValue = DataFlowValueFactory.INSTANCE.createDataFlowValue(expression, trace.getBindingContext()); +// for (JetType possibleType : dataFlowInfo.getPossibleTypes(dataFlowValue)) { +// if (typeChecker.isSubtypeOf(possibleType, expectedType)) { +// if (dataFlowValue.isStableIdentifier()) { +// trace.record(AUTOCAST, expression, possibleType); +// } +// else { +// trace.report(AUTOCAST_IMPOSSIBLE.on(expression, possibleType, expression.getText())); +// } +// return possibleType; +// } +// } +//// VariableDescriptor variableDescriptor = DataFlowValueFactory.getVariableDescriptorFromSimpleName(trace.getBindingContext(), expression); +//// if (variableDescriptor != null) { +//// List possibleTypes = Lists.newArrayList(dataFlowInfo.getPossibleTypes(variableDescriptor)); +//// Collections.reverse(possibleTypes); +//// for (JetType possibleType : possibleTypes) { +//// if (typeChecker.isSubtypeOf(possibleType, expectedType)) { +//// if (DataFlowValueFactory.isStableVariable(variableDescriptor)) { +//// trace.record(AUTOCAST, expression, possibleType); +//// } +//// else { +//// trace.report(AUTOCAST_IMPOSSIBLE.on(expression, possibleType, expression.getText())); +//// } +//// return possibleType; +//// } +//// } +//// } +// return null; +// } + +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java new file mode 100644 index 00000000000..f1148ec21d2 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java @@ -0,0 +1,390 @@ +package org.jetbrains.jet.lang.resolve.calls.autocasts; + +import com.google.common.collect.*; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.util.CommonSuppliers; + +import java.util.*; + +import static org.jetbrains.jet.lang.resolve.calls.autocasts.Nullability.NOT_NULL; + +/** + * @author abreslav + */ + +public class DataFlowInfo { + + public static abstract class CompositionOperator { + public abstract DataFlowInfo compose(DataFlowInfo a, DataFlowInfo b); + } + + public static final CompositionOperator AND = new CompositionOperator() { + @Override + public DataFlowInfo compose(DataFlowInfo a, DataFlowInfo b) { + return a.and(b); + } + }; + + public static final CompositionOperator OR = new CompositionOperator() { + @Override + public DataFlowInfo compose(DataFlowInfo a, DataFlowInfo b) { + return a.or(b); + } + }; + + public static DataFlowInfo EMPTY = new DataFlowInfo(ImmutableMap.of(), Multimaps.newListMultimap(Collections.>emptyMap(), CommonSuppliers.getArrayListSupplier())); + + private final ImmutableMap nullabilityInfo; + private final ListMultimap typeInfo; + + private DataFlowInfo(ImmutableMap nullabilityInfo, ListMultimap typeInfo) { + this.nullabilityInfo = nullabilityInfo; + this.typeInfo = typeInfo; + } + + @NotNull + private Nullability getNullability(@NotNull DataFlowValue a) { + if (!a.isStableIdentifier()) return a.getImmanentNullability(); + Nullability nullability = nullabilityInfo.get(a); + if (nullability == null) { + nullability = a.getImmanentNullability(); + } + return nullability; + } + + private boolean putNullability(@NotNull Map map, @NotNull DataFlowValue value, @NotNull Nullability nullability) { + if (!value.isStableIdentifier()) return false; + return map.put(value, nullability) != nullability; + } + + @NotNull + public List getPossibleTypes(DataFlowValue key) { + JetType originalType = key.getType(); + List types = typeInfo.get(key); + Nullability nullability = getNullability(key); + if (nullability.canBeNull()) { + return types; + } + List enrichedTypes = Lists.newArrayListWithCapacity(types.size()); + if (originalType.isNullable()) { + enrichedTypes.add(TypeUtils.makeNotNullable(originalType)); + } + for (JetType type: types) { + if (type.isNullable()) { + enrichedTypes.add(TypeUtils.makeNotNullable(type)); + } + else { + enrichedTypes.add(type); + } + } + return enrichedTypes; + } + + @NotNull + public DataFlowInfo equate(@NotNull DataFlowValue a, @NotNull DataFlowValue b) { + Map builder = Maps.newHashMap(nullabilityInfo); + Nullability nullabilityOfA = getNullability(a); + Nullability nullabilityOfB = getNullability(b); + + boolean changed = false; + changed |= putNullability(builder, a, nullabilityOfA.refine(nullabilityOfB)); + changed |= putNullability(builder, b, nullabilityOfA.refine(nullabilityOfA)); + return changed ? new DataFlowInfo(ImmutableMap.copyOf(builder), typeInfo) : this; + } + + @NotNull + public DataFlowInfo disequate(@NotNull DataFlowValue a, @NotNull DataFlowValue b) { + Map builder = Maps.newHashMap(nullabilityInfo); + Nullability nullabilityOfA = getNullability(a); + Nullability nullabilityOfB = getNullability(b); + + boolean changed = false; + changed |= putNullability(builder, a, nullabilityOfA.refine(nullabilityOfB.invert())); + changed |= putNullability(builder, b, nullabilityOfA.refine(nullabilityOfA.invert())); + return changed ? new DataFlowInfo(ImmutableMap.copyOf(builder), typeInfo) : this; + } + + @NotNull + public DataFlowInfo establishSubtyping(@NotNull DataFlowValue[] values, @NotNull JetType type) { + ListMultimap newTypeInfo = copyTypeInfo(); + Map newNullabilityInfo = Maps.newHashMap(nullabilityInfo); + boolean changed = false; + for (DataFlowValue value : values) { +// if (!value.isStableIdentifier()) continue; + changed = true; + newTypeInfo.put(value, type); + if (!type.isNullable()) { + putNullability(newNullabilityInfo, value, NOT_NULL); + } + } + if (!changed) return this; + return new DataFlowInfo(ImmutableMap.copyOf(newNullabilityInfo), newTypeInfo); + } + + private ListMultimap copyTypeInfo() { + ListMultimap newTypeInfo = Multimaps.newListMultimap(Maps.>newHashMap(), CommonSuppliers.getArrayListSupplier()); + newTypeInfo.putAll(typeInfo); + return newTypeInfo; + } + + public DataFlowInfo and(DataFlowInfo other) { + Map nullabilityMapBuilder = Maps.newHashMap(); + nullabilityMapBuilder.putAll(nullabilityInfo); + for (Map.Entry entry : other.nullabilityInfo.entrySet()) { + DataFlowValue key = entry.getKey(); + Nullability otherFlags = entry.getValue(); + Nullability thisFlags = nullabilityInfo.get(key); + if (thisFlags != null) { + nullabilityMapBuilder.put(key, thisFlags.and(otherFlags)); + } + else { + nullabilityMapBuilder.put(key, otherFlags); + } + } + + ListMultimap newTypeInfo = copyTypeInfo(); + newTypeInfo.putAll(other.typeInfo); + return new DataFlowInfo(ImmutableMap.copyOf(nullabilityMapBuilder), newTypeInfo); + } + + public DataFlowInfo or(DataFlowInfo other) { + Map builder = Maps.newHashMap(nullabilityInfo); + builder.keySet().retainAll(other.nullabilityInfo.keySet()); + for (Map.Entry entry : builder.entrySet()) { + DataFlowValue key = entry.getKey(); + Nullability thisFlags = entry.getValue(); + Nullability otherFlags = other.nullabilityInfo.get(key); + assert (otherFlags != null); + builder.put(key, thisFlags.or(otherFlags)); + } + + ListMultimap newTypeInfo = Multimaps.newListMultimap(Maps.>newHashMap(), CommonSuppliers.getArrayListSupplier()); + + Set keys = newTypeInfo.keySet(); + keys.retainAll(other.typeInfo.keySet()); + + for (DataFlowValue key : keys) { + Collection thisTypes = typeInfo.get(key); + Collection otherTypes = other.typeInfo.get(key); + + Collection newTypes = Sets.newHashSet(thisTypes); + newTypes.retainAll(otherTypes); + + newTypeInfo.putAll(key, newTypes); + } + + return new DataFlowInfo(ImmutableMap.copyOf(builder), newTypeInfo); + } + +} + +//public class DataFlowInfo { +// +// public static abstract class CompositionOperator { +// +// public abstract DataFlowInfo compose(DataFlowInfo a, DataFlowInfo b); +// } +// public static final CompositionOperator AND = new CompositionOperator() { +// @Override +// public DataFlowInfo compose(DataFlowInfo a, DataFlowInfo b) { +// return a.and(b); +// } +// }; +// +// public static final CompositionOperator OR = new CompositionOperator() { +// @Override +// public DataFlowInfo compose(DataFlowInfo a, DataFlowInfo b) { +// return a.or(b); +// } +// }; +// +// private static DataFlowInfo EMPTY = new DataFlowInfo(ImmutableMap.of(), Multimaps.newListMultimap(Collections.>emptyMap(), CommonSuppliers.getArrayListSupplier())); +// +// public static DataFlowInfo getEmpty() { +// return EMPTY; +// } +// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +// private final ImmutableMap nullabilityInfo; +// +// private final ListMultimap typeInfo; +// +// private DataFlowInfo(ImmutableMap nullabilityInfo, ListMultimap typeInfo) { +// this.nullabilityInfo = nullabilityInfo; +// this.typeInfo = typeInfo; +// } +// +// @Nullable +// public JetType getOutType(@NotNull VariableDescriptor variableDescriptor) { +// JetType outType = variableDescriptor.getOutType(); +// if (outType == null) return null; +// if (!outType.isNullable()) return outType; +// NullabilityFlags nullabilityFlags = nullabilityInfo.get(variableDescriptor); +// if (nullabilityFlags != null && !nullabilityFlags.canBeNull()) { +// return TypeUtils.makeNotNullable(outType); +// } +// return outType; +// } +// +// @NotNull +// private List getPossibleTypes(Object key, @NotNull JetType originalType) { +// List types = typeInfo.get(key); +// NullabilityFlags nullabilityFlags = nullabilityInfo.get(key); +// if (nullabilityFlags == null || nullabilityFlags.canBeNull()) { +// return types; +// } +// List enrichedTypes = Lists.newArrayListWithCapacity(types.size()); +// if (originalType.isNullable()) { +// enrichedTypes.add(TypeUtils.makeNotNullable(originalType)); +// } +// for (JetType type: types) { +// if (type.isNullable()) { +// enrichedTypes.add(TypeUtils.makeNotNullable(type)); +// } +// else { +// enrichedTypes.add(type); +// } +// } +// return enrichedTypes; +// } +// +// @NotNull +// public List getPossibleTypesForVariable(@NotNull VariableDescriptor variableDescriptor) { +// return getPossibleTypes(variableDescriptor, variableDescriptor.getOutType()); +// } +// +// public List getPossibleTypesForReceiver(@NotNull ReceiverDescriptor receiver) { +// return getPossibleTypes(receiver, receiver.getType()); +// } +// +// public DataFlowInfo establishEqualityToNull(@NotNull VariableDescriptor variableDescriptor, boolean notNull) { +// return new DataFlowInfo(getEqualsToNullMap(variableDescriptor, notNull), typeInfo); +// } +// +// private ImmutableMap getEqualsToNullMap(VariableDescriptor variableDescriptor, boolean notNull) { +// Map builder = Maps.newHashMap(nullabilityInfo); +// NullabilityFlags nullabilityFlags = nullabilityInfo.get(variableDescriptor); +// boolean varNotNull = notNull || (nullabilityFlags != null && !nullabilityFlags.canBeNull); +// builder.put(variableDescriptor, new NullabilityFlags(!varNotNull, varNotNull)); +// return ImmutableMap.copyOf(builder); +// } +// +// private ImmutableMap getEqualsToNullMap(VariableDescriptor[] variableDescriptors, boolean notNull) { +// if (variableDescriptors.length == 0) return nullabilityInfo; +// Map builder = Maps.newHashMap(nullabilityInfo); +// for (VariableDescriptor variableDescriptor : variableDescriptors) { +// if (variableDescriptor != null) { +// NullabilityFlags nullabilityFlags = nullabilityInfo.get(variableDescriptor); +// boolean varNotNull = notNull || (nullabilityFlags != null && !nullabilityFlags.canBeNull); +// builder.put(variableDescriptor, new NullabilityFlags(!varNotNull, varNotNull)); +// } +// } +// return ImmutableMap.copyOf(builder); +// } +// +// public DataFlowInfo isInstanceOf(@NotNull VariableDescriptor variableDescriptor, @NotNull JetType type) { +// ListMultimap newTypeInfo = copyTypeInfo(); +// newTypeInfo.put(variableDescriptor, type); +// return new DataFlowInfo(getEqualsToNullMap(variableDescriptor, !type.isNullable()), newTypeInfo); +// } +// +// public DataFlowInfo isInstanceOf(@NotNull VariableDescriptor[] variableDescriptors, @NotNull JetType type) { +// if (variableDescriptors.length == 0) return this; +// ListMultimap newTypeInfo = copyTypeInfo(); +// for (VariableDescriptor variableDescriptor : variableDescriptors) { +// if (variableDescriptor != null) { +// newTypeInfo.put(variableDescriptor, type); +// } +// } +// return new DataFlowInfo(getEqualsToNullMap(variableDescriptors, !type.isNullable()), newTypeInfo); +// } +// +// public DataFlowInfo and(DataFlowInfo other) { +// Map nullabilityMapBuilder = Maps.newHashMap(); +// nullabilityMapBuilder.putAll(nullabilityInfo); +// for (Map.Entry entry : other.nullabilityInfo.entrySet()) { +// Object key = entry.getKey(); +// NullabilityFlags otherFlags = entry.getValue(); +// NullabilityFlags thisFlags = nullabilityInfo.get(key); +// if (thisFlags != null) { +// nullabilityMapBuilder.put(key, thisFlags.and(otherFlags)); +// } +// else { +// nullabilityMapBuilder.put(key, otherFlags); +// } +// } +// +// ListMultimap newTypeInfo = copyTypeInfo(); +// newTypeInfo.putAll(other.typeInfo); +// return new DataFlowInfo(ImmutableMap.copyOf(nullabilityMapBuilder), newTypeInfo); +// } +// +// private ListMultimap copyTypeInfo() { +// ListMultimap newTypeInfo = Multimaps.newListMultimap(Maps.>newHashMap(), CommonSuppliers.getArrayListSupplier()); +// newTypeInfo.putAll(typeInfo); +// return newTypeInfo; +// } +// +// public DataFlowInfo or(DataFlowInfo other) { +// Map builder = Maps.newHashMap(nullabilityInfo); +// builder.keySet().retainAll(other.nullabilityInfo.keySet()); +// for (Map.Entry entry : builder.entrySet()) { +// Object key = entry.getKey(); +// NullabilityFlags thisFlags = entry.getValue(); +// NullabilityFlags otherFlags = other.nullabilityInfo.get(key); +// assert (otherFlags != null); +// builder.put(key, thisFlags.or(otherFlags)); +// } +// +// ListMultimap newTypeInfo = Multimaps.newListMultimap(Maps.>newHashMap(), CommonSuppliers.getArrayListSupplier()); +// +// Set keys = newTypeInfo.keySet(); +// keys.retainAll(other.typeInfo.keySet()); +// +// for (Object key : keys) { +// Collection thisTypes = typeInfo.get(key); +// Collection otherTypes = other.typeInfo.get(key); +// +// Collection newTypes = Sets.newHashSet(thisTypes); +// newTypes.retainAll(otherTypes); +// +// newTypeInfo.putAll(key, newTypes); +// } +// +// return new DataFlowInfo(ImmutableMap.copyOf(builder), newTypeInfo); +// } +// +// public DataFlowInfo nullabilityOnly() { +// return new DataFlowInfo(nullabilityInfo, EMPTY.copyTypeInfo()); +// } +// +// private static class NullabilityFlags { +// private final boolean canBeNull; +// private final boolean canBeNonNull; +// +// private NullabilityFlags(boolean canBeNull, boolean canBeNonNull) { +// this.canBeNull = canBeNull; +// this.canBeNonNull = canBeNonNull; +// } +// +// public boolean canBeNull() { +// return canBeNull; +// } +// +// public boolean canBeNonNull() { +// return canBeNonNull; +// } +// +// public NullabilityFlags and(NullabilityFlags other) { +// return new NullabilityFlags(this.canBeNull && other.canBeNull, this.canBeNonNull && other.canBeNonNull); +// } +// +// public NullabilityFlags or(NullabilityFlags other) { +// return new NullabilityFlags(this.canBeNull || other.canBeNull, this.canBeNonNull || other.canBeNonNull); +// } +// +// } +//} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValue.java new file mode 100644 index 00000000000..eaec974829b --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValue.java @@ -0,0 +1,72 @@ +package org.jetbrains.jet.lang.resolve.calls.autocasts; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.types.JetStandardClasses; +import org.jetbrains.jet.lang.types.JetType; + +/** + * @author abreslav + */ +public class DataFlowValue { + + public static final DataFlowValue NULL = new DataFlowValue(new Object(), JetStandardClasses.getNullableNothingType(), false, Nullability.NULL); + public static final DataFlowValue NULLABLE = new DataFlowValue(new Object(), JetStandardClasses.getNullableAnyType(), false, Nullability.UNKNOWN); + + private final boolean stableIdentifier; + private final JetType type; + private final Object id; + private final Nullability immanentNullability; + + // Use DataFlowValueFactory + /*package*/ DataFlowValue(Object id, JetType type, boolean stableIdentifier, Nullability immanentNullability) { + this.stableIdentifier = stableIdentifier; + this.type = type; + this.id = id; + this.immanentNullability = immanentNullability; + } + + @NotNull + public Nullability getImmanentNullability() { + return immanentNullability; + } + + /** + * Stable identifier is a non-literal value that is statically known to be immutable + * @return + */ + public boolean isStableIdentifier() { + return stableIdentifier; + } + + @NotNull + public JetType getType() { + return type; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + DataFlowValue that = (DataFlowValue) o; + + if (stableIdentifier != that.stableIdentifier) return false; + if (id != null ? !id.equals(that.id) : that.id != null) return false; + if (type != null ? !type.equals(that.type) : that.type != null) return false; + + return true; + } + + @Override + public String toString() { + return (stableIdentifier ? "stable " : "unstable ") + (id == null ? null : id.toString()) + " " + immanentNullability; + } + + @Override + public int hashCode() { + int result = (stableIdentifier ? 1 : 0); + result = 31 * result + (type != null ? type.hashCode() : 0); + result = 31 * result + (id != null ? id.hashCode() : 0); + return result; + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java new file mode 100644 index 00000000000..334321bfaf2 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java @@ -0,0 +1,156 @@ +package org.jetbrains.jet.lang.resolve.calls.autocasts; + +import com.intellij.openapi.util.Pair; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.JetNodeTypes; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.JetModuleUtil; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ThisReceiverDescriptor; +import org.jetbrains.jet.lang.types.JetStandardClasses; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.JetTypeChecker; + +import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; + +/** + * @author abreslav + */ +public class DataFlowValueFactory { + public static final DataFlowValueFactory INSTANCE = new DataFlowValueFactory(); + + private DataFlowValueFactory() {} + + @NotNull + public DataFlowValue createDataFlowValue(@NotNull JetExpression expression, @NotNull JetType type, @NotNull BindingContext bindingContext) { + if (expression instanceof JetConstantExpression) { + JetConstantExpression constantExpression = (JetConstantExpression) expression; + if (constantExpression.getNode().getElementType() == JetNodeTypes.NULL) return DataFlowValue.NULL; + } + if (JetTypeChecker.INSTANCE.equalTypes(type, JetStandardClasses.getNullableNothingType())) return DataFlowValue.NULL; // 'null' is the only inhabitant of 'Nothing?' + Pair result = getIdForStableIdentifier(expression, bindingContext, false); + return new DataFlowValue(result.first == null ? expression : result.first, type, result.second, getImmanentNullability(type)); + } + + @NotNull + public DataFlowValue createDataFlowValue(@NotNull ThisReceiverDescriptor receiver) { + JetType type = receiver.getType(); + return new DataFlowValue(receiver.getDeclarationDescriptor(), type, true, getImmanentNullability(type)); + } + + @NotNull + public DataFlowValue createDataFlowValue(@NotNull VariableDescriptor variableDescriptor) { + JetType type = variableDescriptor.getOutType(); + return new DataFlowValue(variableDescriptor, type, isStableVariable(variableDescriptor), getImmanentNullability(type)); + } + + private Nullability getImmanentNullability(JetType type) { + return type.isNullable() ? Nullability.UNKNOWN : Nullability.NOT_NULL; + } + + @NotNull + private static Pair getIdForStableIdentifier(@NotNull JetExpression expression, @NotNull BindingContext bindingContext, boolean allowNamespaces) { + if (expression instanceof JetParenthesizedExpression) { + JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) expression; + JetExpression innerExpression = parenthesizedExpression.getExpression(); + if (innerExpression == null) { + return Pair.create(null, false); + } + return getIdForStableIdentifier(innerExpression, bindingContext, allowNamespaces); + } + else if (expression instanceof JetQualifiedExpression) { + JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) expression; + JetExpression selectorExpression = qualifiedExpression.getSelectorExpression(); + if (selectorExpression == null) { + return Pair.create(null, false); + } + Pair receiverId = getIdForStableIdentifier(qualifiedExpression.getReceiverExpression(), bindingContext, true); + Pair selectorId = getIdForStableIdentifier(selectorExpression, bindingContext, allowNamespaces); + return receiverId.second ? selectorId : Pair.create(receiverId.first, false); + } + if (expression instanceof JetSimpleNameExpression) { + JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression; + DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, simpleNameExpression); + if (declarationDescriptor instanceof VariableDescriptor) { + return Pair.create((Object) declarationDescriptor, isStableVariable((VariableDescriptor) declarationDescriptor)); + } + if (declarationDescriptor instanceof NamespaceDescriptor) { + return Pair.create((Object) declarationDescriptor, allowNamespaces); + } + if (declarationDescriptor instanceof ClassDescriptor) { + ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; + return Pair.create((Object) classDescriptor, classDescriptor.isClassObjectAValue()); + } + } + else if (expression instanceof JetThisExpression) { + JetThisExpression thisExpression = (JetThisExpression) expression; + DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, thisExpression.getInstanceReference()); + if (declarationDescriptor instanceof CallableDescriptor) { + return Pair.create((Object) ((CallableDescriptor) declarationDescriptor).getReceiverParameter(), true); + } + if (declarationDescriptor instanceof ClassDescriptor) { + return Pair.create((Object) ((ClassDescriptor) declarationDescriptor).getImplicitReceiver(), true); + } + return Pair.create(null, true); + } + else if (expression instanceof JetRootNamespaceExpression) { + return Pair.create((Object) JetModuleUtil.getRootNamespaceType(expression), allowNamespaces); + } + return Pair.create(null, false); + } + + @Nullable + public static VariableDescriptor getVariableDescriptorFromSimpleName(@NotNull BindingContext bindingContext, @NotNull JetExpression expression) { + JetExpression receiver = JetPsiUtil.deparenthesize(expression); + VariableDescriptor variableDescriptor = null; + if (receiver instanceof JetSimpleNameExpression) { + JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) receiver; + DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, nameExpression); + if (declarationDescriptor instanceof VariableDescriptor) { + variableDescriptor = (VariableDescriptor) declarationDescriptor; + } + } + return variableDescriptor; + } + + public static boolean isStableVariable(@NotNull VariableDescriptor variableDescriptor) { + if (variableDescriptor.isVar()) return false; + if (variableDescriptor instanceof PropertyDescriptor) { + PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variableDescriptor; + if (!isInternal(propertyDescriptor)) return false; + if (!isFinal(propertyDescriptor)) return false; + if (!hasDefaultGetter(propertyDescriptor)) return false; + } + return true; + } + + private static boolean isFinal(PropertyDescriptor propertyDescriptor) { + DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration(); + if (containingDeclaration instanceof ClassDescriptor) { + ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; + if (classDescriptor.getModality().isOverridable() && propertyDescriptor.getModality().isOverridable()) return false; + } + else { + assert !propertyDescriptor.getModality().isOverridable() : "Property outside a class must not be overridable"; + } + return true; + } + + private static boolean isInternal(@NotNull DeclarationDescriptorWithVisibility descriptor) { + if (Visibility.INTERNAL_VISIBILITIES.contains(descriptor.getVisibility())) return true; + + DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); + if (!(containingDeclaration instanceof DeclarationDescriptorWithVisibility)) { + return false; + } + + return isInternal((DeclarationDescriptorWithVisibility) containingDeclaration); + } + + private static boolean hasDefaultGetter(PropertyDescriptor propertyDescriptor) { + PropertyGetterDescriptor getter = propertyDescriptor.getGetter(); + return getter == null || getter.isDefault(); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/Nullability.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/Nullability.java new file mode 100644 index 00000000000..52582233db3 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/Nullability.java @@ -0,0 +1,83 @@ +package org.jetbrains.jet.lang.resolve.calls.autocasts; + +import org.jetbrains.annotations.NotNull; + +/** +* @author abreslav +*/ +public enum Nullability { + NULL(true, false), + NOT_NULL(false, true), + UNKNOWN(true, true), + IMPOSSIBLE(false, false); + + @NotNull + public static Nullability fromFlags(boolean canBeNull, boolean canBeNonNull) { + if (!canBeNull && !canBeNonNull) return IMPOSSIBLE; + if (!canBeNull && canBeNonNull) return NOT_NULL; + if (canBeNull && !canBeNonNull) return NULL; + return UNKNOWN; + } + + private final boolean canBeNull; + private final boolean canBeNonNull; + + Nullability(boolean canBeNull, boolean canBeNonNull) { + this.canBeNull = canBeNull; + this.canBeNonNull = canBeNonNull; + } + + public boolean canBeNull() { + return canBeNull; + } + + public boolean canBeNonNull() { + return canBeNonNull; + } + + @NotNull + public Nullability refine(@NotNull Nullability other) { + switch (this) { + case UNKNOWN: + return other; + case IMPOSSIBLE: + return other; + case NULL: + switch (other) { + case NOT_NULL: return NOT_NULL; + default: return NULL; + } + case NOT_NULL: + switch (other) { + case NULL: return NOT_NULL; + default: return NOT_NULL; + } + } + throw new IllegalStateException(); + } + + @NotNull + public Nullability invert() { + switch (this) { + case NULL: + return NOT_NULL; + case NOT_NULL: + return UNKNOWN; + case UNKNOWN: + return UNKNOWN; + case IMPOSSIBLE: + return UNKNOWN; + } + throw new IllegalStateException(); + } + + @NotNull + public Nullability and(@NotNull Nullability other) { + return fromFlags(this.canBeNull && other.canBeNull, this.canBeNonNull && other.canBeNonNull); + } + + @NotNull + public Nullability or(@NotNull Nullability other) { + return fromFlags(this.canBeNull || other.canBeNull, this.canBeNonNull || other.canBeNonNull); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java index 6e457d2ebce..d68055d33f3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java @@ -3,7 +3,6 @@ package org.jetbrains.jet.lang.resolve.scopes; import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import java.util.Collection; @@ -109,21 +108,6 @@ public class ChainedScope implements JetScope { return null; } - @Override - public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { - if (DescriptorUtils.definesItsOwnThis(getContainingDeclaration())) { - return getContainingDeclaration(); - } - - for (JetScope jetScope : scopeChain) { - DeclarationDescriptor containingDeclaration = jetScope.getContainingDeclaration(); - if (DescriptorUtils.definesItsOwnThis(containingDeclaration)) { - return containingDeclaration; - } - } - return null; - } - @NotNull @Override public Collection getAllDescriptors() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java index 6f4495e1bef..aa3123b79c8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java @@ -17,7 +17,7 @@ public interface JetScope { @NotNull @Override public DeclarationDescriptor getContainingDeclaration() { - throw new UnsupportedOperationException(); + throw new UnsupportedOperationException("Don't take containing declaration of the EMPTY scope"); } @Override @@ -51,9 +51,6 @@ public interface JetScope { @Nullable PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName); - @Nullable - DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis(); - @NotNull Collection getAllDescriptors(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java index b738d76a50c..589bee9496b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java @@ -51,11 +51,6 @@ public abstract class JetScopeImpl implements JetScope { return null; } - @Override - public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { - return null; - } - @NotNull @Override public Collection getAllDescriptors() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java index f09364216e1..a45bab80eda 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java @@ -109,12 +109,6 @@ public class SubstitutingScope implements JetScope { throw new UnsupportedOperationException(); // TODO } - @Override - @Nullable - public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { - return workerScope.getDeclarationDescriptorForUnqualifiedThis(); - } - @NotNull @Override public Collection getAllDescriptors() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java index 65e2693b630..81ee15a1873 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java @@ -1,10 +1,12 @@ package org.jetbrains.jet.lang.resolve.scopes; -import com.google.common.collect.*; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.SetMultimap; +import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.util.CommonSuppliers; @@ -51,14 +53,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { return ownerDeclarationDescriptor; } - @Override - public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { - if (DescriptorUtils.definesItsOwnThis(ownerDeclarationDescriptor)) { - return ownerDeclarationDescriptor; - } - return super.getDeclarationDescriptorForUnqualifiedThis(); - } - @Override public void importScope(@NotNull JetScope imported) { super.importScope(imported); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ClassReceiver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ClassReceiver.java index ac1ac9c5b4a..2f5f916a626 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ClassReceiver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ClassReceiver.java @@ -2,12 +2,13 @@ package org.jetbrains.jet.lang.resolve.scopes.receivers; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.types.JetType; /** * @author abreslav */ -public class ClassReceiver implements ReceiverDescriptor { +public class ClassReceiver implements ThisReceiverDescriptor { private final ClassDescriptor classDescriptor; @@ -26,6 +27,12 @@ public class ClassReceiver implements ReceiverDescriptor { return classDescriptor.getDefaultType(); } + @NotNull + @Override + public DeclarationDescriptor getDeclarationDescriptor() { + return classDescriptor; + } + @Override public R accept(@NotNull ReceiverDescriptorVisitor visitor, D data) { return visitor.visitClassReceiver(this, data); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExtensionReceiver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExtensionReceiver.java index 834b1420c42..ed7e876e29c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExtensionReceiver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExtensionReceiver.java @@ -2,15 +2,25 @@ package org.jetbrains.jet.lang.resolve.scopes.receivers; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.types.JetType; /** * @author abreslav */ -public class ExtensionReceiver extends ImplicitReceiverDescriptor { +public class ExtensionReceiver extends AbstractReceiverDescriptor implements ThisReceiverDescriptor { + + private final CallableDescriptor descriptor; public ExtensionReceiver(@NotNull CallableDescriptor callableDescriptor, @NotNull JetType receiverType) { - super(callableDescriptor, receiverType); + super(receiverType); + this.descriptor = callableDescriptor; + } + + @NotNull + @Override + public DeclarationDescriptor getDeclarationDescriptor() { + return descriptor; } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ImplicitReceiverDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ImplicitReceiverDescriptor.java deleted file mode 100644 index 4c566658f83..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ImplicitReceiverDescriptor.java +++ /dev/null @@ -1,25 +0,0 @@ -package org.jetbrains.jet.lang.resolve.scopes.receivers; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.types.JetType; - -/** - * Describes a "this" receiver - * - * @author abreslav - */ -public abstract class ImplicitReceiverDescriptor extends AbstractReceiverDescriptor { - private final DeclarationDescriptor declarationDescriptor; - - protected ImplicitReceiverDescriptor(@NotNull DeclarationDescriptor declarationDescriptor, @NotNull JetType receiverType) { - super(receiverType); - this.declarationDescriptor = declarationDescriptor; - } - - @NotNull - public DeclarationDescriptor getDeclarationDescriptor() { - return declarationDescriptor; - } -} - diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ThisReceiverDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ThisReceiverDescriptor.java new file mode 100644 index 00000000000..a6cff4192e5 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ThisReceiverDescriptor.java @@ -0,0 +1,15 @@ +package org.jetbrains.jet.lang.resolve.scopes.receivers; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; + +/** + * Describes a "this" receiver + * + * @author abreslav + */ +public interface ThisReceiverDescriptor extends ReceiverDescriptor { + @NotNull + DeclarationDescriptor getDeclarationDescriptor(); +} + diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java index 549684f6fc5..52af4480db1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java @@ -64,11 +64,6 @@ public class ErrorUtils { return null; // TODO : review } - @Override - public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { - return ERROR_CLASS; // TODO : review - } - @NotNull @Override public Collection getAllDescriptors() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java index 41774dc14c4..70db11221a4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java @@ -39,12 +39,12 @@ public class JetStandardClasses { @Override public Iterator iterator() { - throw new UnsupportedOperationException(); + throw new UnsupportedOperationException("Don't enumerate supertypes of Nothing"); } @Override public int size() { - throw new UnsupportedOperationException(); + throw new UnsupportedOperationException("Supertypes of Nothing do not constitute a valid collection"); } }, JetScope.EMPTY, @@ -278,8 +278,13 @@ public class JetStandardClasses { } public static boolean isNothing(@NotNull JetType type) { - return !(type instanceof NamespaceType) && - type.getConstructor() == NOTHING_CLASS.getTypeConstructor(); + return isNothingOrNullableNothing(type) + && !type.isNullable(); + } + + public static boolean isNothingOrNullableNothing(@NotNull JetType type) { + return !(type instanceof NamespaceType) + && type.getConstructor() == NOTHING_CLASS.getTypeConstructor(); } public static boolean isUnit(@NotNull JetType type) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeChecker.java index bd6ecce87ca..d3a36c2652c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeChecker.java @@ -81,7 +81,7 @@ public class JetTypeChecker { JetType type = iterator.next(); assert type != null; // TODO : This admits 'Nothing?'. Review - if (JetStandardClasses.isNothing(type)) { + if (JetStandardClasses.isNothingOrNullableNothing(type)) { iterator.remove(); } nullable |= type.isNullable(); @@ -564,7 +564,7 @@ public class JetTypeChecker { if (!supertype.isNullable() && subtype.isNullable()) { return fail(); } - if (JetStandardClasses.isNothing(subtype)) { + if (JetStandardClasses.isNothingOrNullableNothing(subtype)) { return StatusAction.DONE_WITH_CURRENT_TYPE; } return StatusAction.PROCEED; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index 0e69cc0ab93..74466a6e266 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.types.expressions; import com.google.common.collect.Lists; import com.intellij.lang.ASTNode; +import com.intellij.psi.PsiElement; import com.intellij.psi.tree.IElementType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -10,13 +11,15 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.CallMaker; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.constants.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ThisReceiverDescriptor; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lexer.JetTokens; @@ -49,7 +52,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } else { context.trace.record(REFERENCE_TARGET, expression, property); - return checkType(property.getOutType(), expression, context); + return DataFlowUtils.checkType(property.getOutType(), expression, context); } } else { @@ -74,14 +77,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (result == null) { return ErrorUtils.createErrorType("No class object in " + expression.getReferencedName()); } - return checkType(result, expression, context); + return DataFlowUtils.checkType(result, expression, context); } } JetType[] result = new JetType[1]; TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace); if (furtherNameLookup(expression, referencedName, result, context.replaceBindingTrace(temporaryTrace))) { temporaryTrace.commit(); - return checkType(result[0], expression, context); + return DataFlowUtils.checkType(result[0], expression, context); } // To report NO_CLASS_OBJECT when no namespace found if (classifier != null) { @@ -122,7 +125,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (innerExpression == null) { return null; } - return checkType(facade.getType(innerExpression, context.replaceScope(context.scope)), expression, context); + return DataFlowUtils.checkType(facade.getType(innerExpression, context.replaceScope(context.scope)), expression, context); } @Override @@ -162,7 +165,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } else { context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, value); - return checkType(value.getType(standardLibrary), expression, context); + return DataFlowUtils.checkType(value.getType(standardLibrary), expression, context); } } @@ -197,7 +200,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { else { facade.getType(expression.getLeft(), context.replaceExpectedType(NO_EXPECTED_TYPE)); } - return checkType(result, expression, context); + return DataFlowUtils.checkType(result, expression, context); } private boolean checkBinaryWithTypeRHS(JetBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context, @NotNull JetType targetType, @NotNull JetType expectedType, TemporaryBindingTrace temporaryTrace) { @@ -259,7 +262,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } } // TODO : labels - return checkType(JetStandardClasses.getTupleType(types), expression, context); + return DataFlowUtils.checkType(JetStandardClasses.getTupleType(types), expression, context); } @NotNull @@ -269,7 +272,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } List result = Lists.newArrayListWithCapacity(arguments.size()); for (int i = 0, argumentTypesSize = argumentTypes.size(); i < argumentTypesSize; i++) { - result.add(checkType(argumentTypes.get(i), arguments.get(i), context.replaceExpectedType(expectedArgumentTypes.get(i).getType()))); + result.add(DataFlowUtils.checkType(argumentTypes.get(i), arguments.get(i), context.replaceExpectedType(expectedArgumentTypes.get(i).getType()))); } return result; } @@ -277,60 +280,130 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Override public JetType visitThisExpression(JetThisExpression expression, ExpressionTypingContext context) { JetType result = null; - ReceiverDescriptor thisReceiver = null; - String labelName = expression.getLabelName(); - if (labelName != null) { - thisReceiver = context.labelResolver.resolveThisLabel(expression, context, thisReceiver, labelName); - } - else { - thisReceiver = context.scope.getImplicitReceiver(); - - DeclarationDescriptor declarationDescriptorForUnqualifiedThis = context.scope.getDeclarationDescriptorForUnqualifiedThis(); - if (declarationDescriptorForUnqualifiedThis != null) { - context.trace.record(REFERENCE_TARGET, expression.getThisReference(), declarationDescriptorForUnqualifiedThis); - } - } + ReceiverDescriptor thisReceiver = resolveToReceiver(expression, context, false); if (thisReceiver != null) { if (!thisReceiver.exists()) { context.trace.report(NO_THIS.on(expression)); } else { - JetTypeReference superTypeQualifier = expression.getSuperTypeQualifier(); - if (superTypeQualifier != null) { - JetTypeElement superTypeElement = superTypeQualifier.getTypeElement(); - // Errors are reported by the parser - if (superTypeElement instanceof JetUserType) { - JetUserType typeElement = (JetUserType) superTypeElement; + result = thisReceiver.getType(); + context.trace.record(BindingContext.EXPRESSION_TYPE, expression.getInstanceReference(), result); + } + } + return DataFlowUtils.checkType(result, expression, context); + } - ClassifierDescriptor classifierCandidate = context.getTypeResolver().resolveClass(context.scope, typeElement); - if (classifierCandidate instanceof ClassDescriptor) { - ClassDescriptor superclass = (ClassDescriptor) classifierCandidate; + @Override + public JetType visitSuperExpression(JetSuperExpression expression, ExpressionTypingContext context) { + if (!context.namespacesAllowed) { + context.trace.report(SUPER_IS_NOT_AN_EXPRESSION.on(expression, expression.getText())); + return null; + } + JetType result = null; - JetType thisType = thisReceiver.getType(); - Collection supertypes = thisType.getConstructor().getSupertypes(); - TypeSubstitutor substitutor = TypeSubstitutor.create(thisType); - for (JetType declaredSupertype : supertypes) { - if (declaredSupertype.getConstructor().equals(superclass.getTypeConstructor())) { - result = substitutor.safeSubstitute(declaredSupertype, Variance.INVARIANT); - break; - } - } - if (result == null) { - context.trace.report(NOT_A_SUPERTYPE.on(superTypeElement)); - } - } + ReceiverDescriptor thisReceiver = resolveToReceiver(expression, context, true); + if (thisReceiver == null) return null; + + if (!thisReceiver.exists()) { + context.trace.report(SUPER_NOT_AVAILABLE.on(expression)); + } + else { + JetType thisType = thisReceiver.getType(); + Collection supertypes = thisType.getConstructor().getSupertypes(); + TypeSubstitutor substitutor = TypeSubstitutor.create(thisType); + + JetTypeReference superTypeQualifier = expression.getSuperTypeQualifier(); + if (superTypeQualifier != null) { + JetTypeElement typeElement = superTypeQualifier.getTypeElement(); + + DeclarationDescriptor classifierCandidate = null; + JetType supertype = null; + PsiElement redundantTypeArguments = null; + if (typeElement instanceof JetUserType) { + JetUserType userType = (JetUserType) typeElement; + // This may be just a superclass name even if the superclass is generic + if (userType.getTypeArguments().isEmpty()) { + classifierCandidate = context.getTypeResolver().resolveClass(context.scope, userType); + } + else { + supertype = context.getTypeResolver().resolveType(context.scope, superTypeQualifier); + redundantTypeArguments = userType.getTypeArgumentList(); } } else { - result = thisReceiver.getType(); + supertype = context.getTypeResolver().resolveType(context.scope, superTypeQualifier); } - if (result != null) { - context.trace.record(BindingContext.EXPRESSION_TYPE, expression.getThisReference(), result); + + if (supertype != null) { + if (supertypes.contains(supertype)) { + result = supertype; + } + } + else if (classifierCandidate instanceof ClassDescriptor) { + ClassDescriptor superclass = (ClassDescriptor) classifierCandidate; + + for (JetType declaredSupertype : supertypes) { + if (declaredSupertype.getConstructor().equals(superclass.getTypeConstructor())) { + result = substitutor.safeSubstitute(declaredSupertype, Variance.INVARIANT); + break; + } + } + } + + boolean validClassifier = classifierCandidate != null && !ErrorUtils.isError(classifierCandidate); + boolean validType = supertype != null && !ErrorUtils.isErrorType(supertype); + if (result == null && (validClassifier || validType)) { + context.trace.report(NOT_A_SUPERTYPE.on(superTypeQualifier)); + } + else if (redundantTypeArguments != null) { + context.trace.report(TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER.on(redundantTypeArguments)); } } + else { + if (supertypes.size() > 1) { + context.trace.report(AMBIGUOUS_SUPER.on(expression)); + } + else { + // supertypes may be empty when all the supertypes are error types (are not resolved, for example) + JetType type = supertypes.isEmpty() ? JetStandardClasses.getAnyType() : supertypes.iterator().next(); + result = substitutor.substitute(type, Variance.INVARIANT); + } + } + if (result != null) { + context.trace.record(BindingContext.EXPRESSION_TYPE, expression.getInstanceReference(), result); + context.trace.record(BindingContext.REFERENCE_TARGET, expression.getInstanceReference(), result.getConstructor().getDeclarationDescriptor()); + } } - return checkType(result, expression, context); + return DataFlowUtils.checkType(result, expression, context); + } + + @Nullable // No class receivers + private ReceiverDescriptor resolveToReceiver(JetLabelQualifiedInstanceExpression expression, ExpressionTypingContext context, boolean onlyClassReceivers) { + ReceiverDescriptor thisReceiver = null; + String labelName = expression.getLabelName(); + if (labelName != null) { + thisReceiver = context.labelResolver.resolveThisLabel(expression.getInstanceReference(), expression.getTargetLabel(), context, thisReceiver, labelName); + } + else { + if (onlyClassReceivers) { + List receivers = Lists.newArrayList(); + context.scope.getImplicitReceiversHierarchy(receivers); + for (ReceiverDescriptor receiver : receivers) { + if (receiver instanceof ClassReceiver) { + thisReceiver = receiver; + break; + } + } + } + else { + thisReceiver = context.scope.getImplicitReceiver(); + } + if (thisReceiver instanceof ThisReceiverDescriptor) { + context.trace.record(REFERENCE_TARGET, expression.getInstanceReference(), ((ThisReceiverDescriptor) thisReceiver).getDeclarationDescriptor()); + } + } + return thisReceiver; } @Override @@ -386,7 +459,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (result != null) { context.trace.record(BindingContext.EXPRESSION_TYPE, selectorExpression, result); } - return checkType(result, expression, contextWithExpectedType); + return DataFlowUtils.checkType(result, expression, contextWithExpectedType); } private void propagateConstantValues(JetQualifiedExpression expression, ExpressionTypingContext context, JetSimpleNameExpression selectorExpression) { @@ -432,14 +505,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { VariableDescriptor variableDescriptor = context.replaceBindingTrace(temporaryTrace).resolveSimpleProperty(receiver, callOperationNode, nameExpression); if (variableDescriptor != null) { temporaryTrace.commit(); - return checkType(variableDescriptor.getOutType(), nameExpression, context); + return DataFlowUtils.checkType(variableDescriptor.getOutType(), nameExpression, context); } ExpressionTypingContext newContext = receiver.exists() ? context.replaceScope(receiver.getType().getMemberScope()) : context; JetType jetType = lookupNamespaceOrClassObject(nameExpression, nameExpression.getReferencedName(), newContext); if (jetType == null) { context.trace.report(UNRESOLVED_REFERENCE.on(nameExpression)); } - return checkType(jetType, nameExpression, context); + return DataFlowUtils.checkType(jetType, nameExpression, context); } else if (selectorExpression instanceof JetQualifiedExpression) { JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) selectorExpression; @@ -460,7 +533,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Override public JetType visitCallExpression(JetCallExpression expression, ExpressionTypingContext context) { JetType expressionType = context.resolveCall(NO_RECEIVER, null, expression); - return checkType(expressionType, expression, context); + return DataFlowUtils.checkType(expressionType, expression, context); } @Override @@ -473,7 +546,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { referencedName = referencedName == null ? " " : referencedName; context.labelResolver.enterLabeledElement(referencedName.substring(1), baseExpression); // TODO : Some processing for the label? - JetType type = checkType(facade.getType(baseExpression, context.replaceExpectedReturnType(context.expectedType)), expression, context); + JetType type = DataFlowUtils.checkType(facade.getType(baseExpression, context.replaceExpectedReturnType(context.expectedType)), expression, context); context.labelResolver.exitLabeledElement(baseExpression); return type; } @@ -516,7 +589,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { result = returnType; } - return checkType(result, expression, context); + return DataFlowUtils.checkType(result, expression, context); } @Override @@ -599,7 +672,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { else if (operationType == JetTokens.ANDAND || operationType == JetTokens.OROR) { JetType leftType = facade.getType(left, context.replaceScope(context.scope)); WritableScopeImpl leftScope = newWritableScopeImpl(context).setDebugName("Left scope of && or ||"); - DataFlowInfo flowInfoLeft = extractDataFlowInfoFromCondition(left, operationType == JetTokens.ANDAND, leftScope, context); // TODO: This gets computed twice: here and in extractDataFlowInfoFromCondition() for the whole condition + DataFlowInfo flowInfoLeft = DataFlowUtils.extractDataFlowInfoFromCondition(left, operationType == JetTokens.ANDAND, leftScope, context); // TODO: This gets computed twice: here and in extractDataFlowInfoFromCondition() for the whole condition WritableScopeImpl rightScope = operationType == JetTokens.ANDAND ? leftScope : newWritableScopeImpl(context).setDebugName("Right scope of && or ||"); JetType rightType = right == null ? null : facade.getType(right, context.replaceDataFlowInfo(flowInfoLeft).replaceScope(rightScope)); if (leftType != null && !isBoolean(context.semanticServices, leftType)) { @@ -618,7 +691,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { context.trace.report(USELESS_ELVIS.on(expression, left, leftType)); } if (rightType != null) { - checkType(TypeUtils.makeNullableAsSpecified(leftType, rightType.isNullable()), left, contextWithExpectedType); + DataFlowUtils.checkType(TypeUtils.makeNullableAsSpecified(leftType, rightType.isNullable()), left, contextWithExpectedType); return TypeUtils.makeNullableAsSpecified(context.semanticServices.getTypeChecker().commonSupertype(leftType, rightType), rightType.isNullable()); } } @@ -626,7 +699,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { else { context.trace.report(UNSUPPORTED.on(operationSign, "Unknown operation")); } - return checkType(result, expression, contextWithExpectedType); + return DataFlowUtils.checkType(result, expression, contextWithExpectedType); } public void checkInExpression(JetElement callElement, @NotNull JetSimpleNameExpression operationSign, @NotNull JetExpression left, @NotNull JetExpression right, ExpressionTypingContext context) { @@ -685,7 +758,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { "get", receiver); if (functionDescriptor != null) { - return checkType(functionDescriptor.getReturnType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(functionDescriptor.getReturnType(), expression, contextWithExpectedType); } } return null; @@ -714,7 +787,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Override public JetType visitRootNamespaceExpression(JetRootNamespaceExpression expression, ExpressionTypingContext context) { if (context.namespacesAllowed) { - return ExpressionTypingUtils.checkType(JetModuleUtil.getRootNamespaceType(expression), expression, context); + return DataFlowUtils.checkType(JetModuleUtil.getRootNamespaceType(expression), expression, context); } context.trace.report(NAMESPACE_IS_NOT_AN_EXPRESSION.on(expression)); return null; @@ -764,7 +837,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (value[0] != CompileTimeConstantResolver.OUT_OF_RANGE) { context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new StringValue(builder.toString())); } - return checkType(context.semanticServices.getStandardLibrary().getStringType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(context.semanticServices.getStandardLibrary().getStringType(), expression, contextWithExpectedType); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 1a0f7412042..e0b992f735e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -55,7 +55,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { ObservableBindingTrace traceAdapter = new ObservableBindingTrace(context.trace); traceAdapter.addHandler(CLASS, handler); TopDownAnalyzer.processObject(context.semanticServices, traceAdapter, context.scope, context.scope.getContainingDeclaration(), expression.getObjectDeclaration()); - return ExpressionTypingUtils.checkType(result[0], expression, context); + return DataFlowUtils.checkType(result[0], expression, context); } @Override @@ -152,11 +152,11 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { JetType expectedReturnType = JetStandardClasses.getReturnType(expectedType); if (JetStandardClasses.isUnit(expectedReturnType)) { functionDescriptor.setReturnType(expectedReturnType); - return ExpressionTypingUtils.checkType(JetStandardClasses.getFunctionType(Collections.emptyList(), effectiveReceiverType, parameterTypes, expectedReturnType), expression, context); + return DataFlowUtils.checkType(JetStandardClasses.getFunctionType(Collections.emptyList(), effectiveReceiverType, parameterTypes, expectedReturnType), expression, context); } } - return ExpressionTypingUtils.checkType(JetStandardClasses.getFunctionType(Collections.emptyList(), effectiveReceiverType, parameterTypes, safeReturnType), expression, context); + return DataFlowUtils.checkType(JetStandardClasses.getFunctionType(Collections.emptyList(), effectiveReceiverType, parameterTypes, safeReturnType), expression, context); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index 8d915dbe9b0..c2ca77a049e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java @@ -7,7 +7,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -65,8 +65,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetExpression thenBranch = expression.getThen(); WritableScopeImpl thenScope = newWritableScopeImpl(context).setDebugName("Then scope"); - DataFlowInfo thenInfo = extractDataFlowInfoFromCondition(condition, true, thenScope, context); - DataFlowInfo elseInfo = extractDataFlowInfoFromCondition(condition, false, null, context); + DataFlowInfo thenInfo = DataFlowUtils.extractDataFlowInfoFromCondition(condition, true, thenScope, context); + DataFlowInfo elseInfo = DataFlowUtils.extractDataFlowInfoFromCondition(condition, false, null, context); if (elseBranch == null) { if (thenBranch != null) { @@ -75,7 +75,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { facade.setResultingDataFlowInfo(elseInfo); // resultScope = elseScope; } - return checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); } return null; } @@ -85,7 +85,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { facade.setResultingDataFlowInfo(thenInfo); // resultScope = thenScope; } - return checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); } JetType thenType = getTypeWithNewScopeAndDataFlowInfo(thenScope, thenBranch, thenInfo, contextWithExpectedType); JetType elseType = getTypeWithNewScopeAndDataFlowInfo(context.scope, elseBranch, elseInfo, contextWithExpectedType); @@ -121,13 +121,13 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetExpression body = expression.getBody(); if (body != null) { WritableScopeImpl scopeToExtend = newWritableScopeImpl(context).setDebugName("Scope extended in while's condition"); - DataFlowInfo conditionInfo = condition == null ? context.dataFlowInfo : extractDataFlowInfoFromCondition(condition, true, scopeToExtend, context); + DataFlowInfo conditionInfo = condition == null ? context.dataFlowInfo : DataFlowUtils.extractDataFlowInfoFromCondition(condition, true, scopeToExtend, context); getTypeWithNewScopeAndDataFlowInfo(scopeToExtend, body, conditionInfo, context); } if (!containsBreak(expression, context)) { - facade.setResultingDataFlowInfo(extractDataFlowInfoFromCondition(condition, false, null, context)); + facade.setResultingDataFlowInfo(DataFlowUtils.extractDataFlowInfoFromCondition(condition, false, null, context)); } - return checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); } private boolean containsBreak(final JetLoopExpression loopExpression, final ExpressionTypingContext context) { @@ -178,9 +178,9 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetExpression condition = expression.getCondition(); checkCondition(conditionScope, condition, context); if (!containsBreak(expression, context)) { - facade.setResultingDataFlowInfo(extractDataFlowInfoFromCondition(condition, false, null, context)); + facade.setResultingDataFlowInfo(DataFlowUtils.extractDataFlowInfoFromCondition(condition, false, null, context)); } - return checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); } @Override @@ -225,7 +225,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { facade.getType(body, context.replaceScope(loopScope)); } - return checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); } @Nullable @@ -372,7 +372,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetType type = facade.getType(thrownExpression, context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).replaceScope(context.scope)); // TODO : check that it inherits Throwable } - return checkType(JetStandardClasses.getNothingType(), expression, context); + return DataFlowUtils.checkType(JetStandardClasses.getNothingType(), expression, context); } @Override @@ -395,19 +395,19 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { context.trace.report(RETURN_TYPE_MISMATCH.on(expression, context.expectedReturnType)); } } - return checkType(JetStandardClasses.getNothingType(), expression, context); + return DataFlowUtils.checkType(JetStandardClasses.getNothingType(), expression, context); } @Override public JetType visitBreakExpression(JetBreakExpression expression, ExpressionTypingContext context) { context.labelResolver.recordLabel(expression, context); - return checkType(JetStandardClasses.getNothingType(), expression, context); + return DataFlowUtils.checkType(JetStandardClasses.getNothingType(), expression, context); } @Override public JetType visitContinueExpression(JetContinueExpression expression, ExpressionTypingContext context) { context.labelResolver.recordLabel(expression, context); - return checkType(JetStandardClasses.getNothingType(), expression, context); + return DataFlowUtils.checkType(JetStandardClasses.getNothingType(), expression, context); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java new file mode 100644 index 00000000000..f7980849808 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java @@ -0,0 +1,157 @@ +package org.jetbrains.jet.lang.types.expressions; + +import com.intellij.openapi.util.Ref; +import com.intellij.psi.tree.IElementType; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValue; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValueFactory; +import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.JetTypeChecker; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lexer.JetTokens; + +import java.util.List; + +import static org.jetbrains.jet.lang.diagnostics.Errors.AUTOCAST_IMPOSSIBLE; +import static org.jetbrains.jet.lang.diagnostics.Errors.TYPE_MISMATCH; +import static org.jetbrains.jet.lang.resolve.BindingContext.AUTOCAST; + +/** + * @author abreslav + */ +public class DataFlowUtils { + @NotNull + public static DataFlowInfo extractDataFlowInfoFromCondition(@Nullable JetExpression condition, final boolean conditionValue, @Nullable final WritableScope scopeToExtend, final ExpressionTypingContext context) { + if (condition == null) return context.dataFlowInfo; + final Ref result = new Ref(context.dataFlowInfo); + condition.accept(new JetVisitorVoid() { + @Override + public void visitIsExpression(JetIsExpression expression) { + if (conditionValue && !expression.isNegated() || !conditionValue && expression.isNegated()) { + JetPattern pattern = expression.getPattern(); + result.set(context.patternsToDataFlowInfo.get(pattern)); + if (scopeToExtend != null) { + List descriptors = context.patternsToBoundVariableLists.get(pattern); + if (descriptors != null) { + for (VariableDescriptor variableDescriptor : descriptors) { + scopeToExtend.addVariableDescriptor(variableDescriptor); + } + } + } + } + } + + @Override + public void visitBinaryExpression(JetBinaryExpression expression) { + IElementType operationToken = expression.getOperationToken(); + if (operationToken == JetTokens.ANDAND || operationToken == JetTokens.OROR) { + WritableScope actualScopeToExtend; + if (operationToken == JetTokens.ANDAND) { + actualScopeToExtend = conditionValue ? scopeToExtend : null; + } + else { + actualScopeToExtend = conditionValue ? null : scopeToExtend; + } + + DataFlowInfo dataFlowInfo = extractDataFlowInfoFromCondition(expression.getLeft(), conditionValue, actualScopeToExtend, context); + JetExpression expressionRight = expression.getRight(); + if (expressionRight != null) { + DataFlowInfo rightInfo = extractDataFlowInfoFromCondition(expressionRight, conditionValue, actualScopeToExtend, context); + DataFlowInfo.CompositionOperator operator; + if (operationToken == JetTokens.ANDAND) { + operator = conditionValue ? DataFlowInfo.AND : DataFlowInfo.OR; + } + else { + operator = conditionValue ? DataFlowInfo.OR : DataFlowInfo.AND; + } + dataFlowInfo = operator.compose(dataFlowInfo, rightInfo); + } + result.set(dataFlowInfo); + } + else { + JetExpression left = expression.getLeft(); + JetExpression right = expression.getRight(); + if (right == null) return; + + JetType lhsType = context.trace.getBindingContext().get(BindingContext.EXPRESSION_TYPE, left); + if (lhsType == null) return; + JetType rhsType = context.trace.getBindingContext().get(BindingContext.EXPRESSION_TYPE, right); + if (rhsType == null) return; + + BindingContext bindingContext = context.trace.getBindingContext(); + DataFlowValue leftValue = DataFlowValueFactory.INSTANCE.createDataFlowValue(left, lhsType, bindingContext); + DataFlowValue rightValue = DataFlowValueFactory.INSTANCE.createDataFlowValue(right, rhsType, bindingContext); + + Boolean equals = null; + if (operationToken == JetTokens.EQEQ || operationToken == JetTokens.EQEQEQ) { + equals = true; + } + else if (operationToken == JetTokens.EXCLEQ || operationToken == JetTokens.EXCLEQEQEQ) { + equals = false; + } + if (equals != null) { + if (equals == conditionValue) { // this means: equals && conditionValue || !equals && !conditionValue + result.set(context.dataFlowInfo.equate(leftValue, rightValue)); + } + else { + result.set(context.dataFlowInfo.disequate(leftValue, rightValue)); + } + + } + } + } + + @Override + public void visitUnaryExpression(JetUnaryExpression expression) { + IElementType operationTokenType = expression.getOperationSign().getReferencedNameElementType(); + if (operationTokenType == JetTokens.EXCL) { + JetExpression baseExpression = expression.getBaseExpression(); + if (baseExpression != null) { + result.set(extractDataFlowInfoFromCondition(baseExpression, !conditionValue, scopeToExtend, context)); + } + } + } + + @Override + public void visitParenthesizedExpression(JetParenthesizedExpression expression) { + JetExpression body = expression.getExpression(); + if (body != null) { + body.accept(this); + } + } + }); + if (result.get() == null) { + return context.dataFlowInfo; + } + return result.get(); + } + + @Nullable + public static JetType checkType(@Nullable JetType expressionType, @NotNull JetExpression expression, @NotNull ExpressionTypingContext context) { + if (expressionType == null || context.expectedType == null || context.expectedType == TypeUtils.NO_EXPECTED_TYPE || + context.semanticServices.getTypeChecker().isSubtypeOf(expressionType, context.expectedType)) { + return expressionType; + } + + DataFlowValue dataFlowValue = DataFlowValueFactory.INSTANCE.createDataFlowValue(expression, expressionType, context.trace.getBindingContext()); + for (JetType possibleType : context.dataFlowInfo.getPossibleTypes(dataFlowValue)) { + if (JetTypeChecker.INSTANCE.isSubtypeOf(possibleType, context.expectedType)) { + if (dataFlowValue.isStableIdentifier()) { + context.trace.record(AUTOCAST, expression, possibleType); + } + else { + context.trace.report(AUTOCAST_IMPOSSIBLE.on(expression, possibleType, expression.getText())); + } + return possibleType; + } + } + context.trace.report(TYPE_MISMATCH.on(expression, context.expectedType, expressionType)); + return expressionType; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java index 68a1be872b1..c84fbf93516 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java @@ -12,7 +12,7 @@ import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver; 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.DataFlowInfo; +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; @@ -65,6 +65,7 @@ import java.util.Map; public final Map> patternsToBoundVariableLists; public final LabelResolver labelResolver; + // true for positions on the lhs of a '.', i.e. allows namespace results and 'super' public final boolean namespacesAllowed; private CallResolver callResolver; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingInternals.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingInternals.java index 8dff3d7a264..200174c6bc5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingInternals.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingInternals.java @@ -6,7 +6,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java index c4e0141a02f..aacb5b29402 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java @@ -14,7 +14,7 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; @@ -56,7 +56,7 @@ public class ExpressionTypingServices { ExpressionTypingContext context = ExpressionTypingContext.newContext( semanticServices, new HashMap(), new HashMap>(), new LabelResolver(), - trace, scope, DataFlowInfo.getEmpty(), expectedType, FORBIDDEN, false + trace, scope, DataFlowInfo.EMPTY, expectedType, FORBIDDEN, false ); return expressionTypingFacade.getType(expression, context); } @@ -65,14 +65,14 @@ public class ExpressionTypingServices { ExpressionTypingContext context = ExpressionTypingContext.newContext( semanticServices, new HashMap(), new HashMap>(), new LabelResolver(), - trace, scope, DataFlowInfo.getEmpty(), NO_EXPECTED_TYPE, FORBIDDEN, + trace, scope, DataFlowInfo.EMPTY, NO_EXPECTED_TYPE, FORBIDDEN, true); return expressionTypingFacade.getType(expression, context); // return ((ExpressionTypingContext) ExpressionTyperVisitorWithNamespaces).INSTANCE.getType(expression, ExpressionTypingContext.newRootContext(semanticServices, trace, scope, DataFlowInfo.getEmpty(), TypeUtils.NO_EXPECTED_TYPE, TypeUtils.NO_EXPECTED_TYPE)); } public void checkFunctionReturnType(@NotNull JetScope outerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor) { - checkFunctionReturnType(outerScope, function, functionDescriptor, DataFlowInfo.getEmpty()); + checkFunctionReturnType(outerScope, function, functionDescriptor, DataFlowInfo.EMPTY); } @NotNull @@ -87,7 +87,7 @@ public class ExpressionTypingServices { public void checkFunctionReturnType(JetScope functionInnerScope, JetDeclarationWithBody function, @NotNull final JetType expectedReturnType) { checkFunctionReturnType(function, ExpressionTypingContext.newContext( semanticServices, new HashMap(), new HashMap>(), new LabelResolver(), - trace, functionInnerScope, DataFlowInfo.getEmpty(), NO_EXPECTED_TYPE, expectedReturnType, false + trace, functionInnerScope, DataFlowInfo.EMPTY, NO_EXPECTED_TYPE, expectedReturnType, false )); } @@ -128,7 +128,7 @@ public class ExpressionTypingServices { /*package*/ JetType getBlockReturnedType(@NotNull JetScope outerScope, @NotNull JetBlockExpression expression, @NotNull CoercionStrategy coercionStrategyForLastExpression, ExpressionTypingContext context) { List block = expression.getStatements(); if (block.isEmpty()) { - return ExpressionTypingUtils.checkType(JetStandardClasses.getUnitType(), expression, context); + return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, context); } DeclarationDescriptor containingDescriptor = outerScope.getContainingDeclaration(); @@ -145,7 +145,7 @@ public class ExpressionTypingServices { assert bodyExpression != null; JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(outerScope, functionDescriptor, trace); expressionTypingFacade.getType(bodyExpression, ExpressionTypingContext.newContext(semanticServices, new HashMap(), new HashMap>(), new LabelResolver(), - trace, functionInnerScope, DataFlowInfo.getEmpty(), NO_EXPECTED_TYPE, FORBIDDEN, false)); + trace, functionInnerScope, DataFlowInfo.EMPTY, NO_EXPECTED_TYPE, FORBIDDEN, false)); //todo function literals final Collection returnedExpressions = Lists.newArrayList(); if (function.hasBlockBody()) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 1b181c887b0..b95fe53a31c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -9,23 +9,16 @@ import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.lang.resolve.TraceBasedRedeclarationHandler; -import org.jetbrains.jet.lang.resolve.calls.AutoCastUtils; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValueFactory; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.types.JetStandardClasses; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lexer.JetTokens; - -import java.util.List; import static org.jetbrains.jet.lang.diagnostics.Errors.RESULT_TYPE_MISMATCH; -import static org.jetbrains.jet.lang.diagnostics.Errors.TYPE_MISMATCH; import static org.jetbrains.jet.lang.resolve.BindingContext.MUST_BE_WRAPPED_IN_A_REF; /** @@ -97,140 +90,6 @@ public class ExpressionTypingUtils { } } - @NotNull - public static DataFlowInfo extractDataFlowInfoFromCondition(@Nullable JetExpression condition, final boolean conditionValue, @Nullable final WritableScope scopeToExtend, final ExpressionTypingContext context) { - if (condition == null) return context.dataFlowInfo; - final DataFlowInfo[] result = new DataFlowInfo[] {context.dataFlowInfo}; - condition.accept(new JetVisitorVoid() { - @Override - public void visitIsExpression(JetIsExpression expression) { - if (conditionValue && !expression.isNegated() || !conditionValue && expression.isNegated()) { - JetPattern pattern = expression.getPattern(); - result[0] = context.patternsToDataFlowInfo.get(pattern); - if (scopeToExtend != null) { - List descriptors = context.patternsToBoundVariableLists.get(pattern); - if (descriptors != null) { - for (VariableDescriptor variableDescriptor : descriptors) { - scopeToExtend.addVariableDescriptor(variableDescriptor); - } - } - } - } - } - - @Override - public void visitBinaryExpression(JetBinaryExpression expression) { - IElementType operationToken = expression.getOperationToken(); - if (operationToken == JetTokens.ANDAND || operationToken == JetTokens.OROR) { - WritableScope actualScopeToExtend; - if (operationToken == JetTokens.ANDAND) { - actualScopeToExtend = conditionValue ? scopeToExtend : null; - } - else { - actualScopeToExtend = conditionValue ? null : scopeToExtend; - } - - DataFlowInfo dataFlowInfo = extractDataFlowInfoFromCondition(expression.getLeft(), conditionValue, actualScopeToExtend, context); - JetExpression expressionRight = expression.getRight(); - if (expressionRight != null) { - DataFlowInfo rightInfo = extractDataFlowInfoFromCondition(expressionRight, conditionValue, actualScopeToExtend, context); - DataFlowInfo.CompositionOperator operator; - if (operationToken == JetTokens.ANDAND) { - operator = conditionValue ? DataFlowInfo.AND : DataFlowInfo.OR; - } - else { - operator = conditionValue ? DataFlowInfo.OR : DataFlowInfo.AND; - } - dataFlowInfo = operator.compose(dataFlowInfo, rightInfo); - } - result[0] = dataFlowInfo; - } - else if (operationToken == JetTokens.EQEQ - || operationToken == JetTokens.EXCLEQ - || operationToken == JetTokens.EQEQEQ - || operationToken == JetTokens.EXCLEQEQEQ) { - JetExpression left = expression.getLeft(); - JetExpression right = expression.getRight(); - if (right == null) return; - - if (!(left instanceof JetSimpleNameExpression)) { - JetExpression tmp = left; - left = right; - right = tmp; - - if (!(left instanceof JetSimpleNameExpression)) { - return; - } - } - - VariableDescriptor variableDescriptor = AutoCastUtils.getVariableDescriptorFromSimpleName(context.trace.getBindingContext(), left); - if (variableDescriptor == null) return; - - // TODO : validate that DF makes sense for this variable: local, val, internal w/backing field, etc - - // Comparison to a non-null expression - JetType rhsType = context.trace.getBindingContext().get(BindingContext.EXPRESSION_TYPE, right); - if (rhsType != null && !rhsType.isNullable()) { - extendDataFlowWithNullComparison(operationToken, variableDescriptor, !conditionValue); - return; - } - - VariableDescriptor rightVariable = AutoCastUtils.getVariableDescriptorFromSimpleName(context.trace.getBindingContext(), right); - if (rightVariable != null) { - JetType lhsType = context.trace.getBindingContext().get(BindingContext.EXPRESSION_TYPE, left); - if (lhsType != null && !lhsType.isNullable()) { - extendDataFlowWithNullComparison(operationToken, rightVariable, !conditionValue); - return; - } - } - - // Comparison to 'null' - if (!(right instanceof JetConstantExpression)) { - return; - } - JetConstantExpression constantExpression = (JetConstantExpression) right; - if (constantExpression.getNode().getElementType() != JetNodeTypes.NULL) { - return; - } - - extendDataFlowWithNullComparison(operationToken, variableDescriptor, conditionValue); - } - } - - private void extendDataFlowWithNullComparison(IElementType operationToken, @NotNull VariableDescriptor variableDescriptor, boolean equalsToNull) { - if (operationToken == JetTokens.EQEQ || operationToken == JetTokens.EQEQEQ) { - result[0] = context.dataFlowInfo.equalsToNull(variableDescriptor, !equalsToNull); - } - else if (operationToken == JetTokens.EXCLEQ || operationToken == JetTokens.EXCLEQEQEQ) { - result[0] = context.dataFlowInfo.equalsToNull(variableDescriptor, equalsToNull); - } - } - - @Override - public void visitUnaryExpression(JetUnaryExpression expression) { - IElementType operationTokenType = expression.getOperationSign().getReferencedNameElementType(); - if (operationTokenType == JetTokens.EXCL) { - JetExpression baseExpression = expression.getBaseExpression(); - if (baseExpression != null) { - result[0] = extractDataFlowInfoFromCondition(baseExpression, !conditionValue, scopeToExtend, context); - } - } - } - - @Override - public void visitParenthesizedExpression(JetParenthesizedExpression expression) { - JetExpression body = expression.getExpression(); - if (body != null) { - body.accept(this); - } - } - }); - if (result[0] == null) { - return context.dataFlowInfo; - } - return result[0]; - } - public static boolean isTypeFlexible(@Nullable JetExpression expression) { if (expression == null) return false; @@ -240,23 +99,10 @@ public class ExpressionTypingUtils { ).contains(expression.getNode().getElementType()); } - @Nullable - public static JetType checkType(@Nullable JetType expressionType, @NotNull JetExpression expression, @NotNull ExpressionTypingContext context) { - if (expressionType == null || context.expectedType == null || context.expectedType == TypeUtils.NO_EXPECTED_TYPE || - context.semanticServices.getTypeChecker().isSubtypeOf(expressionType, context.expectedType)) { - return expressionType; - } - if (AutoCastUtils.castExpression(expression, context.expectedType, context.dataFlowInfo, context.trace) == null) { - context.trace.report(TYPE_MISMATCH.on(expression, context.expectedType, expressionType)); - return expressionType; - } - return context.expectedType; - } - public static void checkWrappingInRef(JetExpression expression, ExpressionTypingContext context) { if (!(expression instanceof JetSimpleNameExpression)) return; JetSimpleNameExpression simpleName = (JetSimpleNameExpression) expression; - VariableDescriptor variable = AutoCastUtils.getVariableDescriptorFromSimpleName(context.trace.getBindingContext(), simpleName); + VariableDescriptor variable = DataFlowValueFactory.getVariableDescriptorFromSimpleName(context.trace.getBindingContext(), simpleName); if (variable != null) { DeclarationDescriptor containingDeclaration = variable.getContainingDeclaration(); if (context.scope.getContainingDeclaration() != containingDeclaration && containingDeclaration instanceof CallableDescriptor) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java index 0a8b5efd150..735f0e5e6b3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java @@ -6,7 +6,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.DeferredType; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorWithWritableScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorWithWritableScope.java index acbd1271b57..844f980e8b5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorWithWritableScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorWithWritableScope.java @@ -164,7 +164,7 @@ public class ExpressionTypingVisitorWithWritableScope extends BasicExpressionTyp "set", receiver); if (functionDescriptor == null) return null; context.trace.record(REFERENCE_TARGET, operationSign, functionDescriptor); - return ExpressionTypingUtils.checkType(functionDescriptor.getReturnType(), arrayAccessExpression, context); + return DataFlowUtils.checkType(functionDescriptor.getReturnType(), arrayAccessExpression, context); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/LabelResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/LabelResolver.java index 63e92541bd1..bcf5b82dcd3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/LabelResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/LabelResolver.java @@ -106,10 +106,9 @@ public class LabelResolver { return result; } - public ReceiverDescriptor resolveThisLabel(JetThisExpression expression, ExpressionTypingContext context, ReceiverDescriptor thisReceiver, String labelName) { + public ReceiverDescriptor resolveThisLabel(JetReferenceExpression thisReference, JetSimpleNameExpression targetLabel, ExpressionTypingContext context, ReceiverDescriptor thisReceiver, String labelName) { Collection declarationsByLabel = context.scope.getDeclarationsByLabel(labelName); int size = declarationsByLabel.size(); - final JetSimpleNameExpression targetLabel = expression.getTargetLabel(); assert targetLabel != null; if (size == 1) { DeclarationDescriptor declarationDescriptor = declarationsByLabel.iterator().next(); @@ -127,7 +126,7 @@ public class LabelResolver { PsiElement element = context.trace.get(DESCRIPTOR_TO_DECLARATION, declarationDescriptor); assert element != null; context.trace.record(LABEL_TARGET, targetLabel, element); - context.trace.record(REFERENCE_TARGET, expression.getThisReference(), declarationDescriptor); + context.trace.record(REFERENCE_TARGET, thisReference, declarationDescriptor); } else if (size == 0) { JetElement element = resolveNamedLabel(labelName, targetLabel, false, context); @@ -137,7 +136,7 @@ public class LabelResolver { thisReceiver = ((FunctionDescriptor) declarationDescriptor).getReceiverParameter(); if (thisReceiver.exists()) { context.trace.record(LABEL_TARGET, targetLabel, element); - context.trace.record(REFERENCE_TARGET, expression.getThisReference(), declarationDescriptor); + context.trace.record(REFERENCE_TARGET, thisReference, declarationDescriptor); } } else { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java index 3cd9cc80cab..970198fe48d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java @@ -2,12 +2,14 @@ package org.jetbrains.jet.lang.types.expressions; import com.google.common.collect.Sets; import com.intellij.lang.ASTNode; +import com.intellij.openapi.util.Ref; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.calls.AutoCastUtils; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValue; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValueFactory; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; @@ -19,8 +21,6 @@ import java.util.List; import java.util.Set; import static org.jetbrains.jet.lang.diagnostics.Errors.*; -import static org.jetbrains.jet.lang.diagnostics.Errors.INCOMPATIBLE_TYPES; -import static org.jetbrains.jet.lang.diagnostics.Errors.UNSUPPORTED; import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.ensureBooleanResultWithCustomSubject; import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.newWritableScopeImpl; @@ -35,15 +35,16 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { @Override public JetType visitIsExpression(JetIsExpression expression, ExpressionTypingContext contextWithExpectedType) { ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE); - JetType knownType = facade.safeGetType(expression.getLeftHandSide(), context.replaceScope(context.scope)); + JetExpression leftHandSide = expression.getLeftHandSide(); + JetType knownType = facade.safeGetType(leftHandSide, context.replaceScope(context.scope)); JetPattern pattern = expression.getPattern(); if (pattern != null) { WritableScopeImpl scopeToExtend = newWritableScopeImpl(context).setDebugName("Scope extended in 'is'"); - DataFlowInfo newDataFlowInfo = checkPatternType(pattern, knownType, scopeToExtend, context, AutoCastUtils.getVariableDescriptorFromSimpleName(context.trace.getBindingContext(), expression.getLeftHandSide())); + DataFlowInfo newDataFlowInfo = checkPatternType(pattern, knownType, scopeToExtend, context, DataFlowValueFactory.INSTANCE.createDataFlowValue(leftHandSide, knownType, context.trace.getBindingContext())); context.patternsToDataFlowInfo.put(pattern, newDataFlowInfo); context.patternsToBoundVariableLists.put(pattern, scopeToExtend.getDeclaredVariables()); } - return ExpressionTypingUtils.checkType(context.semanticServices.getStandardLibrary().getBooleanType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(context.semanticServices.getStandardLibrary().getBooleanType(), expression, contextWithExpectedType); } @Override @@ -53,7 +54,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { final JetExpression subjectExpression = expression.getSubjectExpression(); final JetType subjectType = subjectExpression != null ? context.getServices().safeGetType(context.scope, subjectExpression, TypeUtils.NO_EXPECTED_TYPE) : ErrorUtils.createErrorType("Unknown type"); - final VariableDescriptor variableDescriptor = subjectExpression != null ? AutoCastUtils.getVariableDescriptorFromSimpleName(context.trace.getBindingContext(), subjectExpression) : null; + final DataFlowValue variableDescriptor = subjectExpression != null ? DataFlowValueFactory.INSTANCE.createDataFlowValue(subjectExpression, subjectType, context.trace.getBindingContext()) : null; // TODO : exhaustive patterns @@ -108,7 +109,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { return null; } - private DataFlowInfo checkWhenCondition(@Nullable final JetExpression subjectExpression, final JetType subjectType, JetWhenCondition condition, final WritableScope scopeToExtend, final ExpressionTypingContext context, final VariableDescriptor... subjectVariables) { + private DataFlowInfo checkWhenCondition(@Nullable final JetExpression subjectExpression, final JetType subjectType, JetWhenCondition condition, final WritableScope scopeToExtend, final ExpressionTypingContext context, final DataFlowValue... subjectVariables) { final DataFlowInfo[] newDataFlowInfo = new DataFlowInfo[]{context.dataFlowInfo}; condition.accept(new JetVisitorVoid() { @@ -151,8 +152,8 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { return newDataFlowInfo[0]; } - private DataFlowInfo checkPatternType(@NotNull JetPattern pattern, @NotNull final JetType subjectType, @NotNull final WritableScope scopeToExtend, final ExpressionTypingContext context, @NotNull final VariableDescriptor... subjectVariables) { - final DataFlowInfo[] result = new DataFlowInfo[] {context.dataFlowInfo}; + private DataFlowInfo checkPatternType(@NotNull JetPattern pattern, @NotNull final JetType subjectType, @NotNull final WritableScope scopeToExtend, final ExpressionTypingContext context, @NotNull final DataFlowValue... subjectVariables) { + final Ref result = new Ref(context.dataFlowInfo); pattern.accept(new JetVisitorVoid() { @Override public void visitTypePattern(JetTypePattern typePattern) { @@ -160,7 +161,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { if (typeReference != null) { JetType type = context.getTypeResolver().resolveType(context.scope, typeReference); checkTypeCompatibility(type, subjectType, typePattern); - result[0] = context.dataFlowInfo.isInstanceOf(subjectVariables, type); + result.set(context.dataFlowInfo.establishSubtyping(subjectVariables, type)); } } @@ -187,7 +188,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { JetPattern entryPattern = entry.getPattern(); if (entryPattern != null) { - result[0] = result[0].and(checkPatternType(entryPattern, type, scopeToExtend, context)); + result.set(result.get().and(checkPatternType(entryPattern, type, scopeToExtend, context))); } } } @@ -200,7 +201,9 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { ReceiverDescriptor receiver = new TransientReceiver(subjectType); JetType selectorReturnType = facade.getSelectorReturnType(receiver, null, decomposerExpression, context); - result[0] = checkPatternType(pattern.getArgumentList(), selectorReturnType == null ? ErrorUtils.createErrorType("No type") : selectorReturnType, scopeToExtend, context); + result.set(checkPatternType(pattern.getArgumentList(), selectorReturnType == null + ? ErrorUtils.createErrorType("No type") + : selectorReturnType, scopeToExtend, context)); } } @@ -235,10 +238,10 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { JetWhenCondition condition = pattern.getCondition(); if (condition != null) { int oldLength = subjectVariables.length; - VariableDescriptor[] newSubjectVariables = new VariableDescriptor[oldLength + 1]; + DataFlowValue[] newSubjectVariables = new DataFlowValue[oldLength + 1]; System.arraycopy(subjectVariables, 0, newSubjectVariables, 0, oldLength); - newSubjectVariables[oldLength] = variableDescriptor; - result[0] = checkWhenCondition(null, subjectType, condition, scopeToExtend, context, newSubjectVariables); + newSubjectVariables[oldLength] = DataFlowValueFactory.INSTANCE.createDataFlowValue(variableDescriptor); + result.set(checkWhenCondition(null, subjectType, condition, scopeToExtend, context, newSubjectVariables)); } } @@ -259,7 +262,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName())); } }); - return result[0]; + return result.get(); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex b/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex index e13a8025175..95576d76e5a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex @@ -168,6 +168,7 @@ LONG_TEMPLATE_ENTRY_END=\} "trait" { return JetTokens.TRAIT_KEYWORD ;} "throw" { return JetTokens.THROW_KEYWORD ;} "false" { return JetTokens.FALSE_KEYWORD ;} +"super" { return JetTokens.SUPER_KEYWORD ;} "when" { return JetTokens.WHEN_KEYWORD ;} "true" { return JetTokens.TRUE_KEYWORD ;} "type" { return JetTokens.TYPE_KEYWORD ;} diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java index 1322d09776c..c66e06e3a60 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java @@ -36,6 +36,7 @@ public interface JetTokens { JetKeywordToken TYPE_KEYWORD = JetKeywordToken.keyword("type"); JetKeywordToken CLASS_KEYWORD = JetKeywordToken.keyword("class"); JetKeywordToken THIS_KEYWORD = JetKeywordToken.keyword("this"); + JetKeywordToken SUPER_KEYWORD = JetKeywordToken.keyword("super"); JetKeywordToken VAL_KEYWORD = JetKeywordToken.keyword("val"); JetKeywordToken VAR_KEYWORD = JetKeywordToken.keyword("var"); JetKeywordToken FUN_KEYWORD = JetKeywordToken.keyword("fun"); @@ -145,7 +146,7 @@ public interface JetTokens { JetKeywordToken REF_KEYWORD = JetKeywordToken.softKeyword("ref"); TokenSet KEYWORDS = TokenSet.create(NAMESPACE_KEYWORD, AS_KEYWORD, TYPE_KEYWORD, CLASS_KEYWORD, TRAIT_KEYWORD, - THIS_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, FOR_KEYWORD, + THIS_KEYWORD, SUPER_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, FOR_KEYWORD, NULL_KEYWORD, TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD, IN_KEYWORD, THROW_KEYWORD, RETURN_KEYWORD, BREAK_KEYWORD, CONTINUE_KEYWORD, OBJECT_KEYWORD, IF_KEYWORD, diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java index 0e2f7e09222..e2851597318 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java @@ -1,4 +1,4 @@ -/* The following code was generated by JFlex 1.4.3 on 10/17/11 7:35 PM */ +/* The following code was generated by JFlex 1.4.3 on 10/19/11 2:50 PM */ /* It's an automatically generated code. Do not modify it. */ package org.jetbrains.jet.lexer; @@ -14,7 +14,7 @@ import org.jetbrains.jet.lexer.JetTokens; /** * This class is a scanner generated by * JFlex 1.4.3 - * on 10/17/11 7:35 PM from the specification file + * on 10/19/11 2:50 PM from the specification file * /Users/abreslav/work/jet/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex */ class _JetLexer implements FlexLexer { @@ -122,26 +122,26 @@ class _JetLexer implements FlexLexer { private static final String ZZ_ACTION_PACKED_0 = "\4\0\1\1\1\2\1\3\1\4\2\1\1\5\1\6"+ "\1\7\1\2\1\10\1\11\1\12\1\13\1\14\1\15"+ - "\16\3\1\16\1\17\1\20\1\21\1\22\1\23\2\1"+ + "\17\3\1\16\1\17\1\20\1\21\1\22\1\23\2\1"+ "\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33"+ "\1\34\2\35\1\36\1\0\1\37\1\40\1\0\1\41"+ "\1\42\1\0\1\43\1\0\1\44\1\0\1\45\1\0"+ "\1\46\1\47\1\50\1\51\1\52\1\43\2\2\1\43"+ "\1\53\1\54\1\55\1\56\2\12\1\0\2\3\1\57"+ - "\7\3\1\60\1\61\1\62\10\3\1\63\1\0\1\64"+ + "\10\3\1\60\1\61\1\62\10\3\1\63\1\0\1\64"+ "\1\65\1\66\1\67\1\70\1\71\1\72\1\73\1\74"+ "\1\75\1\76\1\0\1\77\1\100\1\0\1\101\1\43"+ "\1\3\2\0\1\50\1\102\4\0\1\103\2\3\1\104"+ - "\6\3\1\105\10\3\1\106\1\107\1\3\1\110\1\111"+ + "\7\3\1\105\10\3\1\106\1\107\1\3\1\110\1\111"+ "\1\112\1\113\1\114\1\115\1\0\1\40\1\44\1\45"+ - "\1\0\2\102\1\43\2\0\1\3\1\116\1\117\4\3"+ + "\1\0\2\102\1\43\2\0\1\3\1\116\1\117\5\3"+ "\1\120\1\121\1\3\1\122\2\3\1\123\2\3\1\124"+ - "\1\125\1\76\1\50\2\0\2\3\1\126\1\3\1\127"+ - "\1\130\1\3\1\131\1\132\1\133\1\103\2\3\1\134"+ - "\1\135\3\3\1\136\1\137"; + "\1\125\1\76\1\50\2\0\1\3\1\126\1\3\1\127"+ + "\1\3\1\130\1\131\1\3\1\132\1\133\1\134\1\103"+ + "\2\3\1\135\1\136\3\3\1\137\1\140"; private static int [] zzUnpackAction() { - int [] result = new int[212]; + int [] result = new int[217]; int offset = 0; offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result); return result; @@ -170,32 +170,33 @@ class _JetLexer implements FlexLexer { "\0\u0200\0\u0240\0\u0280\0\u02c0\0\u0300\0\u0340\0\u0380\0\u03c0"+ "\0\u0400\0\u0440\0\u0100\0\u0100\0\u0480\0\u04c0\0\u0500\0\u0540"+ "\0\u0580\0\u05c0\0\u0600\0\u0640\0\u0680\0\u06c0\0\u0700\0\u0740"+ - "\0\u0780\0\u07c0\0\u0800\0\u0840\0\u0100\0\u0880\0\u08c0\0\u0900"+ - "\0\u0940\0\u0980\0\u09c0\0\u0100\0\u0100\0\u0100\0\u0100\0\u0100"+ - "\0\u0100\0\u0100\0\u0100\0\u0a00\0\u0a40\0\u0100\0\u0a80\0\u0100"+ - "\0\u0ac0\0\u0b00\0\u0100\0\u0100\0\u0b40\0\u0b80\0\u0bc0\0\u0c00"+ - "\0\u0c40\0\u0c80\0\u0cc0\0\u0100\0\u0d00\0\u0d40\0\u0100\0\u0100"+ - "\0\u0d80\0\u0dc0\0\u0e00\0\u0e40\0\u0100\0\u0100\0\u0100\0\u0100"+ - "\0\u0100\0\u0e80\0\u0ec0\0\u0f00\0\u0f40\0\u0f80\0\u0fc0\0\u1000"+ - "\0\u1040\0\u1080\0\u10c0\0\u1100\0\u1140\0\u0180\0\u0180\0\u0180"+ - "\0\u1180\0\u11c0\0\u1200\0\u1240\0\u1280\0\u12c0\0\u1300\0\u1340"+ - "\0\u0180\0\u1380\0\u13c0\0\u1400\0\u0100\0\u0100\0\u0100\0\u0100"+ - "\0\u0100\0\u0100\0\u0100\0\u0100\0\u1440\0\u1480\0\u0100\0\u0100"+ - "\0\u14c0\0\u0100\0\u1500\0\u0100\0\u1540\0\u1580\0\u15c0\0\u1600"+ - "\0\u1640\0\u1680\0\u16c0\0\u1700\0\u1740\0\u1780\0\u17c0\0\u0100"+ - "\0\u1800\0\u1840\0\u1880\0\u18c0\0\u1900\0\u1940\0\u0180\0\u1980"+ - "\0\u19c0\0\u1a00\0\u1a40\0\u1a80\0\u1ac0\0\u1b00\0\u1b40\0\u0180"+ - "\0\u0180\0\u1b80\0\u0180\0\u0180\0\u1bc0\0\u1bc0\0\u0100\0\u0100"+ - "\0\u1c00\0\u0100\0\u0100\0\u0100\0\u1c40\0\u1c80\0\u0100\0\u1cc0"+ - "\0\u1500\0\u1d00\0\u1d40\0\u0180\0\u0180\0\u1d80\0\u1dc0\0\u1e00"+ - "\0\u1e40\0\u0180\0\u0180\0\u1e80\0\u0180\0\u1ec0\0\u1f00\0\u0180"+ - "\0\u1f40\0\u1f80\0\u0180\0\u0100\0\u0100\0\u0100\0\u1fc0\0\u2000"+ - "\0\u2040\0\u2080\0\u0180\0\u20c0\0\u0180\0\u0180\0\u2100\0\u0180"+ - "\0\u0180\0\u0180\0\u0100\0\u2140\0\u2180\0\u0180\0\u0180\0\u21c0"+ - "\0\u2200\0\u2240\0\u0180\0\u0180"; + "\0\u0780\0\u07c0\0\u0800\0\u0840\0\u0880\0\u0100\0\u08c0\0\u0900"+ + "\0\u0940\0\u0980\0\u09c0\0\u0a00\0\u0100\0\u0100\0\u0100\0\u0100"+ + "\0\u0100\0\u0100\0\u0100\0\u0100\0\u0a40\0\u0a80\0\u0100\0\u0ac0"+ + "\0\u0100\0\u0b00\0\u0b40\0\u0100\0\u0100\0\u0b80\0\u0bc0\0\u0c00"+ + "\0\u0c40\0\u0c80\0\u0cc0\0\u0d00\0\u0100\0\u0d40\0\u0d80\0\u0100"+ + "\0\u0100\0\u0dc0\0\u0e00\0\u0e40\0\u0e80\0\u0100\0\u0100\0\u0100"+ + "\0\u0100\0\u0100\0\u0ec0\0\u0f00\0\u0f40\0\u0f80\0\u0fc0\0\u1000"+ + "\0\u1040\0\u1080\0\u10c0\0\u1100\0\u1140\0\u1180\0\u11c0\0\u0180"+ + "\0\u0180\0\u0180\0\u1200\0\u1240\0\u1280\0\u12c0\0\u1300\0\u1340"+ + "\0\u1380\0\u13c0\0\u0180\0\u1400\0\u1440\0\u1480\0\u0100\0\u0100"+ + "\0\u0100\0\u0100\0\u0100\0\u0100\0\u0100\0\u0100\0\u14c0\0\u1500"+ + "\0\u0100\0\u0100\0\u1540\0\u0100\0\u1580\0\u0100\0\u15c0\0\u1600"+ + "\0\u1640\0\u1680\0\u16c0\0\u1700\0\u1740\0\u1780\0\u17c0\0\u1800"+ + "\0\u1840\0\u0100\0\u1880\0\u18c0\0\u1900\0\u1940\0\u1980\0\u19c0"+ + "\0\u1a00\0\u0180\0\u1a40\0\u1a80\0\u1ac0\0\u1b00\0\u1b40\0\u1b80"+ + "\0\u1bc0\0\u1c00\0\u0180\0\u0180\0\u1c40\0\u0180\0\u0180\0\u1c80"+ + "\0\u1c80\0\u0100\0\u0100\0\u1cc0\0\u0100\0\u0100\0\u0100\0\u1d00"+ + "\0\u1d40\0\u0100\0\u1d80\0\u1580\0\u1dc0\0\u1e00\0\u0180\0\u0180"+ + "\0\u1e40\0\u1e80\0\u1ec0\0\u1f00\0\u1f40\0\u0180\0\u0180\0\u1f80"+ + "\0\u0180\0\u1fc0\0\u2000\0\u0180\0\u2040\0\u2080\0\u0180\0\u0100"+ + "\0\u0100\0\u0100\0\u20c0\0\u2100\0\u2140\0\u0180\0\u2180\0\u0180"+ + "\0\u21c0\0\u0180\0\u0180\0\u2200\0\u0180\0\u0180\0\u0180\0\u0100"+ + "\0\u2240\0\u2280\0\u0180\0\u0180\0\u22c0\0\u2300\0\u2340\0\u0180"+ + "\0\u0180"; private static int [] zzUnpackRowMap() { - int [] result = new int[212]; + int [] result = new int[217]; int offset = 0; offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result); return result; @@ -221,209 +222,216 @@ class _JetLexer implements FlexLexer { "\1\5\1\6\1\7\1\10\1\7\1\5\1\11\1\12"+ "\1\13\1\14\1\15\1\10\1\16\2\7\1\17\1\7"+ "\1\20\1\7\1\21\1\5\1\22\1\23\1\24\1\25"+ - "\1\26\1\7\1\27\2\7\1\30\1\31\1\32\1\33"+ - "\1\7\1\34\1\35\1\7\1\36\3\7\1\37\1\7"+ - "\1\40\1\41\1\42\1\43\1\44\1\45\1\46\1\47"+ + "\1\26\1\7\1\27\1\30\1\7\1\31\1\32\1\33"+ + "\1\34\1\7\1\35\1\36\1\7\1\37\3\7\1\40"+ + "\1\7\1\41\1\42\1\43\1\44\1\45\1\46\1\47"+ "\1\50\1\51\1\52\1\53\1\54\1\55\1\56\1\57"+ - "\1\60\1\61\1\62\1\63\7\64\1\65\3\64\1\66"+ - "\10\64\1\67\1\70\52\64\2\0\1\71\1\0\1\71"+ - "\1\0\1\72\6\0\2\71\1\0\1\71\1\0\1\71"+ - "\5\0\27\71\21\0\1\5\1\6\1\7\1\10\1\7"+ - "\1\5\1\11\1\12\1\13\1\14\1\15\1\10\1\16"+ - "\2\7\1\17\1\7\1\20\1\7\1\21\1\5\1\22"+ - "\1\73\1\74\1\25\1\26\1\7\1\27\2\7\1\30"+ - "\1\31\1\32\1\33\1\7\1\34\1\35\1\7\1\36"+ - "\3\7\1\37\1\7\1\40\1\41\1\42\1\43\1\44"+ - "\1\45\1\46\1\47\1\50\1\51\1\52\1\53\1\54"+ - "\1\55\1\56\1\57\1\60\1\61\1\62\1\63\101\0"+ - "\1\6\12\0\1\6\2\0\1\75\1\76\12\0\1\76"+ - "\45\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\27\7\24\0\1\10\7\0\1\10"+ - "\66\0\1\77\1\0\1\77\10\0\2\77\1\0\1\77"+ - "\1\0\1\77\5\0\27\77\23\0\1\100\1\0\1\100"+ - "\1\0\1\101\6\0\2\100\1\0\1\100\1\0\1\100"+ - "\5\0\27\100\23\0\1\102\1\0\1\102\1\0\1\103"+ - "\1\0\1\104\4\0\2\102\1\0\1\102\1\0\1\102"+ - "\5\0\27\102\32\0\1\105\1\106\45\0\1\107\77\0"+ - "\1\110\20\0\1\111\12\0\1\111\1\112\1\113\1\75"+ - "\1\76\12\0\1\76\10\0\1\113\34\0\1\114\12\0"+ - "\1\114\2\0\1\115\101\0\1\116\36\0\1\117\3\0"+ - "\1\120\13\0\13\21\1\0\7\21\1\121\1\122\53\21"+ - "\25\0\1\123\53\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\1\7\1\124\10\7"+ - "\1\125\14\7\22\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\4\7\1\126\22\7"+ + "\1\60\1\61\1\62\1\63\1\64\7\65\1\66\3\65"+ + "\1\67\10\65\1\70\1\71\52\65\2\0\1\72\1\0"+ + "\1\72\1\0\1\73\6\0\2\72\1\0\1\72\1\0"+ + "\1\72\5\0\27\72\21\0\1\5\1\6\1\7\1\10"+ + "\1\7\1\5\1\11\1\12\1\13\1\14\1\15\1\10"+ + "\1\16\2\7\1\17\1\7\1\20\1\7\1\21\1\5"+ + "\1\22\1\74\1\75\1\25\1\26\1\7\1\27\1\30"+ + "\1\7\1\31\1\32\1\33\1\34\1\7\1\35\1\36"+ + "\1\7\1\37\3\7\1\40\1\7\1\41\1\42\1\43"+ + "\1\44\1\45\1\46\1\47\1\50\1\51\1\52\1\53"+ + "\1\54\1\55\1\56\1\57\1\60\1\61\1\62\1\63"+ + "\1\64\101\0\1\6\12\0\1\6\2\0\1\76\1\77"+ + "\12\0\1\77\45\0\2\7\1\0\2\7\6\0\3\7"+ + "\1\0\1\7\1\0\1\7\5\0\27\7\24\0\1\10"+ + "\7\0\1\10\66\0\1\100\1\0\1\100\10\0\2\100"+ + "\1\0\1\100\1\0\1\100\5\0\27\100\23\0\1\101"+ + "\1\0\1\101\1\0\1\102\6\0\2\101\1\0\1\101"+ + "\1\0\1\101\5\0\27\101\23\0\1\103\1\0\1\103"+ + "\1\0\1\104\1\0\1\105\4\0\2\103\1\0\1\103"+ + "\1\0\1\103\5\0\27\103\32\0\1\106\1\107\45\0"+ + "\1\110\77\0\1\111\20\0\1\112\12\0\1\112\1\113"+ + "\1\114\1\76\1\77\12\0\1\77\10\0\1\114\34\0"+ + "\1\115\12\0\1\115\2\0\1\116\101\0\1\117\36\0"+ + "\1\120\3\0\1\121\13\0\13\21\1\0\7\21\1\122"+ + "\1\123\53\21\25\0\1\124\53\0\2\7\1\0\2\7"+ + "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\1\7"+ + "\1\125\10\7\1\126\14\7\22\0\2\7\1\0\2\7"+ + "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\4\7"+ + "\1\127\22\7\22\0\2\7\1\0\2\7\6\0\3\7"+ + "\1\0\1\7\1\0\1\7\5\0\20\7\1\130\6\7"+ "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\20\7\1\127\6\7\22\0\2\7"+ + "\1\0\1\7\5\0\12\7\1\131\14\7\22\0\2\7"+ "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ - "\5\0\7\7\1\130\10\7\1\131\6\7\22\0\2\7"+ + "\5\0\7\7\1\132\10\7\1\133\6\7\22\0\2\7"+ "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ - "\5\0\14\7\1\132\12\7\22\0\2\7\1\0\2\7"+ + "\5\0\14\7\1\134\12\7\22\0\2\7\1\0\2\7"+ "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\13\7"+ - "\1\133\3\7\1\134\3\7\1\135\3\7\22\0\2\7"+ + "\1\135\3\7\1\136\3\7\1\137\3\7\22\0\2\7"+ "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ - "\5\0\1\136\3\7\1\137\15\7\1\140\4\7\22\0"+ + "\5\0\1\140\3\7\1\141\15\7\1\142\4\7\22\0"+ "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ - "\1\7\5\0\3\7\1\141\23\7\22\0\2\7\1\0"+ + "\1\7\5\0\3\7\1\143\23\7\22\0\2\7\1\0"+ "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ - "\13\7\1\142\13\7\22\0\2\7\1\0\2\7\6\0"+ - "\3\7\1\0\1\7\1\0\1\7\5\0\17\7\1\143"+ + "\13\7\1\144\13\7\22\0\2\7\1\0\2\7\6\0"+ + "\3\7\1\0\1\7\1\0\1\7\5\0\17\7\1\145"+ "\7\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ - "\1\7\1\0\1\7\5\0\1\7\1\144\5\7\1\145"+ - "\2\7\1\146\14\7\22\0\2\7\1\0\2\7\6\0"+ - "\3\7\1\0\1\7\1\0\1\7\5\0\17\7\1\147"+ + "\1\7\1\0\1\7\5\0\1\7\1\146\5\7\1\147"+ + "\2\7\1\150\14\7\22\0\2\7\1\0\2\7\6\0"+ + "\3\7\1\0\1\7\1\0\1\7\5\0\17\7\1\151"+ "\7\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ - "\1\7\1\0\1\7\5\0\1\7\1\150\25\7\22\0"+ + "\1\7\1\0\1\7\5\0\1\7\1\152\25\7\22\0"+ "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ - "\1\7\5\0\7\7\1\151\17\7\62\0\1\152\16\0"+ - "\1\153\77\0\1\154\3\0\1\155\73\0\1\156\1\0"+ - "\1\157\75\0\1\160\77\0\1\161\104\0\1\162\100\0"+ - "\1\163\71\0\1\164\17\0\7\64\1\0\3\64\1\0"+ - "\10\64\2\0\52\64\2\0\1\165\1\0\1\165\1\0"+ - "\1\166\6\0\2\165\1\0\1\165\1\0\1\165\3\0"+ - "\1\167\1\0\27\165\21\0\13\170\1\0\64\170\1\0"+ - "\2\71\1\0\2\71\6\0\3\71\1\0\1\71\1\0"+ - "\1\71\5\0\27\71\23\0\1\171\1\0\1\171\10\0"+ - "\2\171\1\0\1\171\1\0\1\171\5\0\27\171\22\0"+ - "\1\114\12\0\1\114\2\0\1\172\61\0\1\173\12\0"+ - "\1\173\4\0\1\173\40\0\1\173\16\0\2\77\1\0"+ - "\2\77\1\174\5\0\3\77\1\0\1\77\1\0\1\77"+ - "\5\0\27\77\22\0\2\100\1\0\2\100\6\0\3\100"+ - "\1\0\1\100\1\0\1\100\5\0\27\100\23\0\1\175"+ - "\1\0\1\175\10\0\2\175\1\0\1\175\1\0\1\175"+ - "\5\0\27\175\22\0\2\102\1\0\2\102\6\0\3\102"+ - "\1\0\1\102\1\0\1\102\5\0\27\102\23\0\1\176"+ - "\1\0\1\176\10\0\2\176\1\0\1\176\1\0\1\176"+ - "\5\0\27\176\21\0\13\105\1\0\64\105\12\177\1\200"+ - "\65\177\1\0\1\111\12\0\1\111\2\0\1\201\1\76"+ - "\12\0\1\76\45\0\2\112\11\0\1\112\1\0\1\112"+ - "\1\202\1\112\1\0\1\203\6\0\1\112\1\0\1\112"+ - "\1\0\1\203\1\112\5\0\1\112\5\0\1\112\3\0"+ - "\1\112\22\0\1\113\12\0\1\113\2\0\1\204\61\0"+ - "\1\114\12\0\1\114\3\0\1\76\12\0\1\76\44\0"+ - "\13\21\1\0\64\21\25\0\1\205\53\0\2\7\1\0"+ + "\1\7\5\0\7\7\1\153\17\7\62\0\1\154\16\0"+ + "\1\155\77\0\1\156\3\0\1\157\73\0\1\160\1\0"+ + "\1\161\75\0\1\162\77\0\1\163\104\0\1\164\100\0"+ + "\1\165\71\0\1\166\17\0\7\65\1\0\3\65\1\0"+ + "\10\65\2\0\52\65\2\0\1\167\1\0\1\167\1\0"+ + "\1\170\6\0\2\167\1\0\1\167\1\0\1\167\3\0"+ + "\1\171\1\0\27\167\21\0\13\172\1\0\64\172\1\0"+ + "\2\72\1\0\2\72\6\0\3\72\1\0\1\72\1\0"+ + "\1\72\5\0\27\72\23\0\1\173\1\0\1\173\10\0"+ + "\2\173\1\0\1\173\1\0\1\173\5\0\27\173\22\0"+ + "\1\115\12\0\1\115\2\0\1\174\61\0\1\175\12\0"+ + "\1\175\4\0\1\175\40\0\1\175\16\0\2\100\1\0"+ + "\2\100\1\176\5\0\3\100\1\0\1\100\1\0\1\100"+ + "\5\0\27\100\22\0\2\101\1\0\2\101\6\0\3\101"+ + "\1\0\1\101\1\0\1\101\5\0\27\101\23\0\1\177"+ + "\1\0\1\177\10\0\2\177\1\0\1\177\1\0\1\177"+ + "\5\0\27\177\22\0\2\103\1\0\2\103\6\0\3\103"+ + "\1\0\1\103\1\0\1\103\5\0\27\103\23\0\1\200"+ + "\1\0\1\200\10\0\2\200\1\0\1\200\1\0\1\200"+ + "\5\0\27\200\21\0\13\106\1\0\64\106\12\201\1\202"+ + "\65\201\1\0\1\112\12\0\1\112\2\0\1\203\1\77"+ + "\12\0\1\77\45\0\2\113\11\0\1\113\1\0\1\113"+ + "\1\204\1\113\1\0\1\205\6\0\1\113\1\0\1\113"+ + "\1\0\1\205\1\113\5\0\1\113\5\0\1\113\3\0"+ + "\1\113\22\0\1\114\12\0\1\114\2\0\1\206\61\0"+ + "\1\115\12\0\1\115\3\0\1\77\12\0\1\77\44\0"+ + "\13\21\1\0\64\21\25\0\1\207\53\0\2\7\1\0"+ "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ - "\2\7\1\206\24\7\22\0\2\7\1\0\2\7\6\0"+ - "\3\7\1\0\1\7\1\0\1\7\5\0\20\7\1\207"+ + "\2\7\1\210\24\7\22\0\2\7\1\0\2\7\6\0"+ + "\3\7\1\0\1\7\1\0\1\7\5\0\20\7\1\211"+ "\6\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ - "\1\7\1\0\1\7\5\0\27\7\2\0\1\210\17\0"+ + "\1\7\1\0\1\7\5\0\27\7\2\0\1\212\17\0"+ "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ - "\1\7\5\0\4\7\1\211\22\7\22\0\2\7\1\0"+ + "\1\7\5\0\4\7\1\213\22\7\22\0\2\7\1\0"+ "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ - "\1\212\26\7\22\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\1\7\1\213\25\7"+ + "\5\7\1\214\21\7\22\0\2\7\1\0\2\7\6\0"+ + "\3\7\1\0\1\7\1\0\1\7\5\0\1\215\26\7"+ "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\15\7\1\214\11\7\22\0\2\7"+ + "\1\0\1\7\5\0\1\7\1\216\25\7\22\0\2\7"+ "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ - "\5\0\1\7\1\215\10\7\1\216\10\7\1\217\3\7"+ - "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\11\7\1\220\1\7\1\221\13\7"+ - "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\5\7\1\222\21\7\22\0\2\7"+ + "\5\0\15\7\1\217\11\7\22\0\2\7\1\0\2\7"+ + "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\1\7"+ + "\1\220\10\7\1\221\10\7\1\222\3\7\22\0\2\7"+ "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ - "\5\0\10\7\1\223\16\7\22\0\2\7\1\0\2\7"+ - "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\3\7"+ - "\1\224\23\7\22\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\3\7\1\225\5\7"+ - "\1\226\15\7\22\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\20\7\1\227\6\7"+ - "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\13\7\1\230\13\7\22\0\2\7"+ + "\5\0\11\7\1\223\1\7\1\224\13\7\22\0\2\7"+ "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ - "\5\0\1\231\26\7\22\0\2\7\1\0\2\7\6\0"+ - "\3\7\1\0\1\7\1\0\1\7\5\0\11\7\1\232"+ - "\15\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ - "\1\7\1\0\1\7\5\0\13\7\1\233\4\7\1\234"+ - "\6\7\51\0\1\235\3\0\1\236\123\0\1\237\77\0"+ - "\1\240\20\0\2\165\1\0\2\165\6\0\3\165\1\0"+ - "\1\165\1\0\1\165\5\0\27\165\23\0\1\241\1\0"+ - "\1\241\10\0\2\241\1\0\1\241\1\0\1\241\5\0"+ - "\27\241\22\0\2\171\1\0\2\171\1\242\5\0\3\171"+ - "\1\0\1\171\1\0\1\171\5\0\27\171\22\0\1\173"+ - "\12\0\1\173\64\0\2\175\1\0\2\175\1\243\5\0"+ - "\3\175\1\0\1\175\1\0\1\175\5\0\27\175\22\0"+ - "\2\176\1\0\2\176\1\244\5\0\3\176\1\0\1\176"+ - "\1\0\1\176\5\0\27\176\21\0\12\177\1\245\65\177"+ - "\11\246\1\247\1\200\65\246\1\0\1\114\12\0\1\114"+ - "\64\0\2\250\11\0\1\250\1\0\1\250\1\172\1\250"+ - "\10\0\1\250\1\0\1\250\2\0\1\250\5\0\1\250"+ - "\5\0\1\250\3\0\1\250\22\0\1\173\12\0\1\173"+ - "\4\0\1\251\40\0\1\251\34\0\1\172\60\0\25\205"+ - "\1\252\52\205\1\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\3\7\1\253\23\7"+ - "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\20\7\1\254\6\7\22\0\2\7"+ - "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ - "\5\0\3\7\1\255\23\7\22\0\2\7\1\0\2\7"+ + "\5\0\5\7\1\225\21\7\22\0\2\7\1\0\2\7"+ "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\10\7"+ - "\1\256\16\7\22\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\4\7\1\257\22\7"+ + "\1\226\16\7\22\0\2\7\1\0\2\7\6\0\3\7"+ + "\1\0\1\7\1\0\1\7\5\0\3\7\1\227\23\7"+ "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\3\7\1\260\23\7\22\0\2\7"+ + "\1\0\1\7\5\0\3\7\1\230\5\7\1\231\15\7"+ + "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ + "\1\0\1\7\5\0\20\7\1\232\6\7\22\0\2\7"+ "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ - "\5\0\11\7\1\261\15\7\22\0\2\7\1\0\2\7"+ + "\5\0\13\7\1\233\13\7\22\0\2\7\1\0\2\7"+ + "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\1\234"+ + "\26\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ + "\1\7\1\0\1\7\5\0\11\7\1\235\15\7\22\0"+ + "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ + "\1\7\5\0\13\7\1\236\4\7\1\237\6\7\51\0"+ + "\1\240\3\0\1\241\123\0\1\242\77\0\1\243\20\0"+ + "\2\167\1\0\2\167\6\0\3\167\1\0\1\167\1\0"+ + "\1\167\5\0\27\167\23\0\1\244\1\0\1\244\10\0"+ + "\2\244\1\0\1\244\1\0\1\244\5\0\27\244\22\0"+ + "\2\173\1\0\2\173\1\245\5\0\3\173\1\0\1\173"+ + "\1\0\1\173\5\0\27\173\22\0\1\175\12\0\1\175"+ + "\64\0\2\177\1\0\2\177\1\246\5\0\3\177\1\0"+ + "\1\177\1\0\1\177\5\0\27\177\22\0\2\200\1\0"+ + "\2\200\1\247\5\0\3\200\1\0\1\200\1\0\1\200"+ + "\5\0\27\200\21\0\12\201\1\250\65\201\11\251\1\252"+ + "\1\202\65\251\1\0\1\115\12\0\1\115\64\0\2\253"+ + "\11\0\1\253\1\0\1\253\1\174\1\253\10\0\1\253"+ + "\1\0\1\253\2\0\1\253\5\0\1\253\5\0\1\253"+ + "\3\0\1\253\22\0\1\175\12\0\1\175\4\0\1\254"+ + "\40\0\1\254\34\0\1\174\60\0\25\207\1\255\52\207"+ + "\1\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ + "\1\0\1\7\5\0\3\7\1\256\23\7\22\0\2\7"+ + "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ + "\5\0\20\7\1\257\6\7\22\0\2\7\1\0\2\7"+ "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\3\7"+ - "\1\262\23\7\22\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\4\7\1\263\22\7"+ + "\1\260\23\7\22\0\2\7\1\0\2\7\6\0\3\7"+ + "\1\0\1\7\1\0\1\7\5\0\3\7\1\261\23\7"+ "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\7\7\1\264\17\7\22\0\2\7"+ + "\1\0\1\7\5\0\10\7\1\262\16\7\22\0\2\7"+ "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ - "\5\0\3\7\1\265\23\7\22\0\2\7\1\0\2\7"+ - "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\12\7"+ - "\1\266\14\7\22\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\1\7\1\267\25\7"+ + "\5\0\4\7\1\263\22\7\22\0\2\7\1\0\2\7"+ + "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\3\7"+ + "\1\264\23\7\22\0\2\7\1\0\2\7\6\0\3\7"+ + "\1\0\1\7\1\0\1\7\5\0\11\7\1\265\15\7"+ "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\1\270\26\7\22\0\2\7\1\0"+ - "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ - "\20\7\1\271\6\7\22\0\2\7\1\0\2\7\6\0"+ - "\3\7\1\0\1\7\1\0\1\7\5\0\4\7\1\272"+ - "\22\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ - "\1\7\1\0\1\7\5\0\4\7\1\273\22\7\22\0"+ - "\2\274\1\0\2\274\6\0\3\274\1\0\1\274\1\0"+ - "\1\274\5\0\27\274\22\0\2\241\1\0\2\241\1\275"+ - "\5\0\3\241\1\0\1\241\1\0\1\241\5\0\27\241"+ - "\21\0\11\177\1\276\1\245\65\177\12\246\1\277\65\246"+ - "\1\0\2\250\11\0\1\250\1\0\1\250\1\0\1\250"+ - "\1\0\1\203\6\0\1\250\1\0\1\250\1\0\1\203"+ - "\1\250\5\0\1\250\5\0\1\250\3\0\1\250\21\0"+ - "\25\205\1\300\52\205\1\0\2\7\1\0\2\7\6\0"+ - "\3\7\1\0\1\7\1\0\1\7\5\0\4\7\1\301"+ - "\22\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ - "\1\7\1\0\1\7\5\0\11\7\1\302\15\7\22\0"+ - "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ - "\1\7\5\0\4\7\1\303\22\7\22\0\2\7\1\0"+ - "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ - "\6\7\1\304\20\7\22\0\2\7\1\0\2\7\6\0"+ - "\3\7\1\0\1\7\1\0\1\7\5\0\10\7\1\305"+ - "\16\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ - "\1\7\1\0\1\7\5\0\16\7\1\306\10\7\22\0"+ - "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ - "\1\7\5\0\13\7\1\307\13\7\22\0\2\7\1\0"+ - "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ - "\21\7\1\310\5\7\22\0\2\7\1\0\2\7\6\0"+ - "\3\7\1\0\1\7\1\0\1\7\5\0\3\7\1\311"+ - "\23\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ - "\1\7\1\0\1\7\5\0\3\7\1\312\23\7\21\0"+ - "\11\246\1\247\1\277\65\246\25\205\1\313\52\205\1\0"+ - "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ - "\1\7\5\0\5\7\1\314\21\7\22\0\2\7\1\0"+ - "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ - "\1\315\26\7\22\0\2\7\1\0\2\7\6\0\3\7"+ - "\1\0\1\7\1\0\1\7\5\0\10\7\1\316\16\7"+ + "\1\0\1\7\5\0\3\7\1\266\23\7\22\0\2\7"+ + "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ + "\5\0\4\7\1\267\22\7\22\0\2\7\1\0\2\7"+ + "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\7\7"+ + "\1\270\17\7\22\0\2\7\1\0\2\7\6\0\3\7"+ + "\1\0\1\7\1\0\1\7\5\0\3\7\1\271\23\7"+ "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+ - "\1\0\1\7\5\0\1\317\26\7\22\0\2\7\1\0"+ - "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ - "\1\7\1\320\25\7\22\0\2\7\1\0\2\7\6\0"+ - "\3\7\1\0\1\7\1\0\1\7\5\0\12\7\1\321"+ - "\14\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ - "\1\7\1\0\1\7\5\0\6\7\1\322\20\7\22\0"+ + "\1\0\1\7\5\0\12\7\1\272\14\7\22\0\2\7"+ + "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+ + "\5\0\1\7\1\273\25\7\22\0\2\7\1\0\2\7"+ + "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\1\274"+ + "\26\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ + "\1\7\1\0\1\7\5\0\20\7\1\275\6\7\22\0"+ "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ - "\1\7\5\0\3\7\1\323\23\7\22\0\2\7\1\0"+ + "\1\7\5\0\4\7\1\276\22\7\22\0\2\7\1\0"+ "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ - "\3\7\1\324\23\7\21\0"; + "\4\7\1\277\22\7\22\0\2\300\1\0\2\300\6\0"+ + "\3\300\1\0\1\300\1\0\1\300\5\0\27\300\22\0"+ + "\2\244\1\0\2\244\1\301\5\0\3\244\1\0\1\244"+ + "\1\0\1\244\5\0\27\244\21\0\11\201\1\302\1\250"+ + "\65\201\12\251\1\303\65\251\1\0\2\253\11\0\1\253"+ + "\1\0\1\253\1\0\1\253\1\0\1\205\6\0\1\253"+ + "\1\0\1\253\1\0\1\205\1\253\5\0\1\253\5\0"+ + "\1\253\3\0\1\253\21\0\25\207\1\304\52\207\1\0"+ + "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ + "\1\7\5\0\4\7\1\305\22\7\22\0\2\7\1\0"+ + "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ + "\13\7\1\306\13\7\22\0\2\7\1\0\2\7\6\0"+ + "\3\7\1\0\1\7\1\0\1\7\5\0\11\7\1\307"+ + "\15\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ + "\1\7\1\0\1\7\5\0\4\7\1\310\22\7\22\0"+ + "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ + "\1\7\5\0\6\7\1\311\20\7\22\0\2\7\1\0"+ + "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ + "\10\7\1\312\16\7\22\0\2\7\1\0\2\7\6\0"+ + "\3\7\1\0\1\7\1\0\1\7\5\0\16\7\1\313"+ + "\10\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ + "\1\7\1\0\1\7\5\0\13\7\1\314\13\7\22\0"+ + "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ + "\1\7\5\0\21\7\1\315\5\7\22\0\2\7\1\0"+ + "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ + "\3\7\1\316\23\7\22\0\2\7\1\0\2\7\6\0"+ + "\3\7\1\0\1\7\1\0\1\7\5\0\3\7\1\317"+ + "\23\7\21\0\11\251\1\252\1\303\65\251\25\207\1\320"+ + "\52\207\1\0\2\7\1\0\2\7\6\0\3\7\1\0"+ + "\1\7\1\0\1\7\5\0\5\7\1\321\21\7\22\0"+ + "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ + "\1\7\5\0\1\322\26\7\22\0\2\7\1\0\2\7"+ + "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\10\7"+ + "\1\323\16\7\22\0\2\7\1\0\2\7\6\0\3\7"+ + "\1\0\1\7\1\0\1\7\5\0\1\324\26\7\22\0"+ + "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ + "\1\7\5\0\1\7\1\325\25\7\22\0\2\7\1\0"+ + "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+ + "\12\7\1\326\14\7\22\0\2\7\1\0\2\7\6\0"+ + "\3\7\1\0\1\7\1\0\1\7\5\0\6\7\1\327"+ + "\20\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+ + "\1\7\1\0\1\7\5\0\3\7\1\330\23\7\22\0"+ + "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+ + "\1\7\5\0\3\7\1\331\23\7\21\0"; private static int [] zzUnpackTrans() { - int [] result = new int[8832]; + int [] result = new int[9088]; int offset = 0; offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result); return result; @@ -464,17 +472,17 @@ class _JetLexer implements FlexLexer { private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute(); private static final String ZZ_ATTRIBUTE_PACKED_0 = - "\4\0\1\11\15\1\2\11\20\1\1\11\6\1\10\11"+ + "\4\0\1\11\15\1\2\11\21\1\1\11\6\1\10\11"+ "\2\1\1\11\1\0\1\11\1\1\1\0\2\11\1\0"+ "\1\1\1\0\1\1\1\0\1\1\1\0\1\11\2\1"+ - "\2\11\4\1\5\11\1\1\1\0\26\1\1\0\2\1"+ + "\2\11\4\1\5\11\1\1\1\0\27\1\1\0\2\1"+ "\10\11\1\1\1\0\2\11\1\0\1\11\1\1\1\11"+ - "\2\0\2\1\4\0\3\1\1\11\26\1\2\11\1\0"+ - "\3\11\1\0\1\1\1\11\1\1\2\0\21\1\3\11"+ - "\2\0\12\1\1\11\11\1"; + "\2\0\2\1\4\0\3\1\1\11\27\1\2\11\1\0"+ + "\3\11\1\0\1\1\1\11\1\1\2\0\22\1\3\11"+ + "\2\0\13\1\1\11\11\1"; private static int [] zzUnpackAttribute() { - int [] result = new int[212]; + int [] result = new int[217]; int offset = 0; offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result); return result; @@ -808,23 +816,23 @@ class _JetLexer implements FlexLexer { case 3: { return JetTokens.IDENTIFIER; } - case 96: break; + case 97: break; case 11: { pushState(STRING); return JetTokens.OPEN_QUOTE; } - case 97: break; + case 98: break; case 70: { return JetTokens.FOR_KEYWORD ; } - case 98: break; - case 93: + case 99: break; + case 94: { return JetTokens.RETURN_KEYWORD ; } - case 99: break; + case 100: break; case 78: { return JetTokens.NULL_KEYWORD ; } - case 100: break; + case 101: break; case 34: { if (lBraceCount == 0) { popState(); @@ -833,365 +841,369 @@ class _JetLexer implements FlexLexer { lBraceCount--; return JetTokens.RBRACE; } - case 101: break; + case 102: break; case 18: { return JetTokens.LT ; } - case 102: break; + case 103: break; case 51: { return JetTokens.DO_KEYWORD ; } - case 103: break; + case 104: break; case 17: { return JetTokens.PLUS ; } - case 104: break; + case 105: break; case 67: { return JetTokens.RAW_STRING_LITERAL; } - case 105: break; + case 106: break; case 55: { return JetTokens.PLUSEQ ; } - case 106: break; + case 107: break; case 27: { return JetTokens.COMMA ; } - case 107: break; + case 108: break; case 19: { return JetTokens.GT ; } - case 108: break; + case 109: break; case 4: { return JetTokens.WHITE_SPACE; } - case 109: break; + case 110: break; case 24: { return JetTokens.RPAR ; } - case 110: break; + case 111: break; case 54: { return JetTokens.DOUBLE_ARROW; } - case 111: break; + case 112: break; case 80: { return JetTokens.TRUE_KEYWORD ; } - case 112: break; + case 113: break; case 36: { return JetTokens.FIELD_IDENTIFIER; } - case 113: break; + case 114: break; case 59: { return JetTokens.ANDAND ; } - case 114: break; + case 115: break; case 63: { pushState(LONG_TEMPLATE_ENTRY); return JetTokens.LONG_TEMPLATE_ENTRY_START; } - case 115: break; + case 116: break; case 66: { return JetTokens.DOC_COMMENT; } - case 116: break; + case 117: break; case 35: { return JetTokens.FLOAT_LITERAL; } - case 117: break; + case 118: break; case 39: { return JetTokens.EOL_COMMENT; } - case 118: break; + case 119: break; case 83: { return JetTokens.WHEN_KEYWORD ; } - case 119: break; + case 120: break; case 25: { return JetTokens.COLON ; } - case 120: break; + case 121: break; case 57: { return JetTokens.LTEQ ; } - case 121: break; + case 122: break; case 46: { return JetTokens.ARROW ; } - case 122: break; + case 123: break; case 32: { popState(); return JetTokens.IDENTIFIER; } - case 123: break; + case 124: break; case 21: { return JetTokens.LBRACKET ; } - case 124: break; + case 125: break; case 65: { yypushback(2); return JetTokens.INTEGER_LITERAL; } - case 125: break; + case 126: break; case 10: { return JetTokens.CHARACTER_LITERAL; } - case 126: break; + case 127: break; case 72: { return JetTokens.VAR_KEYWORD ; } - case 127: break; + case 128: break; case 58: { return JetTokens.GTEQ ; } - case 128: break; + case 129: break; case 2: { return JetTokens.INTEGER_LITERAL; } - case 129: break; + case 130: break; case 13: { return JetTokens.RBRACE ; } - case 130: break; - case 86: + case 131: break; + case 87: { return JetTokens.CLASS_KEYWORD ; } - case 131: break; + case 132: break; case 14: { return JetTokens.EXCL ; } - case 132: break; + case 133: break; case 69: { return JetTokens.TRY_KEYWORD ; } - case 133: break; + case 134: break; case 52: { return JetTokens.EXCLEQ ; } - case 134: break; + case 135: break; case 45: { return JetTokens.MINUSEQ ; } - case 135: break; - case 88: + case 136: break; + case 89: { return JetTokens.THROW_KEYWORD ; } - case 136: break; - case 90: + case 137: break; + case 86: + { return JetTokens.SUPER_KEYWORD ; + } + case 138: break; + case 91: { return JetTokens.WHILE_KEYWORD ; } - case 137: break; + case 139: break; case 44: { return JetTokens.MINUSMINUS; } - case 138: break; - case 94: + case 140: break; + case 95: { return JetTokens.CONTINUE_KEYWORD ; } - case 139: break; + case 141: break; case 74: { return JetTokens.NOT_IN; } - case 140: break; + case 142: break; case 38: { return JetTokens.ATAT ; } - case 141: break; + case 143: break; case 6: { return JetTokens.DIV ; } - case 142: break; + case 144: break; case 37: { return JetTokens.LABEL_IDENTIFIER; } - case 143: break; + case 145: break; case 29: { return JetTokens.REGULAR_STRING_PART; } - case 144: break; + case 146: break; case 16: { return JetTokens.QUEST ; } - case 145: break; + case 147: break; case 60: { return JetTokens.OROR ; } - case 146: break; + case 148: break; case 20: { return JetTokens.PERC ; } - case 147: break; + case 149: break; case 76: { return JetTokens.EXCLEQEQEQ; } - case 148: break; + case 150: break; case 61: { return JetTokens.PERCEQ ; } - case 149: break; + case 151: break; case 43: { return JetTokens.RANGE ; } - case 150: break; + case 152: break; case 1: { return TokenType.BAD_CHARACTER; } - case 151: break; - case 95: + case 153: break; + case 96: { return JetTokens.NAMESPACE_KEYWORD ; } - case 152: break; + case 154: break; case 75: { return JetTokens.NOT_IS; } - case 153: break; + case 155: break; case 7: { return JetTokens.MUL ; } - case 154: break; + case 156: break; case 22: { return JetTokens.RBRACKET ; } - case 155: break; + case 157: break; case 56: { return JetTokens.PLUSPLUS ; } - case 156: break; + case 158: break; case 81: { return JetTokens.THIS_KEYWORD ; } - case 157: break; + case 159: break; case 8: { return JetTokens.DOT ; } - case 158: break; + case 160: break; case 26: { return JetTokens.SEMICOLON ; } - case 159: break; + case 161: break; case 50: { return JetTokens.IF_KEYWORD ; } - case 160: break; + case 162: break; case 64: { return JetTokens.ESCAPE_SEQUENCE; } - case 161: break; + case 163: break; case 31: { popState(); return JetTokens.CLOSING_QUOTE; } - case 162: break; + case 164: break; case 15: { return JetTokens.EQ ; } - case 163: break; + case 165: break; case 5: { return JetTokens.AT ; } - case 164: break; + case 166: break; case 68: { return JetTokens.AS_SAFE; } - case 165: break; + case 167: break; case 23: { return JetTokens.LPAR ; } - case 166: break; + case 168: break; case 9: { return JetTokens.MINUS ; } - case 167: break; - case 91: + case 169: break; + case 92: { return JetTokens.FALSE_KEYWORD ; } - case 168: break; + case 170: break; case 82: { return JetTokens.TYPE_KEYWORD ; } - case 169: break; + case 171: break; case 71: { return JetTokens.FUN_KEYWORD ; } - case 170: break; + case 172: break; case 49: { return JetTokens.IS_KEYWORD ; } - case 171: break; + case 173: break; case 30: { popState(); yypushback(1); return JetTokens.DANGLING_NEWLINE; } - case 172: break; + case 174: break; case 33: { lBraceCount++; return JetTokens.LBRACE; } - case 173: break; + case 175: break; case 85: { yypushback(3); return JetTokens.EXCL; } - case 174: break; + case 176: break; case 41: { return JetTokens.DIVEQ ; } - case 175: break; + case 177: break; case 79: { return JetTokens.ELSE_KEYWORD ; } - case 176: break; + case 178: break; case 47: { return JetTokens.AS_KEYWORD ; } - case 177: break; + case 179: break; case 48: { return JetTokens.IN_KEYWORD ; } - case 178: break; + case 180: break; case 53: { return JetTokens.EQEQ ; } - case 179: break; + case 181: break; case 77: { return JetTokens.EQEQEQ ; } - case 180: break; + case 182: break; case 73: { return JetTokens.VAL_KEYWORD ; } - case 181: break; + case 183: break; case 84: { return JetTokens.CAPITALIZED_THIS_KEYWORD ; } - case 182: break; + case 184: break; case 42: { return JetTokens.MULTEQ ; } - case 183: break; + case 185: break; case 62: { pushState(SHORT_TEMPLATE_ENTRY); yypushback(yylength() - 1); return JetTokens.SHORT_TEMPLATE_ENTRY_START; } - case 184: break; + case 186: break; case 12: { return JetTokens.LBRACE ; } - case 185: break; - case 92: + case 187: break; + case 93: { return JetTokens.OBJECT_KEYWORD ; } - case 186: break; - case 89: + case 188: break; + case 90: { return JetTokens.BREAK_KEYWORD ; } - case 187: break; + case 189: break; case 40: { return JetTokens.BLOCK_COMMENT; } - case 188: break; - case 87: + case 190: break; + case 88: { return JetTokens.TRAIT_KEYWORD ; } - case 189: break; + case 191: break; case 28: { return JetTokens.HASH ; } - case 190: break; + case 192: break; default: if (zzInput == YYEOF && zzStartRead == zzCurrentPos) { zzAtEOF = true; diff --git a/idea/testData/cfg/ArrayAccess.instructions b/compiler/testData/cfg/ArrayAccess.instructions similarity index 100% rename from idea/testData/cfg/ArrayAccess.instructions rename to compiler/testData/cfg/ArrayAccess.instructions diff --git a/idea/testData/cfg/ArrayAccess.jet b/compiler/testData/cfg/ArrayAccess.jet similarity index 100% rename from idea/testData/cfg/ArrayAccess.jet rename to compiler/testData/cfg/ArrayAccess.jet diff --git a/idea/testData/cfg/Assignments.instructions b/compiler/testData/cfg/Assignments.instructions similarity index 100% rename from idea/testData/cfg/Assignments.instructions rename to compiler/testData/cfg/Assignments.instructions diff --git a/idea/testData/cfg/Assignments.jet b/compiler/testData/cfg/Assignments.jet similarity index 100% rename from idea/testData/cfg/Assignments.jet rename to compiler/testData/cfg/Assignments.jet diff --git a/idea/testData/cfg/Basic.instructions b/compiler/testData/cfg/Basic.instructions similarity index 100% rename from idea/testData/cfg/Basic.instructions rename to compiler/testData/cfg/Basic.instructions diff --git a/idea/testData/cfg/Basic.jet b/compiler/testData/cfg/Basic.jet similarity index 100% rename from idea/testData/cfg/Basic.jet rename to compiler/testData/cfg/Basic.jet diff --git a/idea/testData/cfg/EmptyFunction.instructions b/compiler/testData/cfg/EmptyFunction.instructions similarity index 100% rename from idea/testData/cfg/EmptyFunction.instructions rename to compiler/testData/cfg/EmptyFunction.instructions diff --git a/idea/testData/cfg/EmptyFunction.jet b/compiler/testData/cfg/EmptyFunction.jet similarity index 100% rename from idea/testData/cfg/EmptyFunction.jet rename to compiler/testData/cfg/EmptyFunction.jet diff --git a/idea/testData/cfg/FailFunction.instructions b/compiler/testData/cfg/FailFunction.instructions similarity index 100% rename from idea/testData/cfg/FailFunction.instructions rename to compiler/testData/cfg/FailFunction.instructions diff --git a/idea/testData/cfg/FailFunction.jet b/compiler/testData/cfg/FailFunction.jet similarity index 100% rename from idea/testData/cfg/FailFunction.jet rename to compiler/testData/cfg/FailFunction.jet diff --git a/idea/testData/cfg/Finally.instructions b/compiler/testData/cfg/Finally.instructions similarity index 100% rename from idea/testData/cfg/Finally.instructions rename to compiler/testData/cfg/Finally.instructions diff --git a/idea/testData/cfg/Finally.jet b/compiler/testData/cfg/Finally.jet similarity index 100% rename from idea/testData/cfg/Finally.jet rename to compiler/testData/cfg/Finally.jet diff --git a/idea/testData/cfg/LazyBooleans.instructions b/compiler/testData/cfg/LazyBooleans.instructions similarity index 100% rename from idea/testData/cfg/LazyBooleans.instructions rename to compiler/testData/cfg/LazyBooleans.instructions diff --git a/idea/testData/cfg/LazyBooleans.jet b/compiler/testData/cfg/LazyBooleans.jet similarity index 100% rename from idea/testData/cfg/LazyBooleans.jet rename to compiler/testData/cfg/LazyBooleans.jet diff --git a/idea/testData/cfg/OnlyWhileInFunctionBody.instructions b/compiler/testData/cfg/OnlyWhileInFunctionBody.instructions similarity index 100% rename from idea/testData/cfg/OnlyWhileInFunctionBody.instructions rename to compiler/testData/cfg/OnlyWhileInFunctionBody.instructions diff --git a/idea/testData/cfg/OnlyWhileInFunctionBody.jet b/compiler/testData/cfg/OnlyWhileInFunctionBody.jet similarity index 100% rename from idea/testData/cfg/OnlyWhileInFunctionBody.jet rename to compiler/testData/cfg/OnlyWhileInFunctionBody.jet diff --git a/idea/testData/cfg/ReturnFromExpression.instructions b/compiler/testData/cfg/ReturnFromExpression.instructions similarity index 100% rename from idea/testData/cfg/ReturnFromExpression.instructions rename to compiler/testData/cfg/ReturnFromExpression.instructions diff --git a/idea/testData/cfg/ReturnFromExpression.jet b/compiler/testData/cfg/ReturnFromExpression.jet similarity index 100% rename from idea/testData/cfg/ReturnFromExpression.jet rename to compiler/testData/cfg/ReturnFromExpression.jet diff --git a/idea/testData/cfg/ShortFunction.instructions b/compiler/testData/cfg/ShortFunction.instructions similarity index 100% rename from idea/testData/cfg/ShortFunction.instructions rename to compiler/testData/cfg/ShortFunction.instructions diff --git a/idea/testData/cfg/ShortFunction.jet b/compiler/testData/cfg/ShortFunction.jet similarity index 100% rename from idea/testData/cfg/ShortFunction.jet rename to compiler/testData/cfg/ShortFunction.jet diff --git a/idea/testData/checker/Abstract.jet b/compiler/testData/checker/Abstract.jet similarity index 100% rename from idea/testData/checker/Abstract.jet rename to compiler/testData/checker/Abstract.jet diff --git a/idea/testData/checker/AnonymousInitializers.jet b/compiler/testData/checker/AnonymousInitializers.jet similarity index 100% rename from idea/testData/checker/AnonymousInitializers.jet rename to compiler/testData/checker/AnonymousInitializers.jet diff --git a/idea/testData/checker/BinaryCallsOnNullableValues.jet b/compiler/testData/checker/BinaryCallsOnNullableValues.jet similarity index 100% rename from idea/testData/checker/BinaryCallsOnNullableValues.jet rename to compiler/testData/checker/BinaryCallsOnNullableValues.jet diff --git a/idea/testData/checker/Bounds.jet b/compiler/testData/checker/Bounds.jet similarity index 100% rename from idea/testData/checker/Bounds.jet rename to compiler/testData/checker/Bounds.jet diff --git a/idea/testData/checker/BreakContinue.jet b/compiler/testData/checker/BreakContinue.jet similarity index 100% rename from idea/testData/checker/BreakContinue.jet rename to compiler/testData/checker/BreakContinue.jet diff --git a/idea/testData/checker/Builders.jet b/compiler/testData/checker/Builders.jet similarity index 100% rename from idea/testData/checker/Builders.jet rename to compiler/testData/checker/Builders.jet diff --git a/idea/testData/checker/Casts.jet b/compiler/testData/checker/Casts.jet similarity index 100% rename from idea/testData/checker/Casts.jet rename to compiler/testData/checker/Casts.jet diff --git a/idea/testData/checker/ClassObjects.jet b/compiler/testData/checker/ClassObjects.jet similarity index 100% rename from idea/testData/checker/ClassObjects.jet rename to compiler/testData/checker/ClassObjects.jet diff --git a/idea/testData/checker/Constants.jet b/compiler/testData/checker/Constants.jet similarity index 100% rename from idea/testData/checker/Constants.jet rename to compiler/testData/checker/Constants.jet diff --git a/idea/testData/checker/Constructors.jet b/compiler/testData/checker/Constructors.jet similarity index 100% rename from idea/testData/checker/Constructors.jet rename to compiler/testData/checker/Constructors.jet diff --git a/idea/testData/checker/CyclicHierarchy.jet b/compiler/testData/checker/CyclicHierarchy.jet similarity index 100% rename from idea/testData/checker/CyclicHierarchy.jet rename to compiler/testData/checker/CyclicHierarchy.jet diff --git a/idea/testData/checker/Enums.jet b/compiler/testData/checker/Enums.jet similarity index 100% rename from idea/testData/checker/Enums.jet rename to compiler/testData/checker/Enums.jet diff --git a/idea/testData/checker/ExtensionFunctions.jet b/compiler/testData/checker/ExtensionFunctions.jet similarity index 100% rename from idea/testData/checker/ExtensionFunctions.jet rename to compiler/testData/checker/ExtensionFunctions.jet diff --git a/idea/testData/checker/ForRangeConventions.jet b/compiler/testData/checker/ForRangeConventions.jet similarity index 100% rename from idea/testData/checker/ForRangeConventions.jet rename to compiler/testData/checker/ForRangeConventions.jet diff --git a/idea/testData/checker/FunctionReturnTypes.jet b/compiler/testData/checker/FunctionReturnTypes.jet similarity index 100% rename from idea/testData/checker/FunctionReturnTypes.jet rename to compiler/testData/checker/FunctionReturnTypes.jet diff --git a/idea/testData/checker/GenericArgumentConsistency.jet b/compiler/testData/checker/GenericArgumentConsistency.jet similarity index 100% rename from idea/testData/checker/GenericArgumentConsistency.jet rename to compiler/testData/checker/GenericArgumentConsistency.jet diff --git a/idea/testData/checker/IncDec.jet b/compiler/testData/checker/IncDec.jet similarity index 100% rename from idea/testData/checker/IncDec.jet rename to compiler/testData/checker/IncDec.jet diff --git a/idea/testData/checker/IsExpressions.jet b/compiler/testData/checker/IsExpressions.jet similarity index 100% rename from idea/testData/checker/IsExpressions.jet rename to compiler/testData/checker/IsExpressions.jet diff --git a/idea/testData/checker/MultipleBounds.jet b/compiler/testData/checker/MultipleBounds.jet similarity index 100% rename from idea/testData/checker/MultipleBounds.jet rename to compiler/testData/checker/MultipleBounds.jet diff --git a/idea/testData/checker/NamespaceAsExpression.jet b/compiler/testData/checker/NamespaceAsExpression.jet similarity index 100% rename from idea/testData/checker/NamespaceAsExpression.jet rename to compiler/testData/checker/NamespaceAsExpression.jet diff --git a/idea/testData/checker/NamespaceQualified.jet b/compiler/testData/checker/NamespaceQualified.jet similarity index 100% rename from idea/testData/checker/NamespaceQualified.jet rename to compiler/testData/checker/NamespaceQualified.jet diff --git a/idea/testData/checker/Nullability.jet b/compiler/testData/checker/Nullability.jet similarity index 100% rename from idea/testData/checker/Nullability.jet rename to compiler/testData/checker/Nullability.jet diff --git a/idea/testData/checker/Objects.jet b/compiler/testData/checker/Objects.jet similarity index 100% rename from idea/testData/checker/Objects.jet rename to compiler/testData/checker/Objects.jet diff --git a/idea/testData/checker/Override.jet b/compiler/testData/checker/Override.jet similarity index 100% rename from idea/testData/checker/Override.jet rename to compiler/testData/checker/Override.jet diff --git a/idea/testData/checker/PrimaryConstructors.jet b/compiler/testData/checker/PrimaryConstructors.jet similarity index 100% rename from idea/testData/checker/PrimaryConstructors.jet rename to compiler/testData/checker/PrimaryConstructors.jet diff --git a/idea/testData/checker/ProjectionsInSupertypes.jet b/compiler/testData/checker/ProjectionsInSupertypes.jet similarity index 100% rename from idea/testData/checker/ProjectionsInSupertypes.jet rename to compiler/testData/checker/ProjectionsInSupertypes.jet diff --git a/idea/testData/checker/Properties.jet b/compiler/testData/checker/Properties.jet similarity index 100% rename from idea/testData/checker/Properties.jet rename to compiler/testData/checker/Properties.jet diff --git a/idea/testData/checker/QualifiedExpressions.jet b/compiler/testData/checker/QualifiedExpressions.jet similarity index 100% rename from idea/testData/checker/QualifiedExpressions.jet rename to compiler/testData/checker/QualifiedExpressions.jet diff --git a/idea/testData/checker/QualifiedThis.jet b/compiler/testData/checker/QualifiedThis.jet similarity index 100% rename from idea/testData/checker/QualifiedThis.jet rename to compiler/testData/checker/QualifiedThis.jet diff --git a/idea/testData/checker/RecursiveTypeInference.jet b/compiler/testData/checker/RecursiveTypeInference.jet similarity index 100% rename from idea/testData/checker/RecursiveTypeInference.jet rename to compiler/testData/checker/RecursiveTypeInference.jet diff --git a/idea/testData/checker/Redeclarations.jet b/compiler/testData/checker/Redeclarations.jet similarity index 100% rename from idea/testData/checker/Redeclarations.jet rename to compiler/testData/checker/Redeclarations.jet diff --git a/idea/testData/checker/ResolveToJava.jet b/compiler/testData/checker/ResolveToJava.jet similarity index 100% rename from idea/testData/checker/ResolveToJava.jet rename to compiler/testData/checker/ResolveToJava.jet diff --git a/idea/testData/checker/StringTemplates.jet b/compiler/testData/checker/StringTemplates.jet similarity index 100% rename from idea/testData/checker/StringTemplates.jet rename to compiler/testData/checker/StringTemplates.jet diff --git a/idea/testData/checker/SupertypeListChecks.jet b/compiler/testData/checker/SupertypeListChecks.jet similarity index 100% rename from idea/testData/checker/SupertypeListChecks.jet rename to compiler/testData/checker/SupertypeListChecks.jet diff --git a/idea/testData/checker/TraitSupertypeList.jet b/compiler/testData/checker/TraitSupertypeList.jet similarity index 100% rename from idea/testData/checker/TraitSupertypeList.jet rename to compiler/testData/checker/TraitSupertypeList.jet diff --git a/idea/testData/checker/UnreachableCode.jet b/compiler/testData/checker/UnreachableCode.jet similarity index 100% rename from idea/testData/checker/UnreachableCode.jet rename to compiler/testData/checker/UnreachableCode.jet diff --git a/idea/testData/checker/Unresolved.jet b/compiler/testData/checker/Unresolved.jet similarity index 100% rename from idea/testData/checker/Unresolved.jet rename to compiler/testData/checker/Unresolved.jet diff --git a/idea/testData/checker/Variance.jet b/compiler/testData/checker/Variance.jet similarity index 100% rename from idea/testData/checker/Variance.jet rename to compiler/testData/checker/Variance.jet diff --git a/idea/testData/checker/When.jet b/compiler/testData/checker/When.jet similarity index 100% rename from idea/testData/checker/When.jet rename to compiler/testData/checker/When.jet diff --git a/idea/testData/checker/infos/Autocasts.jet b/compiler/testData/checker/infos/Autocasts.jet similarity index 98% rename from idea/testData/checker/infos/Autocasts.jet rename to compiler/testData/checker/infos/Autocasts.jet index 6749da3c345..fc5f8807328 100644 --- a/idea/testData/checker/infos/Autocasts.jet +++ b/compiler/testData/checker/infos/Autocasts.jet @@ -187,11 +187,11 @@ fun tuples(a: Any?) { val s: (Any, String) = (a, a) } if (a is String) { - val s: (Any, String) = (a, a) + val s: (Any, String) = (a, a) } fun illegalTupleReturnType(): (Any, String) = (a, a) if (a is String) { - fun legalTupleReturnType(): (Any, String) = (a, a) + fun legalTupleReturnType(): (Any, String) = (a, a) } val illegalFunctionLiteral: Function0 = { a } val illegalReturnValueInFunctionLiteral: Function0 = { (): Int => a } diff --git a/idea/testData/checker/infos/PropertiesWithBackingFields.jet b/compiler/testData/checker/infos/PropertiesWithBackingFields.jet similarity index 100% rename from idea/testData/checker/infos/PropertiesWithBackingFields.jet rename to compiler/testData/checker/infos/PropertiesWithBackingFields.jet diff --git a/idea/testData/checker/infos/WrapIntoRef.jet b/compiler/testData/checker/infos/WrapIntoRef.jet similarity index 100% rename from idea/testData/checker/infos/WrapIntoRef.jet rename to compiler/testData/checker/infos/WrapIntoRef.jet diff --git a/idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet b/compiler/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet similarity index 100% rename from idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet rename to compiler/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet diff --git a/idea/testData/checker/regression/AssignmentsUnderOperators.jet b/compiler/testData/checker/regression/AssignmentsUnderOperators.jet similarity index 100% rename from idea/testData/checker/regression/AssignmentsUnderOperators.jet rename to compiler/testData/checker/regression/AssignmentsUnderOperators.jet diff --git a/idea/testData/checker/regression/CoercionToUnit.jet b/compiler/testData/checker/regression/CoercionToUnit.jet similarity index 100% rename from idea/testData/checker/regression/CoercionToUnit.jet rename to compiler/testData/checker/regression/CoercionToUnit.jet diff --git a/idea/testData/checker/regression/DoubleDefine.jet b/compiler/testData/checker/regression/DoubleDefine.jet similarity index 100% rename from idea/testData/checker/regression/DoubleDefine.jet rename to compiler/testData/checker/regression/DoubleDefine.jet diff --git a/idea/testData/checker/regression/Jet11.jet b/compiler/testData/checker/regression/Jet11.jet similarity index 100% rename from idea/testData/checker/regression/Jet11.jet rename to compiler/testData/checker/regression/Jet11.jet diff --git a/idea/testData/checker/regression/Jet121.jet b/compiler/testData/checker/regression/Jet121.jet similarity index 100% rename from idea/testData/checker/regression/Jet121.jet rename to compiler/testData/checker/regression/Jet121.jet diff --git a/idea/testData/checker/regression/Jet124.jet b/compiler/testData/checker/regression/Jet124.jet similarity index 100% rename from idea/testData/checker/regression/Jet124.jet rename to compiler/testData/checker/regression/Jet124.jet diff --git a/idea/testData/checker/regression/Jet169.jet b/compiler/testData/checker/regression/Jet169.jet similarity index 100% rename from idea/testData/checker/regression/Jet169.jet rename to compiler/testData/checker/regression/Jet169.jet diff --git a/idea/testData/checker/regression/Jet17.jet b/compiler/testData/checker/regression/Jet17.jet similarity index 100% rename from idea/testData/checker/regression/Jet17.jet rename to compiler/testData/checker/regression/Jet17.jet diff --git a/idea/testData/checker/regression/Jet183-1.jet b/compiler/testData/checker/regression/Jet183-1.jet similarity index 100% rename from idea/testData/checker/regression/Jet183-1.jet rename to compiler/testData/checker/regression/Jet183-1.jet diff --git a/idea/testData/checker/regression/Jet183.jet b/compiler/testData/checker/regression/Jet183.jet similarity index 100% rename from idea/testData/checker/regression/Jet183.jet rename to compiler/testData/checker/regression/Jet183.jet diff --git a/idea/testData/checker/regression/Jet53.jet b/compiler/testData/checker/regression/Jet53.jet similarity index 100% rename from idea/testData/checker/regression/Jet53.jet rename to compiler/testData/checker/regression/Jet53.jet diff --git a/idea/testData/checker/regression/Jet67.jet b/compiler/testData/checker/regression/Jet67.jet similarity index 100% rename from idea/testData/checker/regression/Jet67.jet rename to compiler/testData/checker/regression/Jet67.jet diff --git a/idea/testData/checker/regression/Jet68.jet b/compiler/testData/checker/regression/Jet68.jet similarity index 100% rename from idea/testData/checker/regression/Jet68.jet rename to compiler/testData/checker/regression/Jet68.jet diff --git a/idea/testData/checker/regression/Jet69.jet b/compiler/testData/checker/regression/Jet69.jet similarity index 100% rename from idea/testData/checker/regression/Jet69.jet rename to compiler/testData/checker/regression/Jet69.jet diff --git a/idea/testData/checker/regression/Jet72.jet b/compiler/testData/checker/regression/Jet72.jet similarity index 100% rename from idea/testData/checker/regression/Jet72.jet rename to compiler/testData/checker/regression/Jet72.jet diff --git a/idea/testData/checker/regression/Jet81.jet b/compiler/testData/checker/regression/Jet81.jet similarity index 100% rename from idea/testData/checker/regression/Jet81.jet rename to compiler/testData/checker/regression/Jet81.jet diff --git a/idea/testData/checker/regression/OverrideResolution.jet b/compiler/testData/checker/regression/OverrideResolution.jet similarity index 100% rename from idea/testData/checker/regression/OverrideResolution.jet rename to compiler/testData/checker/regression/OverrideResolution.jet diff --git a/idea/testData/checker/regression/ScopeForSecondaryConstructors.jet b/compiler/testData/checker/regression/ScopeForSecondaryConstructors.jet similarity index 100% rename from idea/testData/checker/regression/ScopeForSecondaryConstructors.jet rename to compiler/testData/checker/regression/ScopeForSecondaryConstructors.jet diff --git a/idea/testData/checker/regression/SpecififcityByReceiver.jet b/compiler/testData/checker/regression/SpecififcityByReceiver.jet similarity index 100% rename from idea/testData/checker/regression/SpecififcityByReceiver.jet rename to compiler/testData/checker/regression/SpecififcityByReceiver.jet diff --git a/idea/testData/checker/regression/ThisConstructorInGenericClass.jet b/compiler/testData/checker/regression/ThisConstructorInGenericClass.jet similarity index 100% rename from idea/testData/checker/regression/ThisConstructorInGenericClass.jet rename to compiler/testData/checker/regression/ThisConstructorInGenericClass.jet diff --git a/idea/testData/checker/regression/WrongTraceInCallResolver.jet b/compiler/testData/checker/regression/WrongTraceInCallResolver.jet similarity index 100% rename from idea/testData/checker/regression/WrongTraceInCallResolver.jet rename to compiler/testData/checker/regression/WrongTraceInCallResolver.jet diff --git a/idea/testData/checker/regression/kt251.jet b/compiler/testData/checker/regression/kt251.jet similarity index 100% rename from idea/testData/checker/regression/kt251.jet rename to compiler/testData/checker/regression/kt251.jet diff --git a/idea/testData/checker/regression/kt303.jet b/compiler/testData/checker/regression/kt303.jet similarity index 100% rename from idea/testData/checker/regression/kt303.jet rename to compiler/testData/checker/regression/kt303.jet diff --git a/idea/testData/checkerWithErrorTypes/checkerTestUtil/test.jet b/compiler/testData/checkerWithErrorTypes/checkerTestUtil/test.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/checkerTestUtil/test.jet rename to compiler/testData/checkerWithErrorTypes/checkerTestUtil/test.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Abstract.jet b/compiler/testData/checkerWithErrorTypes/full/Abstract.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Abstract.jet rename to compiler/testData/checkerWithErrorTypes/full/Abstract.jet diff --git a/idea/testData/checkerWithErrorTypes/full/AnonymousInitializers.jet b/compiler/testData/checkerWithErrorTypes/full/AnonymousInitializers.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/AnonymousInitializers.jet rename to compiler/testData/checkerWithErrorTypes/full/AnonymousInitializers.jet diff --git a/idea/testData/checkerWithErrorTypes/full/BinaryCallsOnNullableValues.jet b/compiler/testData/checkerWithErrorTypes/full/BinaryCallsOnNullableValues.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/BinaryCallsOnNullableValues.jet rename to compiler/testData/checkerWithErrorTypes/full/BinaryCallsOnNullableValues.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Bounds.jet b/compiler/testData/checkerWithErrorTypes/full/Bounds.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Bounds.jet rename to compiler/testData/checkerWithErrorTypes/full/Bounds.jet diff --git a/idea/testData/checkerWithErrorTypes/full/BreakContinue.jet b/compiler/testData/checkerWithErrorTypes/full/BreakContinue.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/BreakContinue.jet rename to compiler/testData/checkerWithErrorTypes/full/BreakContinue.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Builders.jet b/compiler/testData/checkerWithErrorTypes/full/Builders.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Builders.jet rename to compiler/testData/checkerWithErrorTypes/full/Builders.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Casts.jet b/compiler/testData/checkerWithErrorTypes/full/Casts.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Casts.jet rename to compiler/testData/checkerWithErrorTypes/full/Casts.jet diff --git a/idea/testData/checkerWithErrorTypes/full/ClassObjects.jet b/compiler/testData/checkerWithErrorTypes/full/ClassObjects.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/ClassObjects.jet rename to compiler/testData/checkerWithErrorTypes/full/ClassObjects.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Constants.jet b/compiler/testData/checkerWithErrorTypes/full/Constants.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Constants.jet rename to compiler/testData/checkerWithErrorTypes/full/Constants.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Constructors.jet b/compiler/testData/checkerWithErrorTypes/full/Constructors.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Constructors.jet rename to compiler/testData/checkerWithErrorTypes/full/Constructors.jet diff --git a/idea/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet b/compiler/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet rename to compiler/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet diff --git a/idea/testData/checkerWithErrorTypes/full/CyclicHierarchy.jet b/compiler/testData/checkerWithErrorTypes/full/CyclicHierarchy.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/CyclicHierarchy.jet rename to compiler/testData/checkerWithErrorTypes/full/CyclicHierarchy.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Enums.jet b/compiler/testData/checkerWithErrorTypes/full/Enums.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Enums.jet rename to compiler/testData/checkerWithErrorTypes/full/Enums.jet diff --git a/idea/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet b/compiler/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet rename to compiler/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet diff --git a/idea/testData/checkerWithErrorTypes/full/ForRangeConventions.jet b/compiler/testData/checkerWithErrorTypes/full/ForRangeConventions.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/ForRangeConventions.jet rename to compiler/testData/checkerWithErrorTypes/full/ForRangeConventions.jet diff --git a/idea/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet b/compiler/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet rename to compiler/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet diff --git a/idea/testData/checkerWithErrorTypes/full/GenericArgumentConsistency.jet b/compiler/testData/checkerWithErrorTypes/full/GenericArgumentConsistency.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/GenericArgumentConsistency.jet rename to compiler/testData/checkerWithErrorTypes/full/GenericArgumentConsistency.jet diff --git a/idea/testData/checkerWithErrorTypes/full/IllegalModifiers.jet b/compiler/testData/checkerWithErrorTypes/full/IllegalModifiers.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/IllegalModifiers.jet rename to compiler/testData/checkerWithErrorTypes/full/IllegalModifiers.jet diff --git a/idea/testData/checkerWithErrorTypes/full/IncDec.jet b/compiler/testData/checkerWithErrorTypes/full/IncDec.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/IncDec.jet rename to compiler/testData/checkerWithErrorTypes/full/IncDec.jet diff --git a/idea/testData/checkerWithErrorTypes/full/IsExpressions.jet b/compiler/testData/checkerWithErrorTypes/full/IsExpressions.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/IsExpressions.jet rename to compiler/testData/checkerWithErrorTypes/full/IsExpressions.jet diff --git a/idea/testData/checkerWithErrorTypes/full/MultipleBounds.jet b/compiler/testData/checkerWithErrorTypes/full/MultipleBounds.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/MultipleBounds.jet rename to compiler/testData/checkerWithErrorTypes/full/MultipleBounds.jet diff --git a/idea/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet b/compiler/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet rename to compiler/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet diff --git a/idea/testData/checkerWithErrorTypes/full/NamespaceInExpressionPosition.jet b/compiler/testData/checkerWithErrorTypes/full/NamespaceInExpressionPosition.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/NamespaceInExpressionPosition.jet rename to compiler/testData/checkerWithErrorTypes/full/NamespaceInExpressionPosition.jet diff --git a/idea/testData/checkerWithErrorTypes/full/NamespaceQualified.jet b/compiler/testData/checkerWithErrorTypes/full/NamespaceQualified.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/NamespaceQualified.jet rename to compiler/testData/checkerWithErrorTypes/full/NamespaceQualified.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Nullability.jet b/compiler/testData/checkerWithErrorTypes/full/Nullability.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Nullability.jet rename to compiler/testData/checkerWithErrorTypes/full/Nullability.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Objects.jet b/compiler/testData/checkerWithErrorTypes/full/Objects.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Objects.jet rename to compiler/testData/checkerWithErrorTypes/full/Objects.jet diff --git a/idea/testData/checkerWithErrorTypes/full/PrimaryConstructors.jet b/compiler/testData/checkerWithErrorTypes/full/PrimaryConstructors.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/PrimaryConstructors.jet rename to compiler/testData/checkerWithErrorTypes/full/PrimaryConstructors.jet diff --git a/idea/testData/checkerWithErrorTypes/full/ProjectionsInSupertypes.jet b/compiler/testData/checkerWithErrorTypes/full/ProjectionsInSupertypes.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/ProjectionsInSupertypes.jet rename to compiler/testData/checkerWithErrorTypes/full/ProjectionsInSupertypes.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Properties.jet b/compiler/testData/checkerWithErrorTypes/full/Properties.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Properties.jet rename to compiler/testData/checkerWithErrorTypes/full/Properties.jet diff --git a/idea/testData/checkerWithErrorTypes/full/QualifiedExpressions.jet b/compiler/testData/checkerWithErrorTypes/full/QualifiedExpressions.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/QualifiedExpressions.jet rename to compiler/testData/checkerWithErrorTypes/full/QualifiedExpressions.jet diff --git a/idea/testData/checkerWithErrorTypes/full/QualifiedThis.jet b/compiler/testData/checkerWithErrorTypes/full/QualifiedThis.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/QualifiedThis.jet rename to compiler/testData/checkerWithErrorTypes/full/QualifiedThis.jet diff --git a/idea/testData/checkerWithErrorTypes/full/RecursiveTypeInference.jet b/compiler/testData/checkerWithErrorTypes/full/RecursiveTypeInference.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/RecursiveTypeInference.jet rename to compiler/testData/checkerWithErrorTypes/full/RecursiveTypeInference.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Redeclarations.jet b/compiler/testData/checkerWithErrorTypes/full/Redeclarations.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Redeclarations.jet rename to compiler/testData/checkerWithErrorTypes/full/Redeclarations.jet diff --git a/idea/testData/checkerWithErrorTypes/full/ResolveToJava.jet b/compiler/testData/checkerWithErrorTypes/full/ResolveToJava.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/ResolveToJava.jet rename to compiler/testData/checkerWithErrorTypes/full/ResolveToJava.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Return.jet b/compiler/testData/checkerWithErrorTypes/full/Return.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Return.jet rename to compiler/testData/checkerWithErrorTypes/full/Return.jet diff --git a/idea/testData/checkerWithErrorTypes/full/StringTemplates.jet b/compiler/testData/checkerWithErrorTypes/full/StringTemplates.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/StringTemplates.jet rename to compiler/testData/checkerWithErrorTypes/full/StringTemplates.jet diff --git a/idea/testData/checkerWithErrorTypes/full/SupertypeListChecks.jet b/compiler/testData/checkerWithErrorTypes/full/SupertypeListChecks.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/SupertypeListChecks.jet rename to compiler/testData/checkerWithErrorTypes/full/SupertypeListChecks.jet diff --git a/idea/testData/checkerWithErrorTypes/full/TraitSupertypeList.jet b/compiler/testData/checkerWithErrorTypes/full/TraitSupertypeList.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/TraitSupertypeList.jet rename to compiler/testData/checkerWithErrorTypes/full/TraitSupertypeList.jet diff --git a/idea/testData/checkerWithErrorTypes/full/UnreachableCode.jet b/compiler/testData/checkerWithErrorTypes/full/UnreachableCode.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/UnreachableCode.jet rename to compiler/testData/checkerWithErrorTypes/full/UnreachableCode.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Unresolved.jet b/compiler/testData/checkerWithErrorTypes/full/Unresolved.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Unresolved.jet rename to compiler/testData/checkerWithErrorTypes/full/Unresolved.jet diff --git a/idea/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet b/compiler/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet rename to compiler/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet diff --git a/idea/testData/checkerWithErrorTypes/full/Variance.jet b/compiler/testData/checkerWithErrorTypes/full/Variance.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/Variance.jet rename to compiler/testData/checkerWithErrorTypes/full/Variance.jet diff --git a/idea/testData/checkerWithErrorTypes/full/When.jet b/compiler/testData/checkerWithErrorTypes/full/When.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/When.jet rename to compiler/testData/checkerWithErrorTypes/full/When.jet diff --git a/idea/testData/checkerWithErrorTypes/full/infos/Autocasts.jet b/compiler/testData/checkerWithErrorTypes/full/infos/Autocasts.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/infos/Autocasts.jet rename to compiler/testData/checkerWithErrorTypes/full/infos/Autocasts.jet diff --git a/idea/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet b/compiler/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet rename to compiler/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/AmbiguityOnLazyTypeComputation.jet b/compiler/testData/checkerWithErrorTypes/full/regression/AmbiguityOnLazyTypeComputation.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/AmbiguityOnLazyTypeComputation.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/AmbiguityOnLazyTypeComputation.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/AssignmentsUnderOperators.jet b/compiler/testData/checkerWithErrorTypes/full/regression/AssignmentsUnderOperators.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/AssignmentsUnderOperators.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/AssignmentsUnderOperators.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/CoercionToUnit.jet b/compiler/testData/checkerWithErrorTypes/full/regression/CoercionToUnit.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/CoercionToUnit.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/CoercionToUnit.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet b/compiler/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet11.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet11.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet11.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet11.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet121.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet121.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet121.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet121.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet124.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet124.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet124.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet124.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet169.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet169.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet169.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet169.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet17.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet17.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet17.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet17.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet183-1.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet183-1.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet183-1.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet183-1.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet183.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet183.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet183.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet183.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet53.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet53.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet53.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet53.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet67.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet67.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet67.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet67.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet68.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet68.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet68.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet68.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet69.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet69.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet69.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet69.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet72.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet72.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet72.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet72.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet81.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet81.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/Jet81.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/Jet81.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/OverrideResolution.jet b/compiler/testData/checkerWithErrorTypes/full/regression/OverrideResolution.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/OverrideResolution.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/OverrideResolution.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet b/compiler/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/SpecififcityByReceiver.jet b/compiler/testData/checkerWithErrorTypes/full/regression/SpecififcityByReceiver.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/SpecififcityByReceiver.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/SpecififcityByReceiver.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/ThisConstructorInGenericClass.jet b/compiler/testData/checkerWithErrorTypes/full/regression/ThisConstructorInGenericClass.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/ThisConstructorInGenericClass.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/ThisConstructorInGenericClass.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/WrongTraceInCallResolver.jet b/compiler/testData/checkerWithErrorTypes/full/regression/WrongTraceInCallResolver.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/WrongTraceInCallResolver.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/WrongTraceInCallResolver.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/kt251.jet b/compiler/testData/checkerWithErrorTypes/full/regression/kt251.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/kt251.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/kt251.jet diff --git a/idea/testData/checkerWithErrorTypes/full/regression/kt303.jet b/compiler/testData/checkerWithErrorTypes/full/regression/kt303.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/full/regression/kt303.jet rename to compiler/testData/checkerWithErrorTypes/full/regression/kt303.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet b/compiler/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet rename to compiler/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/AutocastAmbiguitites.jet b/compiler/testData/checkerWithErrorTypes/quick/AutocastAmbiguitites.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/AutocastAmbiguitites.jet rename to compiler/testData/checkerWithErrorTypes/quick/AutocastAmbiguitites.jet diff --git a/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet b/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet new file mode 100644 index 00000000000..6bb9d5f51db --- /dev/null +++ b/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet @@ -0,0 +1,91 @@ +namespace example; + +namespace ns { + val y : Any? = 2 +} + +object Obj { + val y : Any? = 2 +} + +class AClass() { + class object { + val y : Any? = 2 + } +} + +val x : Any? = 1 + +fun Any?.vars(a: Any?) : Int { + var b: Int = 0 + if (ns.y is Int) { + b = ns.y + } + if (ns.y is Int) { + b = example.ns.y + } + if (example.ns.y is Int) { + b = ns.y + } + if (example.ns.y is Int) { + b = example.ns.y + } +// if (namespace.bottles.ns.y is Int) { +// b = ns.y +// } + if (Obj.y is Int) { + b = Obj.y + } + if (example.Obj.y is Int) { + b = Obj.y + } + if (AClass.y is Int) { + b = AClass.y + } + if (example.AClass.y is Int) { + b = AClass.y + } + if (x is Int) { + b = x + } + if (example.x is Int) { + b = x + } + if (example.x is Int) { + b = example.x + } + return 1 +} + +fun Any?.foo() : Int { + if (this is Int) + return this + if (this@foo is Int) + return this + if (this@foo is Int) + return this@foo + if (this is Int) + return this@foo + return 1 +} + + +trait T {} + +open class C { + fun foo() { + var t : T? = null + if (this is T) { + t = this + } + if (this is T) { + t = this@C + } + if (this@C is T) { + t = this + } + if (this@C is T) { + t = this@C + } + } +} \ No newline at end of file diff --git a/idea/testData/checkerWithErrorTypes/quick/Basic.jet b/compiler/testData/checkerWithErrorTypes/quick/Basic.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/Basic.jet rename to compiler/testData/checkerWithErrorTypes/quick/Basic.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet b/compiler/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet rename to compiler/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/DeferredTypes.jet b/compiler/testData/checkerWithErrorTypes/quick/DeferredTypes.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/DeferredTypes.jet rename to compiler/testData/checkerWithErrorTypes/quick/DeferredTypes.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/DelegationAndOverriding.jet b/compiler/testData/checkerWithErrorTypes/quick/DelegationAndOverriding.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/DelegationAndOverriding.jet rename to compiler/testData/checkerWithErrorTypes/quick/DelegationAndOverriding.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/DelegationNotTotrait.jet b/compiler/testData/checkerWithErrorTypes/quick/DelegationNotTotrait.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/DelegationNotTotrait.jet rename to compiler/testData/checkerWithErrorTypes/quick/DelegationNotTotrait.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet b/compiler/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet rename to compiler/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/Override.jet b/compiler/testData/checkerWithErrorTypes/quick/Override.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/Override.jet rename to compiler/testData/checkerWithErrorTypes/quick/Override.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/OverridingVarByVal.jet b/compiler/testData/checkerWithErrorTypes/quick/OverridingVarByVal.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/OverridingVarByVal.jet rename to compiler/testData/checkerWithErrorTypes/quick/OverridingVarByVal.jet diff --git a/compiler/testData/checkerWithErrorTypes/quick/Super.jet b/compiler/testData/checkerWithErrorTypes/quick/Super.jet new file mode 100644 index 00000000000..5ec4cfdcb00 --- /dev/null +++ b/compiler/testData/checkerWithErrorTypes/quick/Super.jet @@ -0,0 +1,77 @@ +namespace example; + +trait T { + fun foo() {} +} +open class C() { + fun bar() {} +} + +class A() : C(), T { + + fun test() { + super + super + super.foo() + super.foo() + super.bar() + super@A.foo() + super@A.bar() + super<E>.bar() + super<E>@A.bar() + super<Int>.foo() + super<>.foo() + super<fun() : Unit>.foo() + super<()>.foo() + super@B.foo() + super@B.bar() + } + + class B : T { + fun test() { + super.foo(); + super<C>.bar() + super@A.bar() + super@A.foo() + super@B.foo() + super<C>@B.foo() + super.foo() + super + super + } + } +} + +fun foo() { + super + super.foo() + super.foo() +} + +trait G { + fun foo() {} +} + +class CG : G { + fun test() { + super.foo() // OK + super>.foo() // Warning + super<G<E>>.foo() // Error + super<G>.foo() // Error + } +} + +// The case when no supertype is resolved +class ERROR() : UR { + + fun test() { + super.foo() + } +} + +// No supertype at all +class A1 { + fun test() { + super.equals(null) + } +} \ No newline at end of file diff --git a/idea/testData/checkerWithErrorTypes/quick/Varargs.jet b/compiler/testData/checkerWithErrorTypes/quick/Varargs.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/Varargs.jet rename to compiler/testData/checkerWithErrorTypes/quick/Varargs.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet b/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet rename to compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet diff --git a/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/NullableNothingIsExactlyNull.jet b/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/NullableNothingIsExactlyNull.jet new file mode 100644 index 00000000000..3c52c45b1b9 --- /dev/null +++ b/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/NullableNothingIsExactlyNull.jet @@ -0,0 +1,8 @@ +fun test() { + val out : Int? = null + val x : Nothing? = null + if (out != x) + out.plus(1) + if (out == x) return + out.plus(1) +} diff --git a/idea/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/PreferExtensionsOnNullableReceiver.jet b/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/PreferExtensionsOnNullableReceiver.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/PreferExtensionsOnNullableReceiver.jet rename to compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/PreferExtensionsOnNullableReceiver.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/ReceiverNullability.jet b/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/ReceiverNullability.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/ReceiverNullability.jet rename to compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/ReceiverNullability.jet diff --git a/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/kt362.jet b/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/kt362.jet new file mode 100644 index 00000000000..5fd5f72bfb1 --- /dev/null +++ b/compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/kt362.jet @@ -0,0 +1,30 @@ +// KT-362 Don't allow autocasts on vals that are not internal +namespace example; + +namespace test { + public class Public() { + public val public : Int? = 1; + protected val protected : Int? = 1; + internal protected val i_protected : Int? = 1; + val internal : Int? = 1 + } + internal class Internal() { + public val public : Int? = 1; + protected val protected : Int? = 1; + internal protected val i_protected : Int? = 1; + val internal : Int? = 1 + } +} + +fun test() { + val p = test.Public() + if (p.public is Int) p.public + 1 + if (p.protected is Int) p.protected + 1 + if (p.i_protected is Int) p.i_protected + 1 + if (p.internal is Int) p.internal + 1 + val i = test.Public() + if (i.public is Int) i.public + 1 + if (i.protected is Int) i.protected + 1 + if (i.i_protected is Int) i.i_protected + 1 + if (i.internal is Int) i.internal + 1 +} \ No newline at end of file diff --git a/idea/testData/checkerWithErrorTypes/quick/regressions/kt306.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt306.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/regressions/kt306.jet rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt306.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/regressions/kt307.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt307.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/regressions/kt307.jet rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt307.jet diff --git a/idea/testData/checkerWithErrorTypes/quick/regressions/kt316.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt316.jet similarity index 100% rename from idea/testData/checkerWithErrorTypes/quick/regressions/kt316.jet rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt316.jet diff --git a/idea/testData/codegen/PSVM.jet b/compiler/testData/codegen/PSVM.jet similarity index 100% rename from idea/testData/codegen/PSVM.jet rename to compiler/testData/codegen/PSVM.jet diff --git a/idea/testData/codegen/assign.jet b/compiler/testData/codegen/assign.jet similarity index 100% rename from idea/testData/codegen/assign.jet rename to compiler/testData/codegen/assign.jet diff --git a/idea/testData/codegen/bottles.jet b/compiler/testData/codegen/bottles.jet similarity index 100% rename from idea/testData/codegen/bottles.jet rename to compiler/testData/codegen/bottles.jet diff --git a/idea/testData/codegen/bottles2.jet b/compiler/testData/codegen/bottles2.jet similarity index 100% rename from idea/testData/codegen/bottles2.jet rename to compiler/testData/codegen/bottles2.jet diff --git a/idea/testData/codegen/bridge.jet b/compiler/testData/codegen/bridge.jet similarity index 100% rename from idea/testData/codegen/bridge.jet rename to compiler/testData/codegen/bridge.jet diff --git a/idea/testData/codegen/checkCast.jet b/compiler/testData/codegen/checkCast.jet similarity index 100% rename from idea/testData/codegen/checkCast.jet rename to compiler/testData/codegen/checkCast.jet diff --git a/idea/testData/codegen/classes/classObject.jet b/compiler/testData/codegen/classes/classObject.jet similarity index 100% rename from idea/testData/codegen/classes/classObject.jet rename to compiler/testData/codegen/classes/classObject.jet diff --git a/idea/testData/codegen/classes/classObjectInterface.jet b/compiler/testData/codegen/classes/classObjectInterface.jet similarity index 100% rename from idea/testData/codegen/classes/classObjectInterface.jet rename to compiler/testData/codegen/classes/classObjectInterface.jet diff --git a/idea/testData/codegen/classes/classObjectMethod.jet b/compiler/testData/codegen/classes/classObjectMethod.jet similarity index 100% rename from idea/testData/codegen/classes/classObjectMethod.jet rename to compiler/testData/codegen/classes/classObjectMethod.jet diff --git a/idea/testData/codegen/classes/closureWithParameter.jet b/compiler/testData/codegen/classes/closureWithParameter.jet similarity index 100% rename from idea/testData/codegen/classes/closureWithParameter.jet rename to compiler/testData/codegen/classes/closureWithParameter.jet diff --git a/idea/testData/codegen/classes/closureWithParameterAndBoxing.jet b/compiler/testData/codegen/classes/closureWithParameterAndBoxing.jet similarity index 100% rename from idea/testData/codegen/classes/closureWithParameterAndBoxing.jet rename to compiler/testData/codegen/classes/closureWithParameterAndBoxing.jet diff --git a/idea/testData/codegen/classes/diamondInheritance.jet b/compiler/testData/codegen/classes/diamondInheritance.jet similarity index 100% rename from idea/testData/codegen/classes/diamondInheritance.jet rename to compiler/testData/codegen/classes/diamondInheritance.jet diff --git a/idea/testData/codegen/classes/doubleEnclosedLocalVariable.jet b/compiler/testData/codegen/classes/doubleEnclosedLocalVariable.jet similarity index 100% rename from idea/testData/codegen/classes/doubleEnclosedLocalVariable.jet rename to compiler/testData/codegen/classes/doubleEnclosedLocalVariable.jet diff --git a/idea/testData/codegen/classes/enclosingLocalVariable.jet b/compiler/testData/codegen/classes/enclosingLocalVariable.jet similarity index 100% rename from idea/testData/codegen/classes/enclosingLocalVariable.jet rename to compiler/testData/codegen/classes/enclosingLocalVariable.jet diff --git a/idea/testData/codegen/classes/enclosingThis.jet b/compiler/testData/codegen/classes/enclosingThis.jet similarity index 100% rename from idea/testData/codegen/classes/enclosingThis.jet rename to compiler/testData/codegen/classes/enclosingThis.jet diff --git a/idea/testData/codegen/classes/exceptionConstructor.jet b/compiler/testData/codegen/classes/exceptionConstructor.jet similarity index 100% rename from idea/testData/codegen/classes/exceptionConstructor.jet rename to compiler/testData/codegen/classes/exceptionConstructor.jet diff --git a/idea/testData/codegen/classes/extensionClosure.jet b/compiler/testData/codegen/classes/extensionClosure.jet similarity index 100% rename from idea/testData/codegen/classes/extensionClosure.jet rename to compiler/testData/codegen/classes/extensionClosure.jet diff --git a/idea/testData/codegen/classes/funDelegation.jet b/compiler/testData/codegen/classes/funDelegation.jet similarity index 100% rename from idea/testData/codegen/classes/funDelegation.jet rename to compiler/testData/codegen/classes/funDelegation.jet diff --git a/idea/testData/codegen/classes/inheritance.jet b/compiler/testData/codegen/classes/inheritance.jet similarity index 100% rename from idea/testData/codegen/classes/inheritance.jet rename to compiler/testData/codegen/classes/inheritance.jet diff --git a/idea/testData/codegen/classes/inheritedInnerClass.jet b/compiler/testData/codegen/classes/inheritedInnerClass.jet similarity index 100% rename from idea/testData/codegen/classes/inheritedInnerClass.jet rename to compiler/testData/codegen/classes/inheritedInnerClass.jet diff --git a/idea/testData/codegen/classes/inheritedMethod.jet b/compiler/testData/codegen/classes/inheritedMethod.jet similarity index 100% rename from idea/testData/codegen/classes/inheritedMethod.jet rename to compiler/testData/codegen/classes/inheritedMethod.jet diff --git a/idea/testData/codegen/classes/inheritingFromArrayList.jet b/compiler/testData/codegen/classes/inheritingFromArrayList.jet similarity index 100% rename from idea/testData/codegen/classes/inheritingFromArrayList.jet rename to compiler/testData/codegen/classes/inheritingFromArrayList.jet diff --git a/idea/testData/codegen/classes/initializerBlock.jet b/compiler/testData/codegen/classes/initializerBlock.jet similarity index 100% rename from idea/testData/codegen/classes/initializerBlock.jet rename to compiler/testData/codegen/classes/initializerBlock.jet diff --git a/idea/testData/codegen/classes/initializerBlockDImpl.jet b/compiler/testData/codegen/classes/initializerBlockDImpl.jet similarity index 100% rename from idea/testData/codegen/classes/initializerBlockDImpl.jet rename to compiler/testData/codegen/classes/initializerBlockDImpl.jet diff --git a/idea/testData/codegen/classes/innerClass.jet b/compiler/testData/codegen/classes/innerClass.jet similarity index 100% rename from idea/testData/codegen/classes/innerClass.jet rename to compiler/testData/codegen/classes/innerClass.jet diff --git a/idea/testData/codegen/classes/newInstanceDefaultConstructor.jet b/compiler/testData/codegen/classes/newInstanceDefaultConstructor.jet similarity index 100% rename from idea/testData/codegen/classes/newInstanceDefaultConstructor.jet rename to compiler/testData/codegen/classes/newInstanceDefaultConstructor.jet diff --git a/idea/testData/codegen/classes/outerThis.jet b/compiler/testData/codegen/classes/outerThis.jet similarity index 100% rename from idea/testData/codegen/classes/outerThis.jet rename to compiler/testData/codegen/classes/outerThis.jet diff --git a/idea/testData/codegen/classes/overloadBinaryOperator.jet b/compiler/testData/codegen/classes/overloadBinaryOperator.jet similarity index 100% rename from idea/testData/codegen/classes/overloadBinaryOperator.jet rename to compiler/testData/codegen/classes/overloadBinaryOperator.jet diff --git a/idea/testData/codegen/classes/overloadPlusAssign.jet b/compiler/testData/codegen/classes/overloadPlusAssign.jet similarity index 100% rename from idea/testData/codegen/classes/overloadPlusAssign.jet rename to compiler/testData/codegen/classes/overloadPlusAssign.jet diff --git a/idea/testData/codegen/classes/overloadPlusAssignReturn.jet b/compiler/testData/codegen/classes/overloadPlusAssignReturn.jet similarity index 100% rename from idea/testData/codegen/classes/overloadPlusAssignReturn.jet rename to compiler/testData/codegen/classes/overloadPlusAssignReturn.jet diff --git a/idea/testData/codegen/classes/overloadPlusToPlusAssign.jet b/compiler/testData/codegen/classes/overloadPlusToPlusAssign.jet similarity index 100% rename from idea/testData/codegen/classes/overloadPlusToPlusAssign.jet rename to compiler/testData/codegen/classes/overloadPlusToPlusAssign.jet diff --git a/idea/testData/codegen/classes/overloadUnaryOperator.jet b/compiler/testData/codegen/classes/overloadUnaryOperator.jet similarity index 100% rename from idea/testData/codegen/classes/overloadUnaryOperator.jet rename to compiler/testData/codegen/classes/overloadUnaryOperator.jet diff --git a/idea/testData/codegen/classes/propertyDelegation.jet b/compiler/testData/codegen/classes/propertyDelegation.jet similarity index 100% rename from idea/testData/codegen/classes/propertyDelegation.jet rename to compiler/testData/codegen/classes/propertyDelegation.jet diff --git a/idea/testData/codegen/classes/propertyInInitializer.jet b/compiler/testData/codegen/classes/propertyInInitializer.jet similarity index 100% rename from idea/testData/codegen/classes/propertyInInitializer.jet rename to compiler/testData/codegen/classes/propertyInInitializer.jet diff --git a/idea/testData/codegen/classes/rightHandOverride.jet b/compiler/testData/codegen/classes/rightHandOverride.jet similarity index 100% rename from idea/testData/codegen/classes/rightHandOverride.jet rename to compiler/testData/codegen/classes/rightHandOverride.jet diff --git a/idea/testData/codegen/classes/secondaryConstructors.jet b/compiler/testData/codegen/classes/secondaryConstructors.jet similarity index 100% rename from idea/testData/codegen/classes/secondaryConstructors.jet rename to compiler/testData/codegen/classes/secondaryConstructors.jet diff --git a/idea/testData/codegen/classes/simpleBox.jet b/compiler/testData/codegen/classes/simpleBox.jet similarity index 100% rename from idea/testData/codegen/classes/simpleBox.jet rename to compiler/testData/codegen/classes/simpleBox.jet diff --git a/idea/testData/codegen/classes/simpleClass.jet b/compiler/testData/codegen/classes/simpleClass.jet similarity index 100% rename from idea/testData/codegen/classes/simpleClass.jet rename to compiler/testData/codegen/classes/simpleClass.jet diff --git a/idea/testData/codegen/classes/simplestClosure.jet b/compiler/testData/codegen/classes/simplestClosure.jet similarity index 100% rename from idea/testData/codegen/classes/simplestClosure.jet rename to compiler/testData/codegen/classes/simplestClosure.jet diff --git a/idea/testData/codegen/classes/simplestClosureAndBoxing.jet b/compiler/testData/codegen/classes/simplestClosureAndBoxing.jet similarity index 100% rename from idea/testData/codegen/classes/simplestClosureAndBoxing.jet rename to compiler/testData/codegen/classes/simplestClosureAndBoxing.jet diff --git a/idea/testData/codegen/controlStructures/break.jet b/compiler/testData/codegen/controlStructures/break.jet similarity index 100% rename from idea/testData/codegen/controlStructures/break.jet rename to compiler/testData/codegen/controlStructures/break.jet diff --git a/idea/testData/codegen/controlStructures/continue.jet b/compiler/testData/codegen/controlStructures/continue.jet similarity index 100% rename from idea/testData/codegen/controlStructures/continue.jet rename to compiler/testData/codegen/controlStructures/continue.jet diff --git a/idea/testData/codegen/controlStructures/doWhile.jet b/compiler/testData/codegen/controlStructures/doWhile.jet similarity index 100% rename from idea/testData/codegen/controlStructures/doWhile.jet rename to compiler/testData/codegen/controlStructures/doWhile.jet diff --git a/idea/testData/codegen/controlStructures/for.jet b/compiler/testData/codegen/controlStructures/for.jet similarity index 100% rename from idea/testData/codegen/controlStructures/for.jet rename to compiler/testData/codegen/controlStructures/for.jet diff --git a/idea/testData/codegen/controlStructures/forInArray.jet b/compiler/testData/codegen/controlStructures/forInArray.jet similarity index 100% rename from idea/testData/codegen/controlStructures/forInArray.jet rename to compiler/testData/codegen/controlStructures/forInArray.jet diff --git a/idea/testData/codegen/controlStructures/forIntArray.jet b/compiler/testData/codegen/controlStructures/forIntArray.jet similarity index 100% rename from idea/testData/codegen/controlStructures/forIntArray.jet rename to compiler/testData/codegen/controlStructures/forIntArray.jet diff --git a/compiler/testData/codegen/controlStructures/forIntRange.jet b/compiler/testData/codegen/controlStructures/forIntRange.jet new file mode 100644 index 00000000000..0fe391123eb --- /dev/null +++ b/compiler/testData/codegen/controlStructures/forIntRange.jet @@ -0,0 +1,13 @@ +fun box() : String { + val a = Array(3) + a[0] = "a" + a[1] = "b" + a[2] = "c" + + val result = 0 + for(i in a.indices) { + result += i + } + if (result != 3) return "FAIL" + return "OK" +} \ No newline at end of file diff --git a/idea/testData/codegen/controlStructures/forNullableIntArray.jet b/compiler/testData/codegen/controlStructures/forNullableIntArray.jet similarity index 100% rename from idea/testData/codegen/controlStructures/forNullableIntArray.jet rename to compiler/testData/codegen/controlStructures/forNullableIntArray.jet diff --git a/idea/testData/codegen/controlStructures/forPrimitiveIntArray.jet b/compiler/testData/codegen/controlStructures/forPrimitiveIntArray.jet similarity index 100% rename from idea/testData/codegen/controlStructures/forPrimitiveIntArray.jet rename to compiler/testData/codegen/controlStructures/forPrimitiveIntArray.jet diff --git a/idea/testData/codegen/controlStructures/forUserType.jet b/compiler/testData/codegen/controlStructures/forUserType.jet similarity index 100% rename from idea/testData/codegen/controlStructures/forUserType.jet rename to compiler/testData/codegen/controlStructures/forUserType.jet diff --git a/idea/testData/codegen/controlStructures/if.jet b/compiler/testData/codegen/controlStructures/if.jet similarity index 100% rename from idea/testData/codegen/controlStructures/if.jet rename to compiler/testData/codegen/controlStructures/if.jet diff --git a/idea/testData/codegen/controlStructures/ifBlock.jet b/compiler/testData/codegen/controlStructures/ifBlock.jet similarity index 100% rename from idea/testData/codegen/controlStructures/ifBlock.jet rename to compiler/testData/codegen/controlStructures/ifBlock.jet diff --git a/idea/testData/codegen/controlStructures/ifNoElse.jet b/compiler/testData/codegen/controlStructures/ifNoElse.jet similarity index 100% rename from idea/testData/codegen/controlStructures/ifNoElse.jet rename to compiler/testData/codegen/controlStructures/ifNoElse.jet diff --git a/idea/testData/codegen/controlStructures/singleBranchIf.jet b/compiler/testData/codegen/controlStructures/singleBranchIf.jet similarity index 100% rename from idea/testData/codegen/controlStructures/singleBranchIf.jet rename to compiler/testData/codegen/controlStructures/singleBranchIf.jet diff --git a/idea/testData/codegen/controlStructures/tryCatch.jet b/compiler/testData/codegen/controlStructures/tryCatch.jet similarity index 100% rename from idea/testData/codegen/controlStructures/tryCatch.jet rename to compiler/testData/codegen/controlStructures/tryCatch.jet diff --git a/idea/testData/codegen/controlStructures/tryFinally.jet b/compiler/testData/codegen/controlStructures/tryFinally.jet similarity index 100% rename from idea/testData/codegen/controlStructures/tryFinally.jet rename to compiler/testData/codegen/controlStructures/tryFinally.jet diff --git a/idea/testData/codegen/controlStructures/while.jet b/compiler/testData/codegen/controlStructures/while.jet similarity index 100% rename from idea/testData/codegen/controlStructures/while.jet rename to compiler/testData/codegen/controlStructures/while.jet diff --git a/idea/testData/codegen/extensionFunctions/generic.jet b/compiler/testData/codegen/extensionFunctions/generic.jet similarity index 100% rename from idea/testData/codegen/extensionFunctions/generic.jet rename to compiler/testData/codegen/extensionFunctions/generic.jet diff --git a/idea/testData/codegen/extensionFunctions/simple.jet b/compiler/testData/codegen/extensionFunctions/simple.jet similarity index 100% rename from idea/testData/codegen/extensionFunctions/simple.jet rename to compiler/testData/codegen/extensionFunctions/simple.jet diff --git a/idea/testData/codegen/extensionFunctions/whenFail.jet b/compiler/testData/codegen/extensionFunctions/whenFail.jet similarity index 100% rename from idea/testData/codegen/extensionFunctions/whenFail.jet rename to compiler/testData/codegen/extensionFunctions/whenFail.jet diff --git a/idea/testData/codegen/functionCall.jet b/compiler/testData/codegen/functionCall.jet similarity index 100% rename from idea/testData/codegen/functionCall.jet rename to compiler/testData/codegen/functionCall.jet diff --git a/compiler/testData/codegen/functions/defaultargs.jet b/compiler/testData/codegen/functions/defaultargs.jet new file mode 100644 index 00000000000..137e1b3be9e --- /dev/null +++ b/compiler/testData/codegen/functions/defaultargs.jet @@ -0,0 +1,63 @@ +fun reformat( + str : String, + normalizeCase : Boolean = true, + uppercaseFirstLetter : Boolean = true, + divideByCamelHumps : Boolean = true, + wordSeparator : String = " " +) = + (normalizeCase, uppercaseFirstLetter, divideByCamelHumps, wordSeparator) + +trait A { + fun bar2(arg: Int = 239) : Int + + fun bar(arg: Int = 240) : Int = bar2(arg/2) +} + +open abstract class B() : A, java.lang.Object() { + fun foo(arg: Int = 239 + 1) : Int = arg + + abstract fun foo2(arg: Int = 239) : Int + + override fun bar2(arg: Int) : Int = arg +} + +class C() : B() { + override fun foo2(arg: Int) : Int = arg + + fun Any.toMyPrefixedString(prefix: String = "", suffix: String="") : String = prefix + " " + suffix + + fun testReceiver() : String { + val res : String = "mama".toMyPrefixedString("111", "222") + System.out?.println(res) + return res + } + + override fun toString() : String = "CCC" +} + +fun T.toPrefixedString(prefix: String = "", suffix: String="") = prefix + (this as java.lang.Object).toString() + suffix + +fun box() : String { + val expected = (true, true, true, " ") + + if("mama".toPrefixedString(suffix="321", prefix="papa") != "papamama321") return "fail" + if("mama".toPrefixedString(prefix="papa") != "papamama") return "fail" + if("mama".toPrefixedString("papa", "239") != "papamama239") return "fail" + if("mama".toPrefixedString("papa") != "papamama") return "fail" + if("mama".toPrefixedString() != "mama") return "fail" + if(C().testReceiver() != "111 222") return "fail" + if(C().bar(10) != 5) return "fail" + if(C().bar() != 120) return "fail" + if(C().foo(10) != 10) return "fail" + if(C().foo() != 240) return "fail" + if(C().foo2() != 239) return "fail" + if(C().foo2(10) != 10) return "fail" + if(C().bar2() != 239) return "fail" + if(C().bar2(10) != 10) return "fail" + if(reformat("", true, true, true, " ") != expected) return "fail" + if(reformat("", true, true, true) != expected) return "fail" + if(reformat("", true, true) != expected) return "fail" + if(reformat("", true) != expected) return "fail" + if(reformat("") != expected) return "fail" + return "OK" +} diff --git a/idea/testData/psi/EmptyFile.jet b/compiler/testData/codegen/functions/namedargs.jet similarity index 100% rename from idea/testData/psi/EmptyFile.jet rename to compiler/testData/codegen/functions/namedargs.jet diff --git a/compiler/testData/codegen/functions/nothisnoclosure.jet b/compiler/testData/codegen/functions/nothisnoclosure.jet new file mode 100644 index 00000000000..cb161d00ce0 --- /dev/null +++ b/compiler/testData/codegen/functions/nothisnoclosure.jet @@ -0,0 +1,13 @@ +fun loop(times : Int) { + while(times > 0) { + val u : fun(value : Int) : Unit = { + System.out?.println(it) + } + u(times--) + } +} + +fun box() : String { + loop(5) + return "OK" +} \ No newline at end of file diff --git a/idea/testData/codegen/helloWorld.jet b/compiler/testData/codegen/helloWorld.jet similarity index 100% rename from idea/testData/codegen/helloWorld.jet rename to compiler/testData/codegen/helloWorld.jet diff --git a/idea/testData/codegen/incrementProperty.jet b/compiler/testData/codegen/incrementProperty.jet similarity index 100% rename from idea/testData/codegen/incrementProperty.jet rename to compiler/testData/codegen/incrementProperty.jet diff --git a/idea/testData/codegen/localProperty.jet b/compiler/testData/codegen/localProperty.jet similarity index 100% rename from idea/testData/codegen/localProperty.jet rename to compiler/testData/codegen/localProperty.jet diff --git a/idea/testData/codegen/namespaceQualifiedMethod.jet b/compiler/testData/codegen/namespaceQualifiedMethod.jet similarity index 100% rename from idea/testData/codegen/namespaceQualifiedMethod.jet rename to compiler/testData/codegen/namespaceQualifiedMethod.jet diff --git a/idea/testData/codegen/newInstanceExplicitConstructor.jet b/compiler/testData/codegen/newInstanceExplicitConstructor.jet similarity index 100% rename from idea/testData/codegen/newInstanceExplicitConstructor.jet rename to compiler/testData/codegen/newInstanceExplicitConstructor.jet diff --git a/idea/testData/codegen/objects/methodOnObject.jet b/compiler/testData/codegen/objects/methodOnObject.jet similarity index 100% rename from idea/testData/codegen/objects/methodOnObject.jet rename to compiler/testData/codegen/objects/methodOnObject.jet diff --git a/idea/testData/codegen/objects/objectLiteral.jet b/compiler/testData/codegen/objects/objectLiteral.jet similarity index 100% rename from idea/testData/codegen/objects/objectLiteral.jet rename to compiler/testData/codegen/objects/objectLiteral.jet diff --git a/idea/testData/codegen/objects/simpleObject.jet b/compiler/testData/codegen/objects/simpleObject.jet similarity index 100% rename from idea/testData/codegen/objects/simpleObject.jet rename to compiler/testData/codegen/objects/simpleObject.jet diff --git a/idea/testData/codegen/patternMatching/callProperty.jet b/compiler/testData/codegen/patternMatching/callProperty.jet similarity index 100% rename from idea/testData/codegen/patternMatching/callProperty.jet rename to compiler/testData/codegen/patternMatching/callProperty.jet diff --git a/idea/testData/codegen/patternMatching/constant.jet b/compiler/testData/codegen/patternMatching/constant.jet similarity index 100% rename from idea/testData/codegen/patternMatching/constant.jet rename to compiler/testData/codegen/patternMatching/constant.jet diff --git a/idea/testData/codegen/patternMatching/exceptionOnNoMatch.jet b/compiler/testData/codegen/patternMatching/exceptionOnNoMatch.jet similarity index 100% rename from idea/testData/codegen/patternMatching/exceptionOnNoMatch.jet rename to compiler/testData/codegen/patternMatching/exceptionOnNoMatch.jet diff --git a/idea/testData/codegen/patternMatching/inrange.jet b/compiler/testData/codegen/patternMatching/inrange.jet similarity index 100% rename from idea/testData/codegen/patternMatching/inrange.jet rename to compiler/testData/codegen/patternMatching/inrange.jet diff --git a/idea/testData/codegen/patternMatching/is.jet b/compiler/testData/codegen/patternMatching/is.jet similarity index 100% rename from idea/testData/codegen/patternMatching/is.jet rename to compiler/testData/codegen/patternMatching/is.jet diff --git a/idea/testData/codegen/patternMatching/pattern.jet b/compiler/testData/codegen/patternMatching/pattern.jet similarity index 100% rename from idea/testData/codegen/patternMatching/pattern.jet rename to compiler/testData/codegen/patternMatching/pattern.jet diff --git a/idea/testData/codegen/patternMatching/range.jet b/compiler/testData/codegen/patternMatching/range.jet similarity index 100% rename from idea/testData/codegen/patternMatching/range.jet rename to compiler/testData/codegen/patternMatching/range.jet diff --git a/idea/testData/codegen/patternMatching/rangeChar.jet b/compiler/testData/codegen/patternMatching/rangeChar.jet similarity index 100% rename from idea/testData/codegen/patternMatching/rangeChar.jet rename to compiler/testData/codegen/patternMatching/rangeChar.jet diff --git a/idea/testData/codegen/properties/fieldPropertyAccess.jet b/compiler/testData/codegen/properties/fieldPropertyAccess.jet similarity index 100% rename from idea/testData/codegen/properties/fieldPropertyAccess.jet rename to compiler/testData/codegen/properties/fieldPropertyAccess.jet diff --git a/idea/testData/codegen/properties/fieldSetter.jet b/compiler/testData/codegen/properties/fieldSetter.jet similarity index 100% rename from idea/testData/codegen/properties/fieldSetter.jet rename to compiler/testData/codegen/properties/fieldSetter.jet diff --git a/idea/testData/codegen/properties/fieldSetterPlusEq.jet b/compiler/testData/codegen/properties/fieldSetterPlusEq.jet similarity index 100% rename from idea/testData/codegen/properties/fieldSetterPlusEq.jet rename to compiler/testData/codegen/properties/fieldSetterPlusEq.jet diff --git a/idea/testData/codegen/properties/privateVal.jet b/compiler/testData/codegen/properties/privateVal.jet similarity index 100% rename from idea/testData/codegen/properties/privateVal.jet rename to compiler/testData/codegen/properties/privateVal.jet diff --git a/idea/testData/codegen/properties/privateVar.jet b/compiler/testData/codegen/properties/privateVar.jet similarity index 100% rename from idea/testData/codegen/properties/privateVar.jet rename to compiler/testData/codegen/properties/privateVar.jet diff --git a/idea/testData/codegen/properties/propertyReceiverOnStack.jet b/compiler/testData/codegen/properties/propertyReceiverOnStack.jet similarity index 100% rename from idea/testData/codegen/properties/propertyReceiverOnStack.jet rename to compiler/testData/codegen/properties/propertyReceiverOnStack.jet diff --git a/idea/testData/codegen/regressions/kt232.jet b/compiler/testData/codegen/regressions/kt232.jet similarity index 100% rename from idea/testData/codegen/regressions/kt232.jet rename to compiler/testData/codegen/regressions/kt232.jet diff --git a/idea/testData/codegen/regressions/kt237.jet b/compiler/testData/codegen/regressions/kt237.jet similarity index 100% rename from idea/testData/codegen/regressions/kt237.jet rename to compiler/testData/codegen/regressions/kt237.jet diff --git a/idea/testData/codegen/regressions/kt238.jet b/compiler/testData/codegen/regressions/kt238.jet similarity index 100% rename from idea/testData/codegen/regressions/kt238.jet rename to compiler/testData/codegen/regressions/kt238.jet diff --git a/idea/testData/codegen/regressions/kt239.jet b/compiler/testData/codegen/regressions/kt239.jet similarity index 100% rename from idea/testData/codegen/regressions/kt239.jet rename to compiler/testData/codegen/regressions/kt239.jet diff --git a/idea/testData/codegen/regressions/kt242.jet b/compiler/testData/codegen/regressions/kt242.jet similarity index 100% rename from idea/testData/codegen/regressions/kt242.jet rename to compiler/testData/codegen/regressions/kt242.jet diff --git a/idea/testData/codegen/regressions/kt243.jet b/compiler/testData/codegen/regressions/kt243.jet similarity index 100% rename from idea/testData/codegen/regressions/kt243.jet rename to compiler/testData/codegen/regressions/kt243.jet diff --git a/idea/testData/codegen/regressions/kt245.jet b/compiler/testData/codegen/regressions/kt245.jet similarity index 100% rename from idea/testData/codegen/regressions/kt245.jet rename to compiler/testData/codegen/regressions/kt245.jet diff --git a/idea/testData/codegen/regressions/kt247.jet b/compiler/testData/codegen/regressions/kt247.jet similarity index 100% rename from idea/testData/codegen/regressions/kt247.jet rename to compiler/testData/codegen/regressions/kt247.jet diff --git a/idea/testData/codegen/regressions/kt248.jet b/compiler/testData/codegen/regressions/kt248.jet similarity index 100% rename from idea/testData/codegen/regressions/kt248.jet rename to compiler/testData/codegen/regressions/kt248.jet diff --git a/idea/testData/codegen/regressions/kt249.jet b/compiler/testData/codegen/regressions/kt249.jet similarity index 100% rename from idea/testData/codegen/regressions/kt249.jet rename to compiler/testData/codegen/regressions/kt249.jet diff --git a/idea/testData/codegen/regressions/kt257.jet b/compiler/testData/codegen/regressions/kt257.jet similarity index 100% rename from idea/testData/codegen/regressions/kt257.jet rename to compiler/testData/codegen/regressions/kt257.jet diff --git a/idea/testData/codegen/regressions/kt259.jet b/compiler/testData/codegen/regressions/kt259.jet similarity index 100% rename from idea/testData/codegen/regressions/kt259.jet rename to compiler/testData/codegen/regressions/kt259.jet diff --git a/idea/testData/codegen/regressions/kt297.jet b/compiler/testData/codegen/regressions/kt297.jet similarity index 100% rename from idea/testData/codegen/regressions/kt297.jet rename to compiler/testData/codegen/regressions/kt297.jet diff --git a/idea/testData/codegen/regressions/kt299.jet b/compiler/testData/codegen/regressions/kt299.jet similarity index 100% rename from idea/testData/codegen/regressions/kt299.jet rename to compiler/testData/codegen/regressions/kt299.jet diff --git a/idea/testData/codegen/regressions/kt326.jet b/compiler/testData/codegen/regressions/kt326.jet similarity index 100% rename from idea/testData/codegen/regressions/kt326.jet rename to compiler/testData/codegen/regressions/kt326.jet diff --git a/idea/testData/codegen/regressions/kt343.jet b/compiler/testData/codegen/regressions/kt343.jet similarity index 100% rename from idea/testData/codegen/regressions/kt343.jet rename to compiler/testData/codegen/regressions/kt343.jet diff --git a/idea/testData/codegen/regressions/kt344.jet b/compiler/testData/codegen/regressions/kt344.jet similarity index 100% rename from idea/testData/codegen/regressions/kt344.jet rename to compiler/testData/codegen/regressions/kt344.jet diff --git a/idea/testData/codegen/regressions/kt48.jet b/compiler/testData/codegen/regressions/kt48.jet similarity index 100% rename from idea/testData/codegen/regressions/kt48.jet rename to compiler/testData/codegen/regressions/kt48.jet diff --git a/idea/testData/codegen/systemOut.jet b/compiler/testData/codegen/systemOut.jet similarity index 100% rename from idea/testData/codegen/systemOut.jet rename to compiler/testData/codegen/systemOut.jet diff --git a/idea/testData/codegen/traits/multiple.jet b/compiler/testData/codegen/traits/multiple.jet similarity index 100% rename from idea/testData/codegen/traits/multiple.jet rename to compiler/testData/codegen/traits/multiple.jet diff --git a/idea/testData/codegen/traits/simple.jet b/compiler/testData/codegen/traits/simple.jet similarity index 100% rename from idea/testData/codegen/traits/simple.jet rename to compiler/testData/codegen/traits/simple.jet diff --git a/idea/testData/codegen/traits/stdlib.jet b/compiler/testData/codegen/traits/stdlib.jet similarity index 100% rename from idea/testData/codegen/traits/stdlib.jet rename to compiler/testData/codegen/traits/stdlib.jet diff --git a/idea/testData/codegen/traits/withRequired.jet b/compiler/testData/codegen/traits/withRequired.jet similarity index 100% rename from idea/testData/codegen/traits/withRequired.jet rename to compiler/testData/codegen/traits/withRequired.jet diff --git a/idea/testData/codegen/typeInfo/asInLoop.jet b/compiler/testData/codegen/typeInfo/asInLoop.jet similarity index 100% rename from idea/testData/codegen/typeInfo/asInLoop.jet rename to compiler/testData/codegen/typeInfo/asInLoop.jet diff --git a/idea/testData/codegen/typeInfo/asSafeWithGenerics.jet b/compiler/testData/codegen/typeInfo/asSafeWithGenerics.jet similarity index 100% rename from idea/testData/codegen/typeInfo/asSafeWithGenerics.jet rename to compiler/testData/codegen/typeInfo/asSafeWithGenerics.jet diff --git a/idea/testData/codegen/typeInfo/classObjectInTypeInfo.jet b/compiler/testData/codegen/typeInfo/classObjectInTypeInfo.jet similarity index 100% rename from idea/testData/codegen/typeInfo/classObjectInTypeInfo.jet rename to compiler/testData/codegen/typeInfo/classObjectInTypeInfo.jet diff --git a/idea/testData/codegen/typeInfo/forwardTypeParameter.jet b/compiler/testData/codegen/typeInfo/forwardTypeParameter.jet similarity index 100% rename from idea/testData/codegen/typeInfo/forwardTypeParameter.jet rename to compiler/testData/codegen/typeInfo/forwardTypeParameter.jet diff --git a/idea/testData/codegen/typeInfo/genericFunction.jet b/compiler/testData/codegen/typeInfo/genericFunction.jet similarity index 100% rename from idea/testData/codegen/typeInfo/genericFunction.jet rename to compiler/testData/codegen/typeInfo/genericFunction.jet diff --git a/idea/testData/codegen/typeInfo/getTypeInfo.jet b/compiler/testData/codegen/typeInfo/getTypeInfo.jet similarity index 100% rename from idea/testData/codegen/typeInfo/getTypeInfo.jet rename to compiler/testData/codegen/typeInfo/getTypeInfo.jet diff --git a/idea/testData/codegen/typeInfo/inner.jet b/compiler/testData/codegen/typeInfo/inner.jet similarity index 100% rename from idea/testData/codegen/typeInfo/inner.jet rename to compiler/testData/codegen/typeInfo/inner.jet diff --git a/idea/testData/codegen/typeInfo/isTypeParameter.jet b/compiler/testData/codegen/typeInfo/isTypeParameter.jet similarity index 100% rename from idea/testData/codegen/typeInfo/isTypeParameter.jet rename to compiler/testData/codegen/typeInfo/isTypeParameter.jet diff --git a/idea/testData/codegen/typeInfo/isWithGenericParameters.jet b/compiler/testData/codegen/typeInfo/isWithGenericParameters.jet similarity index 100% rename from idea/testData/codegen/typeInfo/isWithGenericParameters.jet rename to compiler/testData/codegen/typeInfo/isWithGenericParameters.jet diff --git a/idea/testData/codegen/typeInfo/isWithGenerics.jet b/compiler/testData/codegen/typeInfo/isWithGenerics.jet similarity index 100% rename from idea/testData/codegen/typeInfo/isWithGenerics.jet rename to compiler/testData/codegen/typeInfo/isWithGenerics.jet diff --git a/idea/testData/codegen/typeInfo/nullability.jet b/compiler/testData/codegen/typeInfo/nullability.jet similarity index 100% rename from idea/testData/codegen/typeInfo/nullability.jet rename to compiler/testData/codegen/typeInfo/nullability.jet diff --git a/idea/testData/codegen/typeInfo/oneArgTypeinfo.jet b/compiler/testData/codegen/typeInfo/oneArgTypeinfo.jet similarity index 100% rename from idea/testData/codegen/typeInfo/oneArgTypeinfo.jet rename to compiler/testData/codegen/typeInfo/oneArgTypeinfo.jet diff --git a/idea/testData/codegen/typeInfo/primitiveTypeInfo.jet b/compiler/testData/codegen/typeInfo/primitiveTypeInfo.jet similarity index 100% rename from idea/testData/codegen/typeInfo/primitiveTypeInfo.jet rename to compiler/testData/codegen/typeInfo/primitiveTypeInfo.jet diff --git a/idea/testData/mockJDK-1.7/jre/lib/annotations.jar b/compiler/testData/mockJDK-1.7/jre/lib/annotations.jar similarity index 100% rename from idea/testData/mockJDK-1.7/jre/lib/annotations.jar rename to compiler/testData/mockJDK-1.7/jre/lib/annotations.jar diff --git a/idea/testData/mockJDK-1.7/jre/lib/rt.jar b/compiler/testData/mockJDK-1.7/jre/lib/rt.jar similarity index 100% rename from idea/testData/mockJDK-1.7/jre/lib/rt.jar rename to compiler/testData/mockJDK-1.7/jre/lib/rt.jar diff --git a/idea/testData/mockJDK-1.7/src.zip b/compiler/testData/mockJDK-1.7/src.zip similarity index 100% rename from idea/testData/mockJDK-1.7/src.zip rename to compiler/testData/mockJDK-1.7/src.zip diff --git a/idea/testData/psi/AnnotatedExpressions.jet b/compiler/testData/psi/AnnotatedExpressions.jet similarity index 100% rename from idea/testData/psi/AnnotatedExpressions.jet rename to compiler/testData/psi/AnnotatedExpressions.jet diff --git a/idea/testData/psi/AnnotatedExpressions.txt b/compiler/testData/psi/AnnotatedExpressions.txt similarity index 100% rename from idea/testData/psi/AnnotatedExpressions.txt rename to compiler/testData/psi/AnnotatedExpressions.txt diff --git a/idea/testData/psi/AnonymousInitializer.jet b/compiler/testData/psi/AnonymousInitializer.jet similarity index 100% rename from idea/testData/psi/AnonymousInitializer.jet rename to compiler/testData/psi/AnonymousInitializer.jet diff --git a/idea/testData/psi/AnonymousInitializer.txt b/compiler/testData/psi/AnonymousInitializer.txt similarity index 100% rename from idea/testData/psi/AnonymousInitializer.txt rename to compiler/testData/psi/AnonymousInitializer.txt diff --git a/idea/testData/psi/Attributes.jet b/compiler/testData/psi/Attributes.jet similarity index 100% rename from idea/testData/psi/Attributes.jet rename to compiler/testData/psi/Attributes.jet diff --git a/idea/testData/psi/Attributes.txt b/compiler/testData/psi/Attributes.txt similarity index 100% rename from idea/testData/psi/Attributes.txt rename to compiler/testData/psi/Attributes.txt diff --git a/idea/testData/psi/AttributesOnPatterns.jet b/compiler/testData/psi/AttributesOnPatterns.jet similarity index 100% rename from idea/testData/psi/AttributesOnPatterns.jet rename to compiler/testData/psi/AttributesOnPatterns.jet diff --git a/idea/testData/psi/AttributesOnPatterns.txt b/compiler/testData/psi/AttributesOnPatterns.txt similarity index 100% rename from idea/testData/psi/AttributesOnPatterns.txt rename to compiler/testData/psi/AttributesOnPatterns.txt diff --git a/idea/testData/psi/Attributes_ERR.jet b/compiler/testData/psi/Attributes_ERR.jet similarity index 100% rename from idea/testData/psi/Attributes_ERR.jet rename to compiler/testData/psi/Attributes_ERR.jet diff --git a/idea/testData/psi/Attributes_ERR.txt b/compiler/testData/psi/Attributes_ERR.txt similarity index 100% rename from idea/testData/psi/Attributes_ERR.txt rename to compiler/testData/psi/Attributes_ERR.txt diff --git a/idea/testData/psi/BabySteps.jet b/compiler/testData/psi/BabySteps.jet similarity index 100% rename from idea/testData/psi/BabySteps.jet rename to compiler/testData/psi/BabySteps.jet diff --git a/idea/testData/psi/BabySteps.txt b/compiler/testData/psi/BabySteps.txt similarity index 100% rename from idea/testData/psi/BabySteps.txt rename to compiler/testData/psi/BabySteps.txt diff --git a/idea/testData/psi/BabySteps_ERR.jet b/compiler/testData/psi/BabySteps_ERR.jet similarity index 100% rename from idea/testData/psi/BabySteps_ERR.jet rename to compiler/testData/psi/BabySteps_ERR.jet diff --git a/idea/testData/psi/BabySteps_ERR.txt b/compiler/testData/psi/BabySteps_ERR.txt similarity index 100% rename from idea/testData/psi/BabySteps_ERR.txt rename to compiler/testData/psi/BabySteps_ERR.txt diff --git a/idea/testData/psi/ByCaluses.jet b/compiler/testData/psi/ByCaluses.jet similarity index 100% rename from idea/testData/psi/ByCaluses.jet rename to compiler/testData/psi/ByCaluses.jet diff --git a/idea/testData/psi/ByCaluses.txt b/compiler/testData/psi/ByCaluses.txt similarity index 100% rename from idea/testData/psi/ByCaluses.txt rename to compiler/testData/psi/ByCaluses.txt diff --git a/idea/testData/psi/CallWithManyClosures.jet b/compiler/testData/psi/CallWithManyClosures.jet similarity index 100% rename from idea/testData/psi/CallWithManyClosures.jet rename to compiler/testData/psi/CallWithManyClosures.jet diff --git a/idea/testData/psi/CallWithManyClosures.txt b/compiler/testData/psi/CallWithManyClosures.txt similarity index 100% rename from idea/testData/psi/CallWithManyClosures.txt rename to compiler/testData/psi/CallWithManyClosures.txt diff --git a/idea/testData/psi/CallsInWhen.jet b/compiler/testData/psi/CallsInWhen.jet similarity index 100% rename from idea/testData/psi/CallsInWhen.jet rename to compiler/testData/psi/CallsInWhen.jet diff --git a/idea/testData/psi/CallsInWhen.txt b/compiler/testData/psi/CallsInWhen.txt similarity index 100% rename from idea/testData/psi/CallsInWhen.txt rename to compiler/testData/psi/CallsInWhen.txt diff --git a/idea/testData/psi/Constructors.jet b/compiler/testData/psi/Constructors.jet similarity index 100% rename from idea/testData/psi/Constructors.jet rename to compiler/testData/psi/Constructors.jet diff --git a/idea/testData/psi/Constructors.txt b/compiler/testData/psi/Constructors.txt similarity index 100% rename from idea/testData/psi/Constructors.txt rename to compiler/testData/psi/Constructors.txt diff --git a/idea/testData/psi/ControlStructures.jet b/compiler/testData/psi/ControlStructures.jet similarity index 100% rename from idea/testData/psi/ControlStructures.jet rename to compiler/testData/psi/ControlStructures.jet diff --git a/idea/testData/psi/ControlStructures.txt b/compiler/testData/psi/ControlStructures.txt similarity index 100% rename from idea/testData/psi/ControlStructures.txt rename to compiler/testData/psi/ControlStructures.txt diff --git a/idea/testData/psi/EOLsInComments.jet b/compiler/testData/psi/EOLsInComments.jet similarity index 100% rename from idea/testData/psi/EOLsInComments.jet rename to compiler/testData/psi/EOLsInComments.jet diff --git a/idea/testData/psi/EOLsInComments.txt b/compiler/testData/psi/EOLsInComments.txt similarity index 100% rename from idea/testData/psi/EOLsInComments.txt rename to compiler/testData/psi/EOLsInComments.txt diff --git a/idea/testData/psi/EOLsOnRollback.jet b/compiler/testData/psi/EOLsOnRollback.jet similarity index 100% rename from idea/testData/psi/EOLsOnRollback.jet rename to compiler/testData/psi/EOLsOnRollback.jet diff --git a/idea/testData/psi/EOLsOnRollback.txt b/compiler/testData/psi/EOLsOnRollback.txt similarity index 100% rename from idea/testData/psi/EOLsOnRollback.txt rename to compiler/testData/psi/EOLsOnRollback.txt diff --git a/compiler/testData/psi/EmptyFile.jet b/compiler/testData/psi/EmptyFile.jet new file mode 100644 index 00000000000..e69de29bb2d diff --git a/idea/testData/psi/EmptyFile.txt b/compiler/testData/psi/EmptyFile.txt similarity index 100% rename from idea/testData/psi/EmptyFile.txt rename to compiler/testData/psi/EmptyFile.txt diff --git a/idea/testData/psi/Enums.jet b/compiler/testData/psi/Enums.jet similarity index 100% rename from idea/testData/psi/Enums.jet rename to compiler/testData/psi/Enums.jet diff --git a/idea/testData/psi/Enums.txt b/compiler/testData/psi/Enums.txt similarity index 100% rename from idea/testData/psi/Enums.txt rename to compiler/testData/psi/Enums.txt diff --git a/idea/testData/psi/Expressions_ERR.jet b/compiler/testData/psi/Expressions_ERR.jet similarity index 100% rename from idea/testData/psi/Expressions_ERR.jet rename to compiler/testData/psi/Expressions_ERR.jet diff --git a/idea/testData/psi/Expressions_ERR.txt b/compiler/testData/psi/Expressions_ERR.txt similarity index 100% rename from idea/testData/psi/Expressions_ERR.txt rename to compiler/testData/psi/Expressions_ERR.txt diff --git a/idea/testData/psi/FileStart_ERR.jet b/compiler/testData/psi/FileStart_ERR.jet similarity index 100% rename from idea/testData/psi/FileStart_ERR.jet rename to compiler/testData/psi/FileStart_ERR.jet diff --git a/idea/testData/psi/FileStart_ERR.txt b/compiler/testData/psi/FileStart_ERR.txt similarity index 100% rename from idea/testData/psi/FileStart_ERR.txt rename to compiler/testData/psi/FileStart_ERR.txt diff --git a/idea/testData/psi/FunctionCalls.jet b/compiler/testData/psi/FunctionCalls.jet similarity index 100% rename from idea/testData/psi/FunctionCalls.jet rename to compiler/testData/psi/FunctionCalls.jet diff --git a/idea/testData/psi/FunctionCalls.txt b/compiler/testData/psi/FunctionCalls.txt similarity index 100% rename from idea/testData/psi/FunctionCalls.txt rename to compiler/testData/psi/FunctionCalls.txt diff --git a/idea/testData/psi/FunctionLiterals.jet b/compiler/testData/psi/FunctionLiterals.jet similarity index 100% rename from idea/testData/psi/FunctionLiterals.jet rename to compiler/testData/psi/FunctionLiterals.jet diff --git a/idea/testData/psi/FunctionLiterals.txt b/compiler/testData/psi/FunctionLiterals.txt similarity index 100% rename from idea/testData/psi/FunctionLiterals.txt rename to compiler/testData/psi/FunctionLiterals.txt diff --git a/idea/testData/psi/FunctionLiterals_ERR.jet b/compiler/testData/psi/FunctionLiterals_ERR.jet similarity index 100% rename from idea/testData/psi/FunctionLiterals_ERR.jet rename to compiler/testData/psi/FunctionLiterals_ERR.jet diff --git a/idea/testData/psi/FunctionLiterals_ERR.txt b/compiler/testData/psi/FunctionLiterals_ERR.txt similarity index 100% rename from idea/testData/psi/FunctionLiterals_ERR.txt rename to compiler/testData/psi/FunctionLiterals_ERR.txt diff --git a/idea/testData/psi/FunctionTypes.jet b/compiler/testData/psi/FunctionTypes.jet similarity index 100% rename from idea/testData/psi/FunctionTypes.jet rename to compiler/testData/psi/FunctionTypes.jet diff --git a/idea/testData/psi/FunctionTypes.txt b/compiler/testData/psi/FunctionTypes.txt similarity index 100% rename from idea/testData/psi/FunctionTypes.txt rename to compiler/testData/psi/FunctionTypes.txt diff --git a/idea/testData/psi/FunctionTypes_ERR.jet b/compiler/testData/psi/FunctionTypes_ERR.jet similarity index 100% rename from idea/testData/psi/FunctionTypes_ERR.jet rename to compiler/testData/psi/FunctionTypes_ERR.jet diff --git a/idea/testData/psi/FunctionTypes_ERR.txt b/compiler/testData/psi/FunctionTypes_ERR.txt similarity index 100% rename from idea/testData/psi/FunctionTypes_ERR.txt rename to compiler/testData/psi/FunctionTypes_ERR.txt diff --git a/idea/testData/psi/Functions.jet b/compiler/testData/psi/Functions.jet similarity index 100% rename from idea/testData/psi/Functions.jet rename to compiler/testData/psi/Functions.jet diff --git a/idea/testData/psi/Functions.txt b/compiler/testData/psi/Functions.txt similarity index 100% rename from idea/testData/psi/Functions.txt rename to compiler/testData/psi/Functions.txt diff --git a/idea/testData/psi/Functions_ERR.jet b/compiler/testData/psi/Functions_ERR.jet similarity index 100% rename from idea/testData/psi/Functions_ERR.jet rename to compiler/testData/psi/Functions_ERR.jet diff --git a/idea/testData/psi/Functions_ERR.txt b/compiler/testData/psi/Functions_ERR.txt similarity index 100% rename from idea/testData/psi/Functions_ERR.txt rename to compiler/testData/psi/Functions_ERR.txt diff --git a/idea/testData/psi/HangOnLonelyModifier.jet b/compiler/testData/psi/HangOnLonelyModifier.jet similarity index 100% rename from idea/testData/psi/HangOnLonelyModifier.jet rename to compiler/testData/psi/HangOnLonelyModifier.jet diff --git a/idea/testData/psi/HangOnLonelyModifier.txt b/compiler/testData/psi/HangOnLonelyModifier.txt similarity index 100% rename from idea/testData/psi/HangOnLonelyModifier.txt rename to compiler/testData/psi/HangOnLonelyModifier.txt diff --git a/idea/testData/psi/IfWithPropery.jet b/compiler/testData/psi/IfWithPropery.jet similarity index 100% rename from idea/testData/psi/IfWithPropery.jet rename to compiler/testData/psi/IfWithPropery.jet diff --git a/idea/testData/psi/IfWithPropery.txt b/compiler/testData/psi/IfWithPropery.txt similarity index 100% rename from idea/testData/psi/IfWithPropery.txt rename to compiler/testData/psi/IfWithPropery.txt diff --git a/idea/testData/psi/ImportSoftKW.jet b/compiler/testData/psi/ImportSoftKW.jet similarity index 100% rename from idea/testData/psi/ImportSoftKW.jet rename to compiler/testData/psi/ImportSoftKW.jet diff --git a/idea/testData/psi/ImportSoftKW.txt b/compiler/testData/psi/ImportSoftKW.txt similarity index 100% rename from idea/testData/psi/ImportSoftKW.txt rename to compiler/testData/psi/ImportSoftKW.txt diff --git a/idea/testData/psi/Imports.jet b/compiler/testData/psi/Imports.jet similarity index 100% rename from idea/testData/psi/Imports.jet rename to compiler/testData/psi/Imports.jet diff --git a/idea/testData/psi/Imports.txt b/compiler/testData/psi/Imports.txt similarity index 100% rename from idea/testData/psi/Imports.txt rename to compiler/testData/psi/Imports.txt diff --git a/idea/testData/psi/Imports_ERR.jet b/compiler/testData/psi/Imports_ERR.jet similarity index 100% rename from idea/testData/psi/Imports_ERR.jet rename to compiler/testData/psi/Imports_ERR.jet diff --git a/idea/testData/psi/Imports_ERR.txt b/compiler/testData/psi/Imports_ERR.txt similarity index 100% rename from idea/testData/psi/Imports_ERR.txt rename to compiler/testData/psi/Imports_ERR.txt diff --git a/idea/testData/psi/Labels.jet b/compiler/testData/psi/Labels.jet similarity index 92% rename from idea/testData/psi/Labels.jet rename to compiler/testData/psi/Labels.jet index 57f1eb85da4..43299ecec35 100644 --- a/idea/testData/psi/Labels.jet +++ b/compiler/testData/psi/Labels.jet @@ -53,8 +53,8 @@ fun foo() { this@a this@@ - this - this@ - this@a - this@@ + super + super@ + super@a + super@@ } \ No newline at end of file diff --git a/idea/testData/psi/Labels.txt b/compiler/testData/psi/Labels.txt similarity index 98% rename from idea/testData/psi/Labels.txt rename to compiler/testData/psi/Labels.txt index 23a51e07506..118356f871c 100644 --- a/idea/testData/psi/Labels.txt +++ b/compiler/testData/psi/Labels.txt @@ -412,9 +412,9 @@ JetFile: Labels.jet LABEL_REFERENCE PsiElement(ATAT)('@@') PsiWhiteSpace('\n\n ') - THIS_EXPRESSION + SUPER_EXPRESSION REFERENCE_EXPRESSION - PsiElement(this)('this') + PsiElement(super)('super') PsiElement(LT)('<') TYPE_REFERENCE USER_TYPE @@ -422,43 +422,43 @@ JetFile: Labels.jet PsiElement(IDENTIFIER)('A') PsiElement(GT)('>') PsiWhiteSpace('\n ') - THIS_EXPRESSION + SUPER_EXPRESSION REFERENCE_EXPRESSION - PsiElement(this)('this') + PsiElement(super)('super') + PsiElement(LT)('<') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('A') + PsiElement(GT)('>') LABEL_QUALIFIER LABEL_REFERENCE PsiElement(AT)('@') + PsiWhiteSpace('\n ') + SUPER_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(super)('super') PsiElement(LT)('<') TYPE_REFERENCE USER_TYPE REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('A') PsiElement(GT)('>') - PsiWhiteSpace('\n ') - THIS_EXPRESSION - REFERENCE_EXPRESSION - PsiElement(this)('this') LABEL_QUALIFIER LABEL_REFERENCE PsiElement(LABEL_IDENTIFIER)('@a') + PsiWhiteSpace('\n ') + SUPER_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(super)('super') PsiElement(LT)('<') TYPE_REFERENCE USER_TYPE REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('A') PsiElement(GT)('>') - PsiWhiteSpace('\n ') - THIS_EXPRESSION - REFERENCE_EXPRESSION - PsiElement(this)('this') LABEL_QUALIFIER LABEL_REFERENCE PsiElement(ATAT)('@@') - PsiElement(LT)('<') - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('A') - PsiElement(GT)('>') PsiWhiteSpace('\n') PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/idea/testData/psi/LocalDeclarations.jet b/compiler/testData/psi/LocalDeclarations.jet similarity index 100% rename from idea/testData/psi/LocalDeclarations.jet rename to compiler/testData/psi/LocalDeclarations.jet diff --git a/idea/testData/psi/LocalDeclarations.txt b/compiler/testData/psi/LocalDeclarations.txt similarity index 100% rename from idea/testData/psi/LocalDeclarations.txt rename to compiler/testData/psi/LocalDeclarations.txt diff --git a/idea/testData/psi/ModifierAsSelector.jet b/compiler/testData/psi/ModifierAsSelector.jet similarity index 100% rename from idea/testData/psi/ModifierAsSelector.jet rename to compiler/testData/psi/ModifierAsSelector.jet diff --git a/idea/testData/psi/ModifierAsSelector.txt b/compiler/testData/psi/ModifierAsSelector.txt similarity index 100% rename from idea/testData/psi/ModifierAsSelector.txt rename to compiler/testData/psi/ModifierAsSelector.txt diff --git a/idea/testData/psi/NamespaceBlock.jet b/compiler/testData/psi/NamespaceBlock.jet similarity index 100% rename from idea/testData/psi/NamespaceBlock.jet rename to compiler/testData/psi/NamespaceBlock.jet diff --git a/idea/testData/psi/NamespaceBlock.txt b/compiler/testData/psi/NamespaceBlock.txt similarity index 100% rename from idea/testData/psi/NamespaceBlock.txt rename to compiler/testData/psi/NamespaceBlock.txt diff --git a/idea/testData/psi/NamespaceBlockFirst.jet b/compiler/testData/psi/NamespaceBlockFirst.jet similarity index 100% rename from idea/testData/psi/NamespaceBlockFirst.jet rename to compiler/testData/psi/NamespaceBlockFirst.jet diff --git a/idea/testData/psi/NamespaceBlockFirst.txt b/compiler/testData/psi/NamespaceBlockFirst.txt similarity index 100% rename from idea/testData/psi/NamespaceBlockFirst.txt rename to compiler/testData/psi/NamespaceBlockFirst.txt diff --git a/idea/testData/psi/NamespaceBlock_ERR.jet b/compiler/testData/psi/NamespaceBlock_ERR.jet similarity index 100% rename from idea/testData/psi/NamespaceBlock_ERR.jet rename to compiler/testData/psi/NamespaceBlock_ERR.jet diff --git a/idea/testData/psi/NamespaceBlock_ERR.txt b/compiler/testData/psi/NamespaceBlock_ERR.txt similarity index 100% rename from idea/testData/psi/NamespaceBlock_ERR.txt rename to compiler/testData/psi/NamespaceBlock_ERR.txt diff --git a/idea/testData/psi/NamespaceModifiers.jet b/compiler/testData/psi/NamespaceModifiers.jet similarity index 100% rename from idea/testData/psi/NamespaceModifiers.jet rename to compiler/testData/psi/NamespaceModifiers.jet diff --git a/idea/testData/psi/NamespaceModifiers.txt b/compiler/testData/psi/NamespaceModifiers.txt similarity index 100% rename from idea/testData/psi/NamespaceModifiers.txt rename to compiler/testData/psi/NamespaceModifiers.txt diff --git a/idea/testData/psi/NewlinesInParentheses.jet b/compiler/testData/psi/NewlinesInParentheses.jet similarity index 100% rename from idea/testData/psi/NewlinesInParentheses.jet rename to compiler/testData/psi/NewlinesInParentheses.jet diff --git a/idea/testData/psi/NewlinesInParentheses.txt b/compiler/testData/psi/NewlinesInParentheses.txt similarity index 100% rename from idea/testData/psi/NewlinesInParentheses.txt rename to compiler/testData/psi/NewlinesInParentheses.txt diff --git a/idea/testData/psi/NotIsAndNotIn.jet b/compiler/testData/psi/NotIsAndNotIn.jet similarity index 100% rename from idea/testData/psi/NotIsAndNotIn.jet rename to compiler/testData/psi/NotIsAndNotIn.jet diff --git a/idea/testData/psi/NotIsAndNotIn.txt b/compiler/testData/psi/NotIsAndNotIn.txt similarity index 100% rename from idea/testData/psi/NotIsAndNotIn.txt rename to compiler/testData/psi/NotIsAndNotIn.txt diff --git a/idea/testData/psi/Precedence.jet b/compiler/testData/psi/Precedence.jet similarity index 100% rename from idea/testData/psi/Precedence.jet rename to compiler/testData/psi/Precedence.jet diff --git a/idea/testData/psi/Precedence.txt b/compiler/testData/psi/Precedence.txt similarity index 100% rename from idea/testData/psi/Precedence.txt rename to compiler/testData/psi/Precedence.txt diff --git a/idea/testData/psi/PredicateExpression.jet b/compiler/testData/psi/PredicateExpression.jet similarity index 100% rename from idea/testData/psi/PredicateExpression.jet rename to compiler/testData/psi/PredicateExpression.jet diff --git a/idea/testData/psi/PredicateExpression.txt b/compiler/testData/psi/PredicateExpression.txt similarity index 100% rename from idea/testData/psi/PredicateExpression.txt rename to compiler/testData/psi/PredicateExpression.txt diff --git a/idea/testData/psi/Properties.jet b/compiler/testData/psi/Properties.jet similarity index 100% rename from idea/testData/psi/Properties.jet rename to compiler/testData/psi/Properties.jet diff --git a/idea/testData/psi/Properties.txt b/compiler/testData/psi/Properties.txt similarity index 100% rename from idea/testData/psi/Properties.txt rename to compiler/testData/psi/Properties.txt diff --git a/idea/testData/psi/PropertiesFollowedByInitializers.jet b/compiler/testData/psi/PropertiesFollowedByInitializers.jet similarity index 100% rename from idea/testData/psi/PropertiesFollowedByInitializers.jet rename to compiler/testData/psi/PropertiesFollowedByInitializers.jet diff --git a/idea/testData/psi/PropertiesFollowedByInitializers.txt b/compiler/testData/psi/PropertiesFollowedByInitializers.txt similarity index 100% rename from idea/testData/psi/PropertiesFollowedByInitializers.txt rename to compiler/testData/psi/PropertiesFollowedByInitializers.txt diff --git a/idea/testData/psi/Properties_ERR.jet b/compiler/testData/psi/Properties_ERR.jet similarity index 100% rename from idea/testData/psi/Properties_ERR.jet rename to compiler/testData/psi/Properties_ERR.jet diff --git a/idea/testData/psi/Properties_ERR.txt b/compiler/testData/psi/Properties_ERR.txt similarity index 100% rename from idea/testData/psi/Properties_ERR.txt rename to compiler/testData/psi/Properties_ERR.txt diff --git a/idea/testData/psi/QuotedIdentifiers.jet b/compiler/testData/psi/QuotedIdentifiers.jet similarity index 100% rename from idea/testData/psi/QuotedIdentifiers.jet rename to compiler/testData/psi/QuotedIdentifiers.jet diff --git a/idea/testData/psi/QuotedIdentifiers.txt b/compiler/testData/psi/QuotedIdentifiers.txt similarity index 100% rename from idea/testData/psi/QuotedIdentifiers.txt rename to compiler/testData/psi/QuotedIdentifiers.txt diff --git a/idea/testData/psi/RootNamespace.jet b/compiler/testData/psi/RootNamespace.jet similarity index 100% rename from idea/testData/psi/RootNamespace.jet rename to compiler/testData/psi/RootNamespace.jet diff --git a/idea/testData/psi/RootNamespace.txt b/compiler/testData/psi/RootNamespace.txt similarity index 100% rename from idea/testData/psi/RootNamespace.txt rename to compiler/testData/psi/RootNamespace.txt diff --git a/idea/testData/psi/SemicolonAfterIf.jet b/compiler/testData/psi/SemicolonAfterIf.jet similarity index 100% rename from idea/testData/psi/SemicolonAfterIf.jet rename to compiler/testData/psi/SemicolonAfterIf.jet diff --git a/idea/testData/psi/SemicolonAfterIf.txt b/compiler/testData/psi/SemicolonAfterIf.txt similarity index 100% rename from idea/testData/psi/SemicolonAfterIf.txt rename to compiler/testData/psi/SemicolonAfterIf.txt diff --git a/idea/testData/psi/ShortAnnotations.jet b/compiler/testData/psi/ShortAnnotations.jet similarity index 100% rename from idea/testData/psi/ShortAnnotations.jet rename to compiler/testData/psi/ShortAnnotations.jet diff --git a/idea/testData/psi/ShortAnnotations.txt b/compiler/testData/psi/ShortAnnotations.txt similarity index 100% rename from idea/testData/psi/ShortAnnotations.txt rename to compiler/testData/psi/ShortAnnotations.txt diff --git a/idea/testData/psi/SimpleClassMembers.jet b/compiler/testData/psi/SimpleClassMembers.jet similarity index 100% rename from idea/testData/psi/SimpleClassMembers.jet rename to compiler/testData/psi/SimpleClassMembers.jet diff --git a/idea/testData/psi/SimpleClassMembers.txt b/compiler/testData/psi/SimpleClassMembers.txt similarity index 100% rename from idea/testData/psi/SimpleClassMembers.txt rename to compiler/testData/psi/SimpleClassMembers.txt diff --git a/idea/testData/psi/SimpleClassMembers_ERR.jet b/compiler/testData/psi/SimpleClassMembers_ERR.jet similarity index 100% rename from idea/testData/psi/SimpleClassMembers_ERR.jet rename to compiler/testData/psi/SimpleClassMembers_ERR.jet diff --git a/idea/testData/psi/SimpleClassMembers_ERR.txt b/compiler/testData/psi/SimpleClassMembers_ERR.txt similarity index 100% rename from idea/testData/psi/SimpleClassMembers_ERR.txt rename to compiler/testData/psi/SimpleClassMembers_ERR.txt diff --git a/idea/testData/psi/SimpleExpressions.jet b/compiler/testData/psi/SimpleExpressions.jet similarity index 97% rename from idea/testData/psi/SimpleExpressions.jet rename to compiler/testData/psi/SimpleExpressions.jet index 2bdebc0f908..a3969d2b230 100644 --- a/idea/testData/psi/SimpleExpressions.jet +++ b/compiler/testData/psi/SimpleExpressions.jet @@ -15,7 +15,7 @@ fun a( a : foo = false, a : foo = null, a : foo = this, - a : foo = this, + a : foo = super, a : foo = (10), a : foo = (10, "A", 0xf), a : foo = Foo(bar), diff --git a/idea/testData/psi/SimpleExpressions.txt b/compiler/testData/psi/SimpleExpressions.txt similarity index 99% rename from idea/testData/psi/SimpleExpressions.txt rename to compiler/testData/psi/SimpleExpressions.txt index 077ad384866..16219eac0b0 100644 --- a/idea/testData/psi/SimpleExpressions.txt +++ b/compiler/testData/psi/SimpleExpressions.txt @@ -280,9 +280,9 @@ JetFile: SimpleExpressions.jet PsiWhiteSpace(' ') PsiElement(EQ)('=') PsiWhiteSpace(' ') - THIS_EXPRESSION + SUPER_EXPRESSION REFERENCE_EXPRESSION - PsiElement(this)('this') + PsiElement(super)('super') PsiElement(LT)('<') TYPE_REFERENCE USER_TYPE diff --git a/idea/testData/psi/SimpleModifiers.jet b/compiler/testData/psi/SimpleModifiers.jet similarity index 100% rename from idea/testData/psi/SimpleModifiers.jet rename to compiler/testData/psi/SimpleModifiers.jet diff --git a/idea/testData/psi/SimpleModifiers.txt b/compiler/testData/psi/SimpleModifiers.txt similarity index 100% rename from idea/testData/psi/SimpleModifiers.txt rename to compiler/testData/psi/SimpleModifiers.txt diff --git a/idea/testData/psi/SoftKeywords.jet b/compiler/testData/psi/SoftKeywords.jet similarity index 100% rename from idea/testData/psi/SoftKeywords.jet rename to compiler/testData/psi/SoftKeywords.jet diff --git a/idea/testData/psi/SoftKeywords.txt b/compiler/testData/psi/SoftKeywords.txt similarity index 100% rename from idea/testData/psi/SoftKeywords.txt rename to compiler/testData/psi/SoftKeywords.txt diff --git a/idea/testData/psi/SoftKeywordsInTypeArguments.jet b/compiler/testData/psi/SoftKeywordsInTypeArguments.jet similarity index 100% rename from idea/testData/psi/SoftKeywordsInTypeArguments.jet rename to compiler/testData/psi/SoftKeywordsInTypeArguments.jet diff --git a/idea/testData/psi/SoftKeywordsInTypeArguments.txt b/compiler/testData/psi/SoftKeywordsInTypeArguments.txt similarity index 100% rename from idea/testData/psi/SoftKeywordsInTypeArguments.txt rename to compiler/testData/psi/SoftKeywordsInTypeArguments.txt diff --git a/idea/testData/psi/StringTemplates.jet b/compiler/testData/psi/StringTemplates.jet similarity index 100% rename from idea/testData/psi/StringTemplates.jet rename to compiler/testData/psi/StringTemplates.jet diff --git a/idea/testData/psi/StringTemplates.txt b/compiler/testData/psi/StringTemplates.txt similarity index 100% rename from idea/testData/psi/StringTemplates.txt rename to compiler/testData/psi/StringTemplates.txt diff --git a/idea/testData/psi/ThisType.jet b/compiler/testData/psi/ThisType.jet similarity index 100% rename from idea/testData/psi/ThisType.jet rename to compiler/testData/psi/ThisType.jet diff --git a/idea/testData/psi/ThisType.txt b/compiler/testData/psi/ThisType.txt similarity index 100% rename from idea/testData/psi/ThisType.txt rename to compiler/testData/psi/ThisType.txt diff --git a/idea/testData/psi/TupleTypes.jet b/compiler/testData/psi/TupleTypes.jet similarity index 100% rename from idea/testData/psi/TupleTypes.jet rename to compiler/testData/psi/TupleTypes.jet diff --git a/idea/testData/psi/TupleTypes.txt b/compiler/testData/psi/TupleTypes.txt similarity index 100% rename from idea/testData/psi/TupleTypes.txt rename to compiler/testData/psi/TupleTypes.txt diff --git a/idea/testData/psi/TupleTypes_ERR.jet b/compiler/testData/psi/TupleTypes_ERR.jet similarity index 100% rename from idea/testData/psi/TupleTypes_ERR.jet rename to compiler/testData/psi/TupleTypes_ERR.jet diff --git a/idea/testData/psi/TupleTypes_ERR.txt b/compiler/testData/psi/TupleTypes_ERR.txt similarity index 100% rename from idea/testData/psi/TupleTypes_ERR.txt rename to compiler/testData/psi/TupleTypes_ERR.txt diff --git a/idea/testData/psi/TuplesWithLabeledEntries.jet b/compiler/testData/psi/TuplesWithLabeledEntries.jet similarity index 100% rename from idea/testData/psi/TuplesWithLabeledEntries.jet rename to compiler/testData/psi/TuplesWithLabeledEntries.jet diff --git a/idea/testData/psi/TuplesWithLabeledEntries.txt b/compiler/testData/psi/TuplesWithLabeledEntries.txt similarity index 100% rename from idea/testData/psi/TuplesWithLabeledEntries.txt rename to compiler/testData/psi/TuplesWithLabeledEntries.txt diff --git a/idea/testData/psi/TypeAnnotations.jet b/compiler/testData/psi/TypeAnnotations.jet similarity index 100% rename from idea/testData/psi/TypeAnnotations.jet rename to compiler/testData/psi/TypeAnnotations.jet diff --git a/idea/testData/psi/TypeAnnotations.txt b/compiler/testData/psi/TypeAnnotations.txt similarity index 100% rename from idea/testData/psi/TypeAnnotations.txt rename to compiler/testData/psi/TypeAnnotations.txt diff --git a/idea/testData/psi/TypeConstraints.jet b/compiler/testData/psi/TypeConstraints.jet similarity index 100% rename from idea/testData/psi/TypeConstraints.jet rename to compiler/testData/psi/TypeConstraints.jet diff --git a/idea/testData/psi/TypeConstraints.txt b/compiler/testData/psi/TypeConstraints.txt similarity index 100% rename from idea/testData/psi/TypeConstraints.txt rename to compiler/testData/psi/TypeConstraints.txt diff --git a/idea/testData/psi/TypeDef.jet b/compiler/testData/psi/TypeDef.jet similarity index 100% rename from idea/testData/psi/TypeDef.jet rename to compiler/testData/psi/TypeDef.jet diff --git a/idea/testData/psi/TypeDef.txt b/compiler/testData/psi/TypeDef.txt similarity index 100% rename from idea/testData/psi/TypeDef.txt rename to compiler/testData/psi/TypeDef.txt diff --git a/idea/testData/psi/TypeDef_ERR.jet b/compiler/testData/psi/TypeDef_ERR.jet similarity index 100% rename from idea/testData/psi/TypeDef_ERR.jet rename to compiler/testData/psi/TypeDef_ERR.jet diff --git a/idea/testData/psi/TypeDef_ERR.txt b/compiler/testData/psi/TypeDef_ERR.txt similarity index 100% rename from idea/testData/psi/TypeDef_ERR.txt rename to compiler/testData/psi/TypeDef_ERR.txt diff --git a/idea/testData/psi/TypeExpressionAmbiguities_ERR.jet b/compiler/testData/psi/TypeExpressionAmbiguities_ERR.jet similarity index 100% rename from idea/testData/psi/TypeExpressionAmbiguities_ERR.jet rename to compiler/testData/psi/TypeExpressionAmbiguities_ERR.jet diff --git a/idea/testData/psi/TypeExpressionAmbiguities_ERR.txt b/compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt similarity index 100% rename from idea/testData/psi/TypeExpressionAmbiguities_ERR.txt rename to compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt diff --git a/idea/testData/psi/TypeParametersBeforeName.jet b/compiler/testData/psi/TypeParametersBeforeName.jet similarity index 100% rename from idea/testData/psi/TypeParametersBeforeName.jet rename to compiler/testData/psi/TypeParametersBeforeName.jet diff --git a/idea/testData/psi/TypeParametersBeforeName.txt b/compiler/testData/psi/TypeParametersBeforeName.txt similarity index 100% rename from idea/testData/psi/TypeParametersBeforeName.txt rename to compiler/testData/psi/TypeParametersBeforeName.txt diff --git a/idea/testData/psi/When.jet b/compiler/testData/psi/When.jet similarity index 100% rename from idea/testData/psi/When.jet rename to compiler/testData/psi/When.jet diff --git a/idea/testData/psi/When.txt b/compiler/testData/psi/When.txt similarity index 100% rename from idea/testData/psi/When.txt rename to compiler/testData/psi/When.txt diff --git a/idea/testData/psi/When_ERR.jet b/compiler/testData/psi/When_ERR.jet similarity index 100% rename from idea/testData/psi/When_ERR.jet rename to compiler/testData/psi/When_ERR.jet diff --git a/idea/testData/psi/When_ERR.txt b/compiler/testData/psi/When_ERR.txt similarity index 100% rename from idea/testData/psi/When_ERR.txt rename to compiler/testData/psi/When_ERR.txt diff --git a/idea/testData/psi/examples/AnonymousObjects.jet b/compiler/testData/psi/examples/AnonymousObjects.jet similarity index 100% rename from idea/testData/psi/examples/AnonymousObjects.jet rename to compiler/testData/psi/examples/AnonymousObjects.jet diff --git a/idea/testData/psi/examples/AnonymousObjects.txt b/compiler/testData/psi/examples/AnonymousObjects.txt similarity index 100% rename from idea/testData/psi/examples/AnonymousObjects.txt rename to compiler/testData/psi/examples/AnonymousObjects.txt diff --git a/idea/testData/psi/examples/BinaryTree.jet b/compiler/testData/psi/examples/BinaryTree.jet similarity index 100% rename from idea/testData/psi/examples/BinaryTree.jet rename to compiler/testData/psi/examples/BinaryTree.jet diff --git a/idea/testData/psi/examples/BinaryTree.txt b/compiler/testData/psi/examples/BinaryTree.txt similarity index 100% rename from idea/testData/psi/examples/BinaryTree.txt rename to compiler/testData/psi/examples/BinaryTree.txt diff --git a/idea/testData/psi/examples/BitArith.jet b/compiler/testData/psi/examples/BitArith.jet similarity index 100% rename from idea/testData/psi/examples/BitArith.jet rename to compiler/testData/psi/examples/BitArith.jet diff --git a/idea/testData/psi/examples/BitArith.txt b/compiler/testData/psi/examples/BitArith.txt similarity index 100% rename from idea/testData/psi/examples/BitArith.txt rename to compiler/testData/psi/examples/BitArith.txt diff --git a/idea/testData/psi/examples/Builder.jet b/compiler/testData/psi/examples/Builder.jet similarity index 100% rename from idea/testData/psi/examples/Builder.jet rename to compiler/testData/psi/examples/Builder.jet diff --git a/idea/testData/psi/examples/Builder.txt b/compiler/testData/psi/examples/Builder.txt similarity index 100% rename from idea/testData/psi/examples/Builder.txt rename to compiler/testData/psi/examples/Builder.txt diff --git a/idea/testData/psi/examples/Color.jet b/compiler/testData/psi/examples/Color.jet similarity index 100% rename from idea/testData/psi/examples/Color.jet rename to compiler/testData/psi/examples/Color.jet diff --git a/idea/testData/psi/examples/Color.txt b/compiler/testData/psi/examples/Color.txt similarity index 100% rename from idea/testData/psi/examples/Color.txt rename to compiler/testData/psi/examples/Color.txt diff --git a/idea/testData/psi/examples/FunctionsAndTypes.jet b/compiler/testData/psi/examples/FunctionsAndTypes.jet similarity index 100% rename from idea/testData/psi/examples/FunctionsAndTypes.jet rename to compiler/testData/psi/examples/FunctionsAndTypes.jet diff --git a/idea/testData/psi/examples/FunctionsAndTypes.txt b/compiler/testData/psi/examples/FunctionsAndTypes.txt similarity index 100% rename from idea/testData/psi/examples/FunctionsAndTypes.txt rename to compiler/testData/psi/examples/FunctionsAndTypes.txt diff --git a/idea/testData/psi/examples/Graph.jet b/compiler/testData/psi/examples/Graph.jet similarity index 100% rename from idea/testData/psi/examples/Graph.jet rename to compiler/testData/psi/examples/Graph.jet diff --git a/idea/testData/psi/examples/Graph.txt b/compiler/testData/psi/examples/Graph.txt similarity index 100% rename from idea/testData/psi/examples/Graph.txt rename to compiler/testData/psi/examples/Graph.txt diff --git a/idea/testData/psi/examples/IPushPop.jet b/compiler/testData/psi/examples/IPushPop.jet similarity index 100% rename from idea/testData/psi/examples/IPushPop.jet rename to compiler/testData/psi/examples/IPushPop.jet diff --git a/idea/testData/psi/examples/IPushPop.txt b/compiler/testData/psi/examples/IPushPop.txt similarity index 100% rename from idea/testData/psi/examples/IPushPop.txt rename to compiler/testData/psi/examples/IPushPop.txt diff --git a/idea/testData/psi/examples/LINQ.jet b/compiler/testData/psi/examples/LINQ.jet similarity index 100% rename from idea/testData/psi/examples/LINQ.jet rename to compiler/testData/psi/examples/LINQ.jet diff --git a/idea/testData/psi/examples/LINQ.txt b/compiler/testData/psi/examples/LINQ.txt similarity index 100% rename from idea/testData/psi/examples/LINQ.txt rename to compiler/testData/psi/examples/LINQ.txt diff --git a/idea/testData/psi/examples/PolymorphicClassObjects.jet b/compiler/testData/psi/examples/PolymorphicClassObjects.jet similarity index 100% rename from idea/testData/psi/examples/PolymorphicClassObjects.jet rename to compiler/testData/psi/examples/PolymorphicClassObjects.jet diff --git a/idea/testData/psi/examples/PolymorphicClassObjects.txt b/compiler/testData/psi/examples/PolymorphicClassObjects.txt similarity index 100% rename from idea/testData/psi/examples/PolymorphicClassObjects.txt rename to compiler/testData/psi/examples/PolymorphicClassObjects.txt diff --git a/idea/testData/psi/examples/Queue.jet b/compiler/testData/psi/examples/Queue.jet similarity index 100% rename from idea/testData/psi/examples/Queue.jet rename to compiler/testData/psi/examples/Queue.jet diff --git a/idea/testData/psi/examples/Queue.txt b/compiler/testData/psi/examples/Queue.txt similarity index 100% rename from idea/testData/psi/examples/Queue.txt rename to compiler/testData/psi/examples/Queue.txt diff --git a/idea/testData/psi/examples/Stack.jet b/compiler/testData/psi/examples/Stack.jet similarity index 100% rename from idea/testData/psi/examples/Stack.jet rename to compiler/testData/psi/examples/Stack.jet diff --git a/idea/testData/psi/examples/Stack.txt b/compiler/testData/psi/examples/Stack.txt similarity index 100% rename from idea/testData/psi/examples/Stack.txt rename to compiler/testData/psi/examples/Stack.txt diff --git a/idea/testData/psi/examples/UnionFind.jet b/compiler/testData/psi/examples/UnionFind.jet similarity index 100% rename from idea/testData/psi/examples/UnionFind.jet rename to compiler/testData/psi/examples/UnionFind.jet diff --git a/idea/testData/psi/examples/UnionFind.txt b/compiler/testData/psi/examples/UnionFind.txt similarity index 100% rename from idea/testData/psi/examples/UnionFind.txt rename to compiler/testData/psi/examples/UnionFind.txt diff --git a/idea/testData/psi/examples/UpdateOperation.jet b/compiler/testData/psi/examples/UpdateOperation.jet similarity index 100% rename from idea/testData/psi/examples/UpdateOperation.jet rename to compiler/testData/psi/examples/UpdateOperation.jet diff --git a/idea/testData/psi/examples/UpdateOperation.txt b/compiler/testData/psi/examples/UpdateOperation.txt similarity index 100% rename from idea/testData/psi/examples/UpdateOperation.txt rename to compiler/testData/psi/examples/UpdateOperation.txt diff --git a/idea/testData/psi/examples/With.jet b/compiler/testData/psi/examples/With.jet similarity index 100% rename from idea/testData/psi/examples/With.jet rename to compiler/testData/psi/examples/With.jet diff --git a/idea/testData/psi/examples/With.txt b/compiler/testData/psi/examples/With.txt similarity index 100% rename from idea/testData/psi/examples/With.txt rename to compiler/testData/psi/examples/With.txt diff --git a/idea/testData/psi/examples/array/MutableArray.jet b/compiler/testData/psi/examples/array/MutableArray.jet similarity index 100% rename from idea/testData/psi/examples/array/MutableArray.jet rename to compiler/testData/psi/examples/array/MutableArray.jet diff --git a/idea/testData/psi/examples/array/MutableArray.txt b/compiler/testData/psi/examples/array/MutableArray.txt similarity index 100% rename from idea/testData/psi/examples/array/MutableArray.txt rename to compiler/testData/psi/examples/array/MutableArray.txt diff --git a/idea/testData/psi/examples/collections/ArrayList.jet b/compiler/testData/psi/examples/collections/ArrayList.jet similarity index 100% rename from idea/testData/psi/examples/collections/ArrayList.jet rename to compiler/testData/psi/examples/collections/ArrayList.jet diff --git a/idea/testData/psi/examples/collections/ArrayList.txt b/compiler/testData/psi/examples/collections/ArrayList.txt similarity index 100% rename from idea/testData/psi/examples/collections/ArrayList.txt rename to compiler/testData/psi/examples/collections/ArrayList.txt diff --git a/idea/testData/psi/examples/collections/HashMap.jet b/compiler/testData/psi/examples/collections/HashMap.jet similarity index 100% rename from idea/testData/psi/examples/collections/HashMap.jet rename to compiler/testData/psi/examples/collections/HashMap.jet diff --git a/idea/testData/psi/examples/collections/HashMap.txt b/compiler/testData/psi/examples/collections/HashMap.txt similarity index 100% rename from idea/testData/psi/examples/collections/HashMap.txt rename to compiler/testData/psi/examples/collections/HashMap.txt diff --git a/idea/testData/psi/examples/collections/IIterable.jet b/compiler/testData/psi/examples/collections/IIterable.jet similarity index 100% rename from idea/testData/psi/examples/collections/IIterable.jet rename to compiler/testData/psi/examples/collections/IIterable.jet diff --git a/idea/testData/psi/examples/collections/IIterable.txt b/compiler/testData/psi/examples/collections/IIterable.txt similarity index 100% rename from idea/testData/psi/examples/collections/IIterable.txt rename to compiler/testData/psi/examples/collections/IIterable.txt diff --git a/idea/testData/psi/examples/collections/IIterator.jet b/compiler/testData/psi/examples/collections/IIterator.jet similarity index 100% rename from idea/testData/psi/examples/collections/IIterator.jet rename to compiler/testData/psi/examples/collections/IIterator.jet diff --git a/idea/testData/psi/examples/collections/IIterator.txt b/compiler/testData/psi/examples/collections/IIterator.txt similarity index 100% rename from idea/testData/psi/examples/collections/IIterator.txt rename to compiler/testData/psi/examples/collections/IIterator.txt diff --git a/idea/testData/psi/examples/collections/IList.jet b/compiler/testData/psi/examples/collections/IList.jet similarity index 100% rename from idea/testData/psi/examples/collections/IList.jet rename to compiler/testData/psi/examples/collections/IList.jet diff --git a/idea/testData/psi/examples/collections/IList.txt b/compiler/testData/psi/examples/collections/IList.txt similarity index 100% rename from idea/testData/psi/examples/collections/IList.txt rename to compiler/testData/psi/examples/collections/IList.txt diff --git a/idea/testData/psi/examples/collections/IMutableIterable.jet b/compiler/testData/psi/examples/collections/IMutableIterable.jet similarity index 100% rename from idea/testData/psi/examples/collections/IMutableIterable.jet rename to compiler/testData/psi/examples/collections/IMutableIterable.jet diff --git a/idea/testData/psi/examples/collections/IMutableIterable.txt b/compiler/testData/psi/examples/collections/IMutableIterable.txt similarity index 100% rename from idea/testData/psi/examples/collections/IMutableIterable.txt rename to compiler/testData/psi/examples/collections/IMutableIterable.txt diff --git a/idea/testData/psi/examples/collections/IMutableIterator.jet b/compiler/testData/psi/examples/collections/IMutableIterator.jet similarity index 100% rename from idea/testData/psi/examples/collections/IMutableIterator.jet rename to compiler/testData/psi/examples/collections/IMutableIterator.jet diff --git a/idea/testData/psi/examples/collections/IMutableIterator.txt b/compiler/testData/psi/examples/collections/IMutableIterator.txt similarity index 100% rename from idea/testData/psi/examples/collections/IMutableIterator.txt rename to compiler/testData/psi/examples/collections/IMutableIterator.txt diff --git a/idea/testData/psi/examples/collections/IMutableList.jet b/compiler/testData/psi/examples/collections/IMutableList.jet similarity index 100% rename from idea/testData/psi/examples/collections/IMutableList.jet rename to compiler/testData/psi/examples/collections/IMutableList.jet diff --git a/idea/testData/psi/examples/collections/IMutableList.txt b/compiler/testData/psi/examples/collections/IMutableList.txt similarity index 100% rename from idea/testData/psi/examples/collections/IMutableList.txt rename to compiler/testData/psi/examples/collections/IMutableList.txt diff --git a/idea/testData/psi/examples/collections/IMutableSet.jet b/compiler/testData/psi/examples/collections/IMutableSet.jet similarity index 100% rename from idea/testData/psi/examples/collections/IMutableSet.jet rename to compiler/testData/psi/examples/collections/IMutableSet.jet diff --git a/idea/testData/psi/examples/collections/IMutableSet.txt b/compiler/testData/psi/examples/collections/IMutableSet.txt similarity index 100% rename from idea/testData/psi/examples/collections/IMutableSet.txt rename to compiler/testData/psi/examples/collections/IMutableSet.txt diff --git a/idea/testData/psi/examples/collections/ISet.jet b/compiler/testData/psi/examples/collections/ISet.jet similarity index 100% rename from idea/testData/psi/examples/collections/ISet.jet rename to compiler/testData/psi/examples/collections/ISet.jet diff --git a/idea/testData/psi/examples/collections/ISet.txt b/compiler/testData/psi/examples/collections/ISet.txt similarity index 100% rename from idea/testData/psi/examples/collections/ISet.txt rename to compiler/testData/psi/examples/collections/ISet.txt diff --git a/idea/testData/psi/examples/collections/ISized.jet b/compiler/testData/psi/examples/collections/ISized.jet similarity index 100% rename from idea/testData/psi/examples/collections/ISized.jet rename to compiler/testData/psi/examples/collections/ISized.jet diff --git a/idea/testData/psi/examples/collections/ISized.txt b/compiler/testData/psi/examples/collections/ISized.txt similarity index 100% rename from idea/testData/psi/examples/collections/ISized.txt rename to compiler/testData/psi/examples/collections/ISized.txt diff --git a/idea/testData/psi/examples/collections/LinkedList.jet b/compiler/testData/psi/examples/collections/LinkedList.jet similarity index 100% rename from idea/testData/psi/examples/collections/LinkedList.jet rename to compiler/testData/psi/examples/collections/LinkedList.jet diff --git a/idea/testData/psi/examples/collections/LinkedList.txt b/compiler/testData/psi/examples/collections/LinkedList.txt similarity index 100% rename from idea/testData/psi/examples/collections/LinkedList.txt rename to compiler/testData/psi/examples/collections/LinkedList.txt diff --git a/idea/testData/psi/examples/collections/List.jet b/compiler/testData/psi/examples/collections/List.jet similarity index 100% rename from idea/testData/psi/examples/collections/List.jet rename to compiler/testData/psi/examples/collections/List.jet diff --git a/idea/testData/psi/examples/collections/List.txt b/compiler/testData/psi/examples/collections/List.txt similarity index 100% rename from idea/testData/psi/examples/collections/List.txt rename to compiler/testData/psi/examples/collections/List.txt diff --git a/idea/testData/psi/examples/io/IOSamples.jet b/compiler/testData/psi/examples/io/IOSamples.jet similarity index 100% rename from idea/testData/psi/examples/io/IOSamples.jet rename to compiler/testData/psi/examples/io/IOSamples.jet diff --git a/idea/testData/psi/examples/io/IOSamples.txt b/compiler/testData/psi/examples/io/IOSamples.txt similarity index 100% rename from idea/testData/psi/examples/io/IOSamples.txt rename to compiler/testData/psi/examples/io/IOSamples.txt diff --git a/idea/testData/psi/examples/map/IMap.jet b/compiler/testData/psi/examples/map/IMap.jet similarity index 100% rename from idea/testData/psi/examples/map/IMap.jet rename to compiler/testData/psi/examples/map/IMap.jet diff --git a/idea/testData/psi/examples/map/IMap.txt b/compiler/testData/psi/examples/map/IMap.txt similarity index 100% rename from idea/testData/psi/examples/map/IMap.txt rename to compiler/testData/psi/examples/map/IMap.txt diff --git a/idea/testData/psi/examples/priorityqueues/BinaryHeap.jet b/compiler/testData/psi/examples/priorityqueues/BinaryHeap.jet similarity index 100% rename from idea/testData/psi/examples/priorityqueues/BinaryHeap.jet rename to compiler/testData/psi/examples/priorityqueues/BinaryHeap.jet diff --git a/idea/testData/psi/examples/priorityqueues/BinaryHeap.txt b/compiler/testData/psi/examples/priorityqueues/BinaryHeap.txt similarity index 100% rename from idea/testData/psi/examples/priorityqueues/BinaryHeap.txt rename to compiler/testData/psi/examples/priorityqueues/BinaryHeap.txt diff --git a/idea/testData/psi/examples/priorityqueues/IPriorityQueue.jet b/compiler/testData/psi/examples/priorityqueues/IPriorityQueue.jet similarity index 100% rename from idea/testData/psi/examples/priorityqueues/IPriorityQueue.jet rename to compiler/testData/psi/examples/priorityqueues/IPriorityQueue.jet diff --git a/idea/testData/psi/examples/priorityqueues/IPriorityQueue.txt b/compiler/testData/psi/examples/priorityqueues/IPriorityQueue.txt similarity index 100% rename from idea/testData/psi/examples/priorityqueues/IPriorityQueue.txt rename to compiler/testData/psi/examples/priorityqueues/IPriorityQueue.txt diff --git a/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.jet b/compiler/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.jet similarity index 100% rename from idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.jet rename to compiler/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.jet diff --git a/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.txt b/compiler/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.txt similarity index 100% rename from idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.txt rename to compiler/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.txt diff --git a/idea/testData/psi/examples/util/Comparison.jet b/compiler/testData/psi/examples/util/Comparison.jet similarity index 100% rename from idea/testData/psi/examples/util/Comparison.jet rename to compiler/testData/psi/examples/util/Comparison.jet diff --git a/idea/testData/psi/examples/util/Comparison.txt b/compiler/testData/psi/examples/util/Comparison.txt similarity index 100% rename from idea/testData/psi/examples/util/Comparison.txt rename to compiler/testData/psi/examples/util/Comparison.txt diff --git a/idea/testData/psi/examples/util/IComparable.jet b/compiler/testData/psi/examples/util/IComparable.jet similarity index 100% rename from idea/testData/psi/examples/util/IComparable.jet rename to compiler/testData/psi/examples/util/IComparable.jet diff --git a/idea/testData/psi/examples/util/IComparable.txt b/compiler/testData/psi/examples/util/IComparable.txt similarity index 100% rename from idea/testData/psi/examples/util/IComparable.txt rename to compiler/testData/psi/examples/util/IComparable.txt diff --git a/idea/testData/psi/functionReceivers/FunctionTypesWithFunctionReceivers.jet b/compiler/testData/psi/functionReceivers/FunctionTypesWithFunctionReceivers.jet similarity index 100% rename from idea/testData/psi/functionReceivers/FunctionTypesWithFunctionReceivers.jet rename to compiler/testData/psi/functionReceivers/FunctionTypesWithFunctionReceivers.jet diff --git a/idea/testData/psi/functionReceivers/FunctionsWithFunctionReceivers.jet b/compiler/testData/psi/functionReceivers/FunctionsWithFunctionReceivers.jet similarity index 100% rename from idea/testData/psi/functionReceivers/FunctionsWithFunctionReceivers.jet rename to compiler/testData/psi/functionReceivers/FunctionsWithFunctionReceivers.jet diff --git a/idea/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.jet b/compiler/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.jet similarity index 100% rename from idea/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.jet rename to compiler/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.jet diff --git a/idea/testData/resolve/Basic.jet b/compiler/testData/resolve/Basic.jet similarity index 100% rename from idea/testData/resolve/Basic.jet rename to compiler/testData/resolve/Basic.jet diff --git a/idea/testData/resolve/ClassObjects.jet b/compiler/testData/resolve/ClassObjects.jet similarity index 100% rename from idea/testData/resolve/ClassObjects.jet rename to compiler/testData/resolve/ClassObjects.jet diff --git a/idea/testData/resolve/Classifiers.jet b/compiler/testData/resolve/Classifiers.jet similarity index 100% rename from idea/testData/resolve/Classifiers.jet rename to compiler/testData/resolve/Classifiers.jet diff --git a/idea/testData/resolve/ConstructorsAndInitializers.jet b/compiler/testData/resolve/ConstructorsAndInitializers.jet similarity index 100% rename from idea/testData/resolve/ConstructorsAndInitializers.jet rename to compiler/testData/resolve/ConstructorsAndInitializers.jet diff --git a/idea/testData/resolve/ErrorSupertype.jet b/compiler/testData/resolve/ErrorSupertype.jet similarity index 100% rename from idea/testData/resolve/ErrorSupertype.jet rename to compiler/testData/resolve/ErrorSupertype.jet diff --git a/idea/testData/resolve/ExtensionFunctions.jet b/compiler/testData/resolve/ExtensionFunctions.jet similarity index 100% rename from idea/testData/resolve/ExtensionFunctions.jet rename to compiler/testData/resolve/ExtensionFunctions.jet diff --git a/idea/testData/resolve/FunctionVariable.jet b/compiler/testData/resolve/FunctionVariable.jet similarity index 100% rename from idea/testData/resolve/FunctionVariable.jet rename to compiler/testData/resolve/FunctionVariable.jet diff --git a/idea/testData/resolve/LocalObjects.jet b/compiler/testData/resolve/LocalObjects.jet similarity index 100% rename from idea/testData/resolve/LocalObjects.jet rename to compiler/testData/resolve/LocalObjects.jet diff --git a/idea/testData/resolve/Namespaces.jet b/compiler/testData/resolve/Namespaces.jet similarity index 100% rename from idea/testData/resolve/Namespaces.jet rename to compiler/testData/resolve/Namespaces.jet diff --git a/idea/testData/resolve/NestedObjects.jet b/compiler/testData/resolve/NestedObjects.jet similarity index 100% rename from idea/testData/resolve/NestedObjects.jet rename to compiler/testData/resolve/NestedObjects.jet diff --git a/idea/testData/resolve/Objects.jet b/compiler/testData/resolve/Objects.jet similarity index 100% rename from idea/testData/resolve/Objects.jet rename to compiler/testData/resolve/Objects.jet diff --git a/idea/testData/resolve/PrimaryConstructorParameters.jet b/compiler/testData/resolve/PrimaryConstructorParameters.jet similarity index 100% rename from idea/testData/resolve/PrimaryConstructorParameters.jet rename to compiler/testData/resolve/PrimaryConstructorParameters.jet diff --git a/idea/testData/resolve/PrimaryConstructors.jet b/compiler/testData/resolve/PrimaryConstructors.jet similarity index 100% rename from idea/testData/resolve/PrimaryConstructors.jet rename to compiler/testData/resolve/PrimaryConstructors.jet diff --git a/idea/testData/resolve/Projections.jet b/compiler/testData/resolve/Projections.jet similarity index 100% rename from idea/testData/resolve/Projections.jet rename to compiler/testData/resolve/Projections.jet diff --git a/idea/testData/resolve/ResolveOfInfixExpressions.jet b/compiler/testData/resolve/ResolveOfInfixExpressions.jet similarity index 100% rename from idea/testData/resolve/ResolveOfInfixExpressions.jet rename to compiler/testData/resolve/ResolveOfInfixExpressions.jet diff --git a/idea/testData/resolve/ResolveToJava.jet b/compiler/testData/resolve/ResolveToJava.jet similarity index 100% rename from idea/testData/resolve/ResolveToJava.jet rename to compiler/testData/resolve/ResolveToJava.jet diff --git a/idea/testData/resolve/ScopeInteraction.jet b/compiler/testData/resolve/ScopeInteraction.jet similarity index 100% rename from idea/testData/resolve/ScopeInteraction.jet rename to compiler/testData/resolve/ScopeInteraction.jet diff --git a/idea/testData/resolve/StringTemplates.jet b/compiler/testData/resolve/StringTemplates.jet similarity index 100% rename from idea/testData/resolve/StringTemplates.jet rename to compiler/testData/resolve/StringTemplates.jet diff --git a/idea/testData/resolve/TryCatch.jet b/compiler/testData/resolve/TryCatch.jet similarity index 100% rename from idea/testData/resolve/TryCatch.jet rename to compiler/testData/resolve/TryCatch.jet diff --git a/idea/testData/resolve/regressions/kt300.jet b/compiler/testData/resolve/regressions/kt300.jet similarity index 100% rename from idea/testData/resolve/regressions/kt300.jet rename to compiler/testData/resolve/regressions/kt300.jet diff --git a/compiler/tests/compiler-tests.iml b/compiler/tests/compiler-tests.iml new file mode 100644 index 00000000000..d1dadb8a16b --- /dev/null +++ b/compiler/tests/compiler-tests.iml @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/idea/tests/org/jetbrains/jet/JetLightProjectDescriptor.java b/compiler/tests/org/jetbrains/jet/JetLightProjectDescriptor.java similarity index 100% rename from idea/tests/org/jetbrains/jet/JetLightProjectDescriptor.java rename to compiler/tests/org/jetbrains/jet/JetLightProjectDescriptor.java diff --git a/idea/tests/org/jetbrains/jet/JetLiteFixture.java b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java similarity index 98% rename from idea/tests/org/jetbrains/jet/JetLiteFixture.java rename to compiler/tests/org/jetbrains/jet/JetLiteFixture.java index a2142bee57c..323e3559645 100644 --- a/idea/tests/org/jetbrains/jet/JetLiteFixture.java +++ b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java @@ -7,6 +7,7 @@ import com.intellij.mock.*; import com.intellij.openapi.Disposable; import com.intellij.openapi.editor.Document; import com.intellij.openapi.editor.EditorFactory; +import com.intellij.openapi.extensions.Extensions; import com.intellij.openapi.fileEditor.FileDocumentManager; import com.intellij.openapi.fileEditor.impl.FileDocumentManagerImpl; import com.intellij.openapi.fileEditor.impl.LoadTextUtil; @@ -81,6 +82,7 @@ public abstract class JetLiteFixture extends PlatformLiteFixture { public void verify(PicoContainer container) throws PicoIntrospectionException { } }); + Extensions.registerAreaClass("IDEA_PROJECT", null); myProject = disposeOnTearDown(new MockProjectEx(getTestRootDisposable())); myPsiManager = new MockPsiManager(myProject); myFileFactory = new PsiFileFactoryImpl(myPsiManager); diff --git a/idea/tests/org/jetbrains/jet/JetTestCaseBase.java b/compiler/tests/org/jetbrains/jet/JetTestCaseBase.java similarity index 95% rename from idea/tests/org/jetbrains/jet/JetTestCaseBase.java rename to compiler/tests/org/jetbrains/jet/JetTestCaseBase.java index f6ba28dcb72..88dd75b955a 100644 --- a/idea/tests/org/jetbrains/jet/JetTestCaseBase.java +++ b/compiler/tests/org/jetbrains/jet/JetTestCaseBase.java @@ -35,7 +35,7 @@ public abstract class JetTestCaseBase extends LightDaemonAnalyzerTestCase { } public static Sdk jdkFromIdeaHome() { - return new JavaSdkImpl().createJdk("JDK", "idea/testData/mockJDK-1.7/jre", true); + return new JavaSdkImpl().createJdk("JDK", "compiler/testData/mockJDK-1.7/jre", true); } @Override @@ -44,7 +44,7 @@ public abstract class JetTestCaseBase extends LightDaemonAnalyzerTestCase { } public static String getTestDataPathBase() { - return getHomeDirectory() + "/idea/testData"; + return getHomeDirectory() + "/compiler/testData"; } public static String getHomeDirectory() { diff --git a/idea/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java similarity index 100% rename from idea/tests/org/jetbrains/jet/JetTestUtils.java rename to compiler/tests/org/jetbrains/jet/JetTestUtils.java diff --git a/idea/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java b/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java similarity index 99% rename from idea/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java rename to compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java index 90e7ed321ea..4fa45ef3ed8 100644 --- a/idea/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java +++ b/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java @@ -12,7 +12,7 @@ import org.jetbrains.jet.JetTestCaseBase; import org.jetbrains.jet.lang.cfg.LoopInfo; import org.jetbrains.jet.lang.cfg.pseudocode.*; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.plugin.AnalyzerFacade; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import java.io.File; import java.io.FileNotFoundException; diff --git a/idea/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java rename to compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java diff --git a/idea/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java b/compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java similarity index 97% rename from idea/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java rename to compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java index 597eb5e2b95..d71414210c2 100644 --- a/idea/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java @@ -5,6 +5,7 @@ import com.intellij.openapi.util.TextRange; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.CharsetToolkit; +import com.intellij.testFramework.LightPlatformCodeInsightTestCase; import junit.framework.Test; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; @@ -12,7 +13,7 @@ import org.jetbrains.jet.JetTestCaseBase; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.plugin.AnalyzerFacade; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import java.io.File; import java.io.FileWriter; diff --git a/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java b/compiler/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java rename to compiler/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java diff --git a/idea/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java b/compiler/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java rename to compiler/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/ArrayGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java similarity index 97% rename from idea/tests/org/jetbrains/jet/codegen/ArrayGenTest.java rename to compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java index a7aa2572f54..f5f89630aa5 100644 --- a/idea/tests/org/jetbrains/jet/codegen/ArrayGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java @@ -1,10 +1,6 @@ package org.jetbrains.jet.codegen; -import jet.typeinfo.TypeInfo; - -import java.lang.reflect.Array; import java.lang.reflect.Method; -import java.util.ArrayList; public class ArrayGenTest extends CodegenTestCase { public void testKt238 () throws Exception { diff --git a/idea/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java similarity index 88% rename from idea/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java rename to compiler/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java index 2f89c65b0e7..2fcda7706f7 100644 --- a/idea/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java @@ -1,7 +1,5 @@ package org.jetbrains.jet.codegen; -import java.util.List; - public class BridgeMethodGenTest extends CodegenTestCase { public void testBridgeMethod () throws Exception { blackBoxFile("bridge.jet"); diff --git a/idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java rename to compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java rename to compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java similarity index 99% rename from idea/tests/org/jetbrains/jet/codegen/CodegenTestCase.java rename to compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java index 45731728ffc..1706e71b5e4 100644 --- a/idea/tests/org/jetbrains/jet/codegen/CodegenTestCase.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java @@ -63,7 +63,7 @@ public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase { throw new UnsupportedOperationException(); } - protected void blackBoxFile(String filename) throws Exception { + protected void blackBoxFile(String filename) { loadFile(filename); String actual; try { diff --git a/idea/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java b/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java similarity index 98% rename from idea/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java rename to compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java index 698c668b042..f6da4b65c87 100644 --- a/idea/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java @@ -1,7 +1,5 @@ package org.jetbrains.jet.codegen; -import jet.typeinfo.TypeInfo; - import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Arrays; @@ -169,6 +167,10 @@ public class ControlStructuresTest extends CodegenTestCase { blackBoxFile("controlStructures/forNullableIntArray.jet"); } + public void testForIntRange() { + blackBoxFile("controlStructures/forIntRange.jet"); + } + public void testKt237() throws Exception { blackBoxFile("regressions/kt237.jet"); } diff --git a/idea/tests/org/jetbrains/jet/codegen/ExtensionFunctionsTest.java b/compiler/tests/org/jetbrains/jet/codegen/ExtensionFunctionsTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/ExtensionFunctionsTest.java rename to compiler/tests/org/jetbrains/jet/codegen/ExtensionFunctionsTest.java diff --git a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java new file mode 100644 index 00000000000..130148eb40b --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java @@ -0,0 +1,16 @@ +package org.jetbrains.jet.codegen; + +/** + * @author alex.tkachman + */ +public class FunctionGenTest extends CodegenTestCase { + public void testDefaultArgs() throws Exception { + blackBoxFile("functions/defaultargs.jet"); + System.out.println(generateToText()); + } + + public void testNoThisNoClosure() throws Exception { + blackBoxFile("functions/nothisnoclosure.jet"); + System.out.println(generateToText()); + } +} diff --git a/idea/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java rename to compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/ObjectGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/ObjectGenTest.java rename to compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java b/compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java rename to compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java b/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java rename to compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/PropertyGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/PropertyGenTest.java rename to compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/SafeRefTest.java b/compiler/tests/org/jetbrains/jet/codegen/SafeRefTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/SafeRefTest.java rename to compiler/tests/org/jetbrains/jet/codegen/SafeRefTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/TraitsTest.java b/compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/TraitsTest.java rename to compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java diff --git a/idea/tests/org/jetbrains/jet/codegen/TypeInfoTest.java b/compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/codegen/TypeInfoTest.java rename to compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java diff --git a/idea/tests/org/jetbrains/jet/parsing/JetCodeConformanceTest.java b/compiler/tests/org/jetbrains/jet/parsing/JetCodeConformanceTest.java similarity index 100% rename from idea/tests/org/jetbrains/jet/parsing/JetCodeConformanceTest.java rename to compiler/tests/org/jetbrains/jet/parsing/JetCodeConformanceTest.java diff --git a/idea/tests/org/jetbrains/jet/parsing/JetParsingTest.java b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java similarity index 98% rename from idea/tests/org/jetbrains/jet/parsing/JetParsingTest.java rename to compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java index 6e1b8238abf..6413d420c30 100644 --- a/idea/tests/org/jetbrains/jet/parsing/JetParsingTest.java +++ b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java @@ -41,7 +41,7 @@ public class JetParsingTest extends ParsingTestCase { } public static String getTestDataDir() { - return getHomeDirectory() + "/idea/testData"; + return getHomeDirectory() + "/compiler/testData"; } private static String getHomeDirectory() { diff --git a/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java similarity index 97% rename from idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java rename to compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index 6eae3034292..2a86bdc82d5 100644 --- a/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -13,11 +13,11 @@ import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetStandardLibrary; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeConstructor; -import org.jetbrains.jet.plugin.AnalyzerFacade; import java.util.HashMap; import java.util.HashSet; @@ -172,7 +172,9 @@ public class ExpectedResolveData { JetTypeReference typeReference = getAncestorOfType(JetTypeReference.class, element); if (expectedDescriptor != null) { DeclarationDescriptor actual = bindingContext.get(REFERENCE_TARGET, reference); - assertSame("Expected: " + name, expectedDescriptor.getOriginal(), actual == null ? null : actual.getOriginal()); + assertSame("Expected: " + name, expectedDescriptor.getOriginal(), actual == null + ? null + : actual.getOriginal()); continue; } diff --git a/idea/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java b/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java similarity index 100% rename from idea/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java rename to compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java diff --git a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java similarity index 93% rename from idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java rename to compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index 2f07aa92e9f..f93dda39119 100644 --- a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -17,11 +17,13 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; -import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.JetStandardLibrary; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.parsing.JetParsingTest; import java.io.File; @@ -111,10 +113,10 @@ public class JetResolveTest extends ExtensibleResolveTestCase { List parameterTypeList = Arrays.asList(parameterType); // JetTypeInferrer.Services typeInferrerServices = JetSemanticServices.createSemanticServices(getProject()).getTypeInferrerServices(new BindingTraceContext()); - CallResolver callResolver = new CallResolver(JetSemanticServices.createSemanticServices(getProject()), DataFlowInfo.getEmpty()); + CallResolver callResolver = new CallResolver(JetSemanticServices.createSemanticServices(getProject()), DataFlowInfo.EMPTY); OverloadResolutionResults functions = callResolver.resolveExactSignature( classDescriptor.getMemberScope(typeArguments), ReceiverDescriptor.NO_RECEIVER, name, parameterTypeList); - for (ResolvedCall resolvedCall : functions.getResults()) { + for (ResolvedCallImpl resolvedCall : functions.getResults()) { List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters(); for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); @@ -128,7 +130,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { @Override protected String getTestDataPath() { - return getHomeDirectory() + "/idea/testData"; + return getHomeDirectory() + "/compiler/testData"; } @Override @@ -151,7 +153,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { } public static Test suite() { - return JetTestCaseBase.suiteForDirectory(getHomeDirectory() + "/idea/testData/", "/resolve/", true, new JetTestCaseBase.NamedTestFactory() { + return JetTestCaseBase.suiteForDirectory(getHomeDirectory() + "/compiler/testData/", "/resolve/", true, new JetTestCaseBase.NamedTestFactory() { @NotNull @Override public Test createTest(@NotNull String dataPath, @NotNull String name) { diff --git a/idea/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java similarity index 99% rename from idea/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java rename to compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index 2eb81e3b963..9b48938707a 100644 --- a/idea/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -7,11 +7,11 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.types.JetStandardLibrary; -import org.jetbrains.jet.plugin.AnalyzerFacade; import java.util.List; diff --git a/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java similarity index 97% rename from idea/tests/org/jetbrains/jet/types/JetOverridingTest.java rename to compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java index 913fdecbd7e..2af92fa5a29 100644 --- a/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java @@ -6,11 +6,11 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver; import org.jetbrains.jet.lang.resolve.OverridingUtil; -import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.JetStandardLibrary; import org.jetbrains.jet.parsing.JetParsingTest; import java.io.File; @@ -35,7 +35,7 @@ public class JetOverridingTest extends LightDaemonAnalyzerTestCase { @Override protected String getTestDataPath() { - return getHomeDirectory() + "/idea/testData"; + return getHomeDirectory() + "/compiler/testData"; } private static String getHomeDirectory() { diff --git a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java similarity index 99% rename from idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java rename to compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 72d9bdcbffe..651fb148cf1 100644 --- a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -51,7 +51,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase { @Override protected String getTestDataPath() { - return getHomeDirectory() + "/idea/testData"; + return getHomeDirectory() + "/compiler/testData"; } private static String getHomeDirectory() { @@ -310,7 +310,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase { public void testThis() throws Exception { assertType("Derived_T", "this", "Derived_T"); - assertType("Derived_T", "this", "Base_T"); +// assertType("Derived_T", "super", "Base_T"); } public void testLoops() throws Exception { diff --git a/docs/Kotlin-RivieraDev.ppt b/docs/Kotlin-RivieraDev.ppt new file mode 100644 index 00000000000..77fb8065dd6 Binary files /dev/null and b/docs/Kotlin-RivieraDev.ppt differ diff --git a/examples/src/HelloNames.kt b/examples/src/HelloNames.kt new file mode 100644 index 00000000000..a7525288a4d --- /dev/null +++ b/examples/src/HelloNames.kt @@ -0,0 +1,18 @@ +namespace HelloNames + +fun main(args : Array) { + var names = "" + + for (i in args.indices) { + names += args[i] + if (i + 1 < args.size) + names += ", " + } + // string templates + println("Hello, $names!") +} + +fun println(message : String) { + // System.out is a nullable field + System.out?.println(message) +} diff --git a/examples/src/HelloNamesFaster.kt b/examples/src/HelloNamesFaster.kt new file mode 100644 index 00000000000..44a2afa8577 --- /dev/null +++ b/examples/src/HelloNamesFaster.kt @@ -0,0 +1,22 @@ +namespace HelloNamesFaster + +fun main(args : Array) { + var names = StringBuilder() + + for (i in args.indices) { + names += args[i] + if (i + 1 < args.size) + names += ", " + } + // string templates + println("Hello, $names!") +} + +fun println(message : String) { + // System.out is a nullable field + System.out?.println(message) +} + +fun StringBuilder.plusAssign(s : String) { + this.append(s) +} diff --git a/examples/src/HelloNamesRealistic.kt b/examples/src/HelloNamesRealistic.kt new file mode 100644 index 00000000000..a144a5e1db5 --- /dev/null +++ b/examples/src/HelloNamesRealistic.kt @@ -0,0 +1,32 @@ +namespace HelloNamesRealistic + +fun main(args : Array) { + val names = args.join(", ") + println("Hello, $names!") +} + +fun println(message : String) { + // System.out is a nullable field + System.out?.println(message) +} + +fun Iterable.join(separator : String) : String? { + val names = StringBuilder() + forit (this) {(it: Iterator): Unit => + names += it.next() + if (it.hasNext()) + names += separator + } + return names.toString() +} + +fun forit(col : Iterable, f : fun(Iterator) : Unit) { + val it = col.iterator() + while (it.hasNext()) { + f(it) + } +} + +fun StringBuilder.plusAssign(s : String) { + this.append(s) +} diff --git a/examples/src/Point.kt b/examples/src/Point.kt new file mode 100644 index 00000000000..83202ae6054 --- /dev/null +++ b/examples/src/Point.kt @@ -0,0 +1,17 @@ +class Point(val x: Int, val y: Int) { + fun toString() = "($x,$y)" + + fun distanceTo(other: Point): Double { + val dx = x - other.x + val dy = y - other.y + return Math.sqrt((dx*dx + dy*dy).dbl) + } +} + +fun main(args: Array) { + var p = Point(0, 0) + var q = Point(1, 1) + p.distanceTo(q) + + +} \ No newline at end of file diff --git a/grammar/src/class.grm b/grammar/src/class.grm index 8bf1e016edd..56cd2938ad0 100644 --- a/grammar/src/class.grm +++ b/grammar/src/class.grm @@ -19,7 +19,7 @@ internal class Example>(protected val x : Foo, y : So class : modifiers ("class" | "trait") SimpleName typeParameters? - modifiers ("(" primaryConstructorParameter{","} ")")? + modifiers ("(" functionParameter{","} ")")? (":" annotations delegationSpecifier{","})? typeConstraints (classBody? | enumClassBody) diff --git a/grammar/src/expressions.grm b/grammar/src/expressions.grm index fafe44f37f0..af07f14c2e9 100644 --- a/grammar/src/expressions.grm +++ b/grammar/src/expressions.grm @@ -16,7 +16,7 @@ h3. Precedence | |Elvis|{{?:}} | | |Named checks|{{in}}, {{\!in}}, {{is}}, {{\!is}} | | |Comparison|{{<}}, {{>}}, {{<=}}, {{>=}} | -| |Equality|{{==}}, {{\!==}}, {{===}}, {{\!===}} | +| |Equality|{{==}}, {{\!==}}| | |Conjunction|{{&&}}| | |Disjunction|{{\|\|}}| | |Arrow|{{\->}}| @@ -113,7 +113,8 @@ atomicExpression : literalConstant : functionLiteral : tupleLiteral - : "this" label? ("<" type ">")? + : "this" label? + : "super" ("<" type ">")? label? : if : when : try @@ -184,7 +185,7 @@ comparisonOperation ; equalityOperation - : "!=" : "==" : "===" : "!==" + : "!=" : "==" ; assignmentOperator diff --git a/idea/idea.iml b/idea/idea.iml index 23b8c669d6e..c994d198190 100644 --- a/idea/idea.iml +++ b/idea/idea.iml @@ -20,6 +20,8 @@ + + diff --git a/idea/src/org/jetbrains/jet/plugin/JetQuickDocumentationProvider.java b/idea/src/org/jetbrains/jet/plugin/JetQuickDocumentationProvider.java index 68ff66afb3d..bdcca23ba32 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetQuickDocumentationProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/JetQuickDocumentationProvider.java @@ -8,6 +8,7 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.resolve.DescriptorRenderer; /** diff --git a/idea/src/org/jetbrains/jet/plugin/actions/CopyAsDiagnosticTestAction.java b/idea/src/org/jetbrains/jet/plugin/actions/CopyAsDiagnosticTestAction.java index b9c35a7986d..6672b66de6e 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/CopyAsDiagnosticTestAction.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/CopyAsDiagnosticTestAction.java @@ -10,7 +10,7 @@ import com.intellij.psi.PsiFile; import org.jetbrains.jet.checkers.CheckerTestUtil; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.plugin.AnalyzerFacade; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import java.awt.*; import java.awt.datatransfer.Clipboard; diff --git a/idea/src/org/jetbrains/jet/plugin/actions/ShowExpressionTypeAction.java b/idea/src/org/jetbrains/jet/plugin/actions/ShowExpressionTypeAction.java index 26f778b3fe1..4611f9cc010 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/ShowExpressionTypeAction.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/ShowExpressionTypeAction.java @@ -12,8 +12,8 @@ import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.plugin.AnalyzerFacade; import org.jetbrains.jet.plugin.JetLanguage; /** diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java b/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java index bade37c7e0b..9c6702b742c 100644 --- a/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java +++ b/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java @@ -15,10 +15,10 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lexer.JetTokens; -import org.jetbrains.jet.plugin.AnalyzerFacade; import org.jetbrains.jet.plugin.JetHighlighter; import java.util.Collection; @@ -92,7 +92,7 @@ public class DebugInfoAnnotator implements Annotator { target = labelTarget.getText(); } else { - Collection> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, expression); + Collection> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, expression); if (declarationDescriptors != null) { target = "[" + declarationDescriptors.size() + " descriptors]"; } diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java index e53c0587f4e..299adbff7dc 100644 --- a/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java @@ -24,7 +24,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.plugin.AnalyzerFacade; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.resolve.DescriptorRenderer; import javax.swing.*; diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java b/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java index 95962f451d8..d2be0e6939d 100644 --- a/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java +++ b/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java @@ -22,8 +22,8 @@ import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.diagnostics.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.plugin.AnalyzerFacade; import org.jetbrains.jet.plugin.JetHighlighter; import org.jetbrains.jet.plugin.quickfix.JetIntentionActionFactory; import org.jetbrains.jet.plugin.quickfix.QuickFixes; diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java index 073d4d9ba61..f22310cf037 100644 --- a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java +++ b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java @@ -21,8 +21,8 @@ import org.jetbrains.jet.codegen.GenerationState; import org.jetbrains.jet.codegen.JetTypeMapper; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.lang.types.JetStandardLibrary; -import org.jetbrains.jet.plugin.AnalyzerFacade; import java.util.*; diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java index 9916a18468f..220bc1923d3 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java +++ b/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java @@ -11,8 +11,8 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; -import org.jetbrains.jet.plugin.AnalyzerFacade; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import java.util.Collection; @@ -81,7 +81,7 @@ public abstract class JetPsiReference implements PsiPolyVariantReference { if (psiElement != null) { return psiElement; } - Collection> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression); + Collection> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression); if (declarationDescriptors != null) return null; return file; } @@ -89,11 +89,11 @@ public abstract class JetPsiReference implements PsiPolyVariantReference { protected ResolveResult[] doMultiResolve() { JetFile file = (JetFile) getElement().getContainingFile(); BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file); - Collection> resolvedCalls = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression); + Collection> resolvedCalls = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression); if (resolvedCalls == null) return ResolveResult.EMPTY_ARRAY; ResolveResult[] results = new ResolveResult[resolvedCalls.size()]; int i = 0; - for (ResolvedCall resolvedCall : resolvedCalls) { + for (ResolvedCallImpl resolvedCall : resolvedCalls) { PsiElement element = bindingContext.get(DESCRIPTOR_TO_DECLARATION, resolvedCall.getResultingDescriptor()); if (element != null) { results[i] = new PsiElementResolveResult(element, true); diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java index 55d454b3c50..85b0ee34e89 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java +++ b/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java @@ -13,9 +13,9 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.plugin.AnalyzerFacade; import org.jetbrains.jet.resolve.DescriptorRenderer; import java.util.List; diff --git a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfiguration.java b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfiguration.java index e38a9b8fd96..b84b0f8af04 100644 --- a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfiguration.java +++ b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfiguration.java @@ -1,8 +1,7 @@ package org.jetbrains.jet.plugin.run; -import com.intellij.execution.ExecutionException; -import com.intellij.execution.Executor; -import com.intellij.execution.JavaRunConfigurationExtensionManager; +import com.intellij.execution.*; +import com.intellij.execution.configuration.EnvironmentVariablesComponent; import com.intellij.execution.configurations.*; import com.intellij.execution.filters.TextConsoleBuilderFactory; import com.intellij.execution.runners.ExecutionEnvironment; @@ -14,17 +13,27 @@ import com.intellij.openapi.options.SettingsEditor; import com.intellij.openapi.util.DefaultJDOMExternalizer; import com.intellij.openapi.util.InvalidDataException; import com.intellij.openapi.util.WriteExternalException; +import com.intellij.openapi.util.text.StringUtil; import org.jdom.Element; import org.jetbrains.annotations.NotNull; import java.util.Arrays; import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.Map; /** * @author yole */ -public class JetRunConfiguration extends ModuleBasedConfiguration { +public class JetRunConfiguration extends ModuleBasedConfiguration implements CommonJavaRunConfigurationParameters { public String MAIN_CLASS_NAME; + public String VM_PARAMETERS; + public String PROGRAM_PARAMETERS; + public String WORKING_DIRECTORY; + public boolean ALTERNATIVE_JRE_PATH_ENABLED; + public String ALTERNATIVE_JRE_PATH; + private Map myEnvs = new LinkedHashMap(); + public boolean PASS_PARENT_ENVS = true; public JetRunConfiguration(String name, RunConfigurationModule runConfigurationModule, ConfigurationFactory factory) { super(name, runConfigurationModule, factory); @@ -47,21 +56,91 @@ public class JetRunConfiguration extends ModuleBasedConfiguration getEnvs() { + return myEnvs; + } + + public void setEnvs(@NotNull final Map envs) { + this.myEnvs = envs; + } + + public boolean isPassParentEnvs() { + return PASS_PARENT_ENVS; + } + + @Override + public String getRunClass() { + return MAIN_CLASS_NAME; + } + + @Override + public String getPackage() { + return null; + } + + public boolean isAlternativeJrePathEnabled() { + return ALTERNATIVE_JRE_PATH_ENABLED; + } + + public void setAlternativeJrePathEnabled(boolean enabled) { + ALTERNATIVE_JRE_PATH_ENABLED = enabled; + } + + public String getAlternativeJrePath() { + return ALTERNATIVE_JRE_PATH; + } + + public void setAlternativeJrePath(String path) { + ALTERNATIVE_JRE_PATH = path; + } + @Override public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment executionEnvironment) throws ExecutionException { final JavaCommandLineState state = new MyJavaCommandLineState(executionEnvironment); @@ -80,6 +159,12 @@ public class JetRunConfiguration extends ModuleBasedConfiguration
- + @@ -18,7 +18,7 @@ - + @@ -31,12 +31,18 @@ - + + + + + + + diff --git a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationEditor.java b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationEditor.java index 4f9a3030c6a..0ffb1a03e76 100644 --- a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationEditor.java +++ b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationEditor.java @@ -1,5 +1,6 @@ package org.jetbrains.jet.plugin.run; +import com.intellij.execution.ui.CommonJavaParametersPanel; import com.intellij.execution.ui.ConfigurationModuleSelector; import com.intellij.openapi.options.ConfigurationException; import com.intellij.openapi.options.SettingsEditor; @@ -9,6 +10,8 @@ import org.jetbrains.annotations.NotNull; import javax.swing.*; import java.awt.*; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; /** * @author yole @@ -17,16 +20,24 @@ public class JetRunConfigurationEditor extends SettingsEditor moduleChooser = LabeledComponent.create(new JComboBox(), "Use classpath and JDK of module:"); myModuleChooserHolder.add(moduleChooser, BorderLayout.CENTER); myModuleSelector = new ConfigurationModuleSelector(project, moduleChooser.getComponent()); + myCommonProgramParameters.setModuleContext(myModuleSelector.getModule()); + moduleChooser.getComponent().addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + myCommonProgramParameters.setModuleContext(myModuleSelector.getModule()); + } + }); } @Override protected void resetEditorFrom(JetRunConfiguration configuration) { + myCommonProgramParameters.reset(configuration); myMainClassField.setText(configuration.MAIN_CLASS_NAME); myModuleSelector.reset(configuration); } @@ -34,6 +45,7 @@ public class JetRunConfigurationEditor extends SettingsEditor syntax +fun foo() { + super.foo(); + super.foo(); + super<>.foo(); + super@label.foo(); +} \ No newline at end of file diff --git a/idea/testData/psi/Super.txt b/idea/testData/psi/Super.txt new file mode 100644 index 00000000000..c9cd569dcaa --- /dev/null +++ b/idea/testData/psi/Super.txt @@ -0,0 +1,88 @@ +JetFile: Super.jet + PsiComment(EOL_COMMENT)('// KT-156 Fix the this syntax') + PsiWhiteSpace('\n') + NAMESPACE + FUN + PsiElement(fun)('fun') + PsiWhiteSpace(' ') + PsiElement(IDENTIFIER)('foo') + VALUE_PARAMETER_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace('\n ') + DOT_QUALIFIED_EXPRESSION + SUPER_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(super)('super') + PsiElement(DOT)('.') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('foo') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiElement(SEMICOLON)(';') + PsiWhiteSpace('\n ') + DOT_QUALIFIED_EXPRESSION + SUPER_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(super)('super') + PsiElement(LT)('<') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiElement(GT)('>') + PsiElement(DOT)('.') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('foo') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiElement(SEMICOLON)(';') + PsiWhiteSpace('\n ') + DOT_QUALIFIED_EXPRESSION + SUPER_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(super)('super') + PsiElement(LT)('<') + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiElement(DOT)('.') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('foo') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiElement(SEMICOLON)(';') + PsiWhiteSpace('\n ') + DOT_QUALIFIED_EXPRESSION + SUPER_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(super)('super') + PsiElement(LT)('<') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiElement(GT)('>') + LABEL_QUALIFIER + LABEL_REFERENCE + PsiElement(LABEL_IDENTIFIER)('@label') + PsiElement(DOT)('.') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('foo') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiElement(SEMICOLON)(';') + PsiWhiteSpace('\n') + PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/idea/testData/resolve/Super.jet b/idea/testData/resolve/Super.jet new file mode 100644 index 00000000000..10b1995e229 --- /dev/null +++ b/idea/testData/resolve/Super.jet @@ -0,0 +1,36 @@ +~T~trait T { + fun foo() {} +} +~C~open class C() { + fun bar() {} +} + +~A~class A() : C(), T { + + fun test() { + `T`super.foo() + `C`super.bar() + `T`super@A.foo() + `C`super@A.bar() + } + + class B : T { + fun test() { + `T`super.foo(); + `C`super@A.bar() + `T`super@A.foo() + `T`super@B.foo() + `T`super.foo() + } + } +} + +~G~trait G { + fun foo() {} +} + +class CG : G { + fun test() { + `G`super<`G`G>.foo() // OK + } +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractModifierFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractModifierFixTest.java index cbade4283ca..91542507b41 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractModifierFixTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractModifierFixTest.java @@ -1,7 +1,6 @@ package org.jetbrains.jet.plugin.quickfix; import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase; -import org.jetbrains.jet.JetTestCaseBase; /** * @author svtk @@ -19,6 +18,6 @@ public class AbstractModifierFixTest extends LightQuickFixTestCase { @Override protected String getTestDataPath() { - return JetTestCaseBase.getTestDataPathBase(); + return PluginTestCaseBase.getTestDataPathBase(); } } diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFixTest.java index c8a067576f9..633f5f8b09d 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFixTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFixTest.java @@ -19,6 +19,6 @@ public class AddPrimaryConstructorFixTest extends LightQuickFixTestCase { @Override protected String getTestDataPath() { - return JetTestCaseBase.getTestDataPathBase(); + return PluginTestCaseBase.getTestDataPathBase(); } } diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFixTest.java index e2b04a75f1f..78f7e287f9f 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFixTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFixTest.java @@ -1,7 +1,6 @@ package org.jetbrains.jet.plugin.quickfix; import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase; -import org.jetbrains.jet.JetTestCaseBase; /** * @author svtk @@ -19,6 +18,6 @@ public class ChangeVariableMutabilityFixTest extends LightQuickFixTestCase { @Override protected String getTestDataPath() { - return JetTestCaseBase.getTestDataPathBase(); + return PluginTestCaseBase.getTestDataPathBase(); } } diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/ClassImportFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/ClassImportFixTest.java index 215a15eb5b2..d765f6aad5c 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/ClassImportFixTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/ClassImportFixTest.java @@ -20,7 +20,7 @@ public class ClassImportFixTest extends LightQuickFixTestCase { @Override protected String getTestDataPath() { - return JetTestCaseBase.getTestDataPathBase(); + return PluginTestCaseBase.getTestDataPathBase(); } @Override diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/ExpressionsFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/ExpressionsFixTest.java index 9e0affacba6..ad60d7b72e5 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/ExpressionsFixTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/ExpressionsFixTest.java @@ -19,6 +19,6 @@ public class ExpressionsFixTest extends LightQuickFixTestCase { @Override protected String getTestDataPath() { - return JetTestCaseBase.getTestDataPathBase(); + return PluginTestCaseBase.getTestDataPathBase(); } } diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/ModifiersFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/ModifiersFixTest.java index 66b299fded9..32ce67866dd 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/ModifiersFixTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/ModifiersFixTest.java @@ -19,7 +19,7 @@ public class ModifiersFixTest extends LightQuickFixTestCase { @Override protected String getTestDataPath() { - return JetTestCaseBase.getTestDataPathBase(); + return PluginTestCaseBase.getTestDataPathBase(); } } diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/OverrideModifierFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/OverrideModifierFixTest.java index 2a67aa23aeb..6969bcce9b8 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/OverrideModifierFixTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/OverrideModifierFixTest.java @@ -19,7 +19,7 @@ public class OverrideModifierFixTest extends LightQuickFixTestCase { @Override protected String getTestDataPath() { - return JetTestCaseBase.getTestDataPathBase(); + return PluginTestCaseBase.getTestDataPathBase(); } } diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/PluginTestCaseBase.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/PluginTestCaseBase.java new file mode 100644 index 00000000000..c65a3ff5e3f --- /dev/null +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/PluginTestCaseBase.java @@ -0,0 +1,12 @@ +package org.jetbrains.jet.plugin.quickfix; + +import org.jetbrains.jet.JetTestCaseBase; + +/** + * @author yole + */ +public class PluginTestCaseBase { + public static String getTestDataPathBase() { + return JetTestCaseBase.getHomeDirectory() + "/idea/testData"; + } +} diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/TypeAdditionFixTests.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/TypeAdditionFixTests.java index b9154602f09..c870f1e6088 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/TypeAdditionFixTests.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/TypeAdditionFixTests.java @@ -20,7 +20,7 @@ public class TypeAdditionFixTests extends LightQuickFixTestCase { @Override protected String getTestDataPath() { - return JetTestCaseBase.getTestDataPathBase(); + return PluginTestCaseBase.getTestDataPathBase(); } @Override diff --git a/stdlib/src/jet/typeinfo/JetParameterName.java b/stdlib/src/jet/typeinfo/JetParameterName.java new file mode 100644 index 00000000000..904da5dc449 --- /dev/null +++ b/stdlib/src/jet/typeinfo/JetParameterName.java @@ -0,0 +1,15 @@ +package jet.typeinfo; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * @author alex.tkachman + */ +@Target({ElementType.PARAMETER}) +@Retention(RetentionPolicy.RUNTIME) +public @interface JetParameterName { + String value (); +}