diff --git a/bootstrap.xml b/bootstrap.xml
index 1697aacc6b7..695ce5f2e03 100644
--- a/bootstrap.xml
+++ b/bootstrap.xml
@@ -1,4 +1,21 @@
 <project name="Jet CI Bootstrap" default="unzipIdeaSDK">
+    <macrodef name="echoprop">
+        <attribute name="prop"/>
+        <sequential>
+            <echo>@{prop}=${@{prop}}</echo>
+        </sequential>
+    </macrodef>
+
+    <echoprop prop="os.name"/>
+    <echoprop prop="os.version"/>
+    <echoprop prop="os.arch"/>
+    <echoprop prop="java.home"/>
+    <echoprop prop="java.vendor"/>
+    <echoprop prop="java.version"/>
+    <echoprop prop="user.name"/>
+    <echoprop prop="user.home"/>
+    <echoprop prop="user.dir"/>
+
     <target name="unzipIdeaSDK">
         <unzip dest="ideaSDK">
             <fileset dir="ideaSDK" includes="ideaIC*.zip"/>
diff --git a/build.xml b/build.xml
index bc0ee63e9f7..6c91c946fa5 100644
--- a/build.xml
+++ b/build.xml
@@ -20,7 +20,7 @@
 
     <target name="compileRT">
         <mkdir dir="${output}/classes/runtime"/>
-        <javac destdir="${output}/classes/runtime">
+        <javac destdir="${output}/classes/runtime" debug="true" debuglevel="lines,vars,source">
             <src path="${basedir}/stdlib/src"/>
             <classpath refid="classpath"/>
         </javac>
@@ -36,7 +36,7 @@
     
     <target name="compile" depends="compileRT">
         <mkdir dir="${output}/classes/compiler"/>
-        <javac destdir="${output}/classes/compiler">
+        <javac destdir="${output}/classes/compiler" debug="true" debuglevel="lines,vars,source">
             <src refid="sourcepath"/>
             <classpath refid="classpath"/>
         </javac>
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java
index ce0eb62f800..a1135e9c65c 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java
@@ -10,6 +10,7 @@ import org.objectweb.asm.commons.InstructionAdapter;
 
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 
 /*
  * @author max
@@ -38,6 +39,8 @@ public abstract class CodegenContext {
     public  final ObjectOrClosureCodegen closure;
     
     HashMap<JetType,Integer> typeInfoConstants;
+    HashMap<Integer,JetType> reverseTypeInfoConstants;
+    int typeInfoConstantsCount;
     HashMap<DeclarationDescriptor, DeclarationDescriptor> accessors;
 
     protected StackValue outerExpression;
@@ -177,13 +180,16 @@ public abstract class CodegenContext {
         if(parentContext != STATIC)
             return parentContext.getTypeInfoConstantIndex(type);
         
-        if(typeInfoConstants == null)
-            typeInfoConstants = new HashMap<JetType, Integer>();
+        if(typeInfoConstants == null) {
+            typeInfoConstants = new LinkedHashMap<JetType, Integer>();
+            reverseTypeInfoConstants = new LinkedHashMap<Integer, JetType>();
+        }
 
         Integer index = typeInfoConstants.get(type);
         if(index == null) {
-            index = typeInfoConstants.size();
+            index = typeInfoConstantsCount++;
             typeInfoConstants.put(type, index);
+            reverseTypeInfoConstants.put(index, type);
         }
         return index;
     }
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
index e69555a882b..3ab8cc82519 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
@@ -35,18 +35,10 @@ import java.util.*;
  * @author alex.tkachman
  */
 public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
-    private static final String CLASS_OBJECT = "java/lang/Object";
-    private static final String CLASS_STRING = "java/lang/String";
-    public static final String CLASS_STRING_BUILDER = "java/lang/StringBuilder";
-    private static final String CLASS_COMPARABLE = "java/lang/Comparable";
 
     private static final String CLASS_NO_PATTERN_MATCHED_EXCEPTION = "jet/NoPatternMatchedException";
     private static final String CLASS_TYPE_CAST_EXCEPTION = "jet/TypeCastException";
 
-    private static final Type OBJECT_TYPE = Type.getType(Object.class);
-    private static final Type THROWABLE_TYPE = Type.getType(Throwable.class);
-    private static final Type STRING_TYPE = Type.getObjectType(CLASS_STRING);
-
     private final Stack<Label> myContinueTargets = new Stack<Label>();
     private final Stack<Label> myBreakTargets = new Stack<Label>();
 
@@ -574,10 +566,10 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
                             ? ((JetEscapeStringTemplateEntry) entry).getUnescapedValue()
                             : entry.getText();
                     v.aconst(text);
-                    invokeAppendMethod(STRING_TYPE);
+                    invokeAppendMethod(JetTypeMapper.JL_STRING_TYPE);
                 }
             }
-            v.invokevirtual(CLASS_STRING_BUILDER, "toString", "()Ljava/lang/String;");
+            v.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;");
             return StackValue.onStack(expressionType(expression));
         }
     }
@@ -972,7 +964,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
                 v.invokevirtual("jet/typeinfo/TypeInfo", "getClassObject", "()Ljava/lang/Object;");
                 v.checkcast(typeMapper.mapType(typeParameterDescriptor.getClassObjectType()));
 
-                return StackValue.onStack(OBJECT_TYPE);
+                return StackValue.onStack(JetTypeMapper.TYPE_OBJECT);
             }
             else {
                 // receiver
@@ -1693,7 +1685,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
 
     private StackValue generateNullSafeEquals(IElementType opToken, boolean leftNullable, boolean rightNullable) {
         if(!leftNullable) {
-            v.invokevirtual(CLASS_OBJECT, "equals", "(Ljava/lang/Object;)Z");
+            v.invokevirtual("java/lang/Object", "equals", "(Ljava/lang/Object;)Z");
             if (opToken == JetTokens.EXCLEQ) {
                 v.iconst(1);
                 v.xor(Type.INT_TYPE);
@@ -1706,7 +1698,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
                 v.ifnull(rightNull);
                 Label leftNull = new Label();
                 v.ifnull(leftNull);
-                v.invokevirtual(CLASS_OBJECT, "equals", "(Ljava/lang/Object;)Z");
+                v.invokevirtual("java/lang/Object", "equals", "(Ljava/lang/Object;)Z");
                 if (opToken == JetTokens.EXCLEQ || opToken == JetTokens.EXCLEQEQEQ) {
                     v.iconst(1);
                     v.xor(Type.INT_TYPE);
@@ -1731,7 +1723,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
                 v.pop();
                 Label leftNull = new Label();
                 v.ifnull(leftNull);
-                v.invokevirtual(CLASS_OBJECT, "equals", "(Ljava/lang/Object;)Z");
+                v.invokevirtual("java/lang/Object", "equals", "(Ljava/lang/Object;)Z");
                 if (opToken == JetTokens.EXCLEQ || opToken == JetTokens.EXCLEQEQEQ) {
                     v.iconst(1);
                     v.xor(Type.INT_TYPE);
@@ -1796,7 +1788,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
 
     private StackValue compareExpressionsOnStack(IElementType opToken, Type operandType) {
         if (operandType.getSort() == Type.OBJECT) {
-            v.invokeinterface(CLASS_COMPARABLE, "compareTo", "(Ljava/lang/Object;)I");
+            v.invokeinterface("java/lang/Comparable", "compareTo", "(Ljava/lang/Object;)I");
             v.iconst(0);
             operandType = Type.INT_TYPE;
         }
@@ -1865,7 +1857,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         v.anew(type);
         v.dup();
         Method method = new Method("<init>", Type.VOID_TYPE, new Type[0]);
-        v.invokespecial(CLASS_STRING_BUILDER, method.getName(), method.getDescriptor());
+        v.invokespecial("java/lang/StringBuilder", method.getName(), method.getDescriptor());
     }
 
     public void invokeAppend(final JetExpression expr) {
@@ -1885,7 +1877,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
     public void invokeAppendMethod(Type exprType) {
         Method appendDescriptor = new Method("append", JetTypeMapper.JL_STRING_BUILDER,
                 new Type[] { exprType.getSort() == Type.OBJECT ? JetTypeMapper.TYPE_OBJECT : exprType});
-        v.invokevirtual(CLASS_STRING_BUILDER, "append", appendDescriptor.getDescriptor());
+        v.invokevirtual("java/lang/StringBuilder", "append", appendDescriptor.getDescriptor());
     }
 
     @Override
@@ -2068,14 +2060,14 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         return type;
     }
 
-    private void generateNewArray(JetCallExpression expression, JetType arrayType) {
+    public void generateNewArray(JetCallExpression expression, JetType arrayType) {
         List<? extends ValueArgument> args = expression.getValueArguments();
 
         boolean isArray = state.getStandardLibrary().getArray().equals(arrayType.getConstructor().getDeclarationDescriptor());
         if(isArray) {
-            if (args.size() != 2 && !arrayType.getArguments().get(0).getType().isNullable()) {
-                throw new CompilationException("array constructor of non-nullable type requires two arguments");
-            }
+//            if (args.size() != 2 && !arrayType.getArguments().get(0).getType().isNullable()) {
+//                throw new CompilationException("array constructor of non-nullable type requires two arguments");
+//            }
         }
         else {
             if (args.size() != 1) {
@@ -2331,7 +2323,7 @@ If finally block is present, its last expression is the value of try expression.
             DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
             if (descriptor instanceof ClassDescriptor || descriptor instanceof TypeParameterDescriptor) {
                 Type type = JetTypeMapper.boxType(typeMapper.mapType(jetType));
-                generateInstanceOf(StackValue.expression(OBJECT_TYPE, expression.getLeft(), this), jetType, true);
+                generateInstanceOf(StackValue.expression(JetTypeMapper.TYPE_OBJECT, expression.getLeft(), this), jetType, true);
                 Label isInstance = new Label();
                 v.ifne(isInstance);
                 v.pop();
@@ -2353,7 +2345,7 @@ If finally block is present, its last expression is the value of try expression.
 
     @Override
     public StackValue visitIsExpression(final JetIsExpression expression, StackValue receiver) {
-        final StackValue match = StackValue.expression(OBJECT_TYPE, expression.getLeftHandSide(), this);
+        final StackValue match = StackValue.expression(JetTypeMapper.TYPE_OBJECT, expression.getLeftHandSide(), this);
         return generatePatternMatch(expression.getPattern(), expression.isNegated(), match, null);
     }
 
@@ -2376,7 +2368,7 @@ If finally block is present, its last expression is the value of try expression.
             expressionToMatch.dupReceiver(v);
             expressionToMatch.put(subjectType, v);
             JetExpression condExpression = ((JetExpressionPattern) pattern).getExpression();
-            Type condType = isNumberPrimitive(subjectType) ? expressionType(condExpression) : OBJECT_TYPE;
+            Type condType = isNumberPrimitive(subjectType) ? expressionType(condExpression) : JetTypeMapper.TYPE_OBJECT;
             gen(condExpression, condType);
             return generateEqualsForExpressionsOnStack(JetTokens.EQEQ, subjectType, condType, false, false);
         }
@@ -2407,7 +2399,7 @@ If finally block is present, its last expression is the value of try expression.
         Label lblFail = new Label();
         Label lblDone = new Label();
         expressionToMatch.dupReceiver(v);
-        expressionToMatch.put(OBJECT_TYPE, v);
+        expressionToMatch.put(JetTypeMapper.TYPE_OBJECT, v);
         v.dup();
         final String tupleClassName = "jet/Tuple" + entries.size();
         Type tupleType = Type.getObjectType(tupleClassName);
@@ -2421,7 +2413,7 @@ If finally block is present, its last expression is the value of try expression.
 
         v.mark(lblCheck);
         for (int i = 0; i < entries.size(); i++) {
-            final StackValue tupleField = StackValue.field(OBJECT_TYPE, tupleClassName, "_" + (i + 1), false);
+            final StackValue tupleField = StackValue.field(JetTypeMapper.TYPE_OBJECT, tupleClassName, "_" + (i + 1), false);
             final StackValue stackValue = generatePatternMatch(entries.get(i).getPattern(), false, tupleField, nextEntry);
             stackValue.condJump(lblPopAndFail, true, v);
         }
@@ -2445,19 +2437,29 @@ If finally block is present, its last expression is the value of try expression.
         return StackValue.onStack(Type.BOOLEAN_TYPE);
     }
 
+    public boolean hasTypeInfoForInstanceOf(JetType type) {
+        DeclarationDescriptor declarationDescriptor = type.getConstructor().getDeclarationDescriptor();
+        if(declarationDescriptor instanceof TypeParameterDescriptor)
+            return true;
+
+        ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor.getOriginal();
+        if(classDescriptor.equals(state.getStandardLibrary().getArray())) {
+            return hasTypeInfoForInstanceOf(type.getArguments().get(0).getType());
+        }
+
+        for(TypeParameterDescriptor proj : classDescriptor.getTypeConstructor().getParameters()) {
+            if(proj.isReified()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     private void generateInstanceOf(StackValue expressionToGen, JetType jetType, boolean leaveExpressionOnStack) {
         DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
-        boolean javaClass = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, descriptor) instanceof PsiClass;
-        if (!javaClass && (jetType.getArguments().size() > 0 || !(descriptor instanceof ClassDescriptor))) {
-            generateTypeInfo(jetType);
-            expressionToGen.put(OBJECT_TYPE, v);
-            if (leaveExpressionOnStack) {
-                v.dupX1();
-            }
-            v.invokevirtual("jet/typeinfo/TypeInfo", "isInstance", "(Ljava/lang/Object;)Z");
-        }
-        else {
-            expressionToGen.put(OBJECT_TYPE, v);
+        if (!hasTypeInfoForInstanceOf(jetType)) {
+            expressionToGen.put(JetTypeMapper.TYPE_OBJECT, v);
             if (leaveExpressionOnStack) {
                 v.dup();
             }
@@ -2479,6 +2481,14 @@ If finally block is present, its last expression is the value of try expression.
                 v.instanceOf(type);
             }
         }
+        else {
+            generateTypeInfo(jetType);
+            expressionToGen.put(JetTypeMapper.TYPE_OBJECT, v);
+            if (leaveExpressionOnStack) {
+                v.dupX1();
+            }
+            v.invokevirtual("jet/typeinfo/TypeInfo", "isInstance", "(Ljava/lang/Object;)Z");
+        }
     }
 
     public void generateTypeInfo(JetType jetType) {
@@ -2656,30 +2666,6 @@ If finally block is present, its last expression is the value of try expression.
             conditionValue = generatePatternMatch(pattern, patternCondition.isNegated(),
                                                   StackValue.local(subjectLocal, subjectType), nextEntry);
         }
-        else if (condition instanceof JetWhenConditionCall) {
-            final JetExpression call = ((JetWhenConditionCall) condition).getCallSuffixExpression();
-            if (call instanceof JetCallExpression) {
-                v.load(subjectLocal, subjectType);
-                final DeclarationDescriptor declarationDescriptor = resolveCalleeDescriptor((JetCallExpression) call);
-                if (!(declarationDescriptor instanceof FunctionDescriptor)) {
-                    throw new UnsupportedOperationException("expected function descriptor in when condition with call, found " + declarationDescriptor);
-                }
-                conditionValue = invokeFunction((JetCallExpression) call, declarationDescriptor, StackValue.onStack(subjectType));
-            }
-            else if (call instanceof JetSimpleNameExpression) {
-                final DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) call);
-                if (descriptor instanceof PropertyDescriptor) {
-                    v.load(subjectLocal, subjectType);
-                    conditionValue = intermediateValueForProperty((PropertyDescriptor) descriptor, false, null);
-                }
-                else {
-                    throw new UnsupportedOperationException("unknown simple name resolve result: " + descriptor);
-                }
-            }
-            else {
-                throw new UnsupportedOperationException("unsupported kind of call suffix");
-            }
-        }
         else {
             throw new UnsupportedOperationException("unsupported kind of when condition");
         }
@@ -2724,7 +2710,7 @@ If finally block is present, its last expression is the value of try expression.
         v.dup();
         generateTypeInfo(new ProjectionErasingJetType(bindingContext.get(BindingContext.EXPRESSION_TYPE, expression)));
         for (JetExpression entry : entries) {
-            gen(entry, OBJECT_TYPE);
+            gen(entry, JetTypeMapper.TYPE_OBJECT);
         }
         v.invokespecial(className, "<init>", signature.toString());
         return StackValue.onStack(tupleType);
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java
index 56b432cf2c9..21c99a991f5 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java
@@ -10,6 +10,7 @@ import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -113,6 +114,7 @@ public class GenerationState {
                 }
                 catch (Throwable e) {
                     errorHandler.reportException(e, namespace.getContainingFile().getVirtualFile().getUrl());
+                    DiagnosticUtils.throwIfRunningOnServer(e);
                 }
             }
         }
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
index 908c8d29867..837c1503717 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
@@ -14,9 +14,7 @@ import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Type;
 import org.objectweb.asm.commons.InstructionAdapter;
 
-import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 
 import static org.objectweb.asm.Opcodes.*;
 
@@ -114,11 +112,12 @@ public class NamespaceCodegen {
     private void generateTypeInfoFields(JetNamespace namespace, CodegenContext context) {
         if(context.typeInfoConstants != null) {
             String jvmClassName = getJVMClassName(namespace.getName());
-            for(Map.Entry<JetType,Integer> e : (context.typeInfoConstants != null ? context.typeInfoConstants : Collections.<JetType,Integer>emptyMap()).entrySet()) {
-                String fieldName = "$typeInfoCache$" + e.getValue();
+            for(int index = 0; index != context.typeInfoConstantsCount; index++) {
+                JetType type = context.reverseTypeInfoConstants.get(index);
+                String fieldName = "$typeInfoCache$" + index;
                 v.newField(null, ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC, fieldName, "Ljet/typeinfo/TypeInfo;", null, null);
 
-                MethodVisitor mmv = v.newMethod(null, ACC_PUBLIC | ACC_STATIC | ACC_SYNTHETIC, "$getCachedTypeInfo$" + e.getValue(), "()Ljet/typeinfo/TypeInfo;", null, null);
+                MethodVisitor mmv = v.newMethod(null, ACC_PUBLIC | ACC_STATIC | ACC_SYNTHETIC, "$getCachedTypeInfo$" + index, "()Ljet/typeinfo/TypeInfo;", null, null);
                 InstructionAdapter v = new InstructionAdapter(mmv);
                 v.visitFieldInsn(GETSTATIC, jvmClassName, fieldName, "Ljet/typeinfo/TypeInfo;");
                 v.visitInsn(DUP);
@@ -126,7 +125,7 @@ public class NamespaceCodegen {
                 v.visitJumpInsn(IFNONNULL, end);
 
                 v.pop();
-                generateTypeInfo(context, v, e.getKey(), state.getTypeMapper(), e.getKey());
+                generateTypeInfo(context, v, type, state.getTypeMapper(), type);
                 v.dup();
 
                 v.visitFieldInsn(PUTSTATIC, jvmClassName, fieldName, "Ljet/typeinfo/TypeInfo;");
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
index 2d97b6ede04..2e6bda3f6a3 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
@@ -26,7 +26,7 @@ public class Concat implements IntrinsicMethod {
             codegen.invokeAppend(arguments.get(1));
         }
         
-        v.invokevirtual(ExpressionCodegen.CLASS_STRING_BUILDER, "toString", "()Ljava/lang/String;");
+        v.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;");
         return StackValue.onStack(Type.getObjectType("java/lang/String"));
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Increment.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Increment.java
index 8c199a571a3..fc1292cf899 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Increment.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Increment.java
@@ -5,6 +5,7 @@ import org.jetbrains.jet.codegen.ExpressionCodegen;
 import org.jetbrains.jet.codegen.JetTypeMapper;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.psi.JetParenthesizedExpression;
 import org.jetbrains.jet.lang.psi.JetReferenceExpression;
 import org.objectweb.asm.Type;
 import org.objectweb.asm.commons.InstructionAdapter;
@@ -23,7 +24,10 @@ public class Increment implements IntrinsicMethod {
 
     @Override
     public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
-        final JetExpression operand = arguments.get(0);
+        JetExpression operand = arguments.get(0);
+        while(operand instanceof JetParenthesizedExpression) {
+            operand = ((JetParenthesizedExpression)operand).getExpression();
+        }
         if (operand instanceof JetReferenceExpression) {
             final int index = codegen.indexOfLocal((JetReferenceExpression) operand);
             if (index >= 0 && JetTypeMapper.isIntPrimitive(expectedType)) {
@@ -33,6 +37,7 @@ public class Increment implements IntrinsicMethod {
         }
         StackValue value = codegen.genQualified(receiver, operand);
         value. dupReceiver(v);
+        value. dupReceiver(v);
         value.put(expectedType, v);
         if (expectedType == Type.LONG_TYPE) {
             v.lconst(myDelta);
@@ -44,10 +49,11 @@ public class Increment implements IntrinsicMethod {
             v.dconst(myDelta);
         }
         else {
-            v.aconst(myDelta);
+            v.iconst(myDelta);
         }
         v.add(expectedType);
         value.store(v);
-        return value;
+        value.put(expectedType, v);
+        return StackValue.onStack(expectedType);
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
index a75db2d5a37..75c951e3fe5 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
@@ -85,6 +85,8 @@ public class IntrinsicMethods {
         declareOverload(myStdLib.getLibraryScope().getFunctions("equals"), 1, EQUALS);
         declareOverload(myStdLib.getLibraryScope().getFunctions("identityEquals"), 1, EQUALS);
         declareOverload(myStdLib.getLibraryScope().getFunctions("plus"), 1, new StringPlus());
+        declareOverload(myStdLib.getLibraryScope().getFunctions("Array"), 1, new NewArray());
+        declareOverload(myStdLib.getLibraryScope().getFunctions("sure"), 0, new Sure());
 
         declareIntrinsicFunction("ByteIterator", "next", 0, ITERATOR_NEXT);
         declareIntrinsicFunction("ShortIterator", "next", 0, ITERATOR_NEXT);
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NewArray.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NewArray.java
new file mode 100644
index 00000000000..318dfcfdf7f
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NewArray.java
@@ -0,0 +1,24 @@
+package org.jetbrains.jet.codegen.intrinsics;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.codegen.ExpressionCodegen;
+import org.jetbrains.jet.codegen.JetTypeMapper;
+import org.jetbrains.jet.codegen.StackValue;
+import org.jetbrains.jet.lang.psi.JetCallExpression;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.commons.InstructionAdapter;
+
+import java.util.List;
+
+/**
+ * @author alex.tkachman
+ */
+public class NewArray implements IntrinsicMethod {
+    @Override
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
+        codegen.generateNewArray((JetCallExpression) element, codegen.getBindingContext().get(BindingContext.EXPRESSION_TYPE, (JetExpression) element));
+        return StackValue.onStack(expectedType);
+    }
+}
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Sure.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Sure.java
new file mode 100644
index 00000000000..0019fed155f
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Sure.java
@@ -0,0 +1,24 @@
+package org.jetbrains.jet.codegen.intrinsics;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.codegen.ExpressionCodegen;
+import org.jetbrains.jet.codegen.JetTypeMapper;
+import org.jetbrains.jet.codegen.StackValue;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.commons.InstructionAdapter;
+
+import java.util.List;
+
+/**
+ * @author alex.tkachman
+ */
+public class Sure implements IntrinsicMethod {
+    @Override
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
+        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+        v.invokestatic("jet/runtime/Intrinsics", "sure", "(Ljava/lang/Object;)Ljava/lang/Object;");
+        StackValue.onStack(JetTypeMapper.TYPE_OBJECT).put(expectedType, v);
+        return StackValue.onStack(expectedType);
+    }
+}
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java
index 6ad38396927..ad4e1f20d74 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java
@@ -11,6 +11,7 @@ import com.intellij.psi.util.PsiModificationTracker;
 import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -68,18 +69,8 @@ public class AnalyzerFacade {
                             throw e;
                         }
                         catch (Throwable e) {
-                            // This is needed for the Web Demo server to log the exceptions coming from the analyzer instead of showing them in the editor.
-                            if (System.getProperty("kotlin.running.in.server.mode", "false").equals("true")) {
-                                if (e instanceof RuntimeException) {
-                                    RuntimeException runtimeException = (RuntimeException) e;
-                                    throw runtimeException;
-                                }
-                                if (e instanceof Error) {
-                                    Error error = (Error) e;
-                                    throw error;
-                                }
-                                throw new RuntimeException(e);
-                            }
+                            DiagnosticUtils.throwIfRunningOnServer(e);
+
                             e.printStackTrace();
                             BindingTraceContext bindingTraceContext = new BindingTraceContext();
                             bindingTraceContext.report(Errors.EXCEPTION_WHILE_ANALYZING.on(file, e));
@@ -93,5 +84,4 @@ public class AnalyzerFacade {
         }
         return bindingContextCachedValue.getValue();
     }
-
 }
diff --git a/compiler/frontend/src/jet/Library.jet b/compiler/frontend/src/jet/Library.jet
index 24a7f4e962f..888934c7121 100644
--- a/compiler/frontend/src/jet/Library.jet
+++ b/compiler/frontend/src/jet/Library.jet
@@ -42,9 +42,7 @@ fun Any?.equals(other : Any?) : Boolean// = this === other
 // Returns "null" for null
 fun Any?.toString() : String// = this === other
 
-// fun <T> array(vararg elements : T) : Array<T>
-
-// fun array(vararg elements : Int) : IntArray
+fun <T : Any> T?.sure() : T
 
 fun String?.plus(other: Any?) : String
 
@@ -105,7 +103,9 @@ trait Iterable<out T> {
   fun iterator() : Iterator<T>
 }
 
-class Array<T>(val size : Int, init : fun(Int) : T = null ) {
+fun Array<T>(val size : Int) : Array<T?>
+
+class Array<T>(val size : Int, init : fun(Int) : T) {
   fun get(index : Int) : T
   fun set(index : Int, value : T) : Unit
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java b/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java
index 3f7fe8350e5..0f694b7e8e5 100644
--- a/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java
+++ b/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java
@@ -141,7 +141,6 @@ public interface JetNodeTypes {
 
     JetNodeType WHEN_CONDITION_IN_RANGE   = new JetNodeType("WHEN_CONDITION_IN_RANGE", JetWhenConditionInRange.class);
     JetNodeType WHEN_CONDITION_IS_PATTERN = new JetNodeType("WHEN_CONDITION_IS_PATTERN", JetWhenConditionIsPattern.class);
-    JetNodeType WHEN_CONDITION_CALL       = new JetNodeType("WHEN_CONDITION_CALL", JetWhenConditionCall.class);
 
     JetNodeType NAMESPACE_NAME = new JetNodeType("NAMESPACE_NAME", JetContainerNode.class);
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
index bb1624eda0d..f5bc5122eda 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
@@ -62,10 +62,6 @@ public class JetControlFlowProcessor {
     private class CFPVisitor extends JetVisitorVoid {
         private final boolean inCondition;
         private final JetVisitorVoid conditionVisitor = new JetVisitorVoid() {
-            @Override
-            public void visitWhenConditionCall(JetWhenConditionCall condition) {
-                value(condition.getCallSuffixExpression(), CFPVisitor.this.inCondition); // TODO : inCondition?
-            }
 
             @Override
             public void visitWhenConditionInRange(JetWhenConditionInRange condition) {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableDescriptor.java
index 4e78d2c81f5..752d0da55d3 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableDescriptor.java
@@ -21,7 +21,9 @@ public interface CallableDescriptor extends DeclarationDescriptor {
     @NotNull
     List<TypeParameterDescriptor> getTypeParameters();
 
-    @NotNull
+    /**
+     * Method may return null for not yet fully initialized object or if error occurred.
+     */
     JetType getReturnType();
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java
index ef3ab5aefa0..490b9f889b1 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java
@@ -120,7 +120,6 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
     }
 
     @Override
-    @NotNull
     public JetType getReturnType() {
         return unsubstitutedReturnType;
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
index 69555990589..361eb70fbb4 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
@@ -113,7 +113,6 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab
         return expectedThisObject;
     }
 
-    @NotNull
     @Override
     public JetType getReturnType() {
         return getOutType();
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java
index 4181da25779..095254c7f3d 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java
@@ -34,7 +34,6 @@ public class PropertyGetterDescriptor extends PropertyAccessorDescriptor {
         return Collections.emptyList();
     }
 
-    @NotNull
     @Override
     public JetType getReturnType() {
         return returnType;
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java
index 6daefbce285..9ff1027e6c6 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java
@@ -84,7 +84,6 @@ public abstract class VariableDescriptorImpl extends DeclarationDescriptorImpl i
         return ReceiverDescriptor.NO_RECEIVER;
     }
 
-    @NotNull
     @Override
     public JetType getReturnType() {
         return getOutType();
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java
index 0ff433add71..0e85d64ce6d 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java
@@ -81,4 +81,19 @@ public class DiagnosticUtils {
         }
         return position;
     }
+
+    public static void throwIfRunningOnServer(Throwable e) {
+        // This is needed for the Web Demo server to log the exceptions coming from the analyzer instead of showing them in the editor.
+        if (System.getProperty("kotlin.running.in.server.mode", "false").equals("true")) {
+            if (e instanceof RuntimeException) {
+                RuntimeException runtimeException = (RuntimeException) e;
+                throw runtimeException;
+            }
+            if (e instanceof Error) {
+                Error error = (Error) e;
+                throw error;
+            }
+            throw new RuntimeException(e);
+        }
+    }
 }
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 eecdfed9d7d..2ea2a103180 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
@@ -279,7 +279,10 @@ public interface Errors {
     ParameterizedDiagnosticFactory2<JetType, Integer> TYPE_MISMATCH_IN_TUPLE_PATTERN = ParameterizedDiagnosticFactory2.create(ERROR, "Type mismatch: subject is of type {0} but the pattern is of type Tuple{1}"); // TODO: message
     ParameterizedDiagnosticFactory2<JetType, JetType> TYPE_MISMATCH_IN_BINDING_PATTERN = ParameterizedDiagnosticFactory2.create(ERROR, "{0} must be a supertype of {1}. Use 'is' to match against {0}");
     ParameterizedDiagnosticFactory2<JetType, JetType> INCOMPATIBLE_TYPES = ParameterizedDiagnosticFactory2.create(ERROR, "Incompatible types: {0} and {1}");
-    
+
+    ParameterizedDiagnosticFactory1<JetType> CANNOT_CHECK_FOR_ERASED = ParameterizedDiagnosticFactory1.create(ERROR, "Cannot check for instance of erased type: {0}");
+    ParameterizedDiagnosticFactory2<JetType, JetType> UNCHECKED_CAST = ParameterizedDiagnosticFactory2.create(WARNING, "Unchecked cast: {0} to {1}");
+
     ParameterizedDiagnosticFactory3<TypeParameterDescriptor, ClassDescriptor, Collection<JetType>> INCONSISTENT_TYPE_PARAMETER_VALUES = new ParameterizedDiagnosticFactory3<TypeParameterDescriptor, ClassDescriptor, Collection<JetType>>(ERROR, "Type parameter {0} of {1} has inconsistent values: {2}") {
         @Override
         protected String makeMessageForA(@NotNull TypeParameterDescriptor typeParameterDescriptor) {
@@ -361,7 +364,7 @@ public interface Errors {
     ParameterizedDiagnosticFactory2<JetClassOrObject, CallableMemberDescriptor> ABSTRACT_MEMBER_NOT_IMPLEMENTED = new ParameterizedDiagnosticFactory2<JetClassOrObject, CallableMemberDescriptor>(ERROR, "Class ''{0}'' must be declared abstract or implement abstract member {1}") {
         @Override
         protected String makeMessageForA(@NotNull JetClassOrObject jetClassOrObject) {
-            return jetClassOrObject.getName();
+            return JetPsiUtil.safeName(jetClassOrObject.getName());
         }
 
         @Override
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 d5b8b5a8760..aa9843843da 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java
@@ -419,7 +419,10 @@ public class JetExpressionParsing extends AbstractJetParsing {
             }
             else return false;
         }
-        else return false;
+        else {
+            return false;
+        }
+
         return true;
     }
 
@@ -764,7 +767,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
     /*
      * whenCondition
      *   : expression
-     *   : ("." | "?." postfixExpression typeArguments? valueArguments?
      *   : ("in" | "!in") expression
      *   : ("is" | "!is") isRHS
      *   ;
@@ -793,21 +795,10 @@ public class JetExpressionParsing extends AbstractJetParsing {
                 parsePattern();
             }
             condition.done(WHEN_CONDITION_IS_PATTERN);
-        } else if (at(DOT) || at(SAFE_ACCESS)) {
-            advance(); // DOT or SAFE_ACCESS
-            PsiBuilder.Marker mark = mark();
-            parsePostfixExpression();
-            if (parseCallSuffix()) {
-                mark.done(CALL_EXPRESSION);
-            }
-            else {
-                mark.drop();
-            }
-            condition.done(WHEN_CONDITION_CALL);
         } else {
             PsiBuilder.Marker expressionPattern = mark();
             if (atSet(WHEN_CONDITION_RECOVERY_SET_WITH_DOUBLE_ARROW)) {
-                error("Expecting an element, is-condition or in-condition");
+                error("Expecting an expression, is-condition or in-condition");
             } else {
                 parseExpression();
             }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java
index 4c0dced694d..e01dfdaeee4 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java
@@ -87,6 +87,11 @@ public class JetPsiFactory {
         return function.getBodyExpression();
     }
 
+    public static JetParameter createParameter(Project project, String name, String type) {
+        JetNamedFunction function = createFunction(project, "fun foo(" + name + " : " + type + ") {}");
+        return function.getValueParameters().get(0);
+    }
+
     public static JetNamespace createNamespace(Project project, String text) {
         JetFile file = createFile(project, text);
         return file.getRootNamespace();
@@ -96,7 +101,7 @@ public class JetPsiFactory {
         JetNamespace namespace = createNamespace(project, "import " + classPath);
         return namespace.getImportDirectives().iterator().next();
     }
-    
+
     public static PsiElement createPrimaryConstructor(Project project) {
         JetClass aClass = createClass(project, "class A()");
         return aClass.findElementAt(7).getParent();
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 7b62fcac518..d75649d31e8 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java
@@ -356,10 +356,6 @@ public class JetVisitor<R, D> extends PsiElementVisitor {
         return visitExpression(expression, data);
     }
 
-    public R visitWhenConditionCall(JetWhenConditionCall condition, D data) {
-        return visitJetElement(condition, data);
-    }
-
     public R visitWhenConditionIsPattern(JetWhenConditionIsPattern condition, D data) {
         return visitJetElement(condition, 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 0f649207239..f3b7fde8385 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java
@@ -354,10 +354,6 @@ public class JetVisitorVoid extends PsiElementVisitor {
         visitExpression(expression);
     }
 
-    public void visitWhenConditionCall(JetWhenConditionCall condition) {
-        visitJetElement(condition);
-    }
-
     public void visitWhenConditionIsPattern(JetWhenConditionIsPattern condition) {
         visitJetElement(condition);
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenConditionCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenConditionCall.java
deleted file mode 100644
index c74e0ea6acb..00000000000
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenConditionCall.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package org.jetbrains.jet.lang.psi;
-
-import com.intellij.lang.ASTNode;
-import com.intellij.psi.tree.TokenSet;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lexer.JetTokens;
-
-/**
- * @author abreslav
- */
-public class JetWhenConditionCall extends JetWhenCondition {
-    public JetWhenConditionCall(@NotNull ASTNode node) {
-        super(node);
-    }
-
-    public boolean isSafeCall() {
-        return getNode().findChildByType(JetTokens.SAFE_ACCESS) != null;
-    }
-
-    @NotNull
-    public ASTNode getOperationTokenNode() {
-        return getNode().findChildByType(TokenSet.create(JetTokens.SAFE_ACCESS, JetTokens.DOT));
-    }
-
-    @Nullable @IfNotParsed
-    public JetExpression getCallSuffixExpression() {
-        return findChildByClass(JetExpression.class);
-    }
-
-    @Override
-    public void accept(@NotNull JetVisitorVoid visitor) {
-        visitor.visitWhenConditionCall(this);
-    }
-
-    @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
-        return visitor.visitWhenConditionCall(this, data);
-    }
-}
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 f9bedad327d..68effdfba5e 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
@@ -39,6 +39,8 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
  * @author abreslav
  */
 public class CallResolver {
+    private static final JetType DONT_CARE = ErrorUtils.createErrorTypeWithCustomDebugName("DONT_CARE");
+
     private final JetSemanticServices semanticServices;
     private final OverloadingConflictResolver overloadingConflictResolver;
     private final DataFlowInfo dataFlowInfo;
@@ -412,7 +414,7 @@ public class CallResolver {
                         constraintSystem.registerTypeVariable(typeParameterDescriptor, Variance.INVARIANT); // TODO
                     }
 
-                    TypeSubstitutor substituteUnknown = ConstraintSystemImpl.makeConstantSubstitutor(candidate.getTypeParameters(), ErrorUtils.createErrorType("Unknown"));
+                    TypeSubstitutor substituteDontCare = ConstraintSystemImpl.makeConstantSubstitutor(candidate.getTypeParameters(), DONT_CARE);
 
                     for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> entry : candidateCall.getValueArguments().entrySet()) {
                         ResolvedValueArgument valueArgument = entry.getValue();
@@ -428,7 +430,7 @@ public class CallResolver {
                             // We'll type check the arguments later, with the inferred types expected
                             TemporaryBindingTrace traceForUnknown = TemporaryBindingTrace.create(temporaryTrace);
                             ExpressionTypingServices temporaryServices = new ExpressionTypingServices(semanticServices, traceForUnknown);
-                            JetType type = temporaryServices.getType(scope, expression, substituteUnknown.substitute(valueParameterDescriptor.getOutType(), Variance.INVARIANT));
+                            JetType type = temporaryServices.getType(scope, expression, substituteDontCare.substitute(valueParameterDescriptor.getOutType(), Variance.INVARIANT));
                             if (type != null) {
                                 constraintSystem.addSubtypingConstraint(type, effectiveExpectedType);
                             }
@@ -439,10 +441,10 @@ public class CallResolver {
                     }
 
                     // Error is already reported if something is missing
-                    ReceiverDescriptor receiverParameter = candidateCall.getReceiverArgument();
-                    ReceiverDescriptor candidateReceiver = candidate.getReceiverParameter();
-                    if (receiverParameter.exists() && candidateReceiver.exists()) {
-                        constraintSystem.addSubtypingConstraint(receiverParameter.getType(), candidateReceiver.getType());
+                    ReceiverDescriptor receiverArgument = candidateCall.getReceiverArgument();
+                    ReceiverDescriptor receiverParameter = candidate.getReceiverParameter();
+                    if (receiverArgument.exists() && receiverParameter.exists()) {
+                        constraintSystem.addSubtypingConstraint(receiverArgument.getType(), receiverParameter.getType());
                     }
 
                     if (expectedType != NO_EXPECTED_TYPE) {
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 5cfbbc1301f..1c77b65f443 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java
@@ -171,11 +171,20 @@ public class ErrorUtils {
     }
 
     private static JetType createErrorType(String debugMessage, JetScope memberScope) {
-        return new ErrorTypeImpl(new TypeConstructorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), false, "[ERROR : " + debugMessage + "]", Collections.<TypeParameterDescriptor>emptyList(), Collections.singleton(JetStandardClasses.getAnyType())), memberScope);
+        return createErrorTypeWithCustomDebugName(memberScope, "[ERROR : " + debugMessage + "]");
+    }
+
+    @NotNull
+    public static JetType createErrorTypeWithCustomDebugName(String debugName) {
+        return createErrorTypeWithCustomDebugName(ERROR_SCOPE, debugName);
+    }
+
+    private static JetType createErrorTypeWithCustomDebugName(JetScope memberScope, String debugName) {
+        return new ErrorTypeImpl(new TypeConstructorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), false, debugName, Collections.<TypeParameterDescriptor>emptyList(), Collections.singleton(JetStandardClasses.getAnyType())), memberScope);
     }
 
     public static JetType createWrongVarianceErrorType(TypeProjection value) {
-        return createErrorType(value + " is not allowed here]", value.getType().getMemberScope());
+        return createErrorType(value + " is not allowed here", value.getType().getMemberScope());
     }
 
     public static ClassifierDescriptor getErrorClass() {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java
index 62923713125..c095764a3ab 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java
@@ -284,7 +284,7 @@ public class JetStandardLibrary {
     }
 
     @NotNull
-    public ClassDescriptor getArray() {
+    public ClassDescriptor  getArray() {
         initStdClasses();
         return arrayClass;
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java
index 6304adf84db..82e4416c056 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java
@@ -110,54 +110,65 @@ public class TypeUtils {
     }
 
     @Nullable
-    public static JetType intersect(JetTypeChecker typeChecker, Set<JetType> types) {
+    public static JetType intersect(@NotNull JetTypeChecker typeChecker, @NotNull Set<JetType> types) {
         assert !types.isEmpty();
 
         if (types.size() == 1) {
             return types.iterator().next();
         }
 
-        StringBuilder debugName = new StringBuilder();
-        boolean nullable = false;
-        Set<JetType> resultingTypes = Sets.newHashSet();
+        // Intersection of T1..Tn is an intersection of their non-null versions,
+        //   made nullable is they all were nullable
+        boolean allNullable = true;
+        boolean nothingTypePresent = false;
+        List<JetType> nullabilityStripped = Lists.newArrayList();
+        for (JetType type : types) {
+            nothingTypePresent |= JetStandardClasses.isNothingOrNullableNothing(type);
+            allNullable &= type.isNullable();
+            nullabilityStripped.add(makeNotNullable(type));
+        }
+        
+        if (nothingTypePresent) {
+            return allNullable ? JetStandardClasses.getNullableNothingType() : JetStandardClasses.getNothingType();
+        }
 
+        // Now we remove types that have subtypes in the list
+        List<JetType> resultingTypes = Lists.newArrayList();
         outer:
-        for (Iterator<JetType> iterator = types.iterator(); iterator.hasNext();) {
-            JetType type = iterator.next();
-
+        for (JetType type : nullabilityStripped) {
             if (!canHaveSubtypes(typeChecker, type)) {
-                for (JetType other : types) {
+                for (JetType other : nullabilityStripped) {
                     // It makes sense to check for subtyping of other <: type, despite that
                     // type is not supposed to be open, for there're enums
                     if (!type.equals(other) && !typeChecker.isSubtypeOf(type, other) && !typeChecker.isSubtypeOf(other, type)) {
                         return null;
                     }
                 }
-                return type;
+                return makeNullableAsSpecified(type, allNullable);
             }
             else {
-                for (JetType other : types) {
+                for (JetType other : nullabilityStripped) {
                     if (!type.equals(other) && typeChecker.isSubtypeOf(other, type)) {
                         continue outer;
                     }
+
                 }
             }
 
-            nullable |= type.isNullable();
-
             resultingTypes.add(type);
-            debugName.append(type.toString());
-            if (iterator.hasNext()) {
-                debugName.append(" & ");
-            }
         }
+        
+        if (resultingTypes.size() == 1) {
+            return makeNullableAsSpecified(resultingTypes.get(0), allNullable);
+        }
+
 
         List<AnnotationDescriptor> noAnnotations = Collections.<AnnotationDescriptor>emptyList();
         TypeConstructor constructor = new TypeConstructorImpl(
                 null,
                 noAnnotations,
                 false,
-                debugName.toString(),
+                makeDebugNameForIntersectionType(resultingTypes).toString(),
                 Collections.<TypeParameterDescriptor>emptyList(),
                 resultingTypes);
 
@@ -171,11 +182,25 @@ public class TypeUtils {
         return new JetTypeImpl(
                 noAnnotations,
                 constructor,
-                nullable,
+                allNullable,
                 Collections.<TypeProjection>emptyList(),
                 new ChainedScope(null, scopes)); // TODO : check intersectibility, don't use a chanied scope
     }
 
+    private static StringBuilder makeDebugNameForIntersectionType(Iterable<JetType> resultingTypes) {
+        StringBuilder debugName = new StringBuilder("{");
+        for (Iterator<JetType> iterator = resultingTypes.iterator(); iterator.hasNext(); ) {
+            JetType type = iterator.next();
+
+            debugName.append(type.toString());
+            if (iterator.hasNext()) {
+                debugName.append(" & ");
+            }
+        }
+        debugName.append("}");
+        return debugName;
+    }
+
     public static boolean canHaveSubtypes(JetTypeChecker typeChecker, JetType type) {
         if (type.isNullable()) {
             return true;
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 0446105d479..720155d0206 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
@@ -1,6 +1,7 @@
 package org.jetbrains.jet.lang.types.expressions;
 
 import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
@@ -8,6 +9,7 @@ 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.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.CallMaker;
@@ -245,10 +247,63 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         else {
             if (typeChecker.isSubtypeOf(actualType, targetType)) {
                 context.trace.report(USELESS_CAST.on(expression, expression.getOperationSign()));
+            } else {
+                if (isCastErased(actualType, targetType)) {
+                    context.trace.report(Errors.UNCHECKED_CAST.on(expression, actualType, targetType));
+                }
             }
         }
     }
 
+    /**
+     * Check if assignment from ActualType to TargetType is erased.
+     * It is an error in "is" statement and warning in "as".
+     */
+    public static boolean isCastErased(JetType actualType, JetType targetType) {
+
+        if (!(targetType.getConstructor().getDeclarationDescriptor() instanceof ClassDescriptor)) {
+            // TODO: what if it is TypeParameterDescriptor?
+            return false;
+        }
+
+        JetType targetTypeClerared = TypeUtils.makeUnsubstitutedType(
+                (ClassDescriptor) targetType.getConstructor().getDeclarationDescriptor(), null);
+
+        Multimap<TypeConstructor, TypeProjection> clearTypeSubstitutionMap =
+                TypeUtils.buildDeepSubstitutionMultimap(targetTypeClerared);
+
+        Set<JetType> clearSubstituted = new HashSet<JetType>();
+
+        for (int i = 0; i < actualType.getConstructor().getParameters().size(); ++i) {
+            TypeParameterDescriptor subjectTypeParameterDescriptor = actualType.getConstructor().getParameters().get(i);
+
+            Collection<TypeProjection> subst = clearTypeSubstitutionMap.get(subjectTypeParameterDescriptor.getTypeConstructor());
+            for (TypeProjection proj : subst) {
+                clearSubstituted.add(proj.getType());
+            }
+        }
+
+        for (int i = 0; i < targetType.getConstructor().getParameters().size(); ++i) {
+            TypeParameterDescriptor typeParameter = targetType.getConstructor().getParameters().get(i);
+            TypeProjection typeProjection = targetType.getArguments().get(i);
+
+            if (typeParameter.isReified()) {
+                continue;
+            }
+
+            // "is List<*>"
+            if (typeProjection.equals(TypeUtils.makeStarProjection(typeParameter))) {
+                continue;
+            }
+
+            // if parameter is mapped to nothing then it is erased
+            if (!clearSubstituted.contains(typeParameter.getDefaultType())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     @Override
     public JetType visitTupleExpression(JetTupleExpression expression, ExpressionTypingContext context) {
         List<JetExpression> entries = expression.getEntries();
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java
index 68704d336ee..7ed8e8e7c12 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java
@@ -20,11 +20,12 @@ import org.jetbrains.jet.lexer.JetTokens;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.resolve.BindingContext.INDEXED_LVALUE_SET;
+import static org.jetbrains.jet.lang.resolve.BindingContext.VARIABLE_REASSIGNMENT;
 import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.getExpressionReceiver;
 
 /**
-* @author abreslav
-*/
+ * @author abreslav
+ */
 public class ExpressionTypingVisitorForStatements extends BasicExpressionTypingVisitor {
     private final WritableScope scope;
 
@@ -138,17 +139,35 @@ public class ExpressionTypingVisitorForStatements extends BasicExpressionTypingV
             }
             assignmentOperationType = getTypeForBinaryCall(scope, counterpartName, context, expression);
             if (assignmentOperationType != null) {
-                context.trace.record(BindingContext.VARIABLE_REASSIGNMENT, expression);
+                context.trace.record(VARIABLE_REASSIGNMENT, expression);
                 ExpressionTypingUtils.checkWrappingInRef(expression.getLeft(), context);
             }
         }
         else {
             temporaryBindingTrace.commit();
+            checkReassignment(expression, context, assignmentOperationType, left);
         }
         checkLValue(context.trace, expression.getLeft());
         return checkAssignmentType(assignmentOperationType, expression, contextWithExpectedType);
     }
 
+    private void checkReassignment(@NotNull JetBinaryExpression expression, @NotNull ExpressionTypingContext context,
+                                   @NotNull JetType assignmentOperationType, @Nullable JetExpression left) {
+        if (left == null) return;
+        JetType leftType = facade.getType(left, context.replaceScope(scope));
+        if (leftType == null) return;
+        boolean isUnit = context.semanticServices.getTypeChecker().
+                isSubtypeOf(assignmentOperationType, JetStandardClasses.getUnitType());
+        if (isUnit) return;
+
+        if (context.semanticServices.getTypeChecker().isSubtypeOf(assignmentOperationType, leftType)) {
+            context.trace.record(VARIABLE_REASSIGNMENT, expression);
+        }
+        else {
+            context.trace.report(TYPE_MISMATCH.on(expression, leftType, assignmentOperationType));
+        }
+    }
+
     @Override
     protected JetType visitAssignment(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
         ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).replaceExpectedReturnType(TypeUtils.NO_EXPECTED_TYPE);
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 943343f4d70..f5c277970bb 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
@@ -6,6 +6,7 @@ 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.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValue;
@@ -17,8 +18,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.TransientReceiver;
 import org.jetbrains.jet.lang.types.*;
 
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.ensureBooleanResultWithCustomSubject;
@@ -113,19 +113,6 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
         final DataFlowInfo[] newDataFlowInfo = new DataFlowInfo[]{context.dataFlowInfo};
         condition.accept(new JetVisitorVoid() {
 
-            @Override
-            public void visitWhenConditionCall(JetWhenConditionCall condition) {
-                JetExpression callSuffixExpression = condition.getCallSuffixExpression();
-//                    JetScope compositeScope = new ScopeWithReceiver(context.scope, subjectType, semanticServices.getTypeChecker());
-                if (callSuffixExpression != null) {
-//                        JetType selectorReturnType = getType(compositeScope, callSuffixExpression, false, context);
-                    assert subjectExpression != null;
-                    JetType selectorReturnType = facade.getSelectorReturnType(new ExpressionReceiver(subjectExpression, subjectType), condition.getOperationTokenNode(), callSuffixExpression, context);//getType(compositeScope, callSuffixExpression, false, context);
-                    ensureBooleanResultWithCustomSubject(callSuffixExpression, selectorReturnType, "This expression", context);
-//                        context.getServices().checkNullSafety(subjectType, condition.getOperationTokenNode(), getCalleeFunctionDescriptor(callSuffixExpression, context), condition);
-                }
-            }
-
             @Override
             public void visitWhenConditionInRange(JetWhenConditionInRange condition) {
                 JetExpression rangeExpression = condition.getRangeExpression();
@@ -245,6 +232,9 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
                 }
             }
 
+            /*
+             * (a: SubjectType) is Type
+             */
             private void checkTypeCompatibility(@Nullable JetType type, @NotNull JetType subjectType, @NotNull JetElement reportErrorOn) {
                 // TODO : Take auto casts into account?
                 if (type == null) {
@@ -253,6 +243,11 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
                 if (TypeUtils.intersect(context.semanticServices.getTypeChecker(), Sets.newHashSet(type, subjectType)) == null) {
 //                        context.trace.getErrorHandler().genericError(reportErrorOn.getNode(), "Incompatible types: " + type + " and " + subjectType);
                     context.trace.report(INCOMPATIBLE_TYPES.on(reportErrorOn, type, subjectType));
+                    return;
+                }
+                
+                if (BasicExpressionTypingVisitor.isCastErased(subjectType, type)) {
+                    context.trace.report(Errors.CANNOT_CHECK_FOR_ERASED.on(reportErrorOn, type));
                 }
             }
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/inference/ConstraintSystemImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/inference/ConstraintSystemImpl.java
index e693c3dddf1..c5aff27be5c 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/inference/ConstraintSystemImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/inference/ConstraintSystemImpl.java
@@ -9,6 +9,7 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 
@@ -46,8 +47,19 @@ public class ConstraintSystemImpl implements ConstraintSystem {
     }
 
     public static abstract class TypeValue {
-        private final Set<TypeValue> upperBounds = Sets.newHashSet();
-        private final Set<TypeValue> lowerBounds = Sets.newHashSet();
+        private final Set<TypeValue> mutableUpperBounds = Sets.newHashSet();
+        private final Set<TypeValue> upperBounds = Collections.unmodifiableSet(mutableUpperBounds);
+
+        private final Set<TypeValue> mutableLowerBounds = Sets.newHashSet();
+        private final Set<TypeValue> lowerBounds = Collections.unmodifiableSet(mutableLowerBounds);
+
+        public void addUpperBound(@NotNull TypeValue bound) {
+            mutableUpperBounds.add(bound);
+        }
+        
+        public void addLowerBound(@NotNull TypeValue bound) {
+            mutableLowerBounds.add(bound);
+        }
 
         @NotNull
         public Set<TypeValue> getUpperBounds() {
@@ -86,8 +98,8 @@ public class ConstraintSystemImpl implements ConstraintSystem {
                 throw new LoopInTypeVariableConstraintsException();
             }
             if (value == null) {
-                JetTypeChecker typeChecker = JetTypeChecker.INSTANCE;
                 beingComputed = true;
+                JetTypeChecker typeChecker = JetTypeChecker.INSTANCE;
                 try {
                     if (positionVariance == Variance.IN_VARIANCE) {
                         // maximal solution
@@ -320,8 +332,8 @@ public class ConstraintSystemImpl implements ConstraintSystem {
     private void addSubtypingConstraintOnTypeValues(TypeValue typeValueForLower, TypeValue typeValueForUpper) {
         println(typeValueForLower + " :< " + typeValueForUpper);
         if (typeValueForLower != typeValueForUpper) {
-            typeValueForLower.getUpperBounds().add(typeValueForUpper);
-            typeValueForUpper.getLowerBounds().add(typeValueForLower);
+            typeValueForLower.addUpperBound(typeValueForUpper);
+            typeValueForUpper.addLowerBound(typeValueForLower);
         }
     }
 
@@ -358,13 +370,20 @@ public class ConstraintSystemImpl implements ConstraintSystem {
 
         // effective bounds for each node
         Set<TypeValue> visited = Sets.newHashSet();
-        for (KnownType knownType : knownTypes.values()) {
-            transitiveClosure(knownType, visited);
-        }
         for (UnknownType unknownType : unknownTypes.values()) {
             transitiveClosure(unknownType, visited);
         }
 
+        for (UnknownType unknownType : unknownTypes.values()) {
+            println("Constraints for " + unknownType.getTypeParameterDescriptor());
+            printTypeValue(unknownType);
+        }
+
+        for (KnownType knownType : knownTypes.values()) {
+            println("Constraints for " + knownType.getType());
+            printTypeValue(knownType);
+        }
+
         // Find inconsistencies
         Solution solution = new Solution();
 
@@ -382,6 +401,15 @@ public class ConstraintSystemImpl implements ConstraintSystem {
         return solution;
     }
 
+    private void printTypeValue(TypeValue typeValue) {
+        for (TypeValue bound : typeValue.getUpperBounds()) {
+            println(" :< " + bound);
+        }
+        for (TypeValue bound : typeValue.getLowerBounds()) {
+            println(" :> " + bound);
+        }
+    }
+
     private void check(TypeValue typeValue, Solution solution) {
         try {
             KnownType resultingValue = typeValue.getValue();
@@ -416,7 +444,7 @@ public class ConstraintSystemImpl implements ConstraintSystem {
                 }
             }
             solution.registerError("[TODO] Loop in constraints");
-            e.printStackTrace();
+//            e.printStackTrace();
         }
     }
 
@@ -426,6 +454,9 @@ public class ConstraintSystemImpl implements ConstraintSystem {
         }
 
         for (TypeValue upperBound : Sets.newHashSet(current.getUpperBounds())) {
+            if (upperBound instanceof KnownType) {
+                continue;
+            }
             transitiveClosure(upperBound, visited);
             Set<TypeValue> upperBounds = upperBound.getUpperBounds();
             for (TypeValue transitiveBound : upperBounds) {
diff --git a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java
index a378e31d39b..991c3ced6a9 100644
--- a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java
+++ b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java
@@ -73,7 +73,11 @@ public class DescriptorRenderer implements Renderer {
     }
 
     public String renderType(JetType type) {
-        return escape(type.toString());
+        if (type == null) {
+            return escape("[NULL]");
+        } else {
+            return escape(type.toString());
+        }
     }
 
     protected String escape(String s) {
@@ -222,7 +226,6 @@ public class DescriptorRenderer implements Renderer {
 
             renderName(descriptor, builder);
             renderValueParameters(descriptor, builder);
-            // TODO: getReturnType may be uninitialized and throw IllegalStateException // stepan.koltsov@ 2011-11-21
             builder.append(" : ").append(escape(renderType(descriptor.getReturnType())));
             return super.visitFunctionDescriptor(descriptor, builder);
         }
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet53.jet b/compiler/testData/checkerWithErrorTypes/full/regression/Jet53.jet
deleted file mode 100644
index e880fe25bbd..00000000000
--- a/compiler/testData/checkerWithErrorTypes/full/regression/Jet53.jet
+++ /dev/null
@@ -1,4 +0,0 @@
-import java.util.Collections
-import java.util.List
-
-val ab = Collections.emptyList<Int>() : List<Int>?
\ No newline at end of file
diff --git a/compiler/testData/checkerWithErrorTypes/full/Abstract.jet b/compiler/testData/checkerWithErrorTypes/quick/Abstract.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/Abstract.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Abstract.jet
index ce355f02045..a13891668c6 100644
--- a/compiler/testData/checkerWithErrorTypes/full/Abstract.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/Abstract.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 namespace abstract
 
 class MyClass() {
@@ -235,7 +237,7 @@ abstract class B3(i: Int) {
     this(): this(1)
 }
 
-fun foo(a: B3) {
+fun foo(c: B3) {
     val <!UNUSED_VARIABLE!>a<!> = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B3()<!>
     val <!UNUSED_VARIABLE!>b<!> = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B1(2, "s")<!>
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/AnonymousInitializers.jet b/compiler/testData/checkerWithErrorTypes/quick/AnonymousInitializers.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/AnonymousInitializers.jet
rename to compiler/testData/checkerWithErrorTypes/quick/AnonymousInitializers.jet
diff --git a/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet b/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet
index 25c73139ff1..c46164e8c73 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet
@@ -88,4 +88,4 @@ open class C {
           t = <!UNUSED_VALUE!>this@C<!>
        }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/BinaryCallsOnNullableValues.jet b/compiler/testData/checkerWithErrorTypes/quick/BinaryCallsOnNullableValues.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/BinaryCallsOnNullableValues.jet
rename to compiler/testData/checkerWithErrorTypes/quick/BinaryCallsOnNullableValues.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/Bounds.jet b/compiler/testData/checkerWithErrorTypes/quick/Bounds.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Bounds.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Bounds.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/BreakContinue.jet b/compiler/testData/checkerWithErrorTypes/quick/BreakContinue.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/BreakContinue.jet
rename to compiler/testData/checkerWithErrorTypes/quick/BreakContinue.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/Builders.jet b/compiler/testData/checkerWithErrorTypes/quick/Builders.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/Builders.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Builders.jet
index 1d26cbbc8b2..10791f68875 100644
--- a/compiler/testData/checkerWithErrorTypes/full/Builders.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/Builders.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 import java.util.*
 
 namespace html {
diff --git a/compiler/testData/checkerWithErrorTypes/full/Casts.jet b/compiler/testData/checkerWithErrorTypes/quick/Casts.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Casts.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Casts.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/ClassObjects.jet b/compiler/testData/checkerWithErrorTypes/quick/ClassObjects.jet
similarity index 97%
rename from compiler/testData/checkerWithErrorTypes/full/ClassObjects.jet
rename to compiler/testData/checkerWithErrorTypes/quick/ClassObjects.jet
index 5be76d57e39..f933004a4d5 100644
--- a/compiler/testData/checkerWithErrorTypes/full/ClassObjects.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/ClassObjects.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 namespace Jet86
 
 class A {
@@ -27,4 +29,4 @@ val s = <!NO_CLASS_OBJECT!>System<!>  // error
 fun test() {
   System.out?.println()
   java.lang.System.out?.println()
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/Constants.jet b/compiler/testData/checkerWithErrorTypes/quick/Constants.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Constants.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Constants.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/Constructors.jet b/compiler/testData/checkerWithErrorTypes/quick/Constructors.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Constructors.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Constructors.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet b/compiler/testData/checkerWithErrorTypes/quick/CovariantOverrideType.jet
similarity index 98%
rename from compiler/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet
rename to compiler/testData/checkerWithErrorTypes/quick/CovariantOverrideType.jet
index 1ffd989245c..ca0116bf983 100644
--- a/compiler/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/CovariantOverrideType.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 trait A {
     fun foo() : Int = 1
     fun foo2() : Int = 1
diff --git a/compiler/testData/checkerWithErrorTypes/full/CyclicHierarchy.jet b/compiler/testData/checkerWithErrorTypes/quick/CyclicHierarchy.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/CyclicHierarchy.jet
rename to compiler/testData/checkerWithErrorTypes/quick/CyclicHierarchy.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/Enums.jet b/compiler/testData/checkerWithErrorTypes/quick/Enums.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Enums.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Enums.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet b/compiler/testData/checkerWithErrorTypes/quick/ExtensionFunctions.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet
rename to compiler/testData/checkerWithErrorTypes/quick/ExtensionFunctions.jet
index 141e47ae591..245be61e735 100644
--- a/compiler/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/ExtensionFunctions.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 fun Int?.optint() : Unit {}
 val Int?.optval : Unit = ()
 
@@ -68,4 +70,4 @@ namespace null_safety {
             if (command == null) 1
         }
 
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/ForRangeConventions.jet b/compiler/testData/checkerWithErrorTypes/quick/ForRangeConventions.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/ForRangeConventions.jet
rename to compiler/testData/checkerWithErrorTypes/quick/ForRangeConventions.jet
index 1f14e587fcd..66142d55fbb 100644
--- a/compiler/testData/checkerWithErrorTypes/full/ForRangeConventions.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/ForRangeConventions.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 import java.util.*;
 
 class NotRange1() {
diff --git a/compiler/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet b/compiler/testData/checkerWithErrorTypes/quick/FunctionReturnTypes.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet
rename to compiler/testData/checkerWithErrorTypes/quick/FunctionReturnTypes.jet
index 850cb2fd5e0..27d52fb227b 100644
--- a/compiler/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/FunctionReturnTypes.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 fun none() {}
 
 fun unitEmptyInfer() {}
@@ -209,4 +211,4 @@ fun testFunctionLiterals() {
         object A {}
     }
 
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/GenericArgumentConsistency.jet b/compiler/testData/checkerWithErrorTypes/quick/GenericArgumentConsistency.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/GenericArgumentConsistency.jet
rename to compiler/testData/checkerWithErrorTypes/quick/GenericArgumentConsistency.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/IllegalModifiers.jet b/compiler/testData/checkerWithErrorTypes/quick/IllegalModifiers.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/IllegalModifiers.jet
rename to compiler/testData/checkerWithErrorTypes/quick/IllegalModifiers.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/IncDec.jet b/compiler/testData/checkerWithErrorTypes/quick/IncDec.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/IncDec.jet
rename to compiler/testData/checkerWithErrorTypes/quick/IncDec.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/IsExpressions.jet b/compiler/testData/checkerWithErrorTypes/quick/IsExpressions.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/IsExpressions.jet
rename to compiler/testData/checkerWithErrorTypes/quick/IsExpressions.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/MultipleBounds.jet b/compiler/testData/checkerWithErrorTypes/quick/MultipleBounds.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/MultipleBounds.jet
rename to compiler/testData/checkerWithErrorTypes/quick/MultipleBounds.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet b/compiler/testData/checkerWithErrorTypes/quick/NamespaceAsExpression.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet
rename to compiler/testData/checkerWithErrorTypes/quick/NamespaceAsExpression.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/NamespaceInExpressionPosition.jet b/compiler/testData/checkerWithErrorTypes/quick/NamespaceInExpressionPosition.jet
similarity index 97%
rename from compiler/testData/checkerWithErrorTypes/full/NamespaceInExpressionPosition.jet
rename to compiler/testData/checkerWithErrorTypes/quick/NamespaceInExpressionPosition.jet
index 863f25630cc..f8520b087f1 100644
--- a/compiler/testData/checkerWithErrorTypes/full/NamespaceInExpressionPosition.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/NamespaceInExpressionPosition.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 namespace foo
 
 class X {}
diff --git a/compiler/testData/checkerWithErrorTypes/full/NamespaceQualified.jet b/compiler/testData/checkerWithErrorTypes/quick/NamespaceQualified.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/NamespaceQualified.jet
rename to compiler/testData/checkerWithErrorTypes/quick/NamespaceQualified.jet
index 213e2867d94..194c1047e24 100644
--- a/compiler/testData/checkerWithErrorTypes/full/NamespaceQualified.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/NamespaceQualified.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 namespace foobar
 
 namespace a {
@@ -60,4 +62,4 @@ abstract class Collection<E> : Iterable<E> {
       }
       return iteratee.done()
   }
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/Nullability.jet b/compiler/testData/checkerWithErrorTypes/quick/Nullability.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/Nullability.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Nullability.jet
index 8479b364cd8..95e8ebb3700 100644
--- a/compiler/testData/checkerWithErrorTypes/full/Nullability.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/Nullability.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 fun test() {
   val a : Int? = 0
   if (a != null) {
@@ -277,4 +279,4 @@ fun f9(a : Int?) : Int {
   if (a != null)
     return a
   return 1
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/Objects.jet b/compiler/testData/checkerWithErrorTypes/quick/Objects.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Objects.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Objects.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/PrimaryConstructors.jet b/compiler/testData/checkerWithErrorTypes/quick/PrimaryConstructors.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/PrimaryConstructors.jet
rename to compiler/testData/checkerWithErrorTypes/quick/PrimaryConstructors.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/ProjectionsInSupertypes.jet b/compiler/testData/checkerWithErrorTypes/quick/ProjectionsInSupertypes.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/ProjectionsInSupertypes.jet
rename to compiler/testData/checkerWithErrorTypes/quick/ProjectionsInSupertypes.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/Properties.jet b/compiler/testData/checkerWithErrorTypes/quick/Properties.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Properties.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Properties.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/QualifiedExpressions.jet b/compiler/testData/checkerWithErrorTypes/quick/QualifiedExpressions.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/QualifiedExpressions.jet
rename to compiler/testData/checkerWithErrorTypes/quick/QualifiedExpressions.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/QualifiedThis.jet b/compiler/testData/checkerWithErrorTypes/quick/QualifiedThis.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/QualifiedThis.jet
rename to compiler/testData/checkerWithErrorTypes/quick/QualifiedThis.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/RecursiveTypeInference.jet b/compiler/testData/checkerWithErrorTypes/quick/RecursiveTypeInference.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/RecursiveTypeInference.jet
rename to compiler/testData/checkerWithErrorTypes/quick/RecursiveTypeInference.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/Redeclarations.jet b/compiler/testData/checkerWithErrorTypes/quick/Redeclarations.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Redeclarations.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Redeclarations.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/ResolveOfJavaGenerics.jet b/compiler/testData/checkerWithErrorTypes/quick/ResolveOfJavaGenerics.jet
similarity index 96%
rename from compiler/testData/checkerWithErrorTypes/full/ResolveOfJavaGenerics.jet
rename to compiler/testData/checkerWithErrorTypes/quick/ResolveOfJavaGenerics.jet
index d98dd030994..2353e215293 100644
--- a/compiler/testData/checkerWithErrorTypes/full/ResolveOfJavaGenerics.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/ResolveOfJavaGenerics.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 // Fixpoint generic in Java: Enum<T extends Enum<T>>
 fun test(a : annotation.RetentionPolicy) {
 
@@ -17,4 +19,4 @@ fun test(a : java.util.ArrayList<Int>) {
 
 fun test(a : java.lang.Class<Int>) {
 
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/ResolveToJava.jet b/compiler/testData/checkerWithErrorTypes/quick/ResolveToJava.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/ResolveToJava.jet
rename to compiler/testData/checkerWithErrorTypes/quick/ResolveToJava.jet
index 61483f8ea48..d404b2365ba 100644
--- a/compiler/testData/checkerWithErrorTypes/full/ResolveToJava.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/ResolveToJava.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 import java.*
 import util.*
 import <!UNRESOLVED_REFERENCE!>utils<!>.*
@@ -49,4 +51,4 @@ fun test(l : java.util.List<Int>) {
 
 namespace xxx {
   import java.lang.Class;
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/Return.jet b/compiler/testData/checkerWithErrorTypes/quick/Return.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Return.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Return.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/StringTemplates.jet b/compiler/testData/checkerWithErrorTypes/quick/StringTemplates.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/StringTemplates.jet
rename to compiler/testData/checkerWithErrorTypes/quick/StringTemplates.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/SupertypeListChecks.jet b/compiler/testData/checkerWithErrorTypes/quick/SupertypeListChecks.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/SupertypeListChecks.jet
rename to compiler/testData/checkerWithErrorTypes/quick/SupertypeListChecks.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/TraitSupertypeList.jet b/compiler/testData/checkerWithErrorTypes/quick/TraitSupertypeList.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/TraitSupertypeList.jet
rename to compiler/testData/checkerWithErrorTypes/quick/TraitSupertypeList.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/UnreachableCode.jet b/compiler/testData/checkerWithErrorTypes/quick/UnreachableCode.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/UnreachableCode.jet
rename to compiler/testData/checkerWithErrorTypes/quick/UnreachableCode.jet
index 60efa628adf..36bfd0e8925 100644
--- a/compiler/testData/checkerWithErrorTypes/full/UnreachableCode.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/UnreachableCode.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 fun t1() : Int{
   return 0
   <!UNREACHABLE_CODE!>1<!>
diff --git a/compiler/testData/checkerWithErrorTypes/full/Unresolved.jet b/compiler/testData/checkerWithErrorTypes/quick/Unresolved.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Unresolved.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Unresolved.jet
diff --git a/compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet b/compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet
index dab85168b91..dd23f8a97d6 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet
@@ -50,7 +50,7 @@ class MyTest() {
         i = <!UNUSED_VALUE!>456<!>;
     }
 
-    fun testWhile(a : Any?, b : Any?) {
+    fun testWhile() {
         var a : Any? = true
         var b : Any? = 34
         while (a is Any) {
@@ -139,4 +139,4 @@ fun testBackingFieldsNotMarked() {
     }
 }
 
-fun doSmth(i : Int) {}
\ No newline at end of file
+fun doSmth(i : Int) {}
diff --git a/compiler/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet b/compiler/testData/checkerWithErrorTypes/quick/ValAndFunOverrideCompatibilityClash.jet
similarity index 93%
rename from compiler/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet
rename to compiler/testData/checkerWithErrorTypes/quick/ValAndFunOverrideCompatibilityClash.jet
index f18974bb51f..f493c55a093 100644
--- a/compiler/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/ValAndFunOverrideCompatibilityClash.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 class Foo1() : java.util.ArrayList<Int>()
 
 open class Bar() {
diff --git a/compiler/testData/checkerWithErrorTypes/full/VarargTypes.jet b/compiler/testData/checkerWithErrorTypes/quick/VarargTypes.jet
similarity index 98%
rename from compiler/testData/checkerWithErrorTypes/full/VarargTypes.jet
rename to compiler/testData/checkerWithErrorTypes/quick/VarargTypes.jet
index 2ce06de117c..d5a3b859b8c 100644
--- a/compiler/testData/checkerWithErrorTypes/full/VarargTypes.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/VarargTypes.jet
@@ -1,4 +1,5 @@
 // KT-389 Wrong type inference for varargs etc.
+// +JDK
 
 import java.util.*
 
@@ -23,4 +24,4 @@ fun test() {
     fool(1, 2, 3)
     food(1.0, 2.0, 3.0)
     foof(1.0.flt, 2.0.flt, 3.0.flt)
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/Variance.jet b/compiler/testData/checkerWithErrorTypes/quick/Variance.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/Variance.jet
rename to compiler/testData/checkerWithErrorTypes/quick/Variance.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/When.jet b/compiler/testData/checkerWithErrorTypes/quick/When.jet
similarity index 73%
rename from compiler/testData/checkerWithErrorTypes/full/When.jet
rename to compiler/testData/checkerWithErrorTypes/quick/When.jet
index 7f53fb38c9d..bff65aac380 100644
--- a/compiler/testData/checkerWithErrorTypes/full/When.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/When.jet
@@ -13,16 +13,19 @@ fun foo() : Int {
       1 + <!UNRESOLVED_REFERENCE!>a<!> => 1
       in 1..<!UNRESOLVED_REFERENCE!>a<!> => 1
       !in 1..<!UNRESOLVED_REFERENCE!>a<!> => 1
-      .<!UNRESOLVED_REFERENCE!>a<!> => 1
-      .equals(1).<!UNRESOLVED_REFERENCE!>a<!> => 1
-      <!UNNECESSARY_SAFE_CALL!>?.<!>equals(1) => 1
+      // Commented for KT-621 .<!!UNRESOLVED_REFERENCE!>a<!!> => 1
+      // Commented for KT-621 .equals(1).<!!UNRESOLVED_REFERENCE!>a<!!> => 1
+      // Commented for KT-621 <!UNNECESSARY_SAFE_CALL!!>?.<!!>equals(1) => 1
       else => 1
     }
-    return when (<!USELESS_ELVIS!>x<!>?:null) {
-      <!UNSAFE_CALL!>.<!>foo() => 1
-      .equals(1) => 1
-      ?.equals(1).equals(2) => 1
-    }
+
+    // Commented for KT-621
+    // return when (<!!USELESS_ELVIS!>x<!!>?:null) {
+    //  <!!UNSAFE_CALL!!>.<!!>foo() => 1
+    //  .equals(1) => 1
+    //  ?.equals(1).equals(2) => 1
+    // }
+    return 0
 }
 
 val _type_test : Int = foo() // this is needed to ensure the inferred return type of foo()
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedError.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedError.jet
new file mode 100644
index 00000000000..2b6a8a020d3
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedError.jet
@@ -0,0 +1,6 @@
+// +JDK
+
+import java.util.List;
+import java.util.Collection;
+
+fun ff(c: Collection<String>) = c <!CAST_NEVER_SUCCEEDS!>as<!> List<Int>
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedFine.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedFine.jet
new file mode 100644
index 00000000000..b4c50dc6b11
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedFine.jet
@@ -0,0 +1,6 @@
+// +JDK
+
+import java.util.List;
+import java.util.Collection;
+
+fun ff(c: Collection<String>) = c as List<String>
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedStar.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedStar.jet
new file mode 100644
index 00000000000..4217aae11df
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedStar.jet
@@ -0,0 +1,6 @@
+// +JDK
+
+import java.util.List;
+
+fun ff(l: Any) = l as List<*>
+
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedWarning.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedWarning.jet
new file mode 100644
index 00000000000..eff6dff6487
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/AsErasedWarning.jet
@@ -0,0 +1,5 @@
+// +JDK
+
+import java.util.List;
+
+fun ff(a: Any) = <!UNCHECKED_CAST!>a as List<String><!>
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedAllow.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedAllow.jet
new file mode 100644
index 00000000000..ca46b082bc1
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedAllow.jet
@@ -0,0 +1,7 @@
+// +JDK
+
+import java.util.Collection;
+import java.util.List;
+
+fun ff(l: Collection<String>) = l is List<String>
+
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedAllowParameterSubtype.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedAllowParameterSubtype.jet
new file mode 100644
index 00000000000..a4d9a515e30
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedAllowParameterSubtype.jet
@@ -0,0 +1,11 @@
+// +JDK
+
+import java.util.Collection;
+import java.util.List;
+
+open class A
+
+class B : A
+
+fun ff(l: Collection<B>) = l is List<out A>
+
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedDisallowFromAny.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedDisallowFromAny.jet
new file mode 100644
index 00000000000..76e1b3e530e
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedDisallowFromAny.jet
@@ -0,0 +1,5 @@
+// +JDK
+
+import java.util.List;
+
+fun ff(l: Any) = l is <!CANNOT_CHECK_FOR_ERASED!>List<String><!>
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedStar.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedStar.jet
new file mode 100644
index 00000000000..232d2a2f1c9
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/IsErasedStar.jet
@@ -0,0 +1,5 @@
+// +JDK
+
+import java.util.List;
+
+fun ff(l: Any) = l is List<*>
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/IsReified.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/IsReified.jet
new file mode 100644
index 00000000000..247196d6e84
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/IsReified.jet
@@ -0,0 +1,3 @@
+class MyList<T>
+
+fun ff(a: Any) = a is MyList<String>
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/IsTraits.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/IsTraits.jet
new file mode 100644
index 00000000000..99656c2ab24
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/IsTraits.jet
@@ -0,0 +1,4 @@
+trait Aaa
+trait Bbb
+
+fun f(a: Aaa) = a is Bbb
diff --git a/compiler/testData/checkerWithErrorTypes/quick/cast/WhenErasedDisallowFromAny.jet b/compiler/testData/checkerWithErrorTypes/quick/cast/WhenErasedDisallowFromAny.jet
new file mode 100644
index 00000000000..af0653dd699
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/cast/WhenErasedDisallowFromAny.jet
@@ -0,0 +1,8 @@
+// +JDK
+
+import java.util.List;
+
+fun ff(l: Any) = when(l) {
+    is <!CANNOT_CHECK_FOR_ERASED!>List<String><!> => 1
+    else 2
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/infos/Autocasts.jet b/compiler/testData/checkerWithErrorTypes/quick/infos/Autocasts.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/infos/Autocasts.jet
rename to compiler/testData/checkerWithErrorTypes/quick/infos/Autocasts.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet b/compiler/testData/checkerWithErrorTypes/quick/infos/PropertiesWithBackingFields.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet
rename to compiler/testData/checkerWithErrorTypes/quick/infos/PropertiesWithBackingFields.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/AmbiguityOnLazyTypeComputation.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/AmbiguityOnLazyTypeComputation.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/AmbiguityOnLazyTypeComputation.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/AmbiguityOnLazyTypeComputation.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/AssignmentsUnderOperators.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/AssignmentsUnderOperators.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/AssignmentsUnderOperators.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/AssignmentsUnderOperators.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/CoercionToUnit.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/CoercionToUnit.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/CoercionToUnit.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/CoercionToUnit.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/DoubleDefine.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/DoubleDefine.jet
index 996c4608778..74da10dc846 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/DoubleDefine.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 import java.*
 import util.*
 
@@ -63,4 +65,4 @@ fun main(args: Array<String>) {
   catch(e: Throwable) {
     System.out?.println(e.getMessage())
   }
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/ErrorsOnIbjectExpressionsAsParameters.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/ErrorsOnIbjectExpressionsAsParameters.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/ErrorsOnIbjectExpressionsAsParameters.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/ErrorsOnIbjectExpressionsAsParameters.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet11.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet11.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet11.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet11.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet121.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet121.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet121.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet121.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet124.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet124.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet124.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet124.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet169.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet169.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet169.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet169.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet17.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet17.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet17.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet17.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet183-1.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet183-1.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet183-1.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet183-1.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet183.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet183.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet183.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet183.jet
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet53.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet53.jet
new file mode 100644
index 00000000000..a138884afc2
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet53.jet
@@ -0,0 +1,6 @@
+// +JDK
+
+import java.util.Collections
+import java.util.List
+
+val ab = Collections.emptyList<Int>() : List<Int>?
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet67.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet67.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet67.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet67.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet68.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet68.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet68.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet68.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet69.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet69.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet69.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet69.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet72.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet72.jet
similarity index 97%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet72.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet72.jet
index d3d3272c8e3..5ca74129847 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/Jet72.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet72.jet
@@ -1,4 +1,5 @@
 // JET-72 Type inference doesn't work when iterating over ArrayList
+// +JDK
 
 import java.util.ArrayList
 
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/Jet81.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/Jet81.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/Jet81.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/Jet81.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/OverrideResolution.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/OverrideResolution.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/OverrideResolution.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/OverrideResolution.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/ScopeForSecondaryConstructors.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/ScopeForSecondaryConstructors.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/SpecififcityByReceiver.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/SpecififcityByReceiver.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/SpecififcityByReceiver.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/SpecififcityByReceiver.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/ThisConstructorInGenericClass.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/ThisConstructorInGenericClass.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/ThisConstructorInGenericClass.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/ThisConstructorInGenericClass.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/WrongTraceInCallResolver.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/WrongTraceInCallResolver.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/WrongTraceInCallResolver.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/WrongTraceInCallResolver.jet
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet
index 7bcb076f08c..19ad92b2d52 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet
@@ -8,8 +8,11 @@ fun Any?.equals1(other : Any?) : Boolean = true
 fun main(args: Array<String>) {
 
     val command : Foo? = null
-    when (command) {
-      .equals(null) => 1; // must be resolved
-      ?.equals(null) => 1 // same here
-    }
+
+    // Commented for KT-621
+    // when (command) {
+    //   .equals(null) => 1; // must be resolved
+    //   ?.equals(null) => 1 // same here
+    // }
+    command.equals(null)
 }
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet
index 7420cb938e5..c5a96d7c961 100644
--- a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet
@@ -1,4 +1,5 @@
 //KT-235 Illegal assignment return type
+// +JDK
 
 namespace kt235
 
@@ -16,7 +17,7 @@ fun main(args: Array<String>) {
        <!EXPECTED_TYPE_MISMATCH!>x = 2<!>  //the same
     }
     val array1 = MyArray1()
-    val <!UNUSED_VARIABLE!>x<!> = { (): String =>
+    val <!UNUSED_VARIABLE!>i<!> = { (): String =>
        <!EXPECTED_TYPE_MISMATCH!>array1[2] = 23<!>
     }
 
@@ -46,4 +47,4 @@ class MyArray1() {
 
 class MyNumber() {
     fun inc(): MyNumber = MyNumber()
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt251.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt251.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt251.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt251.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt258.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt258.jet
similarity index 97%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt258.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt258.jet
index 257dfb12378..00b7e9696d4 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/kt258.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt258.jet
@@ -1,4 +1,5 @@
 // KT-258 Support equality constraints in type inference
+// +JDK
 
 import java.util.*
 
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt287.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt287.jet
similarity index 96%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt287.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt287.jet
index b0efe2e6460..69d2d526fb0 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/kt287.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt287.jet
@@ -1,4 +1,6 @@
 // KT-287 Infer constructor type arguments
+// +JDK
+
 import java.util.*
 
 fun attributes() : Map<String, String> = HashMap() // Should be inferred;
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt303.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt303.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt303.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt303.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt313.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt313.jet
similarity index 97%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt313.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt313.jet
index d22f0dc4f2e..7a112bcb106 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/kt313.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt313.jet
@@ -1,4 +1,5 @@
 // KT-313 Bug in substitutions in a function returning its type parameter T
+// +JDK
 
 fun <T> Iterable<T>.join(separator : String?) : String {
     return separator.npe()
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt335.336.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt335.336.jet
similarity index 98%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt335.336.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt335.336.jet
index 46537f0041c..e874d8f005d 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/kt335.336.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt335.336.jet
@@ -1,5 +1,6 @@
 // KT-336 Can't infer type parameter for ArrayList in a generic function (Exception in type inference)
 // KT-335 Type inference fails on Collections.sort
+// +JDK
 
 import java.util.*
 import java.lang.Comparable as Comparable
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt385.109.441.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt385.109.441.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt385.109.441.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt385.109.441.jet
index 8af621372fd..9dcac990807 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/kt385.109.441.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt385.109.441.jet
@@ -1,6 +1,7 @@
 // KT-385 type inference does not work properly`
 // KT-109 Good code is red: type arguments are not inferred
 // KT-441 Exception in type inference when multiple overloads accepting an integer literal are accessible
+// +JDK
 
 import java.util.*
 
@@ -31,4 +32,4 @@ inline fun run<T>(body : fun() : T) : T = body()
 fun main(args : Array<String>) {
 
     println(run { 1 })
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt402.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt402.jet
similarity index 100%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt402.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt402.jet
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt459.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt459.jet
similarity index 92%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt459.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt459.jet
index e2dd54ef0da..faa62212f38 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/kt459.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt459.jet
@@ -1,8 +1,9 @@
 // KT-459 Type argument inference fails when class names are fully qualified
+// +JDK
 
 fun test() {
   val attributes : java.util.HashMap<String, String> = java.util.HashMap() // failure!
   attributes["href"] = "1" // inference fails, but it shouldn't
 }
 
-fun <K, V> java.util.Map<K, V>.set(key : K, value : V) {}//= this.put(key, value)
\ No newline at end of file
+fun <K, V> java.util.Map<K, V>.set(key : K, value : V) {}//= this.put(key, value)
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt469.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt469.jet
similarity index 98%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt469.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt469.jet
index 3d01d2efee9..a9ff4c1d291 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/kt469.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt469.jet
@@ -1,3 +1,5 @@
+// +JDK
+
 namespace kt469
 
 //KT-512 plusAssign() : Unit does not work properly
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt549.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt549.jet
new file mode 100644
index 00000000000..5fc17be122b
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt549.jet
@@ -0,0 +1,18 @@
+//KT-549 type inference failed
+// +JDK
+
+namespace demo
+
+  fun filter<T>(list : Array<T>, filter : fun (T) : Boolean) : java.util.List<T> {
+    val answer = java.util.ArrayList<T>();
+    for (l in list) {
+      if (filter(l)) answer.add(l)
+    }
+    return answer;
+  }
+
+fun main(args : Array<String>) {
+  for (a in filter(args, {it.length > 1})) {
+    System.out?.println("Hello, ${a}!")
+  }
+}
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt571.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt571.jet
new file mode 100644
index 00000000000..2333eb78644
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt571.jet
@@ -0,0 +1,3 @@
+//KT-571 Type inference failed
+fun <T, R> let(t : T, body : fun(T) : R) = body(t)
+private fun double(d : Int) : Int = let(d * 2) {it / 10 + it * 2 % 10}
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt58.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt58.jet
similarity index 99%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt58.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt58.jet
index 7ebe0ee8feb..57562a61f37 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/kt58.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt58.jet
@@ -1,4 +1,5 @@
 //KT-58 Allow finally around definite returns
+// +JDK
 
 namespace kt58
 
@@ -88,4 +89,4 @@ fun t7() : Int {
 }
 
 fun doSmth(i: Int) {
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt580.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt580.jet
new file mode 100644
index 00000000000..c2d12ec6e93
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt580.jet
@@ -0,0 +1,22 @@
+//KT-580 Type inference failed
+// +JDK
+
+namespace whats.the.difference
+
+import java.util.*
+
+fun iarray(vararg a : String) = a // BUG
+
+fun main() {
+    val vals = iarray("789", "678", "567")
+    val diffs = ArrayList<Int>
+    for (i in vals.indices) {
+        for (j in i..vals.lastIndex())  // Type inference failed
+             diffs.add(vals[i].length - vals[j].length)
+        for (j in i..vals.lastIndex)  // Type inference failed
+             diffs.add(vals[i].length - vals[j].length)
+    }
+}
+
+fun <T> Array<T>.lastIndex() = size - 1
+val <T> Array<T>.lastIndex : Int get() = size - 1
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/kt588.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt588.jet
similarity index 95%
rename from compiler/testData/checkerWithErrorTypes/full/regression/kt588.jet
rename to compiler/testData/checkerWithErrorTypes/quick/regressions/kt588.jet
index 2b4b4d86ff4..410c70c3479 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/kt588.jet
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt588.jet
@@ -1,4 +1,6 @@
 // KT-588 Unresolved static method
+// +JDK
+
 class Test() : Thread("Test") {
     class object {
         fun init2() {
@@ -9,4 +11,4 @@ class Test() : Thread("Test") {
         init2()      // unresolved
         Test.init2() // ok
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt600.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt600.jet
new file mode 100644
index 00000000000..0ca74ae5c33
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt600.jet
@@ -0,0 +1,9 @@
+//KT-600 Problem with 'sure' extension function type inference
+// +JDK
+
+fun <T : Any> T?._sure() : T { if (this != null) return this else throw NullPointerException() }
+
+fun test() {
+    val i : Int? = 10
+    val <!UNUSED_VARIABLE!>i2<!> : Int = i._sure() // inferred type is Int? but Int was excepted
+}
diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/kt618.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt618.jet
new file mode 100644
index 00000000000..569d286c17b
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/kt618.jet
@@ -0,0 +1,28 @@
+namespace lol
+
+class B() {
+    fun plusAssign(other : B) : String {
+        return "s"
+    }
+    fun minusAssign(other : B) : String {
+        return "s"
+    }
+    fun modAssign(other : B) : String {
+        return "s"
+    }
+    fun divAssign(other : B) : String {
+        return "s"
+    }
+    fun timesAssign(other : B) : String {
+        return "s"
+    }
+}
+
+fun main(args : Array<String>) {
+    var c = B()
+    <!TYPE_MISMATCH!>c += B()<!>
+    <!TYPE_MISMATCH!>c *= B()<!>
+    <!TYPE_MISMATCH!>c /= B()<!>
+    <!TYPE_MISMATCH!>c -= B()<!>
+    <!TYPE_MISMATCH!>c %= B()<!>
+}
diff --git a/compiler/testData/codegen/patternMatching/callProperty.jet b/compiler/testData/codegen/patternMatching/callProperty.jet
index b52ac44de96..65fc9b7997d 100644
--- a/compiler/testData/codegen/patternMatching/callProperty.jet
+++ b/compiler/testData/codegen/patternMatching/callProperty.jet
@@ -2,8 +2,11 @@ class C(val p: Boolean) { }
 
 fun box(): String {
   val c = C(true)
-  return when(c) {
-    .p => "OK"
-    else => "fail"
-  }
+
+  // Commented for KT-621
+  // return when(c) {
+  //  .p => "OK"
+  //  else => "fail"
+  // }
+  return if (c.p) "OK" else "fail"
 }
diff --git a/compiler/testData/codegen/patternMatching/is.jet b/compiler/testData/codegen/patternMatching/is.jet
index a5b5f33195f..9fac50c586b 100644
--- a/compiler/testData/codegen/patternMatching/is.jet
+++ b/compiler/testData/codegen/patternMatching/is.jet
@@ -1,6 +1,6 @@
 fun typeName(a: Any?) : String {
     return when(a) {
-        is java.util.ArrayList<Int> => "array list"
+        is java.util.ArrayList<*> => "array list"
         else => "no idea"
     }
 }
@@ -8,4 +8,4 @@ fun typeName(a: Any?) : String {
 fun box() : String {
     if(typeName(java.util.ArrayList<Int> ()) != "array list") return "array list failed"
     return "OK"
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/codegen/regressions/kt247.jet b/compiler/testData/codegen/regressions/kt247.jet
index 49637518d25..af13811dee9 100644
--- a/compiler/testData/codegen/regressions/kt247.jet
+++ b/compiler/testData/codegen/regressions/kt247.jet
@@ -19,7 +19,7 @@ fun t3() {
 
 fun t4() {
     val e: E? = E()
-    System.out?.println(e?.foo() == e) //verify error
+    System.out?.println(e?.bar() == e) //verify error
     System.out?.println(e?.foo())  //verify error
 }
 
@@ -35,4 +35,5 @@ class C(val x: Int)
 class D(val s: String)
 class E() {
     fun foo() = 1
+    fun bar() = this
 }
diff --git a/compiler/testData/codegen/regressions/kt528.kt b/compiler/testData/codegen/regressions/kt528.kt
index 456f55d04be..8cfe1707aee 100644
--- a/compiler/testData/codegen/regressions/kt528.kt
+++ b/compiler/testData/codegen/regressions/kt528.kt
@@ -25,14 +25,25 @@ class Luhny() {
 
     fun charIn(it : Char) {
         buffer.addLast(it)
-        when (it) {
-            .isDigit() => digits.addLast(it.int - '0'.int)
-            ' ', '-' => {}
-            else => {
-                    printAll()
-                    digits.clear()
-            }
+
+        // Commented for KT-621
+        // when (it) {
+        //    .isDigit() => digits.addLast(it.int - '0'.int)
+        //    ' ', '-' => {}
+        //    else => {
+        //            printAll()
+        //            digits.clear()
+        //    }
+        // }
+
+        if (it.isDigit()) {
+            digits.addLast(it.int - '0'.int)
+        } else if (it == ' ' || it == '-') {
+        } else {
+            printAll()
+            digits.clear()
         }
+
         if (digits.size() > 16)
           printOneDigit()
         check()
diff --git a/compiler/testData/codegen/regressions/kt529.kt b/compiler/testData/codegen/regressions/kt529.kt
index 66487f37509..84a6d3edc52 100644
--- a/compiler/testData/codegen/regressions/kt529.kt
+++ b/compiler/testData/codegen/regressions/kt529.kt
@@ -23,11 +23,21 @@ class Luhny() {
 
     fun process(it : Char) {
         buffer.addLast(it)
-        when (it) {
-            .isDigit() => digits.addLast(it.int - '0'.int)
-            ' ', '-'   => {}
-            else       => printAll()
+
+        // Commented for KT-621
+        // when (it) {
+        //     .isDigit() => digits.addLast(it.int - '0'.int)
+        //     ' ', '-'   => {}
+        //     else       => printAll()
+        // }
+
+        if (it.isDigit()) {
+            digits.addLast(it.int - '0'.int)
+        } else if (it == ' ' || it == '-') {
+        } else {
+            printAll()
         }
+
         if (digits.size() > 16)
           printOneDigit()
         check()
diff --git a/compiler/testData/codegen/regressions/kt533.kt b/compiler/testData/codegen/regressions/kt533.kt
index 05e55878b81..7e7ef961ffd 100644
--- a/compiler/testData/codegen/regressions/kt533.kt
+++ b/compiler/testData/codegen/regressions/kt533.kt
@@ -24,14 +24,25 @@ class Luhny() {
 
     fun charIn(it : Char) {
         buffer.push(it)
-        when (it) {
-            .isDigit() => digits.push(it.int - '0'.int)
-            ' ', '-' => {}
-            else => {
-                    printAll()
-                    digits.clear()
-            }
+
+        // Commented for KT-621
+        // when (it) {
+        //   .isDigit() => digits.push(it.int - '0'.int)
+        //   ' ', '-' => {}
+        //   else => {
+        //           printAll()
+        //           digits.clear()
+        //   }
+        // }
+
+        if (it.isDigit()) {
+            digits.push(it.int - '0'.int)
+        } else if (it == ' ' || it == '-') {
+        } else {
+            printAll()
+            digits.clear()
         }
+
         if (digits.size() > 16)
           printOneDigit()
         check()
diff --git a/compiler/testData/codegen/regressions/kt602.jet b/compiler/testData/codegen/regressions/kt602.jet
new file mode 100644
index 00000000000..aae930a7328
--- /dev/null
+++ b/compiler/testData/codegen/regressions/kt602.jet
@@ -0,0 +1 @@
+fun box() = if(Array<Int>(10) is Array<java.lang.Integer>) "OK" else "fail"
diff --git a/compiler/testData/codegen/regressions/kt613.jet b/compiler/testData/codegen/regressions/kt613.jet
new file mode 100644
index 00000000000..463b77aa909
--- /dev/null
+++ b/compiler/testData/codegen/regressions/kt613.jet
@@ -0,0 +1,15 @@
+namespace name
+
+class Test() {
+  var i = 5
+  val ten = 10.lng
+
+  fun Long.t() = this.int + i++ + ++i
+
+  fun tt() = ten.t()
+}
+
+fun box() : String {
+  var m = Test()
+  return if((m.i)++ == 5 && ++(m.i) == 7 && m.tt() == 26) "OK" else "fail"
+}
\ No newline at end of file
diff --git a/compiler/testData/psi/CallsInWhen.jet b/compiler/testData/psi/CallsInWhen.jet
index ad63479bd65..2675ba89523 100644
--- a/compiler/testData/psi/CallsInWhen.jet
+++ b/compiler/testData/psi/CallsInWhen.jet
@@ -1,13 +1,13 @@
 fun foo() {
   when (a) {
-    .foo => a
-    .foo() => a
-    .foo<T> => a
-    .foo<T>(a) => a
-    .foo<T>(a, d) => a
-    .{bar} => a
-    .{!bar} => a
-    .{() => !bar} => a
+    a.foo => a
+    a.foo() => a
+    a.foo<T> => a
+    a.foo<T>(a) => a
+    a.foo<T>(a, d) => a
+    a.{bar} => a
+    a.{!bar} => a
+    a.{() => !bar} => a
     else => a
   }
 }
diff --git a/compiler/testData/psi/CallsInWhen.txt b/compiler/testData/psi/CallsInWhen.txt
index dff80072a3d..c3992ac542b 100644
--- a/compiler/testData/psi/CallsInWhen.txt
+++ b/compiler/testData/psi/CallsInWhen.txt
@@ -22,10 +22,14 @@ JetFile: CallsInWhen.jet
           PsiElement(LBRACE)('{')
           PsiWhiteSpace('\n    ')
           WHEN_ENTRY
-            WHEN_CONDITION_CALL
-              PsiElement(DOT)('.')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('foo')
+            WHEN_CONDITION_IS_PATTERN
+              EXPRESSION_PATTERN
+                DOT_QUALIFIED_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(DOT)('.')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('foo')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -33,14 +37,18 @@ JetFile: CallsInWhen.jet
               PsiElement(IDENTIFIER)('a')
           PsiWhiteSpace('\n    ')
           WHEN_ENTRY
-            WHEN_CONDITION_CALL
-              PsiElement(DOT)('.')
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  PsiElement(RPAR)(')')
+            WHEN_CONDITION_IS_PATTERN
+              EXPRESSION_PATTERN
+                DOT_QUALIFIED_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(DOT)('.')
+                  CALL_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('foo')
+                    VALUE_ARGUMENT_LIST
+                      PsiElement(LPAR)('(')
+                      PsiElement(RPAR)(')')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -48,19 +56,53 @@ JetFile: CallsInWhen.jet
               PsiElement(IDENTIFIER)('a')
           PsiWhiteSpace('\n    ')
           WHEN_ENTRY
-            WHEN_CONDITION_CALL
-              PsiElement(DOT)('.')
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-                TYPE_ARGUMENT_LIST
-                  PsiElement(LT)('<')
-                  TYPE_PROJECTION
-                    TYPE_REFERENCE
-                      USER_TYPE
+            WHEN_CONDITION_IS_PATTERN
+              EXPRESSION_PATTERN
+                DOT_QUALIFIED_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(DOT)('.')
+                  CALL_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('foo')
+                    TYPE_ARGUMENT_LIST
+                      PsiElement(LT)('<')
+                      TYPE_PROJECTION
+                        TYPE_REFERENCE
+                          USER_TYPE
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('T')
+                      PsiElement(GT)('>')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
+          PsiWhiteSpace('\n    ')
+          WHEN_ENTRY
+            WHEN_CONDITION_IS_PATTERN
+              EXPRESSION_PATTERN
+                DOT_QUALIFIED_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(DOT)('.')
+                  CALL_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('foo')
+                    TYPE_ARGUMENT_LIST
+                      PsiElement(LT)('<')
+                      TYPE_PROJECTION
+                        TYPE_REFERENCE
+                          USER_TYPE
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('T')
+                      PsiElement(GT)('>')
+                    VALUE_ARGUMENT_LIST
+                      PsiElement(LPAR)('(')
+                      VALUE_ARGUMENT
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('T')
-                  PsiElement(GT)('>')
+                          PsiElement(IDENTIFIER)('a')
+                      PsiElement(RPAR)(')')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -68,56 +110,34 @@ JetFile: CallsInWhen.jet
               PsiElement(IDENTIFIER)('a')
           PsiWhiteSpace('\n    ')
           WHEN_ENTRY
-            WHEN_CONDITION_CALL
-              PsiElement(DOT)('.')
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-                TYPE_ARGUMENT_LIST
-                  PsiElement(LT)('<')
-                  TYPE_PROJECTION
-                    TYPE_REFERENCE
-                      USER_TYPE
+            WHEN_CONDITION_IS_PATTERN
+              EXPRESSION_PATTERN
+                DOT_QUALIFIED_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(DOT)('.')
+                  CALL_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('foo')
+                    TYPE_ARGUMENT_LIST
+                      PsiElement(LT)('<')
+                      TYPE_PROJECTION
+                        TYPE_REFERENCE
+                          USER_TYPE
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('T')
+                      PsiElement(GT)('>')
+                    VALUE_ARGUMENT_LIST
+                      PsiElement(LPAR)('(')
+                      VALUE_ARGUMENT
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('T')
-                  PsiElement(GT)('>')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_ARGUMENT
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('a')
-                  PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(DOUBLE_ARROW)('=>')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace('\n    ')
-          WHEN_ENTRY
-            WHEN_CONDITION_CALL
-              PsiElement(DOT)('.')
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-                TYPE_ARGUMENT_LIST
-                  PsiElement(LT)('<')
-                  TYPE_PROJECTION
-                    TYPE_REFERENCE
-                      USER_TYPE
+                          PsiElement(IDENTIFIER)('a')
+                      PsiElement(COMMA)(',')
+                      PsiWhiteSpace(' ')
+                      VALUE_ARGUMENT
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('T')
-                  PsiElement(GT)('>')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_ARGUMENT
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('a')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_ARGUMENT
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('d')
-                  PsiElement(RPAR)(')')
+                          PsiElement(IDENTIFIER)('d')
+                      PsiElement(RPAR)(')')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -125,15 +145,19 @@ JetFile: CallsInWhen.jet
               PsiElement(IDENTIFIER)('a')
           PsiWhiteSpace('\n    ')
           WHEN_ENTRY
-            WHEN_CONDITION_CALL
-              PsiElement(DOT)('.')
-              FUNCTION_LITERAL_EXPRESSION
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  BLOCK
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('bar')
-                  PsiElement(RBRACE)('}')
+            WHEN_CONDITION_IS_PATTERN
+              EXPRESSION_PATTERN
+                DOT_QUALIFIED_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(DOT)('.')
+                  FUNCTION_LITERAL_EXPRESSION
+                    FUNCTION_LITERAL
+                      PsiElement(LBRACE)('{')
+                      BLOCK
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('bar')
+                      PsiElement(RBRACE)('}')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -141,18 +165,22 @@ JetFile: CallsInWhen.jet
               PsiElement(IDENTIFIER)('a')
           PsiWhiteSpace('\n    ')
           WHEN_ENTRY
-            WHEN_CONDITION_CALL
-              PsiElement(DOT)('.')
-              FUNCTION_LITERAL_EXPRESSION
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  BLOCK
-                    PREFIX_EXPRESSION
-                      OPERATION_REFERENCE
-                        PsiElement(EXCL)('!')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('bar')
-                  PsiElement(RBRACE)('}')
+            WHEN_CONDITION_IS_PATTERN
+              EXPRESSION_PATTERN
+                DOT_QUALIFIED_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(DOT)('.')
+                  FUNCTION_LITERAL_EXPRESSION
+                    FUNCTION_LITERAL
+                      PsiElement(LBRACE)('{')
+                      BLOCK
+                        PREFIX_EXPRESSION
+                          OPERATION_REFERENCE
+                            PsiElement(EXCL)('!')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('bar')
+                      PsiElement(RBRACE)('}')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -160,24 +188,28 @@ JetFile: CallsInWhen.jet
               PsiElement(IDENTIFIER)('a')
           PsiWhiteSpace('\n    ')
           WHEN_ENTRY
-            WHEN_CONDITION_CALL
-              PsiElement(DOT)('.')
-              FUNCTION_LITERAL_EXPRESSION
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  VALUE_PARAMETER_LIST
-                    PsiElement(LPAR)('(')
-                    PsiElement(RPAR)(')')
-                  PsiWhiteSpace(' ')
-                  PsiElement(DOUBLE_ARROW)('=>')
-                  PsiWhiteSpace(' ')
-                  BLOCK
-                    PREFIX_EXPRESSION
-                      OPERATION_REFERENCE
-                        PsiElement(EXCL)('!')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('bar')
-                  PsiElement(RBRACE)('}')
+            WHEN_CONDITION_IS_PATTERN
+              EXPRESSION_PATTERN
+                DOT_QUALIFIED_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(DOT)('.')
+                  FUNCTION_LITERAL_EXPRESSION
+                    FUNCTION_LITERAL
+                      PsiElement(LBRACE)('{')
+                      VALUE_PARAMETER_LIST
+                        PsiElement(LPAR)('(')
+                        PsiElement(RPAR)(')')
+                      PsiWhiteSpace(' ')
+                      PsiElement(DOUBLE_ARROW)('=>')
+                      PsiWhiteSpace(' ')
+                      BLOCK
+                        PREFIX_EXPRESSION
+                          OPERATION_REFERENCE
+                            PsiElement(EXCL)('!')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('bar')
+                      PsiElement(RBRACE)('}')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
diff --git a/compiler/testData/psi/When_ERR.txt b/compiler/testData/psi/When_ERR.txt
index dba08d47c7f..64b931828e9 100644
--- a/compiler/testData/psi/When_ERR.txt
+++ b/compiler/testData/psi/When_ERR.txt
@@ -82,7 +82,7 @@ JetFile: When_ERR.jet
           WHEN_ENTRY
             WHEN_CONDITION_IS_PATTERN
               EXPRESSION_PATTERN
-                PsiErrorElement:Expecting an element, is-condition or in-condition
+                PsiErrorElement:Expecting an expression, is-condition or in-condition
                   <empty list>
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -164,7 +164,7 @@ JetFile: When_ERR.jet
           WHEN_ENTRY
             WHEN_CONDITION_IS_PATTERN
               EXPRESSION_PATTERN
-                PsiErrorElement:Expecting an element, is-condition or in-condition
+                PsiErrorElement:Expecting an expression, is-condition or in-condition
                   <empty list>
             PsiElement(DOUBLE_ARROW)('=>')
             PsiErrorElement:Expecting an element
diff --git a/compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java b/compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java
deleted file mode 100644
index b16946132bf..00000000000
--- a/compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java
+++ /dev/null
@@ -1,119 +0,0 @@
-package org.jetbrains.jet.checkers;
-
-import com.google.common.collect.Lists;
-import com.intellij.openapi.util.TextRange;
-import junit.framework.Test;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetLiteFixture;
-import org.jetbrains.jet.JetTestCaseBuilder;
-import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.ImportingStrategy;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade;
-import org.jetbrains.jet.lang.resolve.java.JavaDefaultImports;
-
-import java.util.List;
-
-/**
- * @author abreslav
- */
-public class FullJetPsiCheckerTest extends JetLiteFixture {
-    private final String myDataPath;
-    private String myName;
-
-    public FullJetPsiCheckerTest(@NonNls String dataPath, String name) {
-        myDataPath = dataPath;
-        myName = name;
-    }
-
-    @Override
-    public String getName() {
-        return "test" + myName;
-    }
-
-    @Override
-    public void runTest() throws Exception {
-        String fileName = myName + ".jet";
-        String fullPath = myDataPath + "/" + fileName;
-
-
-        String expectedText = loadFile(fullPath);
-
-        List<CheckerTestUtil.DiagnosedRange> diagnosedRanges = Lists.newArrayList();
-        String clearText = CheckerTestUtil.parseDiagnosedRanges(expectedText, diagnosedRanges);
-
-        myFile = createPsiFile(myName, clearText);
-
-        boolean importJdk = !expectedText.contains("-JDK");
-        ImportingStrategy importingStrategy = importJdk ? JavaDefaultImports.JAVA_DEFAULT_IMPORTS : ImportingStrategy.NONE;
-
-        BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(AnalyzingUtils.getInstance(importingStrategy), myFile, AnalyzerFacade.SINGLE_DECLARATION_PROVIDER);
-
-        CheckerTestUtil.diagnosticsDiff(diagnosedRanges, bindingContext.getDiagnostics(), new CheckerTestUtil.DiagnosticDiffCallbacks() {
-            @Override
-            public void missingDiagnostic(String type, int expectedStart, int expectedEnd) {
-                String message = "Missing " + type + DiagnosticUtils.atLocation(myFile, new TextRange(expectedStart, expectedEnd));
-                System.err.println(message);
-            }
-
-            @Override
-            public void unexpectedDiagnostic(String type, int actualStart, int actualEnd) {
-                String message = "Unexpected " + type + DiagnosticUtils.atLocation(myFile, new TextRange(actualStart, actualEnd));
-                System.err.println(message);
-            }
-        });
-
-        String actualText = CheckerTestUtil.addDiagnosticMarkersToText(myFile, bindingContext).toString();
-
-        assertEquals(expectedText, actualText);
-
-//        String myFullDataPath = getTestDataPath() + getDataPath();
-//        System.out.println("myFullDataPath = " + myFullDataPath);
-//        convert(new File(myFullDataPath + "/../../checker/"), new File(myFullDataPath));
-    }
-
-/*
-    private void convert(File src, File dest) throws IOException {
-        File[] files = src.listFiles();
-        for (File file : files) {
-            try {
-                if (file.isDirectory()) {
-                    File destDir = new File(dest, file.getName());
-                    destDir.mkdir();
-                    convert(file, destDir);
-                    continue;
-                }
-                if (!file.getName().endsWith(".jet")) continue;
-                String text = loadFile(file.getAbsolutePath());
-                Pattern pattern = Pattern.compile("</?(error|warning|info( descr=\"[\\w ]+\")?)>");
-                String clearText = pattern.matcher(text).replaceAll("");
-
-                configureFromFileText(file.getName(), clearText);
-
-                BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache((JetFile) myFile);
-                String expectedText = CheckerTestUtil.addDiagnosticMarkersToText(myFile, bindingContext).toString();
-
-                File destFile = new File(dest, file.getName());
-                FileWriter fileWriter = new FileWriter(destFile);
-                fileWriter.write(expectedText);
-                fileWriter.close();
-            }
-            catch (RuntimeException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-*/
-
-    public static Test suite() {
-        return JetTestCaseBuilder.suiteForDirectory(JetTestCaseBuilder.getTestDataPathBase(), "/checkerWithErrorTypes/full/", true, new JetTestCaseBuilder.NamedTestFactory() {
-            @NotNull
-            @Override
-            public Test createTest(@NotNull String dataPath, @NotNull String name) {
-                return new FullJetPsiCheckerTest(dataPath, name);
-            }
-        });
-    }
-}
diff --git a/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java
index 80063a36516..f5e8faf941a 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java
@@ -9,7 +9,7 @@ public class ArrayGenTest extends CodegenTestCase {
 
     public void testKt326 () throws Exception {
         blackBoxFile("regressions/kt326.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testCreateMultiInt () throws Exception {
@@ -39,7 +39,7 @@ public class ArrayGenTest extends CodegenTestCase {
 
     public void testCreateMultiGenerics () throws Exception {
         loadText("class L<T>() { val a = Array<T?>(5) } fun foo() = L<Int>.a");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         Object invoke = foo.invoke(null);
         System.out.println(invoke.getClass());
@@ -48,7 +48,7 @@ public class ArrayGenTest extends CodegenTestCase {
 
     public void testIntGenerics () throws Exception {
         loadText("class L<T>(var a : T) {} fun foo() = L<Int>(5).a");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         Object invoke = foo.invoke(null);
         System.out.println(invoke.getClass());
@@ -57,147 +57,147 @@ public class ArrayGenTest extends CodegenTestCase {
 
     public void testIterator () throws Exception {
         loadText("fun box() { val x = Array<Int>(5, { it } ).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testPrimitiveIterator () throws Exception {
         loadText("fun box() { val x = ByteArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.nextByte()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testPrimitiveIteratorByte () throws Exception {
         loadText("fun box() { for(x in ByteArray(5)) { java.lang.System.out?.println(x) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testPrimitiveIteratorShort () throws Exception {
         loadText("fun box() { for(x in ShortArray(5)) { java.lang.System.out?.println(x) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testPrimitiveIteratorInt () throws Exception {
         loadText("fun box() { for(x in IntArray(5)) { java.lang.System.out?.println(x) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testPrimitiveIteratorLong () throws Exception {
         loadText("fun box() { for(x in LongArray(5)) { java.lang.System.out?.println(x) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testPrimitiveIteratorFloat () throws Exception {
         loadText("fun box() { for(x in FloatArray(5)) { java.lang.System.out?.println(x) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testPrimitiveIteratorDouble () throws Exception {
         loadText("fun box() { for(x in DoubleArray(5)) { java.lang.System.out?.println(x) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testPrimitiveIteratorChar () throws Exception {
         loadText("fun box() { for(x in CharArray(5)) { java.lang.System.out?.println(x) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testPrimitiveIteratorBoolean () throws Exception {
         loadText("fun box() { for(x in BooleanArray(5)) { java.lang.System.out?.println(x) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testLongIterator () throws Exception {
         loadText("fun box() { val x = LongArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.nextLong()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testCharIterator () throws Exception {
         loadText("fun box() { val x = CharArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testByteIterator () throws Exception {
         loadText("fun box() { val x = ByteArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testShortIterator () throws Exception {
         loadText("fun box() { val x = ShortArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testIntIterator () throws Exception {
         loadText("fun box() { val x = IntArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testLongIterator2 () throws Exception {
         loadText("fun box() { val x = LongArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testFloatIterator () throws Exception {
         loadText("fun box() { val x = FloatArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testDoubleIterator () throws Exception {
         loadText("fun box() { val x = ShortArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testBooleanIterator () throws Exception {
         loadText("fun box() { val x = BooleanArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testArrayIndices () throws Exception {
         loadText("fun box() { val x = Array<Int>(5, {it}).indices.iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
 
     public void testCharIndices () throws Exception {
         loadText("fun box() { val x = CharArray(5).indices.iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         foo.invoke(null);
     }
@@ -208,7 +208,7 @@ public class ArrayGenTest extends CodegenTestCase {
 
     public void testArrayPlusAssign () throws Exception {
         loadText("fun box() : Int { val s = IntArray(1); s [0] = 5; s[0] += 7; return s[0] }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         assertTrue((Integer)foo.invoke(null) == 12);
     }
@@ -218,7 +218,7 @@ public class ArrayGenTest extends CodegenTestCase {
                          "fun box() : String { val s = ArrayList<String>(1); s.add(\"\"); s [1, -1] = \"5\"; s[2, -2] += \"7\"; return s[2,-2] }\n" +
                          "fun ArrayList<String>.get(index1: Int, index2 : Int) = this[index1+index2]\n" +
                          "fun ArrayList<String>.set(index1: Int, index2 : Int, elem: String) { this[index1+index2] = elem }\n");
-            System.out.println(generateToText());
+//            System.out.println(generateToText());
             Method foo = generateFunction("box");
         assertTrue(foo.invoke(null).equals("57"));
         }
@@ -228,7 +228,7 @@ public class ArrayGenTest extends CodegenTestCase {
                      "fun box() : String? { val s = Array<String>(1,{ \"\" }); s [1, -1] = \"5\"; s[2, -2] += \"7\"; return s[-3,3] }\n" +
                      "fun Array<String>.get(index1: Int, index2 : Int) = this[index1+index2]\n" +
                      "fun Array<String>.set(index1: Int, index2 : Int, elem: String) { this[index1+index2] = elem\n }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction("box");
         assertTrue(foo.invoke(null).equals("57"));
     }
@@ -238,7 +238,7 @@ public class ArrayGenTest extends CodegenTestCase {
                          "fun box() : String { val s = ArrayList<String>(1); s.add(\"\"); s [1, -1] = \"5\"; return s[2, -2] }\n" +
                          "fun ArrayList<String>.get(index1: Int, index2 : Int) = this[index1+index2]\n" +
                          "fun ArrayList<String>.set(index1: Int, index2 : Int, elem: String) { this[index1+index2] = elem }\n");
-            System.out.println(generateToText());
+//            System.out.println(generateToText());
             Method foo = generateFunction("box");
             assertTrue(foo.invoke(null).equals("5"));
         }
@@ -248,7 +248,7 @@ public class ArrayGenTest extends CodegenTestCase {
                      "fun box() : String? { val s = Array<String>(1,{ \"\" }); s [1, -1] = \"5\"; return s[-2, 2] }\n" +
                      "fun Array<String>.get(index1: Int, index2 : Int) = this[index1+index2]\n" +
                      "fun Array<String>.set(index1: Int, index2 : Int, elem: String) { this[index1+index2] = elem\n }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction("box");
         assertTrue(foo.invoke(null).equals("5"));
     }
@@ -257,7 +257,7 @@ public class ArrayGenTest extends CodegenTestCase {
         loadText(
                      "fun box() : Int? { val s = java.util.HashMap<String,Int?>(); s[\"239\"] = 239; return s[\"239\"] }\n" +
                      "fun java.util.HashMap<String,Int?>.set(index: String, elem: Int?) { this.put(index, elem) }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction("box");
         assertTrue((Integer)foo.invoke(null) == 239);
     }
@@ -267,7 +267,7 @@ public class ArrayGenTest extends CodegenTestCase {
                      "fun box() : Int { var l = IntArray(1); l[0.lng] = 4; l[0.lng] += 6; return l[0.lng];}\n" +
                      "fun IntArray.set(index: Long, elem: Int) { this[index.int] = elem }\n" +
                      "fun IntArray.get(index: Long) = this[index.int]");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction("box");
         assertTrue((Integer)foo.invoke(null) == 10);
     }
@@ -276,9 +276,14 @@ public class ArrayGenTest extends CodegenTestCase {
         blackBoxFile("regressions/kt503.jet");
     }
 
+    public void testKt602() {
+        blackBoxFile("regressions/kt602.jet");
+//        System.out.println(generateToText());
+    }
+
     public void testKt594() throws Exception {
         loadFile("regressions/kt594.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         blackBox();
     }
 }
diff --git a/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java
index 6b44f7b8d94..1f300ca6406 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java
@@ -49,7 +49,7 @@ public class ClassGenTest extends CodegenTestCase {
 
     public void testNewInstanceExplicitConstructor() throws Exception {
         loadFile("classes/newInstanceDefaultConstructor.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method method = generateFunction("test");
         final Integer returnValue = (Integer) method.invoke(null);
         assertEquals(610, returnValue.intValue());
@@ -149,7 +149,7 @@ public class ClassGenTest extends CodegenTestCase {
     public void testEnumClass() throws Exception {
         loadText("enum class Direction { NORTH; SOUTH; EAST; WEST }");
         final Class direction = loadAllClasses(generateClassesInFile()).get("Direction");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Field north = direction.getField("NORTH");
         assertEquals(direction, north.getType());
         assertInstanceOf(north.get(null), direction);
@@ -170,36 +170,36 @@ public class ClassGenTest extends CodegenTestCase {
 
     public void testKt48 () throws Exception {
         blackBoxFile("regressions/kt48.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testKt309 () throws Exception {
         loadText("fun box() = null");
         final Method method = generateFunction("box");
         assertEquals(method.getReturnType().getName(), "java.lang.Object");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testKt343 () throws Exception {
         blackBoxFile("regressions/kt343.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testKt344 () throws Exception {
         loadFile("regressions/kt344.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         blackBox();
     }
 
     public void testKt508 () throws Exception {
         loadFile("regressions/kt508.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         blackBox();
     }
 
     public void testKt504 () throws Exception {
         loadFile("regressions/kt504.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         blackBox();
     }
 
@@ -209,7 +209,7 @@ public class ClassGenTest extends CodegenTestCase {
 
     public void testKt496 () throws Exception {
         blackBoxFile("regressions/kt496.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testKt500 () throws Exception {
diff --git a/compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java
index 07b094c344d..9533317fbb2 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java
@@ -6,7 +6,7 @@ package org.jetbrains.jet.codegen;
 public class ClosuresGenTest extends CodegenTestCase {
     public void testSimplestClosure() throws Exception {
         blackBoxFile("classes/simplestClosure.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testSimplestClosureAndBoxing() throws Exception {
@@ -27,7 +27,7 @@ public class ClosuresGenTest extends CodegenTestCase {
 
     public void testEnclosingLocalVariable() throws Exception {
         blackBoxFile("classes/enclosingLocalVariable.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testDoubleEnclosedLocalVariable() throws Exception {
diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
index 8c584e9cc26..485a97b80d2 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
@@ -7,10 +7,12 @@ 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.parsing.JetParsingTest;
+import org.junit.Assert;
 
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -157,7 +159,21 @@ public abstract class CodegenTestCase extends JetLiteFixture {
     protected Method generateFunction() {
         Class aClass = generateNamespaceClass();
         try {
-            return aClass.getMethods()[0];
+            Method r = null;
+            for (Method method : aClass.getMethods()) {
+                if (method.getDeclaringClass().equals(Object.class)) {
+                    continue;
+                }
+
+                if (r != null) {
+                    throw new AssertionError("more then one public method in class " + aClass);
+                }
+
+                r = method;
+            }
+            if (r == null)
+                throw new AssertionError();
+            return r;
         } catch (Error e) {
             System.out.println(generateToText());
             throw e;
diff --git a/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java b/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java
index 11914b419ac..0c1d8f4aa41 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java
@@ -17,7 +17,7 @@ public class ControlStructuresTest extends CodegenTestCase {
     public void testIf() throws Exception {
         loadFile();
 
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(15, main.invoke(null, true));
         assertEquals(20, main.invoke(null, false));
@@ -26,7 +26,7 @@ public class ControlStructuresTest extends CodegenTestCase {
     public void testSingleBranchIf() throws Exception {
         loadFile();
 
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(15, main.invoke(null, true));
         assertEquals(20, main.invoke(null, false));
@@ -47,7 +47,7 @@ public class ControlStructuresTest extends CodegenTestCase {
     private void factorialTest(final String name) throws IllegalAccessException, InvocationTargetException {
         loadFile(name);
 
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(6, main.invoke(null, 3));
         assertEquals(120, main.invoke(null, 5));
@@ -55,7 +55,7 @@ public class ControlStructuresTest extends CodegenTestCase {
 
     public void testContinue() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(3, main.invoke(null, 4));
         assertEquals(7, main.invoke(null, 5));
@@ -63,7 +63,7 @@ public class ControlStructuresTest extends CodegenTestCase {
 
     public void testIfNoElse() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(5, main.invoke(null, 5, true));
         assertEquals(10, main.invoke(null, 5, false));
@@ -78,7 +78,7 @@ public class ControlStructuresTest extends CodegenTestCase {
 
     public void testFor() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         List<String> args = Arrays.asList("IntelliJ", " ", "IDEA");
         assertEquals("IntelliJ IDEA", main.invoke(null, args));
@@ -86,7 +86,7 @@ public class ControlStructuresTest extends CodegenTestCase {
 
     public void testIfBlock() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         List<String> args = Arrays.asList("IntelliJ", " ", "IDEA");
         assertEquals("TTT", main.invoke(null, args));
@@ -96,7 +96,7 @@ public class ControlStructuresTest extends CodegenTestCase {
 
     public void testForInArray() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         String[] args = new String[] { "IntelliJ", " ", "IDEA" };
         assertEquals("IntelliJ IDEA", main.invoke(null, new Object[] { args }));
@@ -126,7 +126,7 @@ public class ControlStructuresTest extends CodegenTestCase {
 
     public void testTryCatch() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals("no message", main.invoke(null, "0"));
         assertEquals("For input string: \"a\"", main.invoke(null, "a"));
@@ -134,7 +134,7 @@ public class ControlStructuresTest extends CodegenTestCase {
 
     public void testTryFinally() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         StringBuilder sb = new StringBuilder();
         main.invoke(null, sb, "9");
@@ -187,8 +187,7 @@ public class ControlStructuresTest extends CodegenTestCase {
 
     public void testCompareToNonnullableEq() throws Exception {
         loadText("fun foo(a: String?, b: String): Boolean = a == b || b == a");
-        String text = generateToText();
-        System.out.println(text);
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(false, main.invoke(null, null, "lala"));
         assertEquals(true, main.invoke(null, "papa", "papa"));
@@ -197,7 +196,7 @@ public class ControlStructuresTest extends CodegenTestCase {
     public void testCompareToNonnullableNotEq() throws Exception {
         loadText("fun foo(a: String?, b: String): Boolean = a != b");
         String text = generateToText();
-        System.out.println(text);
+//        System.out.println(text);
         assertTrue(text.contains("IXOR"));
         final Method main = generateFunction();
         assertEquals(true, main.invoke(null, null, "lala"));
@@ -210,7 +209,7 @@ public class ControlStructuresTest extends CodegenTestCase {
 
     public void testKt416() throws Exception {
         blackBoxFile("regressions/kt416.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testKt513() throws Exception {
diff --git a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java
index ceacbc22fe6..8ab99d48757 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java
@@ -9,17 +9,17 @@ import java.lang.reflect.Method;
 public class FunctionGenTest extends CodegenTestCase {
     public void testDefaultArgs() throws Exception {
         blackBoxFile("functions/defaultargs.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testNoThisNoClosure() throws Exception {
         blackBoxFile("functions/nothisnoclosure.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testAnyToString () throws InvocationTargetException, IllegalAccessException {
         loadText("fun foo(x: Any) = x.toString()");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         assertEquals("something", foo.invoke(null, "something"));
         assertEquals("null", foo.invoke(null, new Object[]{null}));
@@ -28,7 +28,7 @@ public class FunctionGenTest extends CodegenTestCase {
 
     public void testNullableAnyToString () throws InvocationTargetException, IllegalAccessException {
         loadText("fun foo(x: Any?) = x.toString()");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         assertEquals("something", foo.invoke(null, "something"));
         assertEquals("null", foo.invoke(null, new Object[]{null}));
@@ -63,7 +63,7 @@ public class FunctionGenTest extends CodegenTestCase {
 
     public void testAnyEqualsNullable () throws InvocationTargetException, IllegalAccessException {
         loadText("fun foo(x: Any?) = x.equals(\"lala\")");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         assertTrue((Boolean) foo.invoke(null, "lala"));
         assertFalse((Boolean) foo.invoke(null, "mama"));
@@ -71,7 +71,7 @@ public class FunctionGenTest extends CodegenTestCase {
 
     public void testAnyEquals () throws InvocationTargetException, IllegalAccessException {
         loadText("fun foo(x: Any) = x.equals(\"lala\")");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         assertTrue((Boolean) foo.invoke(null, "lala"));
         assertFalse((Boolean) foo.invoke(null, "mama"));
diff --git a/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java
index 9c88cfaec3e..295781b1837 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java
@@ -17,8 +17,7 @@ import java.util.Arrays;
 public class NamespaceGenTest extends CodegenTestCase {
     public void testPSVM() throws Exception {
         loadFile("PSVM.jet");
-        final String text = generateToText();
-        System.out.println(text);
+//        System.out.println(generateToText());
 
         final Method main = generateFunction();
         Object[] args = new Object[] { new String[0] };
@@ -27,8 +26,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testReturnOne() throws Exception {
         loadText("fun f() : Int { return 42; }");
-        final String text = generateToText();
-        System.out.println(text);
+//        System.out.println(generateToText());
 
         final Method main = generateFunction();
         final Object returnValue = main.invoke(null, new Object[0]);
@@ -37,8 +35,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testReturnA() throws Exception {
         loadText("fun foo(a : Int) = a");
-        final String text = generateToText();
-        System.out.println(text);
+//        System.out.println(generateToText());
 
         final Method main = generateFunction();
         final Object returnValue = main.invoke(null, 50);
@@ -47,8 +44,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testLocalProperty() throws Exception {
         loadFile("localProperty.jet");
-        final String text = generateToText();
-        System.out.println(text);
+//        System.out.println(generateToText());
 
         final Method main = generateFunction();
         final Object returnValue = main.invoke(null, 76);
@@ -57,7 +53,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testCurrentTime() throws Exception {
         loadText("fun f() : Long { return System.currentTimeMillis(); }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         final long returnValue = (Long) main.invoke(null);
         assertIsCurrentTime(returnValue);
@@ -65,7 +61,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testIdentityHashCode() throws Exception {
         loadText("fun f(o: Any) : Int { return System.identityHashCode(o); }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         Object o = new Object();
         final int returnValue = (Integer) main.invoke(null, o);
@@ -82,7 +78,7 @@ public class NamespaceGenTest extends CodegenTestCase {
     public void testHelloWorld() throws Exception {
         loadFile("helloWorld.jet");
 
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
 
         generateFunction();  // assert that it can be verified
     }
@@ -90,7 +86,7 @@ public class NamespaceGenTest extends CodegenTestCase {
     public void testAssign() throws Exception {
         loadFile("assign.jet");
 
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(2, main.invoke(null));
     }
@@ -116,7 +112,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testBoxVariable() throws Exception {
         loadText("fun foo(): Int? { var x = 239; return x; }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(239, main.invoke(null));
     }
@@ -173,14 +169,14 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testBottles2() throws Exception {
         loadFile("bottles2.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         main.invoke(null);  // ensure no exception
     }
 
     public void testJavaConstructor() throws Exception {
         loadText("fun foo(): StringBuilder = StringBuilder()");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         final Object result = main.invoke(null);
         assertTrue(result instanceof StringBuilder);
@@ -195,7 +191,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testJavaEquals() throws Exception {
         loadText("fun foo(s1: String, s2: String) = s1 == s2");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(Boolean.TRUE, main.invoke(null, new String("jet"), new String("jet")));
         assertEquals(Boolean.FALSE, main.invoke(null, new String("jet"), new String("ceylon")));
@@ -211,7 +207,7 @@ public class NamespaceGenTest extends CodegenTestCase {
     public void testJavaEqualsNull() throws Exception {
         loadText("fun foo(s1: String?, s2: String?) = s1 == s2");
         final Method main = generateFunction();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         assertEquals(Boolean.TRUE, main.invoke(null, null, null));
         assertEquals(Boolean.FALSE, main.invoke(null, "jet", null));
         assertEquals(Boolean.FALSE, main.invoke(null, null, "jet"));
@@ -220,7 +216,7 @@ public class NamespaceGenTest extends CodegenTestCase {
     public void testEqualsNullLiteral() throws Exception {
         loadText("fun foo(s: String?) = s == null");
         final Method main = generateFunction();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         assertEquals(Boolean.TRUE, main.invoke(null, new Object[] { null }));
         assertEquals(Boolean.FALSE, main.invoke(null, "jet"));
     }
@@ -245,7 +241,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testFunctionCall() throws Exception {
         loadFile("functionCall.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction("f");
         assertEquals("foo", main.invoke(null));
     }
@@ -267,14 +263,14 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testStringPlusEq() throws Exception {
         loadText("fun foo(s: String) : String { var result = s; result += s; return result; } ");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals("JarJar", main.invoke(null, "Jar"));
     }
 
     public void testStringCompare() throws Exception {
         loadText("fun foo(s1: String, s2: String) = s1 < s2");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(Boolean.TRUE, main.invoke(null, "Ceylon", "Java"));
         assertEquals(Boolean.FALSE, main.invoke(null, "Jet", "Java"));
@@ -302,7 +298,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testFieldRead() throws Exception {
         loadText("import java.awt.*; fun foo(c: GridBagConstraints) = c.gridx");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         GridBagConstraints c = new GridBagConstraints();
         c.gridx = 239;
@@ -319,7 +315,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testFieldIncrement() throws Exception {
         loadText("import java.awt.*; fun foo(c: GridBagConstraints) { c.gridx++; return; }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         GridBagConstraints c = new GridBagConstraints();
         c.gridx = 609;
@@ -329,7 +325,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testFieldAugAssign() throws Exception {
         loadText("import java.awt.*; fun foo(c: GridBagConstraints) { c.gridx *= 2; return; }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         GridBagConstraints c = new GridBagConstraints();
         c.gridx = 305;
@@ -358,7 +354,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testArrayAugAssign() throws Exception {
         loadText("fun foo(c: Array<Int>) { c[0] *= 2 }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         Integer[] data = new Integer[] { 5 };
         main.invoke(null, new Object[] { data });
@@ -367,7 +363,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testArrayAugAssignLong() throws Exception {
         loadText("fun foo(c: LongArray) { c[0] *= 2.lng }");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         long[] data = new long[] { 5 };
         main.invoke(null, new Object[] { data });
@@ -376,7 +372,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testArrayNew() throws Exception {
         loadText("fun foo() = Array<Int>(4, { it })");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         Integer[] result = (Integer[]) main.invoke(null);
         assertEquals(4, result.length);
@@ -388,14 +384,14 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testArrayNewNullable() throws Exception {
         loadText("fun foo() = Array<Int?>(4)");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         Integer[] result = (Integer[]) main.invoke(null);
         assertEquals(4, result.length);
     }
     public void testFloatArrayNew() throws Exception {
         loadText("fun foo() = FloatArray(4)");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         float[] result = (float[]) main.invoke(null);
         assertEquals(4, result.length);
@@ -403,7 +399,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testFloatArrayArrayNew() throws Exception {
         loadText("fun foo() = Array<FloatArray>(4, { FloatArray(5-it) })");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         float[][] result = (float[][]) main.invoke(null);
         assertEquals(4, result.length);
@@ -412,7 +408,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testArraySize() throws Exception {
         loadText("fun foo(a: Array<Int>) = a.size");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         Object[] args = new Object[] { new Integer[4] };
         int result = (Integer) main.invoke(null, args);
@@ -422,7 +418,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testIntArraySize() throws Exception {
         loadText("fun foo(a: IntArray) = a.size");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         Object[] args = new Object[] { new int[4] };
         int result = (Integer) main.invoke(null, args);
@@ -490,8 +486,8 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testTupleLiteral() throws Exception {
         loadText("fun foo() = (1, \"foo\")");
-        System.out.println(generateToText());
-        final Method main = generateFunction();
+//        System.out.println(generateToText());
+        final Method main = generateFunction("foo");
         Tuple2 tuple2 = (Tuple2) main.invoke(null);
         assertEquals(1, tuple2._1);
         assertEquals("foo", tuple2._2);
@@ -499,7 +495,7 @@ public class NamespaceGenTest extends CodegenTestCase {
 
     public void testParametrizedTupleLiteral() throws Exception {
         loadText("fun <E,D> E.foo(extra: java.util.List<D>) = (1, \"foo\", this, extra)");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         Tuple4 tuple4 = (Tuple4) main.invoke(null, "aaa", TypeInfo.STRING_TYPE_INFO, TypeInfo.INT_TYPE_INFO, Arrays.asList(10));
         assertEquals(1, tuple4._1);
@@ -515,7 +511,7 @@ public class NamespaceGenTest extends CodegenTestCase {
         assertNull(main.invoke(null, "IntelliJ"));
         }
         catch (Throwable t) {
-            System.out.println(generateToText());
+//            System.out.println(generateToText());
             t.printStackTrace();
         }
     }
diff --git a/compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java
index 53b76ccf788..05c5a66ca93 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java
@@ -11,7 +11,7 @@ public class ObjectGenTest extends CodegenTestCase {
 
     public void testObjectLiteral() throws Exception {
         blackBoxFile("objects/objectLiteral.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testMethodOnObject() throws Exception {
diff --git a/compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java b/compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java
index 667415f53f3..a3fd95c3ab3 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java
@@ -37,7 +37,7 @@ public class PatternMatchingTest extends CodegenTestCase {
 
     public void testInrange() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         assertEquals("array list", foo.invoke(null, 239));
         assertEquals("digit", foo.invoke(null, 0));
@@ -49,13 +49,13 @@ public class PatternMatchingTest extends CodegenTestCase {
 
     public void testIs() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         blackBox();
     }
 
     public void testRange() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         assertEquals("array list", foo.invoke(null, 239));
         assertEquals("digit", foo.invoke(null, 0));
@@ -67,7 +67,7 @@ public class PatternMatchingTest extends CodegenTestCase {
 
     public void testRangeChar() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         assertEquals("digit", foo.invoke(null, '0'));
         assertEquals("something", foo.invoke(null, 'A'));
@@ -99,18 +99,19 @@ public class PatternMatchingTest extends CodegenTestCase {
         assertEquals("something", foo.invoke(null, new Tuple2<String, String>(null, "not", "tuple")));
     }
 
-    public void testCall() throws Exception {
-        loadText("fun foo(s: String) = when(s) { .startsWith(\"J\") => \"JetBrains\"; else => \"something\" }");
-        Method foo = generateFunction();
-        try {
-            assertEquals("JetBrains", foo.invoke(null, "Java"));
-            assertEquals("something", foo.invoke(null, "C#"));
-        }
-        catch (Throwable t) {
-            System.out.println(generateToText());
-            t.printStackTrace();
-        }
-    }
+    // Commented for KT-621
+//    public void testCall() throws Exception {
+//        loadText("fun foo(s: String) = when(s) { .startsWith(\"J\") => \"JetBrains\"; else => \"something\" }");
+//        Method foo = generateFunction();
+//        try {
+//            assertEquals("JetBrains", foo.invoke(null, "Java"));
+//            assertEquals("something", foo.invoke(null, "C#"));
+//        }
+//        catch (Throwable t) {
+//            System.out.println(generateToText());
+//            t.printStackTrace();
+//        }
+//    }
 
     public void testCallProperty() throws Exception {
         blackBoxFile("patternMatching/callProperty.jet");
diff --git a/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java b/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
index 0a7b11175ea..e98e1b17a8b 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
@@ -10,7 +10,7 @@ public class PrimitiveTypesTest extends CodegenTestCase {
     public void testPlus() throws Exception {
         loadText("fun f(a: Int, b: Int): Int { return a + b }");
 
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
 
         final Method main = generateFunction();
         final int returnValue = (Integer) main.invoke(null, 37, 5);
@@ -20,7 +20,7 @@ public class PrimitiveTypesTest extends CodegenTestCase {
     public void testGt() throws Exception {
         loadText("fun foo(f: Int): Boolean { if (f > 0) return true; return false; }");
 
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(true, main.invoke(null, 1));
         assertEquals(false, main.invoke(null, 0));
@@ -57,7 +57,7 @@ public class PrimitiveTypesTest extends CodegenTestCase {
 
     public void testLong() throws Exception {
         loadText("fun foo(a: Long, b: Long): Long = a + b");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         long arg = (long) Integer.MAX_VALUE;
         long expected = 2 * (long) Integer.MAX_VALUE;
@@ -66,7 +66,7 @@ public class PrimitiveTypesTest extends CodegenTestCase {
 
     public void testLongCmp() throws Exception {
         loadText("fun foo(a: Long, b: Long): Long = if (a == b) 0xffffffff else 0xfffffffe");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(0xffffffffL, main.invoke(null, 1, 1));
         assertEquals(0xfffffffeL, main.invoke(null, 1, 0));
@@ -132,7 +132,7 @@ public class PrimitiveTypesTest extends CodegenTestCase {
 
     public void testDoubleToInt() throws Exception {
         loadText("fun foo(a: Double): Int = a.int");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(1, main.invoke(null, 1.0));
     }
@@ -216,7 +216,7 @@ public class PrimitiveTypesTest extends CodegenTestCase {
 
     public void testBitInv() throws Exception {
         loadText("fun foo(a: Int): Int = a.inv()");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(0xffff0000, main.invoke(null, 0x0000ffff));
     }
@@ -249,14 +249,14 @@ public class PrimitiveTypesTest extends CodegenTestCase {
 
     public void testDecrementAsStatement() throws Exception {
         loadFile("bottles.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         main.invoke(null);  // ensure no exception
     }
 
     private void binOpTest(final String text, final Object arg1, final Object arg2, final Object expected) throws Exception {
         loadText(text);
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         assertEquals(expected, main.invoke(null, arg1, arg2));
     }
diff --git a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
index 096bd9e1c03..943064ca3bb 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
@@ -64,7 +64,7 @@ public class PropertyGenTest extends CodegenTestCase {
 
     public void testFieldPropertyAccess() throws Exception {
         loadFile("properties/fieldPropertyAccess.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method method = generateFunction();
         assertEquals(1, method.invoke(null));
         assertEquals(2, method.invoke(null));
@@ -136,6 +136,10 @@ public class PropertyGenTest extends CodegenTestCase {
         blackBoxFile("regressions/kt257.jet");
     }
 
+    public void testKt613 () throws Exception {
+        blackBoxFile("regressions/kt613.jet");
+    }
+
     public void testKt160() throws Exception {
         loadText("internal val s = java.lang.Double.toString(1.0)");
         final Method method = generateFunction("getS");
diff --git a/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java b/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java
index fdfbbecfa5b..7337274caac 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java
@@ -71,7 +71,7 @@ public class StdlibTest extends CodegenTestCase {
 
     public void testInputStreamIterator () {
         blackBoxFile("inputStreamIterator.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testKt533 () {
diff --git a/compiler/tests/org/jetbrains/jet/codegen/SuperGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/SuperGenTest.java
index 86bbd2b935e..0b276174692 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/SuperGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/SuperGenTest.java
@@ -3,21 +3,21 @@ package org.jetbrains.jet.codegen;
 public class SuperGenTest extends CodegenTestCase {
     public void testBasicProperty () {
         blackBoxFile("/super/basicproperty.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testTraitProperty () {
         blackBoxFile("/super/traitproperty.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testBasicMethod () {
         blackBoxFile("/super/basicmethod.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testEnclosedMethod () {
         blackBoxFile("/super/enclosed.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 }
diff --git a/compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java b/compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java
index b805c7d2147..4fd7093c08e 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java
@@ -8,12 +8,12 @@ public class TraitsTest  extends CodegenTestCase {
 
     public void testSimple () throws Exception {
         blackBoxFile("traits/simple.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testWithRequired () throws Exception {
         blackBoxFile("traits/withRequired.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testMultiple () throws Exception {
diff --git a/compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java b/compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java
index 2abfd9db28e..1ce4e56d3c8 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java
@@ -65,7 +65,7 @@ public class TypeInfoTest extends CodegenTestCase {
         if (true) return;
 
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         assertFalse((Boolean) foo.invoke(null));
     }
@@ -116,7 +116,7 @@ public class TypeInfoTest extends CodegenTestCase {
 
     public void testClassObjectInTypeInfo() throws Exception {
         loadFile();
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         Method foo = generateFunction();
         JetObject jetObject = (JetObject) foo.invoke(null);
         TypeInfo<?> typeInfo = jetObject.getTypeInfo();
@@ -135,12 +135,12 @@ public class TypeInfoTest extends CodegenTestCase {
 
     public void testKt259() throws Exception {
         blackBoxFile("regressions/kt259.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 
     public void testInner() throws Exception {
         blackBoxFile("typeInfo/inner.jet");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
     }
 }
 
diff --git a/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java b/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java
index a71dacad1af..e08b515771c 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java
@@ -9,7 +9,7 @@ import java.lang.reflect.Method;
 public class VarArgTest extends CodegenTestCase {
     public void testStringArray () throws InvocationTargetException, IllegalAccessException {
         loadText("fun test(vararg ts: String) = ts");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         String[] args = {"mama", "papa"};
         assertTrue(args == main.invoke(null, new Object[]{ args } ));
@@ -17,7 +17,7 @@ public class VarArgTest extends CodegenTestCase {
 
     public void testIntArray () throws InvocationTargetException, IllegalAccessException {
         loadText("fun test(vararg ts: Int) = ts");
-        System.out.println(generateToText());
+//        System.out.println(generateToText());
         final Method main = generateFunction();
         int[] args = {3, 4};
         assertTrue(args == main.invoke(null, new Object[]{ args }));
@@ -25,16 +25,16 @@ public class VarArgTest extends CodegenTestCase {
 
     public void testIntArrayKotlinNoArgs () throws InvocationTargetException, IllegalAccessException {
         loadText("fun test() = testf(); fun testf(vararg ts: Int) = ts");
-        System.out.println(generateToText());
-        final Method main = generateFunction();
+//        System.out.println(generateToText());
+        final Method main = generateFunction("test");
         Object res = main.invoke(null);
         assertTrue(((int[])res).length == 0);
     }
 
     public void testIntArrayKotlin () throws InvocationTargetException, IllegalAccessException {
         loadText("fun test() = testf(239, 7); fun testf(vararg ts: Int) = ts");
-        System.out.println(generateToText());
-        final Method main = generateFunction();
+//        System.out.println(generateToText());
+        final Method main = generateFunction("test");
         Object res = main.invoke(null);
         assertTrue(((int[])res).length == 2);
         assertTrue(((int[])res)[0] == 239);
@@ -43,8 +43,8 @@ public class VarArgTest extends CodegenTestCase {
 
     public void testNullableIntArrayKotlin () throws InvocationTargetException, IllegalAccessException {
         loadText("fun test() = testf(239.byt, 7.byt); fun testf(vararg ts: Byte?) = ts");
-        System.out.println(generateToText());
-        final Method main = generateFunction();
+//        System.out.println(generateToText());
+        final Method main = generateFunction("test");
         Object res = main.invoke(null);
         assertTrue(((Byte[])res).length == 2);
         assertTrue(((Byte[])res)[0] == (byte)239);
@@ -53,8 +53,8 @@ public class VarArgTest extends CodegenTestCase {
 
     public void testIntArrayKotlinObj () throws InvocationTargetException, IllegalAccessException {
         loadText("fun test() = testf(\"239\"); fun testf(vararg ts: String) = ts");
-        System.out.println(generateToText());
-        final Method main = generateFunction();
+//        System.out.println(generateToText());
+        final Method main = generateFunction("test");
         Object res = main.invoke(null);
         assertTrue(((String[])res).length == 1);
         assertTrue(((String[])res)[0].equals("239"));
@@ -62,8 +62,8 @@ public class VarArgTest extends CodegenTestCase {
 
     public void testArrayT () throws InvocationTargetException, IllegalAccessException {
         loadText("fun test() = _array(2, 4); fun <T> _array(vararg elements : T) = elements");
-        System.out.println(generateToText());
-        final Method main = generateFunction();
+//        System.out.println(generateToText());
+        final Method main = generateFunction("test");
         Object res = main.invoke(null);
         assertTrue(((Integer[])res).length == 2);
         assertTrue(((Integer[])res)[0].equals(2));
diff --git a/compiler/tests/org/jetbrains/jet/runtime/JetNpeTest.java b/compiler/tests/org/jetbrains/jet/runtime/JetNpeTest.java
new file mode 100644
index 00000000000..51dd11b201b
--- /dev/null
+++ b/compiler/tests/org/jetbrains/jet/runtime/JetNpeTest.java
@@ -0,0 +1,32 @@
+package org.jetbrains.jet.runtime;
+
+import jet.runtime.Intrinsics;
+import org.jetbrains.jet.codegen.CodegenTestCase;
+
+import java.lang.reflect.Method;
+
+public class JetNpeTest extends CodegenTestCase {
+    public void testStackTrace () {
+        try {
+            Intrinsics.sure(null);
+            fail("No Sure thrown");
+        }
+        catch (NullPointerException e) {
+            StackTraceElement stackTraceElement = e.getStackTrace()[0];
+            assertEquals(stackTraceElement.getMethodName(), "testStackTrace");
+            assertEquals(stackTraceElement.getClassName(), "org.jetbrains.jet.runtime.JetNpeTest");
+        }
+    }
+    
+    public void testNotNull () throws Exception {
+        loadText("fun box() = if(10.sure() == 10) \"OK\" else \"fail\"");
+        blackBox();
+    }
+
+    public void testNull () throws Exception {
+        loadText("fun box() = if(null.sure() == 10) \"OK\" else \"fail\"");
+        System.out.println(generateToText());
+        Method box = generateFunction("box");
+        assertThrows(box, NullPointerException.class, null);
+    }
+}
diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
index bc2d5e09fa3..81687edd8c8 100644
--- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
@@ -162,6 +162,22 @@ public class JetTypeCheckerTest extends JetLiteFixture {
         assertIntersection("Int?", "Int?", "Int?");
         assertIntersection("Int", "Int?", "Int");
         assertIntersection("Int", "Int", "Int?");
+
+        assertIntersection("Int", "Any", "Int");
+        assertIntersection("Int", "Int", "Any");
+
+        assertIntersection("Int", "Any", "Int?");
+        assertIntersection("Int", "Int?", "Any");
+        assertIntersection("Int", "Any?", "Int");
+        assertIntersection("Int", "Int", "Any?");
+
+        assertIntersection("Nothing", "Nothing", "Nothing");
+        assertIntersection("Nothing?", "Nothing?", "Nothing?");
+        assertIntersection("Nothing", "Nothing", "Nothing?");
+        assertIntersection("Nothing", "Nothing?", "Nothing");
+
+        assertIntersection("Nothing?", "String?", "Nothing?");
+        assertIntersection("Nothing?", "Nothing?", "String?");
     }
 
     public void testBasicSubtyping() throws Exception {
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallWithDotCall.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallWithDotCall.java
index d38fad55bcd..c6a18316996 100644
--- a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallWithDotCall.java
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallWithDotCall.java
@@ -40,13 +40,6 @@ public class ReplaceSafeCallWithDotCall extends JetIntentionAction<JetElement> {
             CodeEditUtil.replaceChild(newElement.getNode(), newElement.getSelectorExpression().getNode(), safeQualifiedExpression.getSelectorExpression().getNode());
             CodeEditUtil.replaceChild(newElement.getNode(), newElement.getReceiverExpression().getNode(), safeQualifiedExpression.getReceiverExpression().getNode());
 
-            element.replace(newElement);
-        }
-        else if (element instanceof JetWhenConditionCall) {
-            JetWhenConditionCall newElement = (JetWhenConditionCall) element;
-            JetDotQualifiedExpression callExpression = (JetDotQualifiedExpression) JetPsiFactory.createExpression(project, "x.foo");
-            CodeEditUtil.replaceChild(newElement.getNode(), newElement.getOperationTokenNode(), callExpression.getOperationTokenNode());
-
             element.replace(newElement);
         }
     }
diff --git a/idea/testData/checker/When.jet b/idea/testData/checker/When.jet
index a7bd2a87103..c9e799dd41d 100644
--- a/idea/testData/checker/When.jet
+++ b/idea/testData/checker/When.jet
@@ -13,15 +13,18 @@ fun foo() : Int {
       1 + <error>a</error> => 1
       in 1..<error>a</error> => 1
       !in 1..<error>a</error> => 1
-      .<error>a</error> => 1
-      .equals(1).<error>a</error> => 1
-      <warning>?.</warning>equals(1) => 1
+      // Commented for KT-621 .<!error>a</!error> => 1
+      // Commented for KT-621 .equals(1).<!error>a</!error> => 1
+      // Commented for KT-621 <!warning>?.</!warning>equals(1) => 1
       else => 1
     }
-    return when (<warning>x</warning>?:null) {
-      <error>.</error>foo() => 1
-      ?.equals(1).equals(2) => 1
-    }
+
+    // Commented for KT-621
+    // return when (<!warning>x</!warning>?:null) {
+    //   <!error>.</!error>foo() => 1
+    //   ?.equals(1).equals(2) => 1
+    // }
+    return 0
 }
 
 val _type_test : Int = foo() // this is needed to ensure the inferred return type of foo()
diff --git a/idea/testData/quickfix/expressions/beforeUnnecessarySafeCall2.kt b/idea/testData/quickfix/expressions/beforeUnnecessarySafeCall2.kt
deleted file mode 100644
index cee0f9535b3..00000000000
--- a/idea/testData/quickfix/expressions/beforeUnnecessarySafeCall2.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-// "Replace with dot call" "true"
-fun foo(a: Any) {
-    when (a) {
-        <caret>?.equals(0) => true
-        else => false
-    }
-}
\ No newline at end of file
diff --git a/stdlib/src/jet/runtime/Intrinsics.java b/stdlib/src/jet/runtime/Intrinsics.java
index 9243275e611..1011e0ea2a7 100644
--- a/stdlib/src/jet/runtime/Intrinsics.java
+++ b/stdlib/src/jet/runtime/Intrinsics.java
@@ -1,5 +1,7 @@
 package jet.runtime;
 
+import java.util.ArrayList;
+
 /**
  * @author alex.tkachman
  */
@@ -10,4 +12,40 @@ public class Intrinsics {
     public static String stringPlus(String self, Object other) {
         return ((self == null) ? "null" : self) + ((other == null) ? "null" : other.toString());
     }
+
+    public static Object sure(Object self) {
+        if(self == null)
+            return throwNpe();
+        return self;
+    }
+
+    private static Object throwNpe() {
+        throw new JetNullPointerException();
+    }
+
+    private static Throwable sanitizeStackTrace(Throwable throwable) {
+        StackTraceElement[] stackTrace = throwable.getStackTrace();
+        ArrayList<StackTraceElement> list = new ArrayList<StackTraceElement>();
+        boolean skip = true;
+        for(StackTraceElement ste : stackTrace) {
+            if(!skip) {
+                list.add(ste);
+            }
+            else {
+                if("jet.runtime.Intrinsics".equals(ste.getClassName()) && "sure".equals(ste.getMethodName())) {
+                    skip = false;
+                }
+            }
+        }
+        throwable.setStackTrace(list.toArray(new StackTraceElement[list.size()]));
+        return throwable;
+    }
+
+    private static class JetNullPointerException extends NullPointerException {
+        @Override
+        public synchronized Throwable fillInStackTrace() {
+            super.fillInStackTrace();
+            return sanitizeStackTrace(this);
+        }
+    }
 }