diff --git a/.idea/ant.xml b/.idea/ant.xml
index 82d39650097..544e1256edb 100644
--- a/.idea/ant.xml
+++ b/.idea/ant.xml
@@ -2,14 +2,6 @@
 <project version="4">
   <component name="AntConfiguration">
     <defaultAnt bundledAnt="true" />
-    <buildFile url="file://$PROJECT_DIR$/idea/buildLexer.xml">
-      <additionalClassPath />
-      <antReference projectDefault="true" />
-      <customJdkName value="" />
-      <maximumHeapSize value="128" />
-      <maximumStackSize value="2" />
-      <properties />
-    </buildFile>
     <buildFile url="file://$PROJECT_DIR$/grammar/buildGrammarLexer.xml">
       <additionalClassPath />
       <antReference projectDefault="true" />
@@ -26,6 +18,14 @@
       <maximumStackSize value="2" />
       <properties />
     </buildFile>
+    <buildFile url="file://$PROJECT_DIR$/compiler/frontend/buildLexer.xml">
+      <additionalClassPath />
+      <antReference projectDefault="true" />
+      <customJdkName value="" />
+      <maximumHeapSize value="128" />
+      <maximumStackSize value="2" />
+      <properties />
+    </buildFile>
   </component>
 </project>
 
diff --git a/.idea/libraries/annotations.xml b/.idea/libraries/annotations.xml
new file mode 100644
index 00000000000..5183e286398
--- /dev/null
+++ b/.idea/libraries/annotations.xml
@@ -0,0 +1,9 @@
+<component name="libraryTable">
+  <library name="annotations">
+    <CLASSES>
+      <root url="jar://$IDEA_HOME$/lib/annotations.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
index 8958a9581db..2df90c07743 100644
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@@ -3,7 +3,10 @@
   <component name="ProjectModuleManager">
     <modules>
       <module fileurl="file://$PROJECT_DIR$/Jet.iml" filepath="$PROJECT_DIR$/Jet.iml" />
+      <module fileurl="file://$PROJECT_DIR$/compiler/backend/backend.iml" filepath="$PROJECT_DIR$/compiler/backend/backend.iml" />
       <module fileurl="file://$PROJECT_DIR$/examples/examples.iml" filepath="$PROJECT_DIR$/examples/examples.iml" />
+      <module fileurl="file://$PROJECT_DIR$/compiler/frontend/frontend.iml" filepath="$PROJECT_DIR$/compiler/frontend/frontend.iml" />
+      <module fileurl="file://$PROJECT_DIR$/compiler/frontend.java/frontend.java.iml" filepath="$PROJECT_DIR$/compiler/frontend.java/frontend.java.iml" />
       <module fileurl="file://$PROJECT_DIR$/grammar/grammar.iml" filepath="$PROJECT_DIR$/grammar/grammar.iml" />
       <module fileurl="file://$PROJECT_DIR$/idea/idea.iml" filepath="$PROJECT_DIR$/idea/idea.iml" />
       <module fileurl="file://$PROJECT_DIR$/stdlib/stdlib.iml" filepath="$PROJECT_DIR$/stdlib/stdlib.iml" />
diff --git a/.idea/projectCodeStyle.xml b/.idea/projectCodeStyle.xml
index 4169b3f2f33..25b91e81484 100644
--- a/.idea/projectCodeStyle.xml
+++ b/.idea/projectCodeStyle.xml
@@ -51,16 +51,6 @@
           <option name="LABEL_INDENT_ABSOLUTE" value="false" />
           <option name="USE_RELATIVE_INDENTS" value="false" />
         </ADDITIONAL_INDENT_OPTIONS>
-        <ADDITIONAL_INDENT_OPTIONS fileType="java">
-          <option name="INDENT_SIZE" value="4" />
-          <option name="CONTINUATION_INDENT_SIZE" value="8" />
-          <option name="TAB_SIZE" value="4" />
-          <option name="USE_TAB_CHARACTER" value="false" />
-          <option name="SMART_TABS" value="false" />
-          <option name="LABEL_INDENT_SIZE" value="0" />
-          <option name="LABEL_INDENT_ABSOLUTE" value="false" />
-          <option name="USE_RELATIVE_INDENTS" value="false" />
-        </ADDITIONAL_INDENT_OPTIONS>
         <ADDITIONAL_INDENT_OPTIONS fileType="js">
           <option name="INDENT_SIZE" value="4" />
           <option name="CONTINUATION_INDENT_SIZE" value="8" />
@@ -151,6 +141,17 @@
           <option name="LABEL_INDENT_ABSOLUTE" value="false" />
           <option name="USE_RELATIVE_INDENTS" value="false" />
         </ADDITIONAL_INDENT_OPTIONS>
+        <codeStyleSettings language="JAVA">
+          <option name="ELSE_ON_NEW_LINE" value="true" />
+          <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
+          <option name="ALIGN_MULTILINE_BINARY_OPERATION" value="true" />
+          <option name="ALIGN_MULTILINE_TERNARY_OPERATION" value="true" />
+          <option name="TERNARY_OPERATION_WRAP" value="5" />
+          <option name="TERNARY_OPERATION_SIGNS_ON_NEXT_LINE" value="true" />
+          <option name="IF_BRACE_FORCE" value="1" />
+          <option name="PARENT_SETTINGS_INSTALLED" value="true" />
+          <indentOptions />
+        </codeStyleSettings>
         <codeStyleSettings language="JavaScript">
           <option name="ELSE_ON_NEW_LINE" value="true" />
           <option name="ALIGN_MULTILINE_BINARY_OPERATION" value="true" />
diff --git a/.idea/runConfigurations/All_Tests.xml b/.idea/runConfigurations/All_Tests.xml
index 6ebba66deda..85e2275839b 100644
--- a/.idea/runConfigurations/All_Tests.xml
+++ b/.idea/runConfigurations/All_Tests.xml
@@ -23,10 +23,16 @@
     </option>
     <envs />
     <patterns />
+    <RunnerSettings RunnerId="Debug">
+      <option name="DEBUG_PORT" value="53032" />
+      <option name="TRANSPORT" value="0" />
+      <option name="LOCAL" value="true" />
+    </RunnerSettings>
     <RunnerSettings RunnerId="Profile ">
       <option name="myExternalizedOptions" value="&#13;&#10;snapshots-dir=&#13;&#10;additional-options2=onexit\=snapshot&#13;&#10;" />
     </RunnerSettings>
     <RunnerSettings RunnerId="Run" />
+    <ConfigurationWrapper RunnerId="Debug" />
     <ConfigurationWrapper RunnerId="Run" />
     <method />
   </configuration>
diff --git a/compiler/backend/backend.iml b/compiler/backend/backend.iml
new file mode 100644
index 00000000000..c2cb311107b
--- /dev/null
+++ b/compiler/backend/backend.iml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="IDEA 10.x" jdkType="IDEA JDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module" module-name="frontend" />
+    <orderEntry type="module" module-name="frontend.java" />
+    <orderEntry type="library" name="asm" level="project" />
+    <orderEntry type="module" module-name="stdlib" />
+  </component>
+</module>
+
diff --git a/idea/src/org/jetbrains/jet/codegen/Callable.java b/compiler/backend/src/org/jetbrains/jet/codegen/Callable.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/codegen/Callable.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/Callable.java
diff --git a/idea/src/org/jetbrains/jet/codegen/CallableMethod.java b/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/codegen/CallableMethod.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java
diff --git a/idea/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java
similarity index 92%
rename from idea/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java
index 6c2079241e9..6ffc688431f 100644
--- a/idea/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java
@@ -71,13 +71,17 @@ public abstract class ClassBodyCodegen {
         }
         else if (declaration instanceof JetNamedFunction) {
             try {
-                functionCodegen.gen((JetNamedFunction) declaration);
+                genNamedFunction((JetNamedFunction) declaration, functionCodegen);
             } catch (RuntimeException e) {
                 throw new RuntimeException("Error generating method " + myClass.getName() + "." + declaration.getName() + " in " + context, e);
             }
         }
     }
 
+    protected void genNamedFunction(JetNamedFunction declaration, FunctionCodegen functionCodegen) {
+        functionCodegen.gen(declaration);
+    }
+
     private void generatePrimaryConstructorProperties(PropertyCodegen propertyCodegen) {
         OwnerKind kind = context.getContextKind();
         for (JetParameter p : getPrimaryConstructorParameters()) {
@@ -89,7 +93,8 @@ public abstract class ClassBodyCodegen {
                         propertyCodegen.generateDefaultSetter(propertyDescriptor, Opcodes.ACC_PUBLIC);
                     }
 
-                    if (!(kind instanceof OwnerKind.DelegateKind) && kind != OwnerKind.INTERFACE && state.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
+                    //noinspection ConstantConditions
+                    if (!(kind instanceof OwnerKind.DelegateKind) && state.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
                         v.visitField(Opcodes.ACC_PRIVATE, p.getName(), state.getTypeMapper().mapType(propertyDescriptor.getOutType()).getDescriptor(), null, null);
                     }
                 }
diff --git a/idea/src/org/jetbrains/jet/codegen/ClassCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java
similarity index 51%
rename from idea/src/org/jetbrains/jet/codegen/ClassCodegen.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java
index c7d6d88809f..60dc3bc46f0 100644
--- a/idea/src/org/jetbrains/jet/codegen/ClassCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java
@@ -9,6 +9,7 @@ import org.objectweb.asm.commons.InstructionAdapter;
 
 /**
  * @author max
+ * @author alex.tkachman
  */
 public class ClassCodegen {
     private final GenerationState state;
@@ -20,18 +21,10 @@ public class ClassCodegen {
     public void generate(ClassContext parentContext, JetClassOrObject aClass) {
         GenerationState.prepareAnonymousClasses((JetElement) aClass, state.getTypeMapper());
 
-        if (aClass instanceof JetObjectDeclaration) {
-            generateImplementation(parentContext, aClass, OwnerKind.IMPLEMENTATION);
-        }
-        else {
-            generateInterface(parentContext, aClass);
-            generateImplementation(parentContext, aClass, OwnerKind.IMPLEMENTATION);
-            if (!ImplementationBodyCodegen.isEnum(aClass)) {
-                generateImplementation(parentContext, aClass, OwnerKind.DELEGATING_IMPLEMENTATION);
-            }
-        }
-
         ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass);
+
+        generateImplementation(parentContext, aClass, OwnerKind.IMPLEMENTATION);
+
         final ClassContext contextForInners = parentContext.intoClass(descriptor, OwnerKind.IMPLEMENTATION);
         for (JetDeclaration declaration : aClass.getDeclarations()) {
             if (declaration instanceof JetClass && !(declaration instanceof JetEnumEntry)) {
@@ -40,26 +33,16 @@ public class ClassCodegen {
         }
     }
 
-    private void generateInterface(ClassContext parentContext, JetClassOrObject aClass) {
-        ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass);
-        final ClassVisitor visitor = state.forClassInterface(descriptor);
-        new InterfaceBodyCodegen(aClass, parentContext.intoClass(descriptor, OwnerKind.INTERFACE), visitor, state).generate();
-    }
-
     private void generateImplementation(ClassContext parentContext, JetClassOrObject aClass, OwnerKind kind) {
         ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass);
-        ClassVisitor v = kind == OwnerKind.IMPLEMENTATION
-                ? state.forClassImplementation(descriptor)
-                : state.forClassDelegatingImplementation(descriptor);
+        ClassVisitor v = state.forClassImplementation(descriptor);
         new ImplementationBodyCodegen(aClass, parentContext.intoClass(descriptor, kind), v, state).generate();
+        
+        if(aClass instanceof JetClass && ((JetClass)aClass).isTrait()) {
+            v = state.forTraitImplementation(descriptor);
+            new TraitImplBodyCodegen(aClass, parentContext.intoClass(descriptor, OwnerKind.TRAIT_IMPL), v, state).generate();
+        }
     }
 
 
-    public static void newTypeInfo(InstructionAdapter v, boolean isNullable, Type asmType) {
-        v.anew(JetTypeMapper.TYPE_TYPEINFO);
-        v.dup();
-        v.aconst(asmType);
-        v.aconst(isNullable);
-        v.invokespecial("jet/typeinfo/TypeInfo", "<init>", "(Ljava/lang/Class;Z)V");
-    }
 }
diff --git a/idea/src/org/jetbrains/jet/codegen/ClassContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassContext.java
similarity index 80%
rename from idea/src/org/jetbrains/jet/codegen/ClassContext.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/ClassContext.java
index 87e92d070f7..81d06bf4ea8 100644
--- a/idea/src/org/jetbrains/jet/codegen/ClassContext.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassContext.java
@@ -7,10 +7,13 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.objectweb.asm.Type;
 import org.objectweb.asm.commons.InstructionAdapter;
 
+import java.util.HashMap;
+
 public class ClassContext {
     public static final ClassContext STATIC = new ClassContext(null, OwnerKind.NAMESPACE, null, null, null);
     private final DeclarationDescriptor contextType;
@@ -19,6 +22,8 @@ public class ClassContext {
     private final ClassContext parentContext;
     private final ClosureCodegen closure;
     private boolean thisWasUsed = false;
+    
+    HashMap<JetType,Integer> typeInfoConstants;
 
     public ClassContext(DeclarationDescriptor contextType, OwnerKind contextKind, StackValue thisExpression, ClassContext parentContext, ClosureCodegen closureCodegen) {
         this.contextType = contextType;
@@ -32,12 +37,19 @@ public class ClassContext {
         return contextType;
     }
 
+    public String getNamespaceClassName() {
+        if(parentContext != STATIC)
+            return parentContext.getNamespaceClassName();
+
+        return NamespaceCodegen.getJVMClassName(contextType.getName());
+    }
+
     public OwnerKind getContextKind() {
         return contextKind;
     }
 
     public StackValue getThisExpression() {
-        if (parentContext == null) return null;
+        if (parentContext == null) return StackValue.none();
 
         thisWasUsed = true;
         if (thisExpression != null) return thisExpression;
@@ -50,14 +62,7 @@ public class ClassContext {
 
     public ClassContext intoClass(ClassDescriptor descriptor, OwnerKind kind) {
         final StackValue thisValue;
-        if (kind == OwnerKind.DELEGATING_IMPLEMENTATION) {
-            thisValue = StackValue.instanceField(JetTypeMapper.jetInterfaceType(descriptor),
-                    JetTypeMapper.jetDelegatingImplementationType(descriptor).getInternalName(),
-                    "$this");
-        }
-        else {
-            thisValue = StackValue.local(0, JetTypeMapper.TYPE_OBJECT);
-        }
+        thisValue = StackValue.local(0, JetTypeMapper.TYPE_OBJECT);
 
         return new ClassContext(descriptor, kind, thisValue, this, null);
     }
@@ -68,7 +73,7 @@ public class ClassContext {
             thisIdx++;
         }
 
-        final boolean hasReceiver = descriptor.getReceiverType() != null;
+        final boolean hasReceiver = descriptor.getReceiver().exists();
         if (hasReceiver) {
             thisIdx++;
         }
@@ -98,12 +103,12 @@ public class ClassContext {
         return frameMap;
     }
 
-    private JetType receiverType() {
-        return contextType instanceof FunctionDescriptor ? ((FunctionDescriptor) contextType).getReceiverType() : null;
+    private ReceiverDescriptor receiver() {
+        return contextType instanceof FunctionDescriptor ? ((FunctionDescriptor) contextType).getReceiver() : ReceiverDescriptor.NO_RECEIVER;
     }
 
     private boolean hasReceiver() {
-        return receiverType() != null;
+        return receiver().exists();
     }
 
     public ClassContext getParentContext() {
@@ -150,7 +155,7 @@ public class ClassContext {
     public Type enclosingClassType(JetTypeMapper mapper) {
         DeclarationDescriptor descriptor = getContextDescriptor();
         if (descriptor instanceof ClassDescriptor) {
-            return Type.getObjectType(mapper.jvmName((ClassDescriptor) descriptor, OwnerKind.INTERFACE));
+            return Type.getObjectType(mapper.jvmName((ClassDescriptor) descriptor, OwnerKind.IMPLEMENTATION));
         }
 
         if (descriptor instanceof NamespaceDescriptor) {
@@ -164,4 +169,19 @@ public class ClassContext {
         final ClassContext parent = getParentContext();
         return parent != null ? parent.enclosingClassType(mapper) : null;
     }
+    
+    public int getTypeInfoConstantIndex(JetType type) {
+        if(parentContext != STATIC)
+            return parentContext.getTypeInfoConstantIndex(type);
+        
+        if(typeInfoConstants == null)
+            typeInfoConstants = new HashMap<JetType, Integer>();
+
+        Integer index = typeInfoConstants.get(type);
+        if(index == null) {
+            index = typeInfoConstants.size();
+            typeInfoConstants.put(type, index);
+        }
+        return index;
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/codegen/ClassFileFactory.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/codegen/ClassFileFactory.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java
diff --git a/idea/src/org/jetbrains/jet/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java
similarity index 96%
rename from idea/src/org/jetbrains/jet/codegen/ClosureCodegen.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java
index 4de5e2ff34a..864111bee96 100644
--- a/idea/src/org/jetbrains/jet/codegen/ClosureCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java
@@ -11,6 +11,7 @@ import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.JetFunctionLiteral;
 import org.jetbrains.jet.lang.psi.JetFunctionLiteralExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.MethodVisitor;
@@ -41,7 +42,7 @@ public class ClosureCodegen {
     }
 
     public static Method erasedInvokeSignature(FunctionDescriptor fd) {
-        boolean isExtensionFunction = fd.getReceiverType() != null;
+        boolean isExtensionFunction = fd.getReceiver().exists();
         int paramCount = fd.getValueParameters().size();
         if (isExtensionFunction) {
             paramCount++;
@@ -150,11 +151,11 @@ public class ClosureCodegen {
 
         iv.load(0, Type.getObjectType(className));
 
-        final JetType receiverType = funDescriptor.getReceiverType();
+        final ReceiverDescriptor receiver = funDescriptor.getReceiver();
         int count = 1;
-        if (receiverType != null) {
+        if (receiver.exists()) {
             StackValue.local(count, JetTypeMapper.TYPE_OBJECT).put(JetTypeMapper.TYPE_OBJECT, iv);
-            StackValue.onStack(JetTypeMapper.TYPE_OBJECT).upcast(state.getTypeMapper().mapType(receiverType), iv);
+            StackValue.onStack(JetTypeMapper.TYPE_OBJECT).upcast(state.getTypeMapper().mapType(receiver.getType()), iv);
             count++;
         }
 
@@ -228,7 +229,7 @@ public class ClosureCodegen {
 
     public static String getInternalClassName(FunctionDescriptor descriptor) {
         final int paramCount = descriptor.getValueParameters().size();
-        if (descriptor.getReceiverType() != null) {
+        if (descriptor.getReceiver().exists()) {
             return "jet/ExtensionFunction" + paramCount;
         }
         else {
@@ -249,7 +250,7 @@ public class ClosureCodegen {
         Method descriptor = erasedInvokeSignature(fd);
         String owner = getInternalClassName(fd);
         final CallableMethod result = new CallableMethod(owner, descriptor, Opcodes.INVOKEVIRTUAL, Arrays.asList(descriptor.getArgumentTypes()));
-        if (fd.getReceiverType() != null) {
+        if (fd.getReceiver().exists()) {
             result.setNeedsReceiver(null);
         }
         result.requestGenerateCallee(Type.getObjectType(getInternalClassName(fd)));
diff --git a/idea/src/org/jetbrains/jet/codegen/CodeChunk.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodeChunk.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/codegen/CodeChunk.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/CodeChunk.java
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java
new file mode 100644
index 00000000000..3e3fe413c90
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java
@@ -0,0 +1,105 @@
+package org.jetbrains.jet.codegen;
+
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassKind;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.psi.JetClass;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeProjection;
+import org.objectweb.asm.Type;
+
+/**
+ * @author abreslav
+ * @author alex.tkachman
+ */
+public class CodegenUtil {
+    private CodegenUtil() {
+    }
+
+    public static boolean isInterface(DeclarationDescriptor descriptor) {
+        return descriptor instanceof ClassDescriptor && ((ClassDescriptor)descriptor).getKind() == ClassKind.TRAIT;
+    }
+
+    public static boolean isInterface(JetType type) {
+        return isInterface(type.getConstructor().getDeclarationDescriptor());
+    }
+    
+    public static boolean isClassObject(DeclarationDescriptor descriptor) {
+        if(descriptor instanceof ClassDescriptor) {
+            ClassDescriptor classDescriptor = (ClassDescriptor) descriptor;
+            if(classDescriptor.getKind() == ClassKind.OBJECT) {
+                if(classDescriptor.getContainingDeclaration() instanceof ClassDescriptor) {
+                    ClassDescriptor containingDeclaration = (ClassDescriptor) classDescriptor.getContainingDeclaration();
+                    if(classDescriptor.getDefaultType().equals(containingDeclaration.getClassObjectType())) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    public static boolean hasThis0(ClassDescriptor classDescriptor) {
+        return getOuterClassDescriptor(classDescriptor) != null && !isClassObject(classDescriptor);
+    }
+
+    public static ClassDescriptor getOuterClassDescriptor(DeclarationDescriptor descriptor) {
+        DeclarationDescriptor outerDescriptor = descriptor.getContainingDeclaration();
+        while(outerDescriptor != null) {
+            if(outerDescriptor instanceof ClassDescriptor)
+                break;
+
+            outerDescriptor = outerDescriptor.getContainingDeclaration();
+        }
+        return (ClassDescriptor) outerDescriptor;
+    }
+
+    public static boolean hasOuterTypeInfo(ClassDescriptor descriptor) {
+        ClassDescriptor outerClassDescriptor = getOuterClassDescriptor(descriptor);
+        if(outerClassDescriptor == null)
+            return false;
+
+        if(outerClassDescriptor.getTypeConstructor().getParameters().size() > 0)
+            return true;
+
+        return hasOuterTypeInfo(outerClassDescriptor);
+    }
+
+    public static boolean hasTypeInfoField(JetType type) {
+        if(type.getConstructor().getParameters().size() > 0)
+            return true;
+
+        for (JetType jetType : type.getConstructor().getSupertypes()) {
+            if(hasTypeInfoField(jetType))
+                return true;
+        }
+
+        ClassDescriptor outerClassDescriptor = getOuterClassDescriptor(type.getConstructor().getDeclarationDescriptor());
+        if(outerClassDescriptor == null)
+            return false;
+
+        return hasTypeInfoField(outerClassDescriptor.getDefaultType());
+    }
+
+    public static boolean hasDerivedTypeInfoField(JetType type, boolean exceptOwn) {
+        if(!exceptOwn) {
+            if(!isInterface(type))
+                if(hasTypeInfoField(type))
+                    return true;
+        }
+
+        for (JetType jetType : type.getConstructor().getSupertypes()) {
+            if(hasDerivedTypeInfoField(jetType, false))
+                return true;
+        }
+
+        return false;
+    }
+    
+    public static Type arrayElementType(Type type) {
+        return Type.getType(type.getDescriptor().substring(1));
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java b/compiler/backend/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java
similarity index 79%
rename from idea/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java
index 4ae7b71fd88..17a134befac 100644
--- a/idea/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java
@@ -14,22 +14,16 @@ import java.util.List;
  */
 public class ConstructorFrameMap extends FrameMap {
     private int myOuterThisIndex = -1;
-    private int myDelegateThisIndex = -1;
     private int myFirstTypeParameter = -1;
     private int myTypeParameterCount = 0;
 
-    public ConstructorFrameMap(CallableMethod callableMethod, @Nullable ConstructorDescriptor descriptor, OwnerKind kind) {
+    public ConstructorFrameMap(CallableMethod callableMethod, @Nullable ConstructorDescriptor descriptor, ClassDescriptor classDescriptor, OwnerKind kind) {
         enterTemp(); // this
-        ClassDescriptor classDescriptor = null;
         if (descriptor != null) {
-            classDescriptor = descriptor.getContainingDeclaration();
-            if (classDescriptor.getContainingDeclaration() instanceof ClassDescriptor) {
+            if (CodegenUtil.hasThis0(classDescriptor)) {
                 myOuterThisIndex = enterTemp();   // outer class instance
             }
         }
-        if (kind == OwnerKind.DELEGATING_IMPLEMENTATION) {
-            myDelegateThisIndex = enterTemp();   // $this
-        }
 
         List<Type> explicitArgTypes = callableMethod.getValueParameterTypes();
 
@@ -41,7 +35,6 @@ public class ConstructorFrameMap extends FrameMap {
             enter(parameter, explicitArgTypes.get(i).getSize());
         }
 
-
         if (classDescriptor != null) {
             myTypeParameterCount = classDescriptor.getTypeConstructor().getParameters().size();
             if (kind == OwnerKind.IMPLEMENTATION) {
@@ -59,10 +52,6 @@ public class ConstructorFrameMap extends FrameMap {
         return myOuterThisIndex;
     }
 
-    public int getDelegateThisIndex() {
-        return myDelegateThisIndex;
-    }
-
     public int getFirstTypeParameter() {
         return myFirstTypeParameter;
     }
diff --git a/idea/src/org/jetbrains/jet/codegen/EnclosedValueDescriptor.java b/compiler/backend/src/org/jetbrains/jet/codegen/EnclosedValueDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/codegen/EnclosedValueDescriptor.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/EnclosedValueDescriptor.java
diff --git a/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
similarity index 57%
rename from idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
index 99783414912..91c126fd77d 100644
--- a/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
@@ -1,24 +1,21 @@
 package org.jetbrains.jet.codegen;
 
 import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
-import com.intellij.psi.search.ProjectScope;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import gnu.trove.THashSet;
-import jet.Range;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethod;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
-import org.jetbrains.jet.lang.types.JetStandardClasses;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.TypeProjection;
+import org.jetbrains.jet.lang.resolve.java.JavaClassDescriptor;
+import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.MethodVisitor;
@@ -32,49 +29,26 @@ import java.util.*;
 /**
  * @author max
  * @author yole
+ * @author alex.tkachman
  */
-public class ExpressionCodegen extends JetVisitorVoid {
+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_ITERABLE = "java/lang/Iterable";
-    private static final String CLASS_ITERATOR = "java/util/Iterator";
 
-    private static final String CLASS_RANGE = "jet/Range";
     private static final String CLASS_NO_PATTERN_MATCHED_EXCEPTION = "jet/NoPatternMatchedException";
     private static final String CLASS_TYPE_CAST_EXCEPTION = "jet/TypeCastException";
 
-    private static final String ITERABLE_ITERATOR_DESCRIPTOR = "()Ljava/util/Iterator;";
-    private static final String ITERATOR_HASNEXT_DESCRIPTOR = "()Z";
-    private static final String ITERATOR_NEXT_DESCRIPTOR = "()Ljava/lang/Object;";
-
     private static final Type OBJECT_TYPE = Type.getType(Object.class);
-    private static final Type INTEGER_TYPE = Type.getType(Integer.class);
-    private static final Type ITERATOR_TYPE = Type.getType(Iterator.class);
     private static final Type THROWABLE_TYPE = Type.getType(Throwable.class);
     private static final Type STRING_TYPE = Type.getObjectType(CLASS_STRING);
 
-    private static final Type RANGE_TYPE = Type.getType(Range.class);
-
     private final Stack<Label> myContinueTargets = new Stack<Label>();
     private final Stack<Label> myBreakTargets = new Stack<Label>();
-    private final Stack<StackValue> myStack = new Stack<StackValue>();
 
     private int myLastLineNumber = -1;
 
-    private static final String[] PRIMITIVE_TYPE_INFO_FIELDS = {
-            null,
-            "BOOL_TYPE_INFO",
-            "CHAR_TYPE_INFO",
-            "BYTE_TYPE_INFO",
-            "SHORT_TYPE_INFO",
-            "INT_TYPE_INFO",
-            "FLOAT_TYPE_INFO",
-            "LONG_TYPE_INFO",
-            "DOUBLE_TYPE_INFO"
-    };
-
     private final InstructionAdapter v;
     private final FrameMap myMap;
     private final JetTypeMapper typeMapper;
@@ -108,32 +82,17 @@ public class ExpressionCodegen extends JetVisitorVoid {
         typeParameterExpressions.put(typeParameter, expression);
     }
 
-    static void loadTypeInfo(JetTypeMapper typeMapper, ClassDescriptor descriptor, InstructionAdapter v) {
-        String owner = typeMapper.jvmName(descriptor, OwnerKind.IMPLEMENTATION);
-        if (descriptor.getTypeConstructor().getParameters().size() > 0) {
-            v.load(0, JetTypeMapper.TYPE_OBJECT);
-            v.getfield(owner, "$typeInfo", "Ljet/typeinfo/TypeInfo;");
-        }
-        else {
-            v.getstatic(owner, "$typeInfo", "Ljet/typeinfo/TypeInfo;");
-        }
+    public StackValue genQualified(StackValue receiver, JetElement selector) {
+        markLineNumber(selector);
+        return selector.visit(this, receiver);
     }
 
-    private void gen(JetElement expr) {
-        markLineNumber(expr);
-        expr.accept(this);
+    public StackValue gen(JetElement expr) {
+        return genQualified(StackValue.none(), expr);
     }
 
     public void gen(JetElement expr, Type type) {
-        int oldStackDepth = myStack.size();
-        gen(expr);
-        if (myStack.size() == oldStackDepth+1) {
-            putTopOfStack(type);
-        }
-    }
-
-    public void putTopOfStack(Type type) {
-        StackValue value = myStack.pop();
+        StackValue value = gen(expr);
         value.put(type, v);
     }
 
@@ -141,35 +100,25 @@ public class ExpressionCodegen extends JetVisitorVoid {
         gen(expr, expressionType(expr));
     }
 
-    public StackValue generateIntermediateValue(final JetExpression baseExpression) {
-        int oldStackSize = myStack.size();
-        gen(baseExpression);
-        if (myStack.size() != oldStackSize+1) {
-            throw new UnsupportedOperationException("intermediate value expected");
-        }
-        return myStack.pop();
-    }
-
     @Override
-    public void visitExpression(JetExpression expression) {
+    public StackValue visitExpression(JetExpression expression, StackValue receiver) {
         throw new UnsupportedOperationException("Codegen for " + expression + " is not yet implemented");
     }
 
     @Override
-    public void visitParenthesizedExpression(JetParenthesizedExpression expression) {
-        gen(expression.getExpression());
+    public StackValue visitParenthesizedExpression(JetParenthesizedExpression expression, StackValue receiver) {
+        return genQualified(receiver, expression.getExpression());
     }
 
     @Override
-    public void visitAnnotatedExpression(JetAnnotatedExpression expression) {
-        gen(expression.getBaseExpression());
+    public StackValue visitAnnotatedExpression(JetAnnotatedExpression expression, StackValue receiver) {
+        return genQualified(receiver, expression.getBaseExpression());
     }
 
     @Override
-    public void visitIfExpression(JetIfExpression expression) {
-        JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression);
-        Type asmType = typeMapper.mapType(expressionType);
-        StackValue condition = generateIntermediateValue(expression.getCondition());
+    public StackValue visitIfExpression(JetIfExpression expression, StackValue receiver) {
+        Type asmType = expressionType(expression);
+        StackValue condition = gen(expression.getCondition());
 
         JetExpression thenExpression = expression.getThen();
         JetExpression elseExpression = expression.getElse();
@@ -179,13 +128,11 @@ public class ExpressionCodegen extends JetVisitorVoid {
         }
 
         if (thenExpression == null) {
-            generateSingleBranchIf(condition, elseExpression, false);
-            return;
+            return generateSingleBranchIf(condition, elseExpression, false);
         }
 
         if (elseExpression == null) {
-            generateSingleBranchIf(condition, thenExpression, true);
-            return;
+            return generateSingleBranchIf(condition, thenExpression, true);
         }
 
 
@@ -201,13 +148,12 @@ public class ExpressionCodegen extends JetVisitorVoid {
         gen(elseExpression, asmType);
 
         v.mark(endLabel);
-        if (asmType != Type.VOID_TYPE) {
-            myStack.push(StackValue.onStack(asmType));
-        }
+
+        return StackValue.onStack(asmType);
     }
 
     @Override
-    public void visitWhileExpression(JetWhileExpression expression) {
+    public StackValue visitWhileExpression(JetWhileExpression expression, StackValue receiver) {
         Label condition = new Label();
         myContinueTargets.push(condition);
         v.mark(condition);
@@ -215,7 +161,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
         Label end = new Label();
         myBreakTargets.push(end);
 
-        final StackValue conditionValue = generateIntermediateValue(expression.getCondition());
+        final StackValue conditionValue = gen(expression.getCondition());
         conditionValue.condJump(end, true, v);
 
         gen(expression.getBody(), Type.VOID_TYPE);
@@ -224,10 +170,12 @@ public class ExpressionCodegen extends JetVisitorVoid {
         v.mark(end);
         myBreakTargets.pop();
         myContinueTargets.pop();
+
+        return StackValue.onStack(Type.VOID_TYPE);
     }
 
     @Override
-    public void visitDoWhileExpression(JetDoWhileExpression expression) {
+    public StackValue visitDoWhileExpression(JetDoWhileExpression expression, StackValue receiver) {
         Label condition = new Label();
         v.mark(condition);
         myContinueTargets.push(condition);
@@ -237,52 +185,66 @@ public class ExpressionCodegen extends JetVisitorVoid {
 
         gen(expression.getBody(), Type.VOID_TYPE);
 
-        final StackValue conditionValue = generateIntermediateValue(expression.getCondition());
+        final StackValue conditionValue = gen(expression.getCondition());
         conditionValue.condJump(condition, false, v);
 
         v.mark(end);
 
         myBreakTargets.pop();
         myContinueTargets.pop();
+        return StackValue.onStack(Type.VOID_TYPE);
     }
 
     @Override
-    public void visitForExpression(JetForExpression expression) {
+    public StackValue visitForExpression(JetForExpression expression, StackValue receiver) {
         final JetExpression loopRange = expression.getLoopRange();
         final JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, loopRange);
         Type loopRangeType = typeMapper.mapType(expressionType);
         if (loopRangeType.getSort() == Type.ARRAY) {
             new ForInArrayLoopGenerator(expression, loopRangeType).invoke();
+            return StackValue.none();
         }
         else {
+            assert expressionType != null;
             final DeclarationDescriptor descriptor = expressionType.getConstructor().getDeclarationDescriptor();
-            final PsiElement declaration = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, descriptor);
-            if (declaration instanceof PsiClass) {
-                final Project project = declaration.getProject();
-                final PsiClass iterable = JavaPsiFacade.getInstance(project).findClass("java.lang.Iterable", ProjectScope.getAllScope(project));
-                if (((PsiClass) declaration).isInheritor(iterable, true)) {
-                    generateForInIterable(expression, loopRangeType);
-                    return;
-                }
-            }
             if (isClass(descriptor, "IntRange")) {       // TODO IntRange subclasses
                 new ForInRangeLoopGenerator(expression, loopRangeType).invoke();
-                return;
+                return StackValue.none();
             }
-            throw new UnsupportedOperationException("for/in loop currently only supported for arrays and Iterable instances");
+
+            generateForInIterable(expression, loopRangeType);
+            return StackValue.none();
         }
     }
 
+    @SuppressWarnings("ConstantConditions")
     private void generateForInIterable(JetForExpression expression, Type loopRangeType) {
+        final JetExpression loopRange = expression.getLoopRange();
+
+        FunctionDescriptor iteratorDescriptor = bindingContext.get(BindingContext.LOOP_RANGE_ITERATOR, loopRange);
+        FunctionDescriptor nextDescriptor = bindingContext.get(BindingContext.LOOP_RANGE_NEXT, loopRange);
+        DeclarationDescriptor hasNextDescriptor = bindingContext.get(BindingContext.LOOP_RANGE_HAS_NEXT, loopRange);
+
+        if(iteratorDescriptor == null)
+            throw new IllegalStateException("No iterator() method " + DiagnosticUtils.atLocation(loopRange));
+        if(nextDescriptor == null)
+            throw new IllegalStateException("No next() method " + DiagnosticUtils.atLocation(loopRange));
+        if(hasNextDescriptor == null)
+            throw new IllegalStateException("No iterator() method " + DiagnosticUtils.atLocation(loopRange));
+
         final JetParameter loopParameter = expression.getLoopParameter();
         final VariableDescriptor parameterDescriptor = bindingContext.get(BindingContext.VALUE_PARAMETER, loopParameter);
+
+        JetType iteratorType = parameterDescriptor.getOutType();
+        Type asmIterType = JetTypeMapper.boxType(typeMapper.mapType(iteratorType));
+
         JetType paramType = parameterDescriptor.getOutType();
         Type asmParamType = typeMapper.mapType(paramType);
 
         int iteratorVar = myMap.enterTemp();
         gen(expression.getLoopRange(), loopRangeType);
-        v.invokeinterface(CLASS_ITERABLE, "iterator", ITERABLE_ITERATOR_DESCRIPTOR);
-        v.store(iteratorVar, ITERATOR_TYPE);
+        invokeFunctionNoParams(iteratorDescriptor, asmIterType, v);
+        v.store(iteratorVar, asmIterType);
 
         Label begin = new Label();
         Label end = new Label();
@@ -290,13 +252,21 @@ public class ExpressionCodegen extends JetVisitorVoid {
         myBreakTargets.push(end);
 
         v.mark(begin);
-        v.load(iteratorVar, ITERATOR_TYPE);
-        v.invokeinterface(CLASS_ITERATOR, "hasNext", ITERATOR_HASNEXT_DESCRIPTOR);
+        v.load(iteratorVar, asmIterType);
+        FunctionDescriptor hND;
+        if(hasNextDescriptor instanceof FunctionDescriptor) {
+            hND = (FunctionDescriptor) hasNextDescriptor;
+        }
+        else {
+            hND = ((PropertyDescriptor) hasNextDescriptor).getGetter();
+        }
+        invokeFunctionNoParams(hND, Type.BOOLEAN_TYPE, v);
         v.ifeq(end);
 
         myMap.enter(parameterDescriptor, asmParamType.getSize());
-        v.load(iteratorVar, ITERATOR_TYPE);
-        v.invokeinterface(CLASS_ITERATOR, "next", ITERATOR_NEXT_DESCRIPTOR);
+        v.load(iteratorVar, asmIterType);
+        invokeFunctionNoParams(nextDescriptor, asmParamType, v);
+
         // TODO checkcast should be generated via StackValue
         if (asmParamType.getSort() == Type.OBJECT && !"java.lang.Object".equals(asmParamType.getClassName())) {
             v.checkcast(asmParamType);
@@ -309,6 +279,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
         v.mark(end);
 
         int paramIndex = myMap.leave(parameterDescriptor);
+        //noinspection ConstantConditions
         v.visitLocalVariable(loopParameter.getName(), asmParamType.getDescriptor(), null, begin, end, paramIndex);
         myMap.leaveTemp();
         myBreakTargets.pop();
@@ -330,6 +301,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
     private abstract class ForLoopGenerator {
         protected JetForExpression expression;
         protected Type loopRangeType;
+        protected JetType expressionType;
         protected VariableDescriptor parameterDescriptor;
 
         public ForLoopGenerator(JetForExpression expression, Type loopRangeType) {
@@ -337,6 +309,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
             this.loopRangeType = loopRangeType;
             final JetParameter loopParameter = expression.getLoopParameter();
             this.parameterDescriptor = bindingContext.get(BindingContext.VALUE_PARAMETER, loopParameter);
+            expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression.getLoopRange());
         }
 
         public void invoke() {
@@ -364,6 +337,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
 
             cleanupTemp();
             final int paramIndex = myMap.leave(parameterDescriptor);
+            //noinspection ConstantConditions
             v.visitLocalVariable(expression.getLoopParameter().getName(), asmParamType.getDescriptor(), null, condition, end, paramIndex);
             myBreakTargets.pop();
             myContinueTargets.pop();
@@ -395,19 +369,21 @@ public class ExpressionCodegen extends JetVisitorVoid {
             v.arraylength();
             v.store(myLengthVar, Type.INT_TYPE);
             myIndexVar = myMap.enterTemp();
-            v.aconst(0);
+            v.iconst(0);
             v.store(myIndexVar, Type.INT_TYPE);
         }
 
         protected void generateCondition(Type asmParamType, Label end) {
+            Type arrayElParamType = state.getStandardLibrary().getArray().equals(expressionType.getConstructor().getDeclarationDescriptor()) ? JetTypeMapper.boxType(asmParamType): asmParamType;
+
             v.load(myIndexVar, Type.INT_TYPE);
             v.load(myLengthVar, Type.INT_TYPE);
             v.ificmpge(end);
 
             gen(expression.getLoopRange(), loopRangeType);  // array
             v.load(myIndexVar, Type.INT_TYPE);
-            v.aload(loopRangeType.getElementType());
-            StackValue.onStack(loopRangeType.getElementType()).put(asmParamType, v);
+            v.aload(arrayElParamType);
+            StackValue.onStack(arrayElParamType).put(asmParamType, v);
             v.store(lookupLocal(parameterDescriptor), asmParamType);
         }
 
@@ -421,7 +397,6 @@ public class ExpressionCodegen extends JetVisitorVoid {
     }
 
     private class ForInRangeLoopGenerator extends ForLoopGenerator {
-        private int myRangeVar;
         private int myEndVar;
 
         public ForInRangeLoopGenerator(JetForExpression expression, Type loopRangeType) {
@@ -430,17 +405,24 @@ public class ExpressionCodegen extends JetVisitorVoid {
 
         @Override
         protected void generatePrologue() {
-            myRangeVar = myMap.enterTemp();
             myEndVar = myMap.enterTemp();
-            gen(expression.getLoopRange(), loopRangeType);
-            v.dup();
-            v.dup();
-            v.store(myRangeVar, loopRangeType);
+            if(isIntRangeExpr(expression.getLoopRange())) {
+                JetBinaryExpression rangeExpression = (JetBinaryExpression) expression.getLoopRange();
+                //noinspection ConstantConditions
+                gen(rangeExpression.getLeft(), Type.INT_TYPE);
+                v.store(lookupLocal(parameterDescriptor), Type.INT_TYPE);
+                gen(rangeExpression.getRight(), Type.INT_TYPE);
+                v.store(myEndVar, Type.INT_TYPE);
+            }
+            else {
+                gen(expression.getLoopRange(), loopRangeType);
+                v.dup();
 
-            v.invokevirtual("jet/IntRange", "getStartValue", "()I");
-            v.store(lookupLocal(parameterDescriptor), Type.INT_TYPE);
-            v.invokevirtual("jet/IntRange", "getEndValue", "()I");
-            v.store(myEndVar, Type.INT_TYPE);
+                v.invokevirtual("jet/IntRange", "getStartValue", "()I");
+                v.store(lookupLocal(parameterDescriptor), Type.INT_TYPE);
+                v.invokevirtual("jet/IntRange", "getEndValue", "()I");
+                v.store(myEndVar, Type.INT_TYPE);
+            }
         }
 
         @Override
@@ -457,29 +439,31 @@ public class ExpressionCodegen extends JetVisitorVoid {
 
         @Override
         protected void cleanupTemp() {
-            myMap.leaveTemp(2);
+            myMap.leaveTemp(1);
         }
     }
 
     @Override
-    public void visitBreakExpression(JetBreakExpression expression) {
+    public StackValue visitBreakExpression(JetBreakExpression expression, StackValue receiver) {
         JetSimpleNameExpression labelElement = expression.getTargetLabel();
 
         Label label = labelElement == null ? myBreakTargets.peek() : null; // TODO:
 
         v.goTo(label);
+        return StackValue.none();
     }
 
     @Override
-    public void visitContinueExpression(JetContinueExpression expression) {
+    public StackValue visitContinueExpression(JetContinueExpression expression, StackValue receiver) {
         String labelName = expression.getLabelName();
 
         Label label = labelName == null ? myContinueTargets.peek() : null; // TODO:
 
         v.goTo(label);
+        return StackValue.none();
     }
 
-    private void generateSingleBranchIf(StackValue condition, JetExpression expression, boolean inverse) {
+    private StackValue generateSingleBranchIf(StackValue condition, JetExpression expression, boolean inverse) {
         Label endLabel = new Label();
 
         condition.condJump(endLabel, inverse, v);
@@ -487,17 +471,18 @@ public class ExpressionCodegen extends JetVisitorVoid {
         gen(expression, Type.VOID_TYPE);
 
         v.mark(endLabel);
+        return StackValue.none();
     }
 
     @Override
-    public void visitConstantExpression(JetConstantExpression expression) {
+    public StackValue visitConstantExpression(JetConstantExpression expression, StackValue receiver) {
         CompileTimeConstant<?> compileTimeValue = bindingContext.get(BindingContext.COMPILE_TIME_VALUE, expression);
         assert compileTimeValue != null;
-        myStack.push(StackValue.constant(compileTimeValue.getValue(), expressionType(expression)));
+        return StackValue.constant(compileTimeValue.getValue(), expressionType(expression));
     }
 
     @Override
-    public void visitStringTemplateExpression(JetStringTemplateExpression expression) {
+    public StackValue visitStringTemplateExpression(JetStringTemplateExpression expression, StackValue receiver) {
         StringBuilder constantValue = new StringBuilder("");
         for (JetStringTemplateEntry entry : expression.getEntries()) {
             if (entry instanceof JetLiteralStringTemplateEntry) {
@@ -513,7 +498,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
         }
         if (constantValue != null) {
             final Type type = expressionType(expression);
-            myStack.push(StackValue.constant(constantValue.toString(), type));
+            return StackValue.constant(constantValue.toString(), type);
         }
         else {
             generateStringBuilderConstructor();
@@ -530,20 +515,22 @@ public class ExpressionCodegen extends JetVisitorVoid {
                 }
             }
             v.invokevirtual(CLASS_STRING_BUILDER, "toString", "()Ljava/lang/String;");
-            myStack.push(StackValue.onStack(expressionType(expression)));
+            return StackValue.onStack(expressionType(expression));
         }
     }
 
     @Override
-    public void visitBlockExpression(JetBlockExpression expression) {
+    public StackValue visitBlockExpression(JetBlockExpression expression, StackValue receiver) {
         List<JetElement> statements = expression.getStatements();
-        generateBlock(statements);
+        return generateBlock(statements);
     }
 
     @Override
-    public void visitFunctionLiteralExpression(JetFunctionLiteralExpression expression) {
-        if ((boolean) bindingContext.get(BindingContext.BLOCK, expression)) {
-            generateBlock(expression.getFunctionLiteral().getBodyExpression().getStatements());
+    public StackValue visitFunctionLiteralExpression(JetFunctionLiteralExpression expression, StackValue receiver) {
+        //noinspection ConstantConditions
+        if (bindingContext.get(BindingContext.BLOCK, expression)) {
+            //noinspection ConstantConditions
+            return generateBlock(expression.getFunctionLiteral().getBodyExpression().getStatements());
         }
         else {
             final GeneratedAnonymousClassDescriptor closure = new ClosureCodegen(state, this, context).gen(expression);
@@ -563,33 +550,40 @@ public class ExpressionCodegen extends JetVisitorVoid {
             }
 
             v.invokespecial(closure.getClassname(), "<init>", cons.getDescriptor());
+            return StackValue.onStack(Type.getObjectType(closure.getClassname()));
         }
     }
 
     @Override
-    public void visitObjectLiteralExpression(JetObjectLiteralExpression expression) {
+    public StackValue visitObjectLiteralExpression(JetObjectLiteralExpression expression, StackValue receiver) {
         GeneratedAnonymousClassDescriptor descriptor = state.generateObjectLiteral(expression, this, context);
-        v.anew(Type.getObjectType(descriptor.getClassname()));
+        Type type = Type.getObjectType(descriptor.getClassname());
+        v.anew(type);
         v.dup();
-        v.invokespecial(descriptor.getClassname(), "<init>", descriptor.getConstructor().getDescriptor());
+        v.load(0, JetTypeMapper.TYPE_OBJECT);
+        String jvmDescriptor = descriptor.getConstructor().getDescriptor().replace("(","(" + typeMapper.jetImplementationType((ClassDescriptor) contextType()));
+        v.invokespecial(descriptor.getClassname(), "<init>", jvmDescriptor);
+        return StackValue.onStack(type);
     }
 
-    private void generateBlock(List<JetElement> statements) {
+    private StackValue generateBlock(List<JetElement> statements) {
         Label blockStart = new Label();
         v.mark(blockStart);
 
         for (JetElement statement : statements) {
             if (statement instanceof JetProperty) {
-                final VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, (JetProperty) statement);
+                final VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, statement);
+                assert variableDescriptor != null;
                 final Type type = typeMapper.mapType(variableDescriptor.getOutType());
                 myMap.enter(variableDescriptor, type.getSize());
             }
         }
 
+        StackValue answer = StackValue.none();
         for (int i = 0, statementsSize = statements.size(); i < statementsSize; i++) {
             JetElement statement = statements.get(i);
-            if (i == statements.size() - 1) {
-                gen(statement);
+            if (i == statements.size() - 1 /*&& statement instanceof JetExpression && !bindingContext.get(BindingContext.STATEMENT, statement)*/) {
+                answer = gen(statement);
             }
             else {
                 gen(statement, Type.VOID_TYPE);
@@ -603,12 +597,15 @@ public class ExpressionCodegen extends JetVisitorVoid {
             if (statement instanceof JetProperty) {
                 JetProperty var = (JetProperty) statement;
                 VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, var);
+                assert variableDescriptor != null;
                 Type outType = typeMapper.mapType(variableDescriptor.getOutType());
 
                 int index = myMap.leave(variableDescriptor);
                 v.visitLocalVariable(var.getName(), outType.getDescriptor(), null, blockStart, blockEnd, index);
             }
         }
+
+        return answer;
     }
 
     private void markLineNumber(JetElement statement) {
@@ -627,7 +624,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
     }
 
     @Override
-    public void visitReturnExpression(JetReturnExpression expression) {
+    public StackValue visitReturnExpression(JetReturnExpression expression, StackValue receiver) {
         final JetExpression returnedExpression = expression.getReturnedExpression();
         if (returnedExpression != null) {
             gen(returnedExpression, returnType);
@@ -636,19 +633,34 @@ public class ExpressionCodegen extends JetVisitorVoid {
         else {
             v.visitInsn(Opcodes.RETURN);
         }
+        return StackValue.none();
     }
 
-    public void returnTopOfStack() {
-        if (myStack.size() > 0) {
-            putTopOfStack(returnType);
+    public void returnExpression(JetExpression expr) {
+        StackValue lastValue = gen(expr);
+        
+        if (lastValue.type != Type.VOID_TYPE) {
+            lastValue.put(returnType, v);
+            v.areturn(returnType);
+        }
+        else if (!endsWithReturn(expr)) {
             v.areturn(returnType);
         }
     }
 
+    private static boolean endsWithReturn(JetElement bodyExpression) {
+        if (bodyExpression instanceof JetBlockExpression) {
+            final List<JetElement> statements = ((JetBlockExpression) bodyExpression).getStatements();
+            return statements.size() > 0 && statements.get(statements.size()-1) instanceof JetReturnExpression;
+        }
+    
+        return bodyExpression instanceof JetReturnExpression;
+    }
+    
     @Override
-    public void visitSimpleNameExpression(JetSimpleNameExpression expression) {
+    public StackValue visitSimpleNameExpression(JetSimpleNameExpression expression, StackValue receiver) {
         DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression);
-        if (descriptor instanceof NamespaceDescriptor) return; // No code to generate
+        if (descriptor instanceof NamespaceDescriptor) return StackValue.none(); // No code to generate
 
         if (descriptor instanceof VariableAsFunctionDescriptor) {
             descriptor = ((VariableAsFunctionDescriptor) descriptor).getVariableDescriptor();
@@ -657,10 +669,10 @@ public class ExpressionCodegen extends JetVisitorVoid {
         final IntrinsicMethod intrinsic = intrinsics.getIntrinsic(descriptor);
         if (intrinsic != null) {
             final Type expectedType = expressionType(expression);
-            myStack.push(intrinsic.generate(this, v, expectedType, expression, Collections.<JetExpression>emptyList(), false));
-            return;
+            return intrinsic.generate(this, v, expectedType, expression, Collections.<JetExpression>emptyList(), receiver);
         }
 
+        assert descriptor != null;
         final DeclarationDescriptor container = descriptor.getContainingDeclaration();
 
         PsiElement declaration = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, descriptor);
@@ -670,15 +682,15 @@ public class ExpressionCodegen extends JetVisitorVoid {
             final Type fieldType = JetTypeMapper.psiTypeToAsm(psiField.getType());
             final boolean isStatic = psiField.hasModifierProperty(PsiModifier.STATIC);
             if (!isStatic) {
-                ensureReceiverOnStack(expression, null, JetTypeMapper.TYPE_OBJECT);
+                receiver.put(JetTypeMapper.TYPE_OBJECT, v);
             }
-            myStack.push(StackValue.field(fieldType, owner, psiField.getName(), isStatic));
+            return StackValue.field(fieldType, owner, psiField.getName(), isStatic);
         }
         else {
             int index = lookupLocal(descriptor);
             if (index >= 0) {
                 final JetType outType = ((VariableDescriptor) descriptor).getOutType();
-                myStack.push(StackValue.local(index, typeMapper.mapType(outType)));
+                return StackValue.local(index, typeMapper.mapType(outType));
             }
             else if (descriptor instanceof PropertyDescriptor) {
                 final PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
@@ -688,12 +700,12 @@ public class ExpressionCodegen extends JetVisitorVoid {
                     if (PsiTreeUtil.getParentOfType(expression, JetDelegationSpecifier.class) != null) {
                         JetClass aClass = PsiTreeUtil.getParentOfType(expression, JetClass.class);
                         ConstructorDescriptor constructorDescriptor = bindingContext.get(BindingContext.CONSTRUCTOR, aClass);
+                        assert constructorDescriptor != null;
                         List<ValueParameterDescriptor> parameters = constructorDescriptor.getValueParameters();
                         for (ValueParameterDescriptor parameter : parameters) {
                             if (parameter.getName().equals(descriptor.getName())) {
                                 final JetType outType = ((VariableDescriptor) descriptor).getOutType();
-                                myStack.push(StackValue.local(lookupLocal(parameter), typeMapper.mapType(outType)));
-                                return;
+                                return StackValue.local(lookupLocal(parameter), typeMapper.mapType(outType));
                             }
                         }
                     }
@@ -702,38 +714,58 @@ public class ExpressionCodegen extends JetVisitorVoid {
                 if (declaration instanceof JetObjectDeclarationName) {
                     JetObjectDeclaration objectDeclaration = PsiTreeUtil.getParentOfType(declaration, JetObjectDeclaration.class);
                     ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, objectDeclaration);
-                    myStack.push(StackValue.field(typeMapper.jvmType(classDescriptor, OwnerKind.IMPLEMENTATION),
+                    return StackValue.field(typeMapper.jvmType(classDescriptor, OwnerKind.IMPLEMENTATION),
                             typeMapper.jvmName(classDescriptor, OwnerKind.IMPLEMENTATION),
                             "$instance",
-                            true));
+                            true);
                 }
                 else {
                     boolean isStatic = container instanceof NamespaceDescriptorImpl;
                     final boolean directToField = expression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER;
-                    JetExpression receiver = getReceiverForSelector(expression);
-                    final boolean forceInterface = receiver != null && !(receiver instanceof JetThisExpression);
+                    JetExpression r = getReceiverForSelector(expression);
+                    final boolean forceInterface = r != null && !(r instanceof JetThisExpression);
                     final StackValue iValue = intermediateValueForProperty(propertyDescriptor, directToField, forceInterface);
                     if (!isStatic) {
-                        ensureReceiverOnStack(expression, container instanceof ClassDescriptor ? (ClassDescriptor) container : null, JetTypeMapper.TYPE_OBJECT);
+                        if (receiver == StackValue.none()) {
+                            receiver = generateThisOrOuter((ClassDescriptor) propertyDescriptor.getContainingDeclaration());
+                        }
+                        JetType receiverType = bindingContext.get(BindingContext.EXPRESSION_TYPE, r);
+                        receiver.put(receiverType != null ? typeMapper.mapType(receiverType) : JetTypeMapper.TYPE_OBJECT, v);
+                        if(receiverType != null) {
+                            ClassDescriptor propReceiverDescriptor = (ClassDescriptor) propertyDescriptor.getContainingDeclaration();
+                            if(!CodegenUtil.isInterface(propReceiverDescriptor) && CodegenUtil.isInterface(receiverType.getConstructor().getDeclarationDescriptor())) {
+                                // I hope it happens only in case of required super class for traits
+                                v.checkcast(typeMapper.mapType(propReceiverDescriptor.getDefaultType()));
+                            }
+                        }
                     }
-                    myStack.push(iValue);
+                    return iValue;
                 }
             }
             else if (descriptor instanceof ClassDescriptor) {
-                final JetClassObject classObject = ((JetClass) declaration).getClassObject();
-                if (classObject == null) {
-                    throw new UnsupportedOperationException("trying to reference a class which doesn't have a class object");
+                if(declaration instanceof JetClass) {
+                    final JetClassObject classObject = ((JetClass) declaration).getClassObject();
+                    if (classObject == null) {
+                        throw new UnsupportedOperationException("trying to reference a class which doesn't have a class object");
+                    }
+                    final String type = typeMapper.jvmName(classObject);
+                    return StackValue.field(Type.getObjectType(type),
+                                                  typeMapper.jvmName((ClassDescriptor) descriptor, OwnerKind.IMPLEMENTATION),
+                                                  "$classobj",
+                                                  true);
+                }
+                else {
+                    // todo ?
+                    return StackValue.none();
                 }
-                final String type = typeMapper.jvmName(classObject);
-                myStack.push(StackValue.field(Type.getObjectType(type),
-                                              typeMapper.jvmName((ClassDescriptor) descriptor, OwnerKind.IMPLEMENTATION),
-                                              "$classobj",
-                                              true));
             }
             else if (descriptor instanceof TypeParameterDescriptor) {
-                loadTypeParameterTypeInfo((TypeParameterDescriptor) descriptor);
+                TypeParameterDescriptor typeParameterDescriptor = (TypeParameterDescriptor) descriptor;
+                loadTypeParameterTypeInfo(typeParameterDescriptor);
                 v.invokevirtual("jet/typeinfo/TypeInfo", "getClassObject", "()Ljava/lang/Object;");
-                myStack.push(StackValue.onStack(OBJECT_TYPE));
+                v.checkcast(typeMapper.mapType(typeParameterDescriptor.getClassObjectType()));
+
+                return StackValue.onStack(OBJECT_TYPE);
             }
             else {
                 // receiver
@@ -743,7 +775,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
                 if (value == null) {
                     throw new UnsupportedOperationException("don't know how to generate reference " + descriptor);
                 }
-                myStack.push(value);
+                return value;
             }
         }
     }
@@ -752,11 +784,43 @@ public class ExpressionCodegen extends JetVisitorVoid {
         return myMap.getIndex(descriptor);
     }
 
+    public void invokeFunctionNoParams(FunctionDescriptor functionDescriptor, Type type, InstructionAdapter v) {
+        DeclarationDescriptor containingDeclaration = functionDescriptor.getContainingDeclaration();
+        boolean isStatic = containingDeclaration instanceof NamespaceDescriptorImpl;
+        functionDescriptor = functionDescriptor.getOriginal();
+        String owner;
+
+        boolean isInterface;
+        boolean isInsideClass = containingDeclaration == contextType();
+        if (isInsideClass || isStatic) {
+            owner = typeMapper.getOwner(functionDescriptor, contextKind());
+            isInterface = false;
+        }
+        else {
+            owner = typeMapper.getOwner(functionDescriptor, OwnerKind.IMPLEMENTATION);
+            if(containingDeclaration instanceof JavaClassDescriptor) {
+                PsiClass psiElement = (PsiClass) bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, containingDeclaration);
+                assert psiElement != null;
+                isInterface = psiElement.isInterface();
+            }
+            else {
+                if(containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).getKind() == ClassKind.OBJECT)
+                    isInterface = false;
+                else {
+                    JetClass jetClass = (JetClass) bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, containingDeclaration);
+                    isInterface = jetClass == null || jetClass.isTrait();
+                }
+            }
+        }
+
+        v.visitMethodInsn(isStatic ? Opcodes.INVOKESTATIC : isInterface ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, owner, functionDescriptor.getName(), typeMapper.mapSignature(functionDescriptor.getName(),functionDescriptor).getDescriptor());
+        StackValue.onStack(typeMapper.mapType(functionDescriptor.getReturnType())).coerce(type, v);
+    }
+
     public StackValue intermediateValueForProperty(PropertyDescriptor propertyDescriptor, final boolean forceField, boolean forceInterface) {
         DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
         boolean isStatic = containingDeclaration instanceof NamespaceDescriptorImpl;
         propertyDescriptor = propertyDescriptor.getOriginal();
-        final JetType outType = propertyDescriptor.getOutType();
         boolean isInsideClass = !forceInterface && containingDeclaration == contextType();
         Method getter;
         Method setter;
@@ -765,8 +829,12 @@ public class ExpressionCodegen extends JetVisitorVoid {
             setter = null;
         }
         else {
-            getter = isInsideClass && propertyDescriptor.getGetter() == null ? null : typeMapper.mapGetterSignature(propertyDescriptor);
-            setter = isInsideClass && propertyDescriptor.getSetter() == null ? null : typeMapper.mapSetterSignature(propertyDescriptor);
+            //noinspection ConstantConditions
+            getter = isInsideClass && (propertyDescriptor.getGetter() == null || propertyDescriptor.getGetter().isDefault())
+                     ? null : typeMapper.mapGetterSignature(propertyDescriptor);
+            //noinspection ConstantConditions
+            setter = isInsideClass && (propertyDescriptor.getSetter() == null || propertyDescriptor.getSetter().isDefault())
+                     ? null : typeMapper.mapSetterSignature(propertyDescriptor);
         }
 
         String owner;
@@ -776,43 +844,45 @@ public class ExpressionCodegen extends JetVisitorVoid {
             isInterface = false;
         }
         else {
-            owner = typeMapper.getOwner(propertyDescriptor, OwnerKind.INTERFACE);
-            isInterface = !(containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).isObject());
+            owner = typeMapper.getOwner(propertyDescriptor, OwnerKind.IMPLEMENTATION);
+            if(containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).getKind() == ClassKind.OBJECT)
+                isInterface = false;
+            else {
+                JetClass jetClass = (JetClass) bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, containingDeclaration);
+                isInterface = jetClass == null || jetClass.isTrait();
+            }
         }
 
-        return StackValue.property(propertyDescriptor.getName(), owner, typeMapper.mapType(outType), isStatic, isInterface, getter, setter);
+        return StackValue.property(propertyDescriptor.getName(), owner, typeMapper.mapType(propertyDescriptor.getOutType()), isStatic, isInterface, getter, setter);
     }
 
     @Override
-    public void visitCallExpression(JetCallExpression expression) {
+    public StackValue visitCallExpression(JetCallExpression expression, StackValue receiver) {
         final JetExpression callee = expression.getCalleeExpression();
         DeclarationDescriptor funDescriptor = resolveCalleeDescriptor(expression);
 
         if (funDescriptor instanceof ConstructorDescriptor) {
-            generateConstructorCall(expression, (JetSimpleNameExpression) callee);
+            return generateConstructorCall(expression, (JetSimpleNameExpression) callee, receiver);
         }
         else if (funDescriptor instanceof FunctionDescriptor) {
             final FunctionDescriptor fd = (FunctionDescriptor) funDescriptor;
-            final StackValue stackValue = invokeFunction(expression, fd, false);
-            if (stackValue != null) {
-                myStack.push(stackValue);
-            }
+            return invokeFunction(expression, fd, receiver);
         }
         else {
             throw new UnsupportedOperationException("unknown type of callee descriptor: " + funDescriptor);
         }
     }
 
-    private StackValue invokeFunction(JetCallExpression expression, DeclarationDescriptor fd, boolean haveReceiver) {
+    private StackValue invokeFunction(JetCallExpression expression, DeclarationDescriptor fd, StackValue receiver) {
         Callable callableMethod = resolveToCallable(fd);
-        return invokeCallable(fd, callableMethod, expression, haveReceiver);
+        return invokeCallable(fd, callableMethod, expression, receiver);
     }
 
     @Nullable
-    private StackValue invokeCallable(DeclarationDescriptor fd, Callable callable, JetCallExpression expression, boolean haveReceiver) {
+    private StackValue invokeCallable(DeclarationDescriptor fd, Callable callable, JetCallExpression expression, StackValue receiver) {
         if (callable instanceof CallableMethod) {
             final CallableMethod callableMethod = (CallableMethod) callable;
-            invokeMethodWithArguments(callableMethod, expression, haveReceiver);
+            invokeMethodWithArguments(callableMethod, expression, receiver);
 
             final Type callReturnType = callableMethod.getSignature().getReturnType();
             return returnValueAsStackValue((FunctionDescriptor) fd, callReturnType);
@@ -820,10 +890,10 @@ public class ExpressionCodegen extends JetVisitorVoid {
         else {
             IntrinsicMethod intrinsic = (IntrinsicMethod) callable;
             List<JetExpression> args = new ArrayList<JetExpression>();
-            for (JetValueArgument argument : expression.getValueArguments()) {
+            for (ValueArgument argument : expression.getValueArguments()) {
                 args.add(argument.getArgumentExpression());
             }
-            return intrinsic.generate(this, v, expressionType(expression), expression, args, haveReceiver);
+            return intrinsic.generate(this, v, expressionType(expression), expression, args, receiver);
         }
     }
 
@@ -833,7 +903,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
             StackValue.onStack(callReturnType).upcast(retType, v);
             return StackValue.onStack(retType);
         }
-        return null;
+        return StackValue.none();
     }
 
     private Callable resolveToCallable(DeclarationDescriptor fd) {
@@ -845,7 +915,10 @@ public class ExpressionCodegen extends JetVisitorVoid {
 
         CallableMethod callableMethod;
         if (declarationPsiElement instanceof PsiMethod || declarationPsiElement instanceof JetNamedFunction) {
-            callableMethod = typeMapper.mapToCallableMethod((PsiNamedElement) declarationPsiElement);
+            callableMethod = typeMapper.mapToCallableMethod((PsiNamedElement) declarationPsiElement, null);
+        }
+        else if (fd instanceof VariableAsFunctionDescriptor) {
+            callableMethod = ClosureCodegen.asCallableMethod((FunctionDescriptor) fd);
         }
         else if (fd instanceof FunctionDescriptor) {
             callableMethod = ClosureCodegen.asCallableMethod((FunctionDescriptor) fd);
@@ -868,20 +941,24 @@ public class ExpressionCodegen extends JetVisitorVoid {
         return funDescriptor;
     }
 
-    public void invokeMethodWithArguments(CallableMethod callableMethod, JetCall expression) {
-        invokeMethodWithArguments(callableMethod, expression, false);
+    public void invokeMethodWithArguments(CallableMethod callableMethod, JetCallElement expression) {
+        invokeMethodWithArguments(callableMethod, expression, StackValue.none());
     }
 
-    public void invokeMethodWithArguments(CallableMethod callableMethod, JetCall expression, final boolean haveReceiver) {
+    public void invokeMethodWithArguments(CallableMethod callableMethod, JetCallElement expression, StackValue receiver) {
         final Type calleeType = callableMethod.getGenerateCalleeType();
         if (calleeType != null && expression instanceof JetCallExpression) {
-            gen(((JetCallExpression) expression).getCalleeExpression(), calleeType);
+            gen(expression.getCalleeExpression(), calleeType);
         }
         if (callableMethod.isOwnerFromCall()) {
             setOwnerFromCall(callableMethod, expression);
         }
-        if (callableMethod.needsReceiverOnStack() && !haveReceiver) {
-            ensureReceiverOnStack(expression, callableMethod.getReceiverClass(), JetTypeMapper.TYPE_OBJECT);
+        if (callableMethod.needsReceiverOnStack()) {
+            if (receiver == StackValue.none()) {
+                ClassDescriptor receiverClass = callableMethod.getReceiverClass();
+                receiver = receiverClass == null ? thisExpression() : generateThisOrOuter(receiverClass);
+            }
+            receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         }
         pushMethodArguments(expression, callableMethod.getValueParameterTypes());
         if (callableMethod.acceptsTypeArguments()) {
@@ -890,10 +967,11 @@ public class ExpressionCodegen extends JetVisitorVoid {
         callableMethod.invoke(v);
     }
 
-    private void setOwnerFromCall(CallableMethod callableMethod, JetCall expression) {
+    private void setOwnerFromCall(CallableMethod callableMethod, JetCallElement expression) {
         if (expression.getParent() instanceof JetQualifiedExpression) {
             final JetExpression receiver = ((JetQualifiedExpression) expression.getParent()).getReceiverExpression();
             JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, receiver);
+            assert expressionType != null;
             DeclarationDescriptor declarationDescriptor = expressionType.getConstructor().getDeclarationDescriptor();
             PsiElement ownerDeclaration = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, declarationDescriptor);
             if (ownerDeclaration instanceof PsiClass) {
@@ -910,33 +988,6 @@ public class ExpressionCodegen extends JetVisitorVoid {
         return null;
     }
 
-    public void ensureReceiverOnStack(PsiElement expression, @Nullable ClassDescriptor calleeContainingClass,
-                                      final Type expectedReceiverType) {
-        final StackValue receiver = getReceiverAsStackValue(expression, calleeContainingClass, expectedReceiverType);
-        if (receiver != null) {
-            receiver.put(receiver.type, v);
-        }
-    }
-
-    @Nullable
-    public StackValue getReceiverAsStackValue(PsiElement expression, @Nullable ClassDescriptor calleeContainingClass, Type expectedReceiverType) {
-        JetExpression receiver = getReceiverForSelector(expression);
-        if (receiver != null) {
-            if (!resolvesToClassOrPackage(receiver)) {
-                // we have a receiver on stack
-                if (myStack.isEmpty()) {
-                    throw new IllegalStateException("expected receiver on stack but it's not there: " + receiver.getText());
-                }
-                return myStack.pop();
-            }
-        }
-        else if (!(expression.getParent() instanceof JetSafeQualifiedExpression) &&
-                 !(expression.getParent() instanceof JetPredicateExpression)) {
-            return generateThisOrOuter(calleeContainingClass);
-        }
-        return null;
-    }
-
     private static boolean isSubclass(ClassDescriptor subClass, ClassDescriptor superClass) {
         Set<JetType> allSuperTypes = new THashSet<JetType>();
 
@@ -946,7 +997,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
 
         for (JetType superType : allSuperTypes) {
             final DeclarationDescriptor descriptor = superType.getConstructor().getDeclarationDescriptor();
-            if (descriptor != null && superOriginal == descriptor.getOriginal()) {
+            if (descriptor != null && superOriginal.equals(descriptor.getOriginal())) {
                 return true;
             }
         }
@@ -1009,30 +1060,32 @@ public class ExpressionCodegen extends JetVisitorVoid {
         return false;
     }
 
-    private void pushMethodArguments(JetCall expression, List<Type> valueParameterTypes) {
-        List<JetValueArgument> args = expression.getValueArguments();
+    private void pushMethodArguments(JetCallElement expression, List<Type> valueParameterTypes) {
+        List<? extends ValueArgument> args = expression.getValueArguments();
         for (int i = 0, argsSize = args.size(); i < argsSize; i++) {
-            JetValueArgument arg = args.get(i);
+            ValueArgument arg = args.get(i);
             gen(arg.getArgumentExpression(), valueParameterTypes.get(i));
         }
     }
 
     public Type expressionType(JetExpression expr) {
-        return typeMapper.mapType(bindingContext.get(BindingContext.EXPRESSION_TYPE, expr));
+        JetType type = bindingContext.get(BindingContext.EXPRESSION_TYPE, expr);
+        return type == null ? Type.VOID_TYPE : typeMapper.mapType(type);
     }
 
     public int indexOfLocal(JetReferenceExpression lhs) {
         final DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, lhs);
         return lookupLocal(declarationDescriptor);
     }
+    
+    
 
     @Override
-    public void visitDotQualifiedExpression(JetDotQualifiedExpression expression) {
-        JetExpression receiver = expression.getReceiverExpression();
-        if (!resolvesToClassOrPackage(receiver)) {
-            gen(expression.getReceiverExpression());
-        }
-        gen(expression.getSelectorExpression());
+    public StackValue visitDotQualifiedExpression(JetDotQualifiedExpression expression, StackValue receiver) {
+        StackValue receiverValue = resolvesToClassOrPackage(expression.getReceiverExpression())
+                                   ? StackValue.none()
+                                   : genQualified(receiver, expression.getReceiverExpression());
+        return genQualified(receiverValue, expression.getSelectorExpression());
     }
 
     private boolean resolvesToClassOrPackage(JetExpression receiver) {
@@ -1047,87 +1100,157 @@ public class ExpressionCodegen extends JetVisitorVoid {
     }
 
     @Override
-    public void visitSafeQualifiedExpression(JetSafeQualifiedExpression expression) {
+    public StackValue visitSafeQualifiedExpression(JetSafeQualifiedExpression expression, StackValue receiver) {
         genToJVMStack(expression.getReceiverExpression());
         Label ifnull = new Label();
         Label end = new Label();
         v.dup();
         v.ifnull(ifnull);
-        gen(expression.getSelectorExpression());
+        JetType receiverType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression.getReceiverExpression());
+        StackValue propValue = genQualified(StackValue.onStack(typeMapper.mapType(receiverType)), expression.getSelectorExpression());
+        Type type = propValue.type;
+        propValue.put(type, v);
+        if(JetTypeMapper.isPrimitive(type) && !type.equals(Type.VOID_TYPE)) {
+            StackValue.valueOf(v, type);
+            type = JetTypeMapper.boxType(type);
+        }
         v.goTo(end);
+
         v.mark(ifnull);
-        // null is already on stack here after the dup
-        JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression);
-        if (expressionType.equals(JetStandardClasses.getUnitType())) {
-            v.pop();
+        v.pop();
+        if(!propValue.type.equals(Type.VOID_TYPE)) {
+            v.aconst(null);
         }
         v.mark(end);
+
+        return StackValue.onStack(type);
     }
 
     @Override
-    public void visitPredicateExpression(JetPredicateExpression expression) {
-        genToJVMStack(expression.getReceiverExpression());
+    public StackValue visitPredicateExpression(JetPredicateExpression expression, StackValue receiver) {
+        JetExpression expr = expression.getReceiverExpression();
+        StackValue value = gen(expr);
+        Type receiverType = expressionType(expr);
+        value.put(receiverType, v);
         Label ifFalse = new Label();
         Label end = new Label();
         v.dup();
-        StackValue result = generateIntermediateValue(expression.getSelectorExpression());
+        StackValue result = genQualified(StackValue.onStack(receiverType), expression.getSelectorExpression());
         result.condJump(ifFalse, true, v);
         v.goTo(end);
         v.mark(ifFalse);
         v.pop();
         v.aconst(null);
         v.mark(end);
-        myStack.push(StackValue.onStack(typeMapper.mapType(bindingContext.get(BindingContext.EXPRESSION_TYPE, expression))));
+        return StackValue.onStack(expressionType(expression));
     }
 
     @Override
-    public void visitBinaryExpression(JetBinaryExpression expression) {
+    public StackValue visitBinaryExpression(JetBinaryExpression expression, StackValue receiver) {
         final IElementType opToken = expression.getOperationReference().getReferencedNameElementType();
         if (opToken == JetTokens.EQ) {
-            generateAssignmentExpression(expression);
+            return generateAssignmentExpression(expression);
         }
         else if (JetTokens.AUGMENTED_ASSIGNMENTS.contains(opToken)) {
-            generateAugmentedAssignment(expression);
+            return generateAugmentedAssignment(expression);
         }
         else if (opToken == JetTokens.ANDAND) {
-            generateBooleanAnd(expression);
+            return generateBooleanAnd(expression);
         }
         else if (opToken == JetTokens.OROR) {
-            generateBooleanOr(expression);
+            return generateBooleanOr(expression);
         }
         else if (opToken == JetTokens.EQEQ || opToken == JetTokens.EXCLEQ ||
                  opToken == JetTokens.EQEQEQ || opToken == JetTokens.EXCLEQEQEQ) {
-            generateEquals(expression.getLeft(), expression.getRight(), opToken);
+            return generateEquals(expression.getLeft(), expression.getRight(), opToken);
         }
         else if (opToken == JetTokens.LT || opToken == JetTokens.LTEQ ||
                  opToken == JetTokens.GT || opToken == JetTokens.GTEQ) {
-            generateCompareOp(expression.getLeft(), expression.getRight(), opToken, expressionType(expression.getLeft()));
+            return generateCompareOp(expression.getLeft(), expression.getRight(), opToken, expressionType(expression.getLeft()));
         }
         else if (opToken == JetTokens.ELVIS) {
-            generateElvis(expression);
+            return generateElvis(expression);
+        }
+        else if(opToken == JetTokens.IN_KEYWORD || opToken == JetTokens.NOT_IN) {
+            return generateIn (expression);
         }
         else {
             DeclarationDescriptor op = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getOperationReference());
             final Callable callable = resolveToCallable(op);
             if (callable instanceof IntrinsicMethod) {
                 IntrinsicMethod intrinsic = (IntrinsicMethod) callable;
-                myStack.push(intrinsic.generate(this, v, expressionType(expression), expression,
-                                                Arrays.asList(expression.getLeft(), expression.getRight()), false));
+                return intrinsic.generate(this, v, expressionType(expression), expression,
+                                          Arrays.asList(expression.getLeft(), expression.getRight()), receiver);
             }
             else {
                 CallableMethod callableMethod = (CallableMethod) callable;
                 genToJVMStack(expression.getLeft());
                 genToJVMStack(expression.getRight());
                 callableMethod.invoke(v);
-                final StackValue value = returnValueAsStackValue((FunctionDescriptor) op, callableMethod.getSignature().getReturnType());
-                if (value != null) {
-                    myStack.push(value);
-                }
+                return  returnValueAsStackValue((FunctionDescriptor) op, callableMethod.getSignature().getReturnType());
             }
         }
     }
 
-    private void generateBooleanAnd(JetBinaryExpression expression) {
+    private StackValue generateIn(JetBinaryExpression expression) {
+        JetExpression expr = expression.getLeft();
+        StackValue leftValue = gen(expr);
+        if(isIntRangeExpr(expression.getRight())) {
+            JetBinaryExpression rangeExpression = (JetBinaryExpression) expression.getRight();
+            boolean inverted = expression.getOperationReference().getReferencedNameElementType() == JetTokens.NOT_IN;
+            getInIntRange(leftValue, rangeExpression, inverted);
+        }
+        else {
+            FunctionDescriptor op = (FunctionDescriptor) bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getOperationReference());
+            leftValue.put(typeMapper.mapType(op.getValueParameters().get(0).getOutType()), v);
+            genToJVMStack(expression.getRight());
+            v.swap();
+            invokeFunctionNoParams(op, Type.BOOLEAN_TYPE, v);
+        }
+        return StackValue.onStack(Type.BOOLEAN_TYPE);
+    }
+
+    private void getInIntRange(StackValue leftValue, JetBinaryExpression rangeExpression, boolean inverted) {
+        v.iconst(1);
+        // 1
+        leftValue.put(Type.INT_TYPE, v);
+        // 1 l
+        v.dup2();
+        // 1 l 1 l
+
+        //noinspection ConstantConditions
+        gen(rangeExpression.getLeft(), Type.INT_TYPE);
+        // 1 l 1 l r
+        Label lok = new Label();
+        v.ificmpge(lok);
+        // 1 l 1
+        v.pop();
+        v.iconst(0);
+        v.mark(lok);
+        // 1 l c
+        v.dupX2();
+        // c 1 l c
+        v.pop();
+        // c 1 l
+
+        gen(rangeExpression.getRight(), Type.INT_TYPE);
+        // c 1 l r
+        Label rok = new Label();
+        v.ificmple(rok);
+        // c 1
+        v.pop();
+        v.iconst(0);
+        v.mark(rok);
+        // c c
+
+        v.and(Type.INT_TYPE);
+        if(inverted) {
+            v.iconst(1);
+            v.xor(Type.INT_TYPE);
+        }
+    }
+
+    private StackValue generateBooleanAnd(JetBinaryExpression expression) {
         gen(expression.getLeft(), Type.BOOLEAN_TYPE);
         Label ifFalse = new Label();
         v.ifeq(ifFalse);
@@ -1135,12 +1258,12 @@ public class ExpressionCodegen extends JetVisitorVoid {
         Label end = new Label();
         v.goTo(end);
         v.mark(ifFalse);
-        v.aconst(false);
+        v.iconst(0);
         v.mark(end);
-        myStack.push(StackValue.onStack(Type.BOOLEAN_TYPE));
+        return StackValue.onStack(Type.BOOLEAN_TYPE);
     }
 
-    private void generateBooleanOr(JetBinaryExpression expression) {
+    private StackValue generateBooleanOr(JetBinaryExpression expression) {
         gen(expression.getLeft(), Type.BOOLEAN_TYPE);
         Label ifTrue = new Label();
         v.ifne(ifTrue);
@@ -1148,20 +1271,62 @@ public class ExpressionCodegen extends JetVisitorVoid {
         Label end = new Label();
         v.goTo(end);
         v.mark(ifTrue);
-        v.aconst(true);
+        v.iconst(1);
         v.mark(end);
-        myStack.push(StackValue.onStack(Type.BOOLEAN_TYPE));
+        return StackValue.onStack(Type.BOOLEAN_TYPE);
     }
 
-    private void generateEquals(JetExpression left, JetExpression right, IElementType opToken) {
-        final Type leftType = expressionType(left);
-        final Type rightType = expressionType(right);
-        gen(left, leftType);
-        gen(right, rightType);
-        myStack.push(generateEqualsForExpressionsOnStack(opToken, leftType, rightType));
+    private StackValue generateEquals(JetExpression left, JetExpression right, IElementType opToken) {
+        JetType leftJetType = bindingContext.get(BindingContext.EXPRESSION_TYPE, left);
+        Type leftType = typeMapper.mapType(leftJetType);
+        JetType rightJetType = bindingContext.get(BindingContext.EXPRESSION_TYPE, right);
+        Type rightType = typeMapper.mapType(rightJetType);
+        if(leftType == JetTypeMapper.TYPE_NOTHING) {
+            return genCmpWithNull(right, rightType, opToken);
+        }
+
+        if(rightType == JetTypeMapper.TYPE_NOTHING) {
+            return genCmpWithNull(left, leftType, opToken);
+        }
+
+        if(JetTypeMapper.isPrimitive(leftType) != JetTypeMapper.isPrimitive(rightType)) {
+            gen(left, leftType);
+            StackValue.valueOf(v, leftType);
+            leftType = JetTypeMapper.boxType(leftType);
+            gen(right, rightType);
+            StackValue.valueOf(v, rightType);
+            rightType = JetTypeMapper.boxType(rightType);
+        }
+        else {
+            gen(left, leftType);
+            gen(right, rightType);
+        }
+
+        if(JetTypeMapper.isPrimitive(leftType)) // both are primitive
+            return generateEqualsForExpressionsOnStack(opToken, leftType, rightType, false, false);
+
+        assert leftJetType != null;
+        assert rightJetType != null;
+        return generateEqualsForExpressionsOnStack(opToken, leftType, rightType, leftJetType.isNullable(), rightJetType.isNullable());
     }
 
-    private StackValue generateEqualsForExpressionsOnStack(IElementType opToken, Type leftType, Type rightType) {
+    private StackValue genCmpWithNull(JetExpression exp, Type expType, IElementType opToken) {
+        v.iconst(1);
+        gen(exp, JetTypeMapper.boxType(expType));
+        Label ok = new Label();
+        if(JetTokens.EQEQ == opToken || JetTokens.EQEQEQ == opToken) {
+            v.ifnull(ok);
+        }
+        else {
+            v.ifnonnull(ok);
+        }
+        v.pop();
+        v.iconst(0);
+        v.mark(ok);
+        return StackValue.onStack(Type.BOOLEAN_TYPE);
+    }
+
+    private StackValue generateEqualsForExpressionsOnStack(IElementType opToken, Type leftType, Type rightType, boolean leftNullable, boolean rightNullable) {
         if (isNumberPrimitive(leftType) && leftType == rightType) {
             return compareExpressionsOnStack(opToken, leftType);
         }
@@ -1170,41 +1335,70 @@ public class ExpressionCodegen extends JetVisitorVoid {
                 return StackValue.cmp(opToken, leftType);
             }
             else {
-                return generateNullSafeEquals(opToken);
+                return generateNullSafeEquals(opToken, leftNullable, rightNullable);
             }
         }
     }
 
-    private StackValue generateNullSafeEquals(IElementType opToken) {
-        v.dup2();   // left right left right
-        Label rightNull = new Label();
-        v.ifnull(rightNull);
-        Label leftNull = new Label();
-        v.ifnull(leftNull);
-        v.invokevirtual(CLASS_OBJECT, "equals", "(Ljava/lang/Object;)Z");
-        Label end = new Label();
-        v.goTo(end);
-        v.mark(rightNull);
-        // left right left
-        Label bothNull = new Label();
-        v.ifnull(bothNull);
-        v.mark(leftNull);
-        v.pop2();
-        v.aconst(Boolean.FALSE);
-        v.goTo(end);
-        v.mark(bothNull);
-        v.pop2();
-        v.aconst(Boolean.TRUE);
-        v.mark(end);
-
-        final StackValue onStack = StackValue.onStack(Type.BOOLEAN_TYPE);
-        if (opToken == JetTokens.EXCLEQ) {
-            return StackValue.not(onStack);
+    private StackValue generateNullSafeEquals(IElementType opToken, boolean leftNullable, boolean rightNullable) {
+        if(!leftNullable) {
+            v.invokevirtual(CLASS_OBJECT, "equals", "(Ljava/lang/Object;)Z");
+            if (opToken == JetTokens.EXCLEQ) {
+                v.iconst(1);
+                v.xor(Type.INT_TYPE);
+            }
         }
-        return onStack;
+        else {
+            if(rightNullable) {
+                v.dup2();   // left right left right
+                Label rightNull = new Label();
+                v.ifnull(rightNull);
+                Label leftNull = new Label();
+                v.ifnull(leftNull);
+                v.invokevirtual(CLASS_OBJECT, "equals", "(Ljava/lang/Object;)Z");
+                if (opToken == JetTokens.EXCLEQ || opToken == JetTokens.EXCLEQEQEQ) {
+                    v.iconst(1);
+                    v.xor(Type.INT_TYPE);
+                }
+                Label end = new Label();
+                v.goTo(end);
+                v.mark(rightNull);
+                // left right left
+                Label bothNull = new Label();
+                v.ifnull(bothNull);
+                v.mark(leftNull);
+                v.pop2();
+                v.iconst(opToken == JetTokens.EXCLEQ || opToken == JetTokens.EXCLEQEQEQ ? 1 : 0);
+                v.goTo(end);
+                v.mark(bothNull);
+                v.pop2();
+                v.iconst(opToken == JetTokens.EXCLEQ || opToken == JetTokens.EXCLEQEQEQ ? 0 : 1);
+                v.mark(end);
+            }
+            else {
+                v.dup2();   // left right left right
+                v.pop();
+                Label leftNull = new Label();
+                v.ifnull(leftNull);
+                v.invokevirtual(CLASS_OBJECT, "equals", "(Ljava/lang/Object;)Z");
+                if (opToken == JetTokens.EXCLEQ || opToken == JetTokens.EXCLEQEQEQ) {
+                    v.iconst(1);
+                    v.xor(Type.INT_TYPE);
+                }
+                Label end = new Label();
+                v.goTo(end);
+                // left right
+                v.mark(leftNull);
+                v.pop2();
+                v.iconst(opToken == JetTokens.EXCLEQ ? 1 : 0);
+                v.mark(end);
+            }
+        }
+
+        return StackValue.onStack(Type.BOOLEAN_TYPE);
     }
 
-    private void generateElvis(JetBinaryExpression expression) {
+    private StackValue generateElvis(JetBinaryExpression expression) {
         final Type exprType = expressionType(expression);
         final Type leftType = expressionType(expression.getLeft());
         gen(expression.getLeft(), leftType);
@@ -1218,7 +1412,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
         v.pop();
         gen(expression.getRight(), exprType);
         v.mark(end);
-        myStack.push(StackValue.onStack(exprType));
+        return StackValue.onStack(exprType);
     }
 
     private static boolean isNumberPrimitive(DeclarationDescriptor descriptor) {
@@ -1243,39 +1437,42 @@ public class ExpressionCodegen extends JetVisitorVoid {
         return JetTypeMapper.isIntPrimitive(type) || type == Type.FLOAT_TYPE || type == Type.DOUBLE_TYPE || type == Type.LONG_TYPE;
     }
 
-    private void generateCompareOp(JetExpression left, JetExpression right, IElementType opToken, Type operandType) {
+    private StackValue generateCompareOp(JetExpression left, JetExpression right, IElementType opToken, Type operandType) {
         gen(left, operandType);
         gen(right, operandType);
-        myStack.push(compareExpressionsOnStack(opToken, operandType));
+        return compareExpressionsOnStack(opToken, operandType);
     }
 
     private StackValue compareExpressionsOnStack(IElementType opToken, Type operandType) {
         if (operandType.getSort() == Type.OBJECT) {
             v.invokeinterface(CLASS_COMPARABLE, "compareTo", "(Ljava/lang/Object;)I");
-            v.aconst(0);
+            v.iconst(0);
             operandType = Type.INT_TYPE;
         }
         return StackValue.cmp(opToken, operandType);
     }
 
-    private void generateAssignmentExpression(JetBinaryExpression expression) {
-        StackValue stackValue = generateIntermediateValue(expression.getLeft());
-        genToJVMStack(expression.getRight());
+    private StackValue generateAssignmentExpression(JetBinaryExpression expression) {
+        StackValue stackValue = gen(expression.getLeft());
+        gen(expression.getRight(), stackValue.type);
         stackValue.store(v);
+        return StackValue.none();
     }
 
-    private void generateAugmentedAssignment(JetBinaryExpression expression) {
+    private StackValue generateAugmentedAssignment(JetBinaryExpression expression) {
         DeclarationDescriptor op = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getOperationReference());
         final Callable callable = resolveToCallable(op);
         final JetExpression lhs = expression.getLeft();
         Type lhsType = expressionType(lhs);
-        if ((boolean) bindingContext.get(BindingContext.VARIABLE_REASSIGNMENT, expression)) {
+        //noinspection ConstantConditions
+        if (bindingContext.get(BindingContext.VARIABLE_REASSIGNMENT, expression)) {
             if (callable instanceof IntrinsicMethod) {
-                StackValue value = generateIntermediateValue(lhs);              // receiver
+                StackValue value = gen(lhs);              // receiver
                 value.dupReceiver(v, 0);                                        // receiver receiver
                 value.put(lhsType, v);                                          // receiver lhs
                 final IntrinsicMethod intrinsic = (IntrinsicMethod) callable;
-                intrinsic.generate(this, v, lhsType, expression, Arrays.asList(lhs, expression.getRight()), true);
+                //noinspection NullableProblems
+                intrinsic.generate(this, v, lhsType, expression, Arrays.asList(expression.getRight()), null);
                 value.store(v);
             }
             else {
@@ -1283,13 +1480,16 @@ public class ExpressionCodegen extends JetVisitorVoid {
             }
         }
         else {
+            assert op != null;
             final boolean keepReturnValue = !((FunctionDescriptor) op).getReturnType().equals(JetStandardClasses.getUnitType());
             callAugAssignMethod(expression, (CallableMethod) callable, lhsType, keepReturnValue);
         }
+        
+        return StackValue.none();
     }
 
     private void callAugAssignMethod(JetBinaryExpression expression, CallableMethod callable, Type lhsType, final boolean keepReturnValue) {
-        StackValue value = generateIntermediateValue(expression.getLeft());
+        StackValue value = gen(expression.getLeft());
         if (keepReturnValue) {
             value.dupReceiver(v, 0);
         }
@@ -1302,7 +1502,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
     }
 
     public void generateStringBuilderConstructor() {
-        Type type = Type.getObjectType(CLASS_STRING_BUILDER);
+        Type type = JetTypeMapper.JL_STRING_BUILDER;
         v.anew(type);
         v.dup();
         Method method = new Method("<init>", Type.VOID_TYPE, new Type[0]);
@@ -1324,85 +1524,84 @@ public class ExpressionCodegen extends JetVisitorVoid {
     }
 
     public void invokeAppendMethod(Type exprType) {
-        Method appendDescriptor = new Method("append", Type.getObjectType(CLASS_STRING_BUILDER),
+        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());
     }
 
     @Override
-    public void visitPrefixExpression(JetPrefixExpression expression) {
+    public StackValue visitPrefixExpression(JetPrefixExpression expression, StackValue receiver) {
         DeclarationDescriptor op = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getOperationSign());
         final Callable callable = resolveToCallable(op);
         if (callable instanceof IntrinsicMethod) {
             IntrinsicMethod intrinsic = (IntrinsicMethod) callable;
-            myStack.push(intrinsic.generate(this, v, expressionType(expression), expression,
-                                            Arrays.asList(expression.getBaseExpression()), false));
+            return intrinsic.generate(this, v, expressionType(expression), expression,
+                                      Arrays.asList(expression.getBaseExpression()), receiver);
         }
         else {
             CallableMethod callableMethod = (CallableMethod) callable;
             genToJVMStack(expression.getBaseExpression());
             callableMethod.invoke(v);
-            final StackValue value = returnValueAsStackValue((FunctionDescriptor) op, callableMethod.getSignature().getReturnType());
-            if (value != null) {
-                myStack.push(value);
-            }
+            return returnValueAsStackValue((FunctionDescriptor) op, callableMethod.getSignature().getReturnType());
         }
     }
 
     @Override
-    public void visitPostfixExpression(JetPostfixExpression expression) {
+    public StackValue visitPostfixExpression(JetPostfixExpression expression, StackValue receiver) {
         DeclarationDescriptor op = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getOperationSign());
         if (op instanceof FunctionDescriptor) {
             final Type asmType = expressionType(expression);
             DeclarationDescriptor cls = op.getContainingDeclaration();
             if (isNumberPrimitive(cls) && (op.getName().equals("inc") || op.getName().equals("dec"))) {
-                if ((boolean) bindingContext.get(BindingContext.STATEMENT, expression)) {
-                    generateIncrement(op, asmType, expression.getBaseExpression());
+                receiver.put(receiver.type, v);
+                //noinspection ConstantConditions
+                if (bindingContext.get(BindingContext.STATEMENT, expression)) {
+                    generateIncrement(op, asmType, expression.getBaseExpression(), receiver);
+                    return StackValue.none();
                 }
                 else {
-                    int oldStackSize = myStack.size();
-                    gen(expression.getBaseExpression(), asmType);
-                    generateIncrement(op, asmType, expression.getBaseExpression());
-                    myStack.push(StackValue.onStack(asmType));
-                    assert myStack.size() == oldStackSize+1;
+                    gen(expression.getBaseExpression(), asmType);                               // old value
+                    generateIncrement(op, asmType, expression.getBaseExpression(), receiver);   // increment in-place
+                    return StackValue.onStack(asmType);                                         // old value
                 }
-                return;
             }
         }
         throw new UnsupportedOperationException("Don't know how to generate this prefix expression");
     }
 
-    private StackValue generateIncrement(DeclarationDescriptor op, Type asmType, JetExpression operand) {
+    private void generateIncrement(DeclarationDescriptor op, Type asmType, JetExpression operand, StackValue receiver) {
         int increment = op.getName().equals("inc") ? 1 : -1;
         if (operand instanceof JetReferenceExpression) {
             final int index = indexOfLocal((JetReferenceExpression) operand);
             if (index >= 0 && JetTypeMapper.isIntPrimitive(asmType)) {
                 v.iinc(index, increment);
-                return StackValue.local(index, asmType);
+                return;
             }
         }
-        StackValue value = generateIntermediateValue(operand);
+        StackValue value = genQualified(receiver, operand);
         value.dupReceiver(v, 0);
         value.put(asmType, v);
         if (asmType == Type.LONG_TYPE) {
-            v.aconst(Long.valueOf(increment));
+            //noinspection UnnecessaryBoxing
+            v.lconst(increment);
         }
         else if (asmType == Type.FLOAT_TYPE) {
-            v.aconst(Float.valueOf(increment));
+            //noinspection UnnecessaryBoxing
+            v.fconst(increment);
         }
         else if (asmType == Type.DOUBLE_TYPE) {
-            v.aconst(Double.valueOf(increment));
+            //noinspection UnnecessaryBoxing
+            v.dconst(increment);
         }
         else {
-            v.aconst(increment);
+            v.iconst(increment);
         }
         v.add(asmType);
         value.store(v);
-        return value;
     }
 
     @Override
-    public void visitProperty(JetProperty property) {
+    public StackValue visitProperty(JetProperty property, StackValue receiver) {
         VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, property);
         int index = lookupLocal(variableDescriptor);
 
@@ -1410,13 +1609,15 @@ public class ExpressionCodegen extends JetVisitorVoid {
 
         JetExpression initializer = property.getInitializer();
         if (initializer != null) {
+            assert variableDescriptor != null;
             Type type = typeMapper.mapType(variableDescriptor.getOutType());
             gen(initializer, type);
             v.store(index, type);
         }
+        return StackValue.none();
     }
 
-    private void generateConstructorCall(JetCallExpression expression, JetSimpleNameExpression constructorReference) {
+    private StackValue generateConstructorCall(JetCallExpression expression, JetSimpleNameExpression constructorReference, StackValue receiver) {
         DeclarationDescriptor constructorDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, constructorReference);
         final PsiElement declaration = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, constructorDescriptor);
         Type type;
@@ -1424,18 +1625,35 @@ public class ExpressionCodegen extends JetVisitorVoid {
             type = generateJavaConstructorCall(expression, (PsiMethod) declaration);
         }
         else if (constructorDescriptor instanceof ConstructorDescriptor) {
-            type = typeMapper.mapType(bindingContext.get(BindingContext.EXPRESSION_TYPE, expression), OwnerKind.IMPLEMENTATION);
+            //noinspection ConstantConditions
+            JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression);
+            type = typeMapper.mapType(expressionType, OwnerKind.IMPLEMENTATION);
             if (type.getSort() == Type.ARRAY) {
-                generateNewArray(expression, type);
-            }
-            else {
+                generateNewArray(expression, expressionType);
+            } else {
                 ClassDescriptor classDecl = (ClassDescriptor) constructorDescriptor.getContainingDeclaration();
 
+                receiver.put(receiver.type, v);
                 v.anew(type);
-                v.dup();
 
                 // TODO typechecker must verify that we're the outer class of the instance being created
-                pushOuterClassArguments(classDecl);
+                //noinspection ConstantConditions
+                if (classDecl.getContainingDeclaration() instanceof ClassDescriptor) {
+                    if(!receiver.type.equals(Type.VOID_TYPE)) {
+                        // class object is in receiver
+                        v.dupX1();
+                        v.swap();
+                    }
+                    else {
+                        // this$0 need to be put on stack
+                        v.dup();
+                        v.load(0, JetTypeMapper.jetImplementationType(classDecl));
+                    }
+                }
+                else {
+                    // regular case
+                    v.dup();
+                }
 
                 CallableMethod method = typeMapper.mapToCallableMethod((ConstructorDescriptor) constructorDescriptor, OwnerKind.IMPLEMENTATION);
                 invokeMethodWithArguments(method, expression);
@@ -1444,10 +1662,10 @@ public class ExpressionCodegen extends JetVisitorVoid {
         else {
             throw new UnsupportedOperationException("don't know how to generate this new expression");
         }
-        myStack.push(StackValue.onStack(type));
+        return StackValue.onStack(type);
     }
 
-    private void pushTypeArguments(JetCall expression) {
+    private void pushTypeArguments(JetCallElement expression) {
         for (JetTypeProjection jetTypeArgument : expression.getTypeArguments()) {
             pushTypeArgument(jetTypeArgument);
         }
@@ -1458,12 +1676,6 @@ public class ExpressionCodegen extends JetVisitorVoid {
         generateTypeInfo(typeArgument);
     }
 
-    private void pushOuterClassArguments(ClassDescriptor classDecl) {
-        if (classDecl.getContainingDeclaration() instanceof ClassDescriptor) {
-            v.load(0, JetTypeMapper.jetImplementationType(classDecl));
-        }
-    }
-
     private Type generateJavaConstructorCall(JetCallExpression expression, PsiMethod constructor) {
         PsiClass javaClass = constructor.getContainingClass();
         Type type = JetTypeMapper.psiClassType(javaClass);
@@ -1474,40 +1686,150 @@ public class ExpressionCodegen extends JetVisitorVoid {
         return type;
     }
 
-    private void generateNewArray(JetCallExpression expression, Type type) {
-        List<JetValueArgument> args = expression.getValueArguments();
-        if (args.size() != 1) {
-            throw new CompilationException("array constructor requires one value argument");
+    private 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");
+            }
+        }
+        else {
+            if (args.size() != 1) {
+                throw new CompilationException("primitive array constructor requires one argument");
+            }
         }
         gen(args.get(0).getArgumentExpression(), Type.INT_TYPE);
-        v.newarray(type.getElementType());
+
+        if(isArray) {
+            JetType elementType = typeMapper.getGenericsElementType(arrayType);
+            if(elementType != null) {
+                generateTypeInfo(elementType);
+                v.invokestatic("jet/typeinfo/TypeInfo", "newArray", "(ILjet/typeinfo/TypeInfo;)[Ljava/lang/Object;");
+            }
+            else {
+                v.newarray(JetTypeMapper.boxType(typeMapper.mapType(arrayType.getArguments().get(0).getType())));
+            }
+        }
+        else {
+            Type type = typeMapper.mapType(arrayType, OwnerKind.IMPLEMENTATION);
+            v.newarray(type.getElementType());
+        }
+
+        if(args.size() == 2) {
+            int sizeIndex  = myMap.enterTemp(2);
+            int indexIndex = sizeIndex+1;
+
+            v.dup();
+            v.arraylength();
+            v.store(sizeIndex, Type.INT_TYPE);
+
+            v.iconst(0);
+            v.store(indexIndex, Type.INT_TYPE);
+
+            gen(args.get(1).getArgumentExpression(), JetTypeMapper.TYPE_FUNCTION1);
+
+            Label begin = new Label();
+            Label end = new Label();
+            v.visitLabel(begin);
+            v.load(indexIndex, Type.INT_TYPE);
+            v.load(sizeIndex,  Type.INT_TYPE);
+            v.ificmpge(end);
+
+            v.dup2();
+            v.load(indexIndex, Type.INT_TYPE);
+            v.invokestatic("java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;");
+            v.invokevirtual("jet/Function1", "invoke", "(Ljava/lang/Object;)Ljava/lang/Object;");
+            v.load(indexIndex, Type.INT_TYPE);
+            v.iinc(indexIndex, 1);
+            v.swap();
+            v.astore(JetTypeMapper.TYPE_OBJECT);
+
+            v.goTo(begin);
+            v.visitLabel(end);
+            v.pop();
+
+            myMap.leaveTemp(2);
+        }
     }
 
     @Override
-    public void visitArrayAccessExpression(JetArrayAccessExpression expression) {
+    public StackValue visitArrayAccessExpression(JetArrayAccessExpression expression, StackValue receiver) {
         final JetExpression array = expression.getArrayExpression();
-        final Type arrayType = expressionType(array);
+        JetType type = bindingContext.get(BindingContext.EXPRESSION_TYPE, array);
+        final Type arrayType = type == null ? Type.VOID_TYPE : typeMapper.mapType(type);
         gen(array, arrayType);
         generateArrayIndex(expression);
         if (arrayType.getSort() == Type.ARRAY) {
-            final Type elementType = arrayType.getElementType();
-            myStack.push(StackValue.arrayElement(elementType));
+            if(state.getStandardLibrary().getArray().equals(type.getConstructor().getDeclarationDescriptor())) {
+                JetType elementType = type.getArguments().get(0).getType();
+                Type notBoxed = typeMapper.mapType(elementType);
+                Type boxed = JetTypeMapper.boxType(notBoxed);
+                return StackValue.arrayElement(notBoxed, true);
+            }
+            else {
+                return StackValue.arrayElement(arrayType.getElementType(), false);
+            }
         }
         else {
             final PsiElement declaration = BindingContextUtils.resolveToDeclarationPsiElement(bindingContext, expression);
+            assert declaration != null : "No declaration found for " + expression.getText();
             final CallableMethod accessor;
             if (declaration instanceof PsiMethod) {
                 accessor = JetTypeMapper.mapToCallableMethod((PsiMethod) declaration);
             }
             else if (declaration instanceof JetNamedFunction) {
-                accessor = typeMapper.mapToCallableMethod((JetNamedFunction) declaration);
+                accessor = typeMapper.mapToCallableMethod((JetNamedFunction) declaration, null);
             }
             else {
-                throw new UnsupportedOperationException("unknown accessor type");
+                throw new UnsupportedOperationException("unknown accessor type: " + declaration);
             }
             boolean isGetter = accessor.getSignature().getName().equals("get");
-            myStack.push(StackValue.collectionElement(JetTypeMapper.TYPE_OBJECT, isGetter ? accessor : null,
-                                                      isGetter ? null : accessor));
+            return StackValue.collectionElement(
+                    isGetter ? accessor.getSignature().getReturnType() : accessor.getSignature().getArgumentTypes()[1],
+                    isGetter ? accessor : null,
+                    isGetter ? null : accessor);
+        }
+    }
+
+    public void _derefArray(JetType type) {
+        if (state.getStandardLibrary().getArray().equals(type.getConstructor().getDeclarationDescriptor())) {
+            JetType elementType = type.getArguments().get(0).getType();
+            JetStandardLibrary standardLibrary = state.getStandardLibrary();
+            if (elementType.equals(standardLibrary.getIntType())) {
+                v.getfield("jet/arrays/JetIntArray", "array", "[I");
+            }
+            else if (elementType.equals(standardLibrary.getLongType())) {
+                v.getfield("jet/arrays/JetLongArray", "array", "[J");
+            }
+            else if (elementType.equals(standardLibrary.getShortType())) {
+                v.getfield("jet/arrays/JetShortArray", "array", "[S");
+            }
+            else if (elementType.equals(standardLibrary.getByteType())) {
+                v.getfield("jet/arrays/JetByteArray", "array", "[B");
+            }
+            else if (elementType.equals(standardLibrary.getCharType())) {
+                v.getfield("jet/arrays/JetCharArray", "array", "[C");
+            }
+            else if (elementType.equals(standardLibrary.getFloatType())) {
+                v.getfield("jet/arrays/JetFloatArray", "array", "[F");
+            }
+            else if (elementType.equals(standardLibrary.getDoubleType())) {
+                v.getfield("jet/arrays/JetDoubleArray", "array", "[D");
+            }
+            else if (elementType.equals(standardLibrary.getBooleanType())) {
+                v.getfield("jet/arrays/JetBooleanArray", "array", "[Z");
+            }
+            else {
+                if(typeMapper.isGenericsArray(type)) {
+                    v.visitTypeInsn(Opcodes.CHECKCAST, "jet/arrays/JetArray");
+                }
+                else {
+                    v.getfield("jet/arrays/JetGenericArray", "array", "[Ljava/lang/Object;");
+                    v.visitTypeInsn(Opcodes.CHECKCAST, "[" + typeMapper.mapType(elementType).getDescriptor());
+                }
+            }
         }
     }
 
@@ -1519,33 +1841,29 @@ public class ExpressionCodegen extends JetVisitorVoid {
     }
 
     @Override
-    public void visitThrowExpression(JetThrowExpression expression) {
+    public StackValue visitThrowExpression(JetThrowExpression expression, StackValue receiver) {
         gen(expression.getThrownExpression(), JetTypeMapper.TYPE_OBJECT);
         v.athrow();
+        return StackValue.none();
     }
 
     @Override
-    public void visitThisExpression(JetThisExpression expression) {
+    public StackValue visitThisExpression(JetThisExpression expression, StackValue receiver) {
         final DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getThisReference());
         if (descriptor instanceof ClassDescriptor) {
-            myStack.push(generateThisOrOuter((ClassDescriptor) descriptor));
+            return generateThisOrOuter((ClassDescriptor) descriptor);
         }
         else {
-            generateThis();
+            return thisExpression();
         }
     }
 
     public void thisToStack() {
-        generateThis();
-        putTopOfStack(JetTypeMapper.TYPE_OBJECT);
-    }
-
-    private void generateThis() {
-        myStack.push(thisExpression());
+        thisExpression().put(JetTypeMapper.TYPE_OBJECT, v);
     }
 
     @Override
-    public void visitTryExpression(JetTryExpression expression) {
+    public StackValue visitTryExpression(JetTryExpression expression, StackValue receiver) {
         Label tryStart = new Label();
         v.mark(tryStart);
         gen(expression.getTryBlock(), Type.VOID_TYPE);
@@ -1562,6 +1880,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
             v.mark(clauseStart);
 
             VariableDescriptor descriptor = bindingContext.get(BindingContext.VALUE_PARAMETER, clause.getCatchParameter());
+            assert descriptor != null;
             Type descriptorType = typeMapper.mapType(descriptor.getOutType());
             myMap.enter(descriptor, 1);
             int index = lookupLocal(descriptor);
@@ -1590,44 +1909,48 @@ public class ExpressionCodegen extends JetVisitorVoid {
             v.visitTryCatchBlock(tryStart, tryEnd, finallyStart, null);
         }
         v.mark(end);
+
+        return StackValue.none();
     }
 
     @Override
-    public void visitBinaryWithTypeRHSExpression(final JetBinaryExpressionWithTypeRHS expression) {
+    public StackValue visitBinaryWithTypeRHSExpression(final JetBinaryExpressionWithTypeRHS expression, StackValue receiver) {
         JetSimpleNameExpression operationSign = expression.getOperationSign();
         IElementType opToken = operationSign.getReferencedNameElementType();
         if (opToken == JetTokens.COLON) {
-            gen(expression.getLeft());
+            return gen(expression.getLeft());
         }
         else {
             JetTypeReference typeReference = expression.getRight();
             JetType jetType = bindingContext.get(BindingContext.TYPE, typeReference);
+            assert jetType != null;
             DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
-            if (!(descriptor instanceof ClassDescriptor)) {
-                throw new UnsupportedOperationException("don't know how to handle non-class types in as/as?");
-            }
-            Type type = typeMapper.mapType(jetType, OwnerKind.INTERFACE);
-            generateInstanceOf(StackValue.expression(OBJECT_TYPE, expression.getLeft(), this), jetType, true);
-            Label isInstance = new Label();
-            v.ifne(isInstance);
-            v.pop();
-            if (opToken == JetTokens.AS_SAFE) {
-                v.aconst(null);
+            if (descriptor instanceof ClassDescriptor || descriptor instanceof TypeParameterDescriptor) {
+                Type type = JetTypeMapper.boxType(typeMapper.mapType(jetType));
+                generateInstanceOf(StackValue.expression(OBJECT_TYPE, expression.getLeft(), this), jetType, true);
+                Label isInstance = new Label();
+                v.ifne(isInstance);
+                v.pop();
+                if (opToken == JetTokens.AS_SAFE) {
+                    v.aconst(null);
+                }
+                else {
+                    throwNewException(CLASS_TYPE_CAST_EXCEPTION);
+                }
+                v.mark(isInstance);
+                v.checkcast(type);
+                return StackValue.onStack(type);
             }
             else {
-                throwNewException(CLASS_TYPE_CAST_EXCEPTION);
+                throw new UnsupportedOperationException("don't know how to handle non-class types in as/as?");
             }
-            v.mark(isInstance);
-            v.checkcast(type);
-            myStack.push(StackValue.onStack(type));
         }
     }
 
     @Override
-    public void visitIsExpression(final JetIsExpression expression) {
+    public StackValue visitIsExpression(final JetIsExpression expression, StackValue receiver) {
         final StackValue match = StackValue.expression(OBJECT_TYPE, expression.getLeftHandSide(), this);
-        StackValue result = generatePatternMatch(expression.getPattern(), expression.isNegated(), match, null);
-        myStack.push(result);
+        return generatePatternMatch(expression.getPattern(), expression.isNegated(), match, null);
     }
 
     // on entering the function, expressionToMatch is already placed on stack, and we should consume it
@@ -1651,7 +1974,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
             JetExpression condExpression = ((JetExpressionPattern) pattern).getExpression();
             Type condType = isNumberPrimitive(subjectType) ? expressionType(condExpression) : OBJECT_TYPE;
             gen(condExpression, condType);
-            return generateEqualsForExpressionsOnStack(JetTokens.EQEQ, subjectType, condType);
+            return generateEqualsForExpressionsOnStack(JetTokens.EQEQ, subjectType, condType, false, false);
         }
         else if (pattern instanceof JetWildcardPattern) {
             return StackValue.constant(!negated, Type.BOOLEAN_TYPE);
@@ -1659,6 +1982,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
         else if (pattern instanceof JetBindingPattern) {
             final JetProperty var = ((JetBindingPattern) pattern).getVariableDeclaration();
             final VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, var);
+            assert variableDescriptor != null;
             final Type varType = typeMapper.mapType(variableDescriptor.getOutType());
             myMap.enter(variableDescriptor, varType.getSize());
             expressionToMatch.dupReceiver(v, 0);
@@ -1693,7 +2017,6 @@ public class ExpressionCodegen extends JetVisitorVoid {
 
         v.mark(lblCheck);
         for (int i = 0; i < entries.size(); i++) {
-            final boolean isLast = i == entries.size() - 1;
             final StackValue tupleField = StackValue.field(OBJECT_TYPE, tupleClassName, "_" + (i + 1), false);
             final StackValue stackValue = generatePatternMatch(entries.get(i).getPattern(), false, tupleField, nextEntry);
             stackValue.condJump(lblPopAndFail, true, v);
@@ -1704,7 +2027,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
             v.goTo(nextEntry);
         }
         else {
-            v.aconst(!negated);
+            v.iconst(!negated?1:0);
         }
         v.goTo(lblDone);
         v.mark(lblFail);
@@ -1712,7 +2035,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
             v.goTo(nextEntry);
         }
         else {
-            v.aconst(negated);
+            v.iconst(negated?1:0);
         }
         v.mark(lblDone);
         return StackValue.onStack(Type.BOOLEAN_TYPE);
@@ -1733,47 +2056,87 @@ public class ExpressionCodegen extends JetVisitorVoid {
             if (leaveExpressionOnStack) {
                 v.dup();
             }
-            Type type = typeMapper.mapType(jetType, OwnerKind.INTERFACE);
-            v.instanceOf(type);
+            Type type = JetTypeMapper.boxType(typeMapper.mapType(jetType));
+            if(jetType.isNullable()) {
+                Label nope = new Label();
+                Label end = new Label();
+
+                v.dup();
+                v.ifnull(nope);
+                v.instanceOf(type);
+                v.goTo(end);
+                v.mark(nope);
+                v.pop();
+                v.iconst(1);
+                v.mark(end);
+            }
+            else {
+                v.instanceOf(type);
+            }
         }
     }
 
-    private void generateTypeInfo(JetType jetType) {
+    void generateTypeInfo(JetType jetType) {
+        String knownTypeInfo = typeMapper.isKnownTypeInfo(jetType);
+        if(knownTypeInfo != null) {
+            v.getstatic("jet/typeinfo/TypeInfo", knownTypeInfo, "Ljet/typeinfo/TypeInfo;");
+            return;
+        }
+
         DeclarationDescriptor declarationDescriptor = jetType.getConstructor().getDeclarationDescriptor();
         if (declarationDescriptor instanceof TypeParameterDescriptor) {
             loadTypeParameterTypeInfo((TypeParameterDescriptor) declarationDescriptor);
             return;
         }
 
-        final Type jvmType = typeMapper.mapType(jetType, OwnerKind.INTERFACE);
-        if (jvmType.getSort() <= Type.DOUBLE) {
-            v.getstatic("jet/typeinfo/TypeInfo", PRIMITIVE_TYPE_INFO_FIELDS[jvmType.getSort()], "Ljet/typeinfo/TypeInfo;");
+        if(!CodegenUtil.hasTypeInfoField(jetType)) {
+            // TODO: we need some better checks here
+            v.getstatic(typeMapper.mapType(jetType, OwnerKind.IMPLEMENTATION).getInternalName(), "$staticTypeInfo", "Ljet/typeinfo/TypeInfo;");
+            return;
+        }
+        
+        boolean hasUnsubstituted = TypeUtils.hasUnsubstitutedTypeParameters(jetType);
+        if(!hasUnsubstituted) {
+            int typeInfoConstantIndex = context.getTypeInfoConstantIndex(jetType);
+            v.invokestatic(context.getNamespaceClassName(), "$getCachedTypeInfo$" + typeInfoConstantIndex, "()Ljet/typeinfo/TypeInfo;");
             return;
         }
 
-        v.anew(JetTypeMapper.TYPE_TYPEINFO);
-        v.dup();
+        final Type jvmType = typeMapper.mapType(jetType);
+
         v.aconst(jvmType);
-        v.aconst(jetType.isNullable());
+        v.iconst(jetType.isNullable()?1:0);
         List<TypeProjection> arguments = jetType.getArguments();
         if (arguments.size() > 0) {
             v.iconst(arguments.size());
-            v.newarray(JetTypeMapper.TYPE_TYPEINFO);
+            v.newarray(JetTypeMapper.TYPE_TYPEINFOPROJECTION);
 
             for (int i = 0, argumentsSize = arguments.size(); i < argumentsSize; i++) {
                 TypeProjection argument = arguments.get(i);
                 v.dup();
                 v.iconst(i);
                 generateTypeInfo(argument.getType());
+                genTypeInfoToProjection(v, argument.getProjectionKind());
                 v.astore(JetTypeMapper.TYPE_OBJECT);
             }
-            v.invokespecial("jet/typeinfo/TypeInfo", "<init>", "(Ljava/lang/Class;Z[Ljet/typeinfo/TypeInfo;)V");
+            v.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z[Ljet/typeinfo/TypeInfoProjection;)Ljet/typeinfo/TypeInfo;");
         }
         else {
-            v.invokespecial("jet/typeinfo/TypeInfo", "<init>", "(Ljava/lang/Class;Z)V");
+            v.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z)Ljet/typeinfo/TypeInfo;");
         }
     }
 
+    public static void genTypeInfoToProjection(InstructionAdapter v, Variance variance) {
+        if(variance == Variance.INVARIANT)
+            v.checkcast(JetTypeMapper.TYPE_TYPEINFOPROJECTION);
+        else if(variance == Variance.IN_VARIANCE)
+            v.invokestatic("jet/typeinfo/TypeInfo", "inProjection", "(Ljet/typeinfo/TypeInfo;)Ljet/typeinfo/TypeInfoProjection;");
+        else if(variance == Variance.OUT_VARIANCE)
+            v.invokestatic("jet/typeinfo/TypeInfo", "outProjection", "(Ljet/typeinfo/TypeInfo;)Ljet/typeinfo/TypeInfoProjection;");
+        else
+            throw new UnsupportedOperationException(variance.toString());
+    }
+
     private void loadTypeParameterTypeInfo(TypeParameterDescriptor typeParameterDescriptor) {
         final StackValue value = typeParameterExpressions.get(typeParameterDescriptor);
         if (value != null) {
@@ -1781,17 +2144,44 @@ public class ExpressionCodegen extends JetVisitorVoid {
             return;
         }
         DeclarationDescriptor containingDeclaration = typeParameterDescriptor.getContainingDeclaration();
-        if (containingDeclaration == contextType() && contextType() instanceof ClassDescriptor) {
-            loadTypeInfo(typeMapper, (ClassDescriptor) contextType(), v);
+        if (contextType() instanceof ClassDescriptor) {
+            ClassDescriptor descriptor = (ClassDescriptor) contextType();
+            JetType defaultType = ((ClassDescriptor)containingDeclaration).getDefaultType();
+            Type ownerType = typeMapper.mapType(defaultType);
+            ownerType = JetTypeMapper.boxType(ownerType);
+            if (containingDeclaration == contextType()) {
+                if(!CodegenUtil.isInterface(descriptor)) {
+                    if (CodegenUtil.hasTypeInfoField(defaultType)) {
+                        v.load(0, JetTypeMapper.TYPE_OBJECT);
+                        v.getfield(ownerType.getInternalName(), "$typeInfo", "Ljet/typeinfo/TypeInfo;");
+                    }
+                    else {
+                        v.getstatic(ownerType.getInternalName(), "$typeInfo", "Ljet/typeinfo/TypeInfo;");
+                    }
+                }
+                else {
+                    v.load(0, JetTypeMapper.TYPE_OBJECT);
+                    v.invokeinterface("jet/JetObject", "getTypeInfo", "()Ljet/typeinfo/TypeInfo;");
+                }
+            }
+            else {
+                v.load(0, JetTypeMapper.TYPE_OBJECT);
+                v.invokeinterface("jet/JetObject", "getTypeInfo", "()Ljet/typeinfo/TypeInfo;");
+                while(descriptor != containingDeclaration) {
+                    descriptor = CodegenUtil.getOuterClassDescriptor(descriptor);
+                    v.invokevirtual("jet/typeinfo/TypeInfo", "getOuterTypeInfo", "()Ljet/typeinfo/TypeInfo;");
+                }
+            }
+            v.aconst(ownerType);
             v.iconst(typeParameterDescriptor.getIndex());
-            v.invokevirtual("jet/typeinfo/TypeInfo", "getTypeParameter", "(I)Ljet/typeinfo/TypeInfo;");
+            v.invokevirtual("jet/typeinfo/TypeInfo", "getArgumentType", "(Ljava/lang/Class;I)Ljet/typeinfo/TypeInfo;");
             return;
         }
         throw new UnsupportedOperationException("don't know what this type parameter resolves to");
     }
 
     @Override
-    public void visitWhenExpression(JetWhenExpression expression) {
+    public StackValue visitWhenExpression(JetWhenExpression expression, StackValue receiver) {
         JetExpression expr = expression.getSubjectExpression();
         final Type subjectType = expressionType(expr);
         final int subjectLocal = myMap.enterTemp(subjectType.getSize());
@@ -1833,23 +2223,26 @@ public class ExpressionCodegen extends JetVisitorVoid {
             throwNewException(CLASS_NO_PATTERN_MATCHED_EXCEPTION);
         }
         v.mark(end);
-        final Type type = expressionType(expression);
-        if (type.getSort() != Type.VOID) {
-            myStack.push(StackValue.onStack(type));
-        }
 
         myMap.leaveTemp(subjectType.getSize());
+        return StackValue.onStack(expressionType(expression));
     }
 
-    private StackValue generateWhenCondition(Type subjectType, int subjectLocal, JetWhenCondition condition,
-                                             @Nullable Label nextEntry) {
+    private StackValue generateWhenCondition(Type subjectType, int subjectLocal, JetWhenCondition condition, @Nullable Label nextEntry) {
         StackValue conditionValue;
         if (condition instanceof JetWhenConditionInRange) {
-            JetExpression range = ((JetWhenConditionInRange) condition).getRangeExpression();
-            gen(range, RANGE_TYPE);
-            new StackValue.Local(subjectLocal, subjectType).put(INTEGER_TYPE, v);
-            v.invokeinterface(CLASS_RANGE, "contains", "(Ljava/lang/Comparable;)Z");
-            conditionValue = new StackValue.OnStack(Type.BOOLEAN_TYPE);
+            JetWhenConditionInRange conditionInRange = (JetWhenConditionInRange) condition;
+            JetExpression rangeExpression = conditionInRange.getRangeExpression();
+            if(isIntRangeExpr(rangeExpression)) {
+                getInIntRange(new StackValue.Local(subjectLocal, subjectType), (JetBinaryExpression) rangeExpression, conditionInRange.getOperationReference().getReferencedNameElementType() == JetTokens.NOT_IN);
+            }
+            else {
+                FunctionDescriptor op = (FunctionDescriptor) bindingContext.get(BindingContext.REFERENCE_TARGET, conditionInRange.getOperationReference());
+                genToJVMStack(rangeExpression);
+                new StackValue.Local(subjectLocal, subjectType).put(JetTypeMapper.TYPE_OBJECT, v);
+                invokeFunctionNoParams(op, Type.BOOLEAN_TYPE, v);
+            }
+            return StackValue.onStack(Type.BOOLEAN_TYPE);
         }
         else if (condition instanceof JetWhenConditionIsPattern) {
             JetWhenConditionIsPattern patternCondition = (JetWhenConditionIsPattern) condition;
@@ -1865,7 +2258,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
                 if (!(declarationDescriptor instanceof FunctionDescriptor)) {
                     throw new UnsupportedOperationException("expected function descriptor in when condition with call, found " + declarationDescriptor);
                 }
-                conditionValue = invokeFunction((JetCallExpression) call, (FunctionDescriptor) declarationDescriptor, true);
+                conditionValue = invokeFunction((JetCallExpression) call, declarationDescriptor, StackValue.onStack(subjectType));
             }
             else if (call instanceof JetSimpleNameExpression) {
                 final DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) call);
@@ -1887,16 +2280,36 @@ public class ExpressionCodegen extends JetVisitorVoid {
         return conditionValue;
     }
 
+    private boolean isIntRangeExpr(JetExpression rangeExpression) {
+        if(rangeExpression instanceof JetBinaryExpression) {
+            JetBinaryExpression binaryExpression = (JetBinaryExpression) rangeExpression;
+            if (binaryExpression.getOperationReference().getReferencedNameElementType() == JetTokens.RANGE) {
+                JetType jetType = bindingContext.get(BindingContext.EXPRESSION_TYPE, rangeExpression);
+                assert jetType != null;
+                final DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
+                if (isClass(descriptor, "IntRange")) {       // TODO IntRange subclasses
+                    return true;
+                }
+            }
+        }
+        return false ;
+    }
+
     @Override
-    public void visitTupleExpression(JetTupleExpression expression) {
+    public StackValue visitTupleExpression(JetTupleExpression expression, StackValue receiver) {
         final List<JetExpression> entries = expression.getEntries();
         if (entries.size() > 22) {
             throw new UnsupportedOperationException("tuple too large");
         }
+        if(entries.size() == 0) {
+            v.visitFieldInsn(Opcodes.GETSTATIC, "jet/Tuple0", "INSTANCE", "Ljet/Tuple0;");
+            return StackValue.onStack(Type.getObjectType("jet/Tuple0"));
+        }
+
         final String className = "jet/Tuple" + entries.size();
         Type tupleType = Type.getObjectType(className);
         StringBuilder signature = new StringBuilder("(");
-        for (JetExpression entry : entries) {
+        for (int i = 0; i != entries.size(); ++i) {
             signature.append("Ljava/lang/Object;");
         }
         signature.append(")V");
@@ -1907,7 +2320,7 @@ public class ExpressionCodegen extends JetVisitorVoid {
             gen(entry, OBJECT_TYPE);
         }
         v.invokespecial(className, "<init>", signature.toString());
-        myStack.push(StackValue.onStack(tupleType));
+        return StackValue.onStack(tupleType);
     }
 
     private void throwNewException(final String className) {
diff --git a/idea/src/org/jetbrains/jet/codegen/FrameMap.java b/compiler/backend/src/org/jetbrains/jet/codegen/FrameMap.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/codegen/FrameMap.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/FrameMap.java
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java
new file mode 100644
index 00000000000..d7b0b188569
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java
@@ -0,0 +1,155 @@
+package org.jetbrains.jet.codegen;
+
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
+import org.jetbrains.jet.lang.psi.JetDeclarationWithBody;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.psi.JetNamedFunction;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.commons.InstructionAdapter;
+import org.objectweb.asm.commons.Method;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author max
+ * @author yole
+ */
+public class FunctionCodegen {
+    private final ClassContext owner;
+    private final ClassVisitor v;
+    private final GenerationState state;
+
+    public FunctionCodegen(ClassContext owner, ClassVisitor v, GenerationState state) {
+        this.owner = owner;
+        this.v = v;
+        this.state = state;
+    }
+
+    public void gen(JetNamedFunction f) {
+        Method method = state.getTypeMapper().mapToCallableMethod(f, owner.getContextKind()).getSignature();
+        final FunctionDescriptor functionDescriptor = state.getBindingContext().get(BindingContext.FUNCTION, f);
+        generateMethod(f, method, functionDescriptor);
+    }
+
+    public void generateMethod(JetDeclarationWithBody f, Method jvmMethod, FunctionDescriptor functionDescriptor) {
+        ClassContext funContext = owner.intoFunction(functionDescriptor);
+
+        final JetExpression bodyExpression = f.getBodyExpression();
+        generatedMethod(bodyExpression, jvmMethod, funContext, functionDescriptor);
+    }
+
+    private void generatedMethod(JetExpression bodyExpressions,
+                                 Method jvmSignature,
+                                 ClassContext context,
+                                 FunctionDescriptor functionDescriptor)
+    {
+        List<ValueParameterDescriptor> paramDescrs = functionDescriptor.getValueParameters();
+        List<TypeParameterDescriptor> typeParameters = functionDescriptor.getTypeParameters();
+
+        int flags = Opcodes.ACC_PUBLIC; // TODO.
+
+        OwnerKind kind = context.getContextKind();
+
+        if(kind == OwnerKind.TRAIT_IMPL && bodyExpressions == null)
+            return;
+
+        boolean isStatic = kind == OwnerKind.NAMESPACE || kind == OwnerKind.TRAIT_IMPL;
+        if (isStatic) flags |= Opcodes.ACC_STATIC;
+
+        boolean isAbstract = !isStatic && (bodyExpressions == null || CodegenUtil.isInterface(functionDescriptor.getContainingDeclaration()));
+        if (isAbstract) flags |= Opcodes.ACC_ABSTRACT;
+
+        final MethodVisitor mv = v.visitMethod(flags, jvmSignature.getName(), jvmSignature.getDescriptor(), null, null);
+        if (!isAbstract) {
+            mv.visitCode();
+            FrameMap frameMap = context.prepareFrame();
+
+            ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, jvmSignature.getReturnType(), context, state);
+
+            Type[] argTypes = jvmSignature.getArgumentTypes();
+            for (int i = 0; i < paramDescrs.size(); i++) {
+                ValueParameterDescriptor parameter = paramDescrs.get(i);
+                frameMap.enter(parameter, argTypes[i].getSize());
+            }
+
+            for (final TypeParameterDescriptor typeParameterDescriptor : typeParameters) {
+                int slot = frameMap.enterTemp();
+                codegen.addTypeParameter(typeParameterDescriptor, StackValue.local(slot, JetTypeMapper.TYPE_TYPEINFO));
+            }
+
+            if (kind instanceof OwnerKind.DelegateKind) {
+                OwnerKind.DelegateKind dk = (OwnerKind.DelegateKind) kind;
+                InstructionAdapter iv = new InstructionAdapter(mv);
+                iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                dk.getDelegate().put(JetTypeMapper.TYPE_OBJECT, iv);
+                for (int i = 0; i < argTypes.length; i++) {
+                    Type argType = argTypes[i];
+                    iv.load(i + 1, argType);
+                }
+                iv.invokeinterface(dk.getOwnerClass(), jvmSignature.getName(), jvmSignature.getDescriptor());
+                iv.areturn(jvmSignature.getReturnType());
+            }
+            else {
+                codegen.returnExpression(bodyExpressions);
+            }
+            mv.visitMaxs(0, 0);
+            mv.visitEnd();
+
+            generateBridgeIfNeeded(owner, state, v, jvmSignature, functionDescriptor, kind);
+        }
+    }
+
+    static void generateBridgeIfNeeded(ClassContext owner, GenerationState state, ClassVisitor v, Method jvmSignature, FunctionDescriptor functionDescriptor, OwnerKind kind) {
+        Set<? extends FunctionDescriptor> overriddenFunctions = functionDescriptor.getOverriddenDescriptors();
+        if(kind != OwnerKind.TRAIT_IMPL) {
+            for (FunctionDescriptor overriddenFunction : overriddenFunctions) {
+                // TODO should we check params here as well?
+                checkOverride(owner, state, v, jvmSignature, functionDescriptor, overriddenFunction);
+            }
+            checkOverride(owner, state, v, jvmSignature, functionDescriptor, functionDescriptor.getOriginal());
+        }
+    }
+
+    private static void checkOverride(ClassContext owner, GenerationState state, ClassVisitor v, Method jvmSignature, FunctionDescriptor functionDescriptor, FunctionDescriptor overriddenFunction) {
+        Type type1 = state.getTypeMapper().mapType(overriddenFunction.getOriginal().getReturnType());
+        Type type2 = state.getTypeMapper().mapType(functionDescriptor.getReturnType());
+        if(!type1.equals(type2)) {
+            Method overriden = state.getTypeMapper().mapSignature(overriddenFunction.getName(), overriddenFunction.getOriginal());
+            int flags = Opcodes.ACC_PUBLIC; // TODO.
+
+            final MethodVisitor mv = v.visitMethod(flags, jvmSignature.getName(), overriden.getDescriptor(), null, null);
+            mv.visitCode();
+
+            Type[] argTypes = jvmSignature.getArgumentTypes();
+            InstructionAdapter iv = new InstructionAdapter(mv);
+            iv.load(0, JetTypeMapper.TYPE_OBJECT);
+            for (int i = 0, reg = 1; i < argTypes.length; i++) {
+                Type argType = argTypes[i];
+                iv.load(reg, argType);
+                if(argType.getSort() == Type.OBJECT) {
+                    iv.checkcast(argType);
+                }
+                //noinspection AssignmentToForLoopParameter
+                reg += argType.getSize();
+            }
+
+            iv.invokevirtual(state.getTypeMapper().jvmName((ClassDescriptor) owner.getContextDescriptor(), OwnerKind.IMPLEMENTATION), jvmSignature.getName(), jvmSignature.getDescriptor());
+            if(JetTypeMapper.isPrimitive(jvmSignature.getReturnType()) && !JetTypeMapper.isPrimitive(overriden.getReturnType()))
+                StackValue.valueOf(iv, jvmSignature.getReturnType());
+            if(jvmSignature.getReturnType() == Type.VOID_TYPE)
+                iv.aconst(null);
+            iv.areturn(overriden.getReturnType());
+            mv.visitMaxs(0, 0);
+            mv.visitEnd();
+        }
+    }
+
+}
diff --git a/idea/src/org/jetbrains/jet/codegen/GeneratedAnonymousClassDescriptor.java b/compiler/backend/src/org/jetbrains/jet/codegen/GeneratedAnonymousClassDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/codegen/GeneratedAnonymousClassDescriptor.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/GeneratedAnonymousClassDescriptor.java
diff --git a/idea/src/org/jetbrains/jet/codegen/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java
similarity index 76%
rename from idea/src/org/jetbrains/jet/codegen/GenerationState.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java
index ec7643dc3c4..39862f0051e 100644
--- a/idea/src/org/jetbrains/jet/codegen/GenerationState.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java
@@ -7,16 +7,19 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Pair;
 import com.intellij.util.containers.Stack;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
-import org.jetbrains.jet.lang.ErrorHandler;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.java.JavaDefaultImports;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.commons.Method;
 
+import java.util.Collections;
+import java.util.List;
+
 public class GenerationState {
     private final ClassFileFactory factory;
     private final Project project;
@@ -69,8 +72,8 @@ public class GenerationState {
         return factory.newVisitor(typeMapper.jvmName(aClass, OwnerKind.IMPLEMENTATION) + ".class");
     }
 
-    public ClassVisitor forClassDelegatingImplementation(ClassDescriptor aClass) {
-        return factory.newVisitor(JetTypeMapper.jvmNameForDelegatingImplementation(aClass) + ".class");
+    public ClassVisitor forTraitImplementation(ClassDescriptor aClass) {
+        return factory.newVisitor(typeMapper.jvmName(aClass, OwnerKind.TRAIT_IMPL) + ".class");
     }
 
     public Pair<String, ClassVisitor> forAnonymousSubclass(JetExpression expression) {
@@ -85,13 +88,31 @@ public class GenerationState {
 
     public void compile(JetFile psiFile) {
         final JetNamespace namespace = psiFile.getRootNamespace();
-        NamespaceCodegen codegen = forNamespace(namespace);
-        final BindingContext bindingContext = AnalyzingUtils.analyzeNamespace(namespace, JetControlFlowDataTraceFactory.EMPTY);
-        bindingContexts.push(bindingContext);
+        final BindingContext bindingContext = AnalyzingUtils.getInstance(JavaDefaultImports.JAVA_DEFAULT_IMPORTS).analyzeNamespace(namespace, JetControlFlowDataTraceFactory.EMPTY);
+        AnalyzingUtils.throwExceptionOnErrors(bindingContext);
+        compileCorrectNamespaces(bindingContext, Collections.singletonList(namespace));
+//        NamespaceCodegen codegen = forNamespace(namespace);
+//        bindingContexts.push(bindingContext);
+//        typeMapper = new JetTypeMapper(standardLibrary, bindingContext);
+//        try {
+//            AnalyzingUtils.throwExceptionOnErrors(bindingContext);
+//
+//            codegen.generate(namespace);
+//        }
+//        finally {
+//            bindingContexts.pop();
+//            typeMapper = null;
+//        }
+    }
+
+    public void compileCorrectNamespaces(BindingContext bindingContext, List<JetNamespace> namespaces) {
         typeMapper = new JetTypeMapper(standardLibrary, bindingContext);
+        bindingContexts.push(bindingContext);
         try {
-            AnalyzingUtils.applyHandler(ErrorHandler.THROW_EXCEPTION, bindingContext);
-            codegen.generate(namespace);
+            for (JetNamespace namespace : namespaces) {
+                NamespaceCodegen codegen = forNamespace(namespace);
+                codegen.generate(namespace);
+            }
         }
         finally {
             bindingContexts.pop();
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
new file mode 100644
index 00000000000..bdf2d80bc06
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
@@ -0,0 +1,788 @@
+package org.jetbrains.jet.codegen;
+
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.OverridingUtil;
+import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeProjection;
+import org.jetbrains.jet.lexer.JetTokens;
+import org.objectweb.asm.*;
+import org.objectweb.asm.commons.InstructionAdapter;
+import org.objectweb.asm.commons.Method;
+
+import java.util.*;
+
+/**
+ * @author max
+ * @author yole
+ * @author alex.tkachman
+ */
+public class ImplementationBodyCodegen extends ClassBodyCodegen {
+    private JetDelegationSpecifier superCall;
+    private String superClass = "java/lang/Object";
+
+    public ImplementationBodyCodegen(JetClassOrObject aClass, ClassContext context, ClassVisitor v, GenerationState state) {
+        super(aClass, context, v, state);
+    }
+
+    private Set<String> getSuperInterfaces(JetClassOrObject aClass) {
+        List<JetDelegationSpecifier> delegationSpecifiers = aClass.getDelegationSpecifiers();
+        String superClassName = null;
+        Set<String> superInterfaces = new LinkedHashSet<String>();
+
+        for (JetDelegationSpecifier specifier : delegationSpecifiers) {
+            JetType superType = state.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
+            ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
+            PsiElement superPsi = state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, superClassDescriptor);
+
+            if (superPsi instanceof PsiClass) {
+                PsiClass psiClass = (PsiClass) superPsi;
+                String fqn = psiClass.getQualifiedName();
+                if (psiClass.isInterface()) {
+                    superInterfaces.add(fqn.replace('.', '/'));
+                }
+                else {
+                    if (superClassName == null) {
+                        superClassName = fqn.replace('.', '/');
+
+                        while (psiClass != null) {
+                            for (PsiClass ifs : psiClass.getInterfaces()) {
+                                superInterfaces.add(ifs.getQualifiedName().replace('.', '/'));
+                            }
+                            psiClass = psiClass.getSuperClass();
+                        }
+                    }
+                    else {
+                        throw new RuntimeException("Cannot determine single class to inherit from");
+                    }
+                }
+            }
+            else {
+                if(superPsi == null || ((JetClass)superPsi).isTrait())
+                    superInterfaces.add(JetTypeMapper.jvmNameForInterface(superClassDescriptor));
+            }
+        }
+        return superInterfaces;
+    }
+
+    @Override
+    protected void generateDeclaration() {
+        getSuperClass();
+
+        List<String> interfaces = new ArrayList<String>();
+        interfaces.add("jet/JetObject");
+        interfaces.addAll(getSuperInterfaces(myClass));
+
+        boolean isAbstract = false;
+        boolean isInterface = false;
+        if(myClass instanceof JetClass) {
+           if(((JetClass) myClass).hasModifier(JetTokens.ABSTRACT_KEYWORD))
+               isAbstract = true;
+            if(((JetClass) myClass).isTrait()) {
+                isAbstract = true;
+                isInterface = true;
+            }
+        }
+
+        v.visit(Opcodes.V1_6,
+                Opcodes.ACC_PUBLIC | (isAbstract ? Opcodes.ACC_ABSTRACT : 0) | (isInterface ? Opcodes.ACC_INTERFACE : 0),
+                jvmName(),
+                null,
+                superClass,
+                interfaces.toArray(new String[interfaces.size()])
+        );
+        v.visitSource(myClass.getContainingFile().getName(), null);
+
+        if(descriptor.getContainingDeclaration() instanceof ClassDescriptor) {
+            v.visitOuterClass(state.getTypeMapper().jvmType((ClassDescriptor) descriptor.getContainingDeclaration(), OwnerKind.IMPLEMENTATION).getInternalName(), null, null);
+        }
+
+        if(myClass instanceof JetClass) {
+            AnnotationVisitor annotationVisitor = v.visitAnnotation("Ljet/typeinfo/JetSignature;", true);
+            annotationVisitor.visit("value", SignatureUtil.classToSignature((JetClass)myClass, state.getBindingContext(), state.getTypeMapper()));
+            annotationVisitor.visitEnd();
+        }
+    }
+
+    private String jvmName() {
+        return state.getTypeMapper().jvmName(descriptor, kind);
+    }
+
+    protected void getSuperClass() {
+        List<JetDelegationSpecifier> delegationSpecifiers = myClass.getDelegationSpecifiers();
+
+        if(myClass instanceof JetClass && ((JetClass) myClass).isTrait())
+            return;
+
+        for (JetDelegationSpecifier specifier : delegationSpecifiers) {
+            if (specifier instanceof JetDelegatorToSuperClass || specifier instanceof JetDelegatorToSuperCall) {
+                JetType superType = state.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
+                ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
+                final PsiElement declaration = state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, superClassDescriptor);
+                if (declaration != null) {
+                    if (declaration instanceof PsiClass) {
+                        if (!((PsiClass) declaration).isInterface()) {
+                            superClass = state.getTypeMapper().jvmName(superClassDescriptor, kind);
+                            superCall = specifier;
+                            return;
+                        }
+                    }
+                    else if(declaration instanceof JetClass) {
+                        if(!((JetClass) declaration).isTrait()) {
+                            superClass = state.getTypeMapper().jvmName(superClassDescriptor, kind);
+                            superCall = specifier;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    protected void generateSyntheticParts() {
+        generateFieldForObjectInstance();
+        generateFieldForClassObject();
+
+        try {
+            generatePrimaryConstructor();
+        }
+        catch(RuntimeException e) {
+            throw new RuntimeException("Error generating primary constructor of class " + myClass.getName() + " with kind " + kind, e);
+        }
+
+        generateGetTypeInfo();
+        //genGetSuperTypesTypeInfo();
+    }
+
+    private void generateFieldForObjectInstance() {
+        if (isNonLiteralObject()) {
+            Type type = JetTypeMapper.jetImplementationType(descriptor);
+            v.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "$instance", type.getDescriptor(), null, null);
+
+            staticInitializerChunks.add(new CodeChunk() {
+                @Override
+                public void generate(InstructionAdapter v) {
+                    String name = jvmName();
+                    v.anew(Type.getObjectType(name));
+                    v.dup();
+                    v.invokespecial(name, "<init>", "()V");
+                    v.putstatic(name, "$instance", JetTypeMapper.jetImplementationType(descriptor).getDescriptor());
+                }
+            });
+
+        }
+    }
+
+    private void generateFieldForClassObject() {
+        final JetClassObject classObject = getClassObject();
+        if (classObject != null) {
+            Type type = Type.getObjectType(state.getTypeMapper().jvmName(classObject));
+            v.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "$classobj", type.getDescriptor(), null, null);
+
+            staticInitializerChunks.add(new CodeChunk() {
+                @Override
+                public void generate(InstructionAdapter v) {
+                    String name = state.getTypeMapper().jvmName(classObject);
+                    final Type classObjectType = Type.getObjectType(name);
+                    v.anew(classObjectType);
+                    v.dup();
+                    v.invokespecial(name, "<init>", "()V");
+                    v.putstatic(state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION), "$classobj",
+                                classObjectType.getDescriptor());
+                }
+            });
+        }
+    }
+
+    protected void generatePrimaryConstructor() {
+        if(myClass instanceof JetClass && ((JetClass) myClass).isTrait())
+            return;
+
+        ConstructorDescriptor constructorDescriptor = state.getBindingContext().get(BindingContext.CONSTRUCTOR, myClass);
+
+        Method method;
+        CallableMethod callableMethod;
+        if (constructorDescriptor == null) {
+            List<Type> parameterTypes = new ArrayList<Type>();
+            if (CodegenUtil.hasThis0(descriptor)) {
+                parameterTypes.add(state.getTypeMapper().jvmType(CodegenUtil.getOuterClassDescriptor(descriptor), OwnerKind.IMPLEMENTATION));
+            }
+
+            List<TypeParameterDescriptor> typeParameters = descriptor.getTypeConstructor().getParameters();
+            for (int n = typeParameters.size(); n > 0; n--) {
+                parameterTypes.add(JetTypeMapper.TYPE_TYPEINFO);
+            }
+
+            method = new Method("<init>", Type.VOID_TYPE, parameterTypes.toArray(new Type[parameterTypes.size()]));
+            callableMethod = new CallableMethod("", method, Opcodes.INVOKESPECIAL, Collections.<Type>emptyList());
+        }
+        else {
+            callableMethod = state.getTypeMapper().mapToCallableMethod(constructorDescriptor, kind);
+            method = callableMethod.getSignature();
+        }
+        int flags = Opcodes.ACC_PUBLIC; // TODO
+        final MethodVisitor mv = v.visitMethod(flags, "<init>", method.getDescriptor(), null, null);
+        mv.visitCode();
+
+        List<ValueParameterDescriptor> paramDescrs = constructorDescriptor != null
+                ? constructorDescriptor.getValueParameters()
+                : Collections.<ValueParameterDescriptor>emptyList();
+
+        ConstructorFrameMap frameMap = new ConstructorFrameMap(callableMethod, constructorDescriptor, descriptor, kind);
+
+        final InstructionAdapter iv = new InstructionAdapter(mv);
+        ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, context, state);
+
+        for(int slot = 0; slot != frameMap.getTypeParameterCount(); ++slot) {
+            if(constructorDescriptor != null)
+                codegen.addTypeParameter(constructorDescriptor.getTypeParameters().get(slot), StackValue.local(frameMap.getFirstTypeParameter() + slot, JetTypeMapper.TYPE_TYPEINFO));
+            else
+                codegen.addTypeParameter(descriptor.getTypeConstructor().getParameters().get(slot), StackValue.local(frameMap.getFirstTypeParameter() + slot, JetTypeMapper.TYPE_TYPEINFO));
+        }
+
+        String classname = state.getTypeMapper().jvmName(descriptor, kind);
+        final Type classType = Type.getType("L" + classname + ";");
+
+        HashSet<FunctionDescriptor> overridden = new HashSet<FunctionDescriptor>();
+        for (JetDeclaration declaration : myClass.getDeclarations()) {
+            if (declaration instanceof JetFunction) {
+                overridden.addAll(state.getBindingContext().get(BindingContext.FUNCTION, declaration).getOverriddenDescriptors());
+            }
+        }
+
+        if (superCall == null || superCall instanceof JetDelegatorToSuperClass) {
+            iv.load(0, Type.getType("L" + superClass + ";"));
+            if(superCall == null) {
+                iv.invokespecial(superClass, "<init>", "()V");
+            }
+            else {
+                JetType superType = state.getBindingContext().get(BindingContext.TYPE, superCall.getTypeReference());
+                List<Type> parameterTypes = new ArrayList<Type>();
+                ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
+                if (CodegenUtil.hasThis0(superClassDescriptor)) {
+                    iv.load(1, JetTypeMapper.TYPE_OBJECT);
+                    parameterTypes.add(state.getTypeMapper().jvmType(CodegenUtil.getOuterClassDescriptor(descriptor), OwnerKind.IMPLEMENTATION));
+                }
+                for(TypeProjection typeParameterDescriptor : superType.getArguments()) {
+                    codegen.generateTypeInfo(typeParameterDescriptor.getType());
+                    parameterTypes.add(JetTypeMapper.TYPE_TYPEINFO);
+                }
+                Method superCallMethod = new Method("<init>", Type.VOID_TYPE, parameterTypes.toArray(new Type[parameterTypes.size()]));
+                iv.invokespecial(state.getTypeMapper().jvmName(superClassDescriptor, OwnerKind.IMPLEMENTATION), "<init>", superCallMethod.getDescriptor());
+            }
+        }
+        else {
+            iv.load(0, classType);
+            ConstructorDescriptor constructorDescriptor1 = (ConstructorDescriptor) state.getBindingContext().get(BindingContext.REFERENCE_TARGET, ((JetDelegatorToSuperCall) superCall).getCalleeExpression().getConstructorReferenceExpression());
+            generateDelegatorToConstructorCall(iv, codegen, (JetDelegatorToSuperCall) superCall, constructorDescriptor1, frameMap);
+        }
+
+        int n = 0;
+        for (JetDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) {
+            if(specifier == superCall)
+                continue;
+
+            if (specifier instanceof JetDelegatorByExpressionSpecifier) {
+                iv.load(0, classType);
+                codegen.genToJVMStack(((JetDelegatorByExpressionSpecifier) specifier).getDelegateExpression());
+
+                JetType superType = state.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
+                ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
+                String delegateField = "$delegate_" + n;
+                Type fieldType = JetTypeMapper.jetInterfaceType(superClassDescriptor);
+                String fieldDesc = fieldType.getDescriptor();
+                v.visitField(Opcodes.ACC_PRIVATE, delegateField, fieldDesc, /*TODO*/null, null);
+                iv.putfield(classname, delegateField, fieldDesc);
+
+                JetClass superClass = (JetClass) state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, superClassDescriptor);
+                final ClassContext delegateContext = context.intoClass(superClassDescriptor,
+                        new OwnerKind.DelegateKind(StackValue.field(fieldType, classname, delegateField, false),
+                        JetTypeMapper.jvmNameForInterface(superClassDescriptor)));
+                generateDelegates(superClass, delegateContext, overridden);
+            }
+        }
+
+        final ClassDescriptor outerDescriptor = getOuterClassDescriptor();
+        if (outerDescriptor != null && outerDescriptor.getKind() != ClassKind.OBJECT) {
+            final Type type = JetTypeMapper.jetImplementationType(outerDescriptor);
+            String interfaceDesc = type.getDescriptor();
+            final String fieldName = "this$0";
+            v.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, fieldName, interfaceDesc, null, null);
+            iv.load(0, classType);
+            iv.load(frameMap.getOuterThisIndex(), type);
+            iv.putfield(classname, fieldName, interfaceDesc);
+        }
+
+        if (CodegenUtil.hasTypeInfoField(descriptor.getDefaultType()) && kind == OwnerKind.IMPLEMENTATION) {
+            generateTypeInfoInitializer(frameMap.getFirstTypeParameter(), frameMap.getTypeParameterCount(), iv);
+        }
+
+        generateInitializers(codegen, iv);
+
+        generateTraitMethods(codegen);
+
+        int curParam = 0;
+        List<JetParameter> constructorParameters = getPrimaryConstructorParameters();
+        for (JetParameter parameter : constructorParameters) {
+            if (parameter.getValOrVarNode() != null) {
+                VariableDescriptor descriptor = paramDescrs.get(curParam);
+                Type type = state.getTypeMapper().mapType(descriptor.getOutType());
+                iv.load(0, classType);
+                iv.load(frameMap.getIndex(descriptor), type);
+                iv.putfield(classname, descriptor.getName(), type.getDescriptor());
+            }
+            curParam++;
+        }
+
+        mv.visitInsn(Opcodes.RETURN);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+    }
+
+    private void generateTraitMethods(ExpressionCodegen codegen) {
+        if(!(myClass instanceof JetClass) || ((JetClass)myClass).isTrait() || ((JetClass)myClass).hasModifier(JetTokens.ABSTRACT_KEYWORD))
+            return;
+
+        for (CallableDescriptor callableDescriptor : OverridingUtil.getEffectiveMembers(descriptor)) {
+            if(callableDescriptor instanceof FunctionDescriptor) {
+                FunctionDescriptor fun = (FunctionDescriptor) callableDescriptor;
+                DeclarationDescriptor containingDeclaration = fun.getContainingDeclaration();
+                if(containingDeclaration instanceof ClassDescriptor) {
+                    ClassDescriptor declaration = (ClassDescriptor) containingDeclaration;
+                    PsiElement psiElement = state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, declaration);
+                    if(psiElement instanceof JetClass) {
+                        JetClass jetClass = (JetClass) psiElement;
+                        if(jetClass.isTrait()) {
+                            int flags = Opcodes.ACC_PUBLIC; // TODO.
+
+                            Method function = state.getTypeMapper().mapSignature(fun.getName(), fun);
+                            Method functionOriginal = state.getTypeMapper().mapSignature(fun.getName(), fun.getOriginal());
+
+                            final MethodVisitor mv = v.visitMethod(flags, function.getName(), function.getDescriptor(), null, null);
+                            mv.visitCode();
+
+                            codegen.generateThisOrOuter(descriptor);
+
+                            Type[] argTypes = function.getArgumentTypes();
+                            InstructionAdapter iv = new InstructionAdapter(mv);
+                            iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                            for (int i = 0, reg = 1; i < argTypes.length; i++) {
+                                Type argType = argTypes[i];
+                                iv.load(reg, argType);
+                                //noinspection AssignmentToForLoopParameter
+                                reg += argType.getSize();
+                            }
+
+                            JetType jetType = TraitImplBodyCodegen.getSuperClass(declaration, state.getBindingContext());
+                            Type type = state.getTypeMapper().mapType(jetType);
+                            if(type.getInternalName().equals("java/lang/Object")) {
+                                jetType = declaration.getDefaultType();
+                                type = state.getTypeMapper().mapType(jetType);
+                            }
+
+                            String fdescriptor = functionOriginal.getDescriptor().replace("(","(" +  type.getDescriptor());
+                            iv.invokestatic(state.getTypeMapper().jvmName((ClassDescriptor) fun.getContainingDeclaration(), OwnerKind.TRAIT_IMPL), function.getName(), fdescriptor);
+                            if(function.getReturnType().getSort() == Type.OBJECT) {
+                                iv.checkcast(function.getReturnType());
+                            }
+                            iv.areturn(function.getReturnType());
+                            mv.visitMaxs(0, 0);
+                            mv.visitEnd();
+
+                            FunctionCodegen.generateBridgeIfNeeded(context, state, v, function, fun, kind);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    @Nullable
+    private ClassDescriptor getOuterClassDescriptor() {
+        if (myClass.getParent() instanceof JetClassObject) {
+            return null;
+        }
+
+        return CodegenUtil.getOuterClassDescriptor(descriptor);
+    }
+
+    private void generateDelegatorToConstructorCall(InstructionAdapter iv, ExpressionCodegen codegen, JetCallElement constructorCall,
+                                                    ConstructorDescriptor constructorDescriptor,
+                                                    ConstructorFrameMap frameMap) {
+        ClassDescriptor classDecl = constructorDescriptor.getContainingDeclaration();
+        PsiElement declaration = state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, classDecl);
+        Type type;
+        if (declaration instanceof PsiClass) {
+            type = JetTypeMapper.psiClassType((PsiClass) declaration);
+        }
+        else {
+            type = JetTypeMapper.jetImplementationType(classDecl);
+        }
+
+        iv.load(0, type);
+
+        if (classDecl.getContainingDeclaration() instanceof ClassDescriptor) {
+            iv.load(frameMap.getOuterThisIndex(), state.getTypeMapper().jvmType((ClassDescriptor) descriptor.getContainingDeclaration(), OwnerKind.IMPLEMENTATION));
+        }
+
+        CallableMethod method = state.getTypeMapper().mapToCallableMethod(constructorDescriptor, kind);
+        codegen.invokeMethodWithArguments(method, constructorCall);
+    }
+
+    @Override
+    protected void generateDeclaration(PropertyCodegen propertyCodegen, JetDeclaration declaration, FunctionCodegen functionCodegen) {
+        if (declaration instanceof JetConstructor) {
+            generateSecondaryConstructor((JetConstructor) declaration);
+        }
+        else if (declaration instanceof JetClassObject) {
+            generateClassObject((JetClassObject) declaration);
+        }
+        else if (declaration instanceof JetEnumEntry && !((JetEnumEntry) declaration).hasPrimaryConstructor()) {
+            String name = declaration.getName();
+            final String desc = "L" + state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION) + ";";
+            v.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL, name, desc, null, null);
+            if (myEnumConstants.isEmpty()) {
+                staticInitializerChunks.add(new CodeChunk() {
+                    @Override
+                    public void generate(InstructionAdapter v) {
+                        initializeEnumConstants(v);
+                    }
+                });
+            }
+            myEnumConstants.add((JetEnumEntry) declaration);
+        }
+        else {
+            super.generateDeclaration(propertyCodegen, declaration, functionCodegen);
+        }
+    }
+
+    private final List<JetEnumEntry> myEnumConstants = new ArrayList<JetEnumEntry>();
+
+    private void initializeEnumConstants(InstructionAdapter v) {
+        ExpressionCodegen codegen = new ExpressionCodegen(v, new FrameMap(), Type.VOID_TYPE, context, state);
+        for (JetEnumEntry enumConstant : myEnumConstants) {
+            // TODO type and constructor parameters
+            String implClass = state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION);
+
+            final List<JetDelegationSpecifier> delegationSpecifiers = enumConstant.getDelegationSpecifiers();
+            if (delegationSpecifiers.size() > 1) {
+                throw new UnsupportedOperationException("multiple delegation specifiers for enum constant not supported");
+            }
+
+            v.anew(Type.getObjectType(implClass));
+            v.dup();
+
+            if (delegationSpecifiers.size() == 1) {
+                final JetDelegationSpecifier specifier = delegationSpecifiers.get(0);
+                if (specifier instanceof JetDelegatorToSuperCall) {
+                    final JetDelegatorToSuperCall superCall = (JetDelegatorToSuperCall) specifier;
+                    ConstructorDescriptor constructorDescriptor = (ConstructorDescriptor) state.getBindingContext().get(BindingContext.REFERENCE_TARGET, superCall.getCalleeExpression().getConstructorReferenceExpression());
+                    CallableMethod method = state.getTypeMapper().mapToCallableMethod(constructorDescriptor, OwnerKind.IMPLEMENTATION);
+                    codegen.invokeMethodWithArguments(method, superCall);
+                }
+                else {
+                    throw new UnsupportedOperationException("unsupported type of enum constant initializer: " + specifier);
+                }
+            }
+            else {
+                v.invokespecial(implClass, "<init>", "()V");
+            }
+            v.putstatic(implClass, enumConstant.getName(), "L" + implClass + ";");
+        }
+    }
+
+    private void generateSecondaryConstructor(JetConstructor constructor) {
+        ConstructorDescriptor constructorDescriptor = state.getBindingContext().get(BindingContext.CONSTRUCTOR, constructor);
+        if (constructorDescriptor == null) {
+            throw new UnsupportedOperationException("failed to get descriptor for secondary constructor");
+        }
+        CallableMethod method = state.getTypeMapper().mapToCallableMethod(constructorDescriptor, kind);
+        int flags = Opcodes.ACC_PUBLIC; // TODO
+        final MethodVisitor mv = v.visitMethod(flags, "<init>", method.getSignature().getDescriptor(), null, null);
+        mv.visitCode();
+
+        ConstructorFrameMap frameMap = new ConstructorFrameMap(method, constructorDescriptor, descriptor, kind);
+
+        final InstructionAdapter iv = new InstructionAdapter(mv);
+        ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, context, state);
+
+        for (JetDelegationSpecifier initializer : constructor.getInitializers()) {
+            if (initializer instanceof JetDelegatorToThisCall) {
+                JetDelegatorToThisCall thisCall = (JetDelegatorToThisCall) initializer;
+                DeclarationDescriptor thisDescriptor = state.getBindingContext().get(BindingContext.REFERENCE_TARGET, thisCall.getThisReference());
+                if (!(thisDescriptor instanceof ConstructorDescriptor)) {
+                    throw new UnsupportedOperationException("expected 'this' delegator to resolve to constructor");
+                }
+                generateDelegatorToConstructorCall(iv, codegen, thisCall, (ConstructorDescriptor) thisDescriptor, frameMap);
+            }
+            else {
+                throw new UnsupportedOperationException("unknown initializer type");
+            }
+        }
+
+        JetExpression bodyExpression = constructor.getBodyExpression();
+        if (bodyExpression != null) {
+            codegen.gen(bodyExpression, Type.VOID_TYPE);
+        }
+
+        mv.visitInsn(Opcodes.RETURN);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+    }
+
+    protected void generateTypeInfoInitializer(int firstTypeParameter, int typeParamCount, InstructionAdapter iv) {
+        iv.load(0, JetTypeMapper.TYPE_OBJECT);
+
+        iv.aconst(state.getTypeMapper().jvmType(descriptor, OwnerKind.IMPLEMENTATION));
+        iv.iconst(0);
+
+        if(CodegenUtil.hasOuterTypeInfo(descriptor)) {
+            iv.load(1, JetTypeMapper.TYPE_OBJECT);
+            iv.invokeinterface("jet/JetObject", "getTypeInfo", "()Ljet/typeinfo/TypeInfo;");
+        }
+
+        if(typeParamCount != 0) {
+            iv.iconst(typeParamCount);
+            iv.newarray(JetTypeMapper.TYPE_TYPEINFOPROJECTION);
+
+            for (int i = 0; i < typeParamCount; i++) {
+                iv.dup();
+                iv.iconst(i);
+                iv.load(firstTypeParameter + i, JetTypeMapper.TYPE_OBJECT);
+                iv.checkcast(JetTypeMapper.TYPE_TYPEINFOPROJECTION);
+                iv.astore(JetTypeMapper.TYPE_OBJECT);
+            }
+
+            if(CodegenUtil.hasOuterTypeInfo(descriptor)) {
+                iv.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;ZLjet/typeinfo/TypeInfo;[Ljet/typeinfo/TypeInfoProjection;)Ljet/typeinfo/TypeInfo;");
+            }
+            else
+                iv.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z[Ljet/typeinfo/TypeInfoProjection;)Ljet/typeinfo/TypeInfo;");
+        }
+        else {
+            if(CodegenUtil.hasOuterTypeInfo(descriptor)) {
+                iv.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;ZLjet/typeinfo/TypeInfo;)Ljet/typeinfo/TypeInfo;");
+            }
+            else
+                iv.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z)Ljet/typeinfo/TypeInfo;");
+        }
+
+        iv.invokevirtual(state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION), "$setTypeInfo", "(Ljet/typeinfo/TypeInfo;)V");
+    }
+
+    protected void generateInitializers(ExpressionCodegen codegen, InstructionAdapter iv) {
+        for (JetDeclaration declaration : myClass.getDeclarations()) {
+            if (declaration instanceof JetProperty) {
+                final PropertyDescriptor propertyDescriptor = (PropertyDescriptor) state.getBindingContext().get(BindingContext.VARIABLE, declaration);
+                if (state.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
+                    final JetExpression initializer = ((JetProperty) declaration).getInitializer();
+                    if (initializer != null) {
+                        CompileTimeConstant<?> compileTimeValue = state.getBindingContext().get(BindingContext.COMPILE_TIME_VALUE, initializer);
+                        if(compileTimeValue != null) {
+                            assert compileTimeValue != null;
+                            Object value = compileTimeValue.getValue();
+                            Type type = state.getTypeMapper().mapType(propertyDescriptor.getOutType());
+                            if(JetTypeMapper.isPrimitive(type)) {
+                                if( !propertyDescriptor.getOutType().isNullable() && value instanceof Number) {
+                                    if(type == Type.INT_TYPE && ((Number)value).intValue() == 0)
+                                        continue;
+                                    if(type == Type.BYTE_TYPE && ((Number)value).byteValue() == 0)
+                                        continue;
+                                    if(type == Type.LONG_TYPE && ((Number)value).longValue() == 0L)
+                                        continue;
+                                    if(type == Type.SHORT_TYPE && ((Number)value).shortValue() == 0)
+                                        continue;
+                                    if(type == Type.DOUBLE_TYPE && ((Number)value).doubleValue() == 0d)
+                                        continue;
+                                    if(type == Type.FLOAT_TYPE && ((Number)value).byteValue() == 0f)
+                                        continue;
+                                }
+                                if(type == Type.BOOLEAN_TYPE && value instanceof Boolean && !((Boolean)value))
+                                    continue;
+                                if(type == Type.CHAR_TYPE && value instanceof Character && ((Character)value) == 0)
+                                    continue;
+                            }
+                            else {
+                                if(value == null)
+                                    continue;
+                            }
+                        }
+                        iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                        Type type = codegen.expressionType(initializer);
+                        if(propertyDescriptor.getOutType().isNullable())
+                            type = JetTypeMapper.boxType(type);
+                        codegen.gen(initializer, type);
+                        codegen.intermediateValueForProperty(propertyDescriptor, false, false).store(iv);
+                    }
+
+                }
+            }
+            else if (declaration instanceof JetClassInitializer) {
+                codegen.gen(((JetClassInitializer) declaration).getBody(), Type.VOID_TYPE);
+            }
+        }
+    }
+
+    protected void generateDelegates(JetClass toClass, ClassContext delegateContext, Set<FunctionDescriptor> overriden) {
+        final FunctionCodegen functionCodegen = new FunctionCodegen(delegateContext, v, state);
+        final PropertyCodegen propertyCodegen = new PropertyCodegen(delegateContext, v, functionCodegen, state);
+
+        for (JetDeclaration declaration : toClass.getDeclarations()) {
+            if (declaration instanceof JetProperty) {
+                propertyCodegen.gen((JetProperty) declaration);
+            }
+            else if (declaration instanceof JetFunction) {
+                if (!overriden.contains(state.getBindingContext().get(BindingContext.FUNCTION, declaration))) {
+                    functionCodegen.gen((JetNamedFunction) declaration);
+                }
+            }
+        }
+
+        for (JetParameter p : toClass.getPrimaryConstructorParameters()) {
+            if (p.getValOrVarNode() != null) {
+                PropertyDescriptor propertyDescriptor = state.getBindingContext().get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, p);
+                if (propertyDescriptor != null) {
+                    propertyCodegen.generateDefaultGetter(propertyDescriptor, Opcodes.ACC_PUBLIC);
+                    if (propertyDescriptor.isVar()) {
+                        propertyCodegen.generateDefaultSetter(propertyDescriptor, Opcodes.ACC_PUBLIC);
+                    }
+                }
+            }
+        }
+    }
+
+    @Nullable
+    private JetClassObject getClassObject() {
+        return myClass instanceof JetClass ? ((JetClass) myClass).getClassObject() : null;
+    }
+
+    private boolean isNonLiteralObject() {
+        return myClass instanceof JetObjectDeclaration && !((JetObjectDeclaration) myClass).isObjectLiteral() &&
+                !(myClass.getParent() instanceof JetClassObject);
+    }
+
+    private void generateGetTypeInfo() {
+        if(myClass instanceof JetClass && ((JetClass)myClass).isTrait())
+            return;
+
+        JetType defaultType = descriptor.getDefaultType();
+        if(CodegenUtil.hasTypeInfoField(defaultType)) {
+            if(!CodegenUtil.hasDerivedTypeInfoField(defaultType, true)) {
+                v.visitField(Opcodes.ACC_PRIVATE, "$typeInfo", "Ljet/typeinfo/TypeInfo;", null, null);
+
+                MethodVisitor mv = v.visitMethod(Opcodes.ACC_PUBLIC, "getTypeInfo", "()Ljet/typeinfo/TypeInfo;", null, null);
+                mv.visitCode();
+                InstructionAdapter iv = new InstructionAdapter(mv);
+                String owner = state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION);
+                iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                iv.getfield(owner, "$typeInfo", "Ljet/typeinfo/TypeInfo;");
+                iv.areturn(JetTypeMapper.TYPE_TYPEINFO);
+                mv.visitMaxs(0, 0);
+                mv.visitEnd();
+
+                mv = v.visitMethod(Opcodes.ACC_PROTECTED|Opcodes.ACC_FINAL, "$setTypeInfo", "(Ljet/typeinfo/TypeInfo;)V", null, null);
+                mv.visitCode();
+                iv = new InstructionAdapter(mv);
+                owner = state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION);
+                iv.load(0, JetTypeMapper.TYPE_OBJECT);
+                iv.load(1, JetTypeMapper.TYPE_OBJECT);
+                iv.putfield(owner, "$typeInfo", "Ljet/typeinfo/TypeInfo;");
+                mv.visitInsn(Opcodes.RETURN);
+                mv.visitMaxs(0, 0);
+                mv.visitEnd();
+            }
+        }
+        else {
+            genGetStaticGetTypeInfoMethod();
+            staticTypeInfoField();
+        }
+    }
+
+    private void genGetStaticGetTypeInfoMethod() {
+        final MethodVisitor mv = v.visitMethod(Opcodes.ACC_PUBLIC, "getTypeInfo", "()Ljet/typeinfo/TypeInfo;", null, null);
+        mv.visitCode();
+        InstructionAdapter v = new InstructionAdapter(mv);
+        String owner = state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION);
+        v.getstatic(owner, "$staticTypeInfo", "Ljet/typeinfo/TypeInfo;");
+        v.areturn(JetTypeMapper.TYPE_TYPEINFO);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+    }
+
+    private void staticTypeInfoField() {
+        v.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_STATIC, "$staticTypeInfo", "Ljet/typeinfo/TypeInfo;", null, null);
+        staticInitializerChunks.add(new CodeChunk() {
+            @Override
+            public void generate(InstructionAdapter v) {
+                JetTypeMapper typeMapper = state.getTypeMapper();
+                v.aconst(typeMapper.jvmType(descriptor, OwnerKind.IMPLEMENTATION));
+                v.iconst(0);
+                ClassDescriptor outerClassDescriptor = CodegenUtil.getOuterClassDescriptor(descriptor);
+                if(outerClassDescriptor == null) {
+                    v.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z)Ljet/typeinfo/TypeInfo;");
+                }
+                else {
+                    v.getstatic(state.getTypeMapper().jvmName(outerClassDescriptor, OwnerKind.IMPLEMENTATION), "$staticTypeInfo", "Ljet/typeinfo/TypeInfo;");
+                    v.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;ZLjet/typeinfo/TypeInfo;)Ljet/typeinfo/TypeInfo;");
+                }
+                v.putstatic(typeMapper.jvmName(descriptor, kind), "$staticTypeInfo", "Ljet/typeinfo/TypeInfo;");
+            }
+        });
+    }
+
+    private void generateClassObject(JetClassObject declaration) {
+         state.forClass().generate(context, declaration.getObjectDeclaration());
+    }
+
+    private void genGetSuperTypesTypeInfo() {
+        if(!(myClass instanceof JetClass) || ((JetClass)myClass).isTrait()) {
+            return;
+        }
+
+        String sig = getGetSuperTypesTypeInfoSignature(descriptor.getDefaultType());
+
+        final MethodVisitor mv = v.visitMethod(Opcodes.ACC_PUBLIC|Opcodes.ACC_STATIC,
+                "$$getSuperTypesTypeInfo",
+                sig,
+                null /* TODO */,
+                null);
+        mv.visitCode();
+        InstructionAdapter v = new InstructionAdapter(mv);
+
+        ExpressionCodegen codegen = new ExpressionCodegen(v, new FrameMap(), Type.VOID_TYPE, context, state);
+
+        v.load(0, JetTypeMapper.TYPE_OBJECT);
+
+        int k = 1;
+        for (TypeParameterDescriptor parameterDescriptor : descriptor.getTypeConstructor().getParameters()) {
+            codegen.addTypeParameter(parameterDescriptor, StackValue.local(k++, JetTypeMapper.TYPE_TYPEINFO));
+        }
+
+        for(JetType superType : descriptor.getTypeConstructor().getSupertypes()) {
+            for (TypeProjection typeProjection : superType.getArguments()) {
+                codegen.generateTypeInfo(typeProjection.getType());
+            }
+            v.invokestatic(state.getTypeMapper().mapType(superType).getInternalName(), "$$getSuperTypesTypeInfo", getGetSuperTypesTypeInfoSignature(superType));
+        }
+
+        v.areturn(Type.VOID_TYPE);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+    }
+
+    private static String getGetSuperTypesTypeInfoSignature(JetType type) {
+        List<TypeParameterDescriptor> typeParameters = type.getConstructor().getParameters();
+        StringBuilder sb = new StringBuilder("(Ljava/util/Set;");
+        for(TypeParameterDescriptor tp : typeParameters)
+            sb.append("Ljet/typeinfo/TypeInfo;");
+        sb.append(")V");
+
+        return sb.toString();
+    }
+
+}
diff --git a/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java
similarity index 61%
rename from idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java
index ce26f8dc6dc..61a1584b381 100644
--- a/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java
@@ -2,12 +2,15 @@ package org.jetbrains.jet.codegen;
 
 import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTreeUtil;
+import jet.Function1;
 import jet.JetObject;
 import jet.typeinfo.TypeInfo;
+import jet.typeinfo.TypeInfoProjection;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
@@ -19,20 +22,47 @@ import java.util.*;
 
 /**
  * @author yole
+ * @author alex.tkachman
  */
 public class JetTypeMapper {
     public static final Type TYPE_OBJECT = Type.getObjectType("java/lang/Object");
     public static final Type TYPE_TYPEINFO = Type.getType(TypeInfo.class);
+    public static final Type TYPE_TYPEINFOPROJECTION = Type.getType(TypeInfoProjection.class);
     public static final Type TYPE_JET_OBJECT = Type.getType(JetObject.class);
+    public static final Type TYPE_NOTHING = Type.getObjectType("jet/Nothing");
+    public static final Type JL_INTEGER_TYPE = Type.getObjectType("java/lang/Integer");
+    public static final Type JL_LONG_TYPE = Type.getObjectType("java/lang/Long");
+    public static final Type JL_SHORT_TYPE = Type.getObjectType("java/lang/Short");
+    public static final Type JL_BYTE_TYPE = Type.getObjectType("java/lang/Byte");
+    public static final Type JL_CHAR_TYPE = Type.getObjectType("java/lang/Character");
+    public static final Type JL_FLOAT_TYPE = Type.getObjectType("java/lang/Float");
+    public static final Type JL_DOUBLE_TYPE = Type.getObjectType("java/lang/Double");
+    public static final Type JL_BOOLEAN_TYPE = Type.getObjectType("java/lang/Boolean");
+    public static final Type JL_NUMBER_TYPE = Type.getObjectType("java/lang/Number");
+    public static final Type JL_STRING_BUILDER = Type.getObjectType("java/lang/StringBuilder");
+
+    public static final Type ARRAY_INT_TYPE = Type.getType(int[].class);
+    public static final Type ARRAY_LONG_TYPE = Type.getType(long[].class);
+    public static final Type ARRAY_SHORT_TYPE = Type.getType(short[].class);
+    public static final Type ARRAY_BYTE_TYPE = Type.getType(byte[].class);
+    public static final Type ARRAY_CHAR_TYPE = Type.getType(char[].class);
+    public static final Type ARRAY_FLOAT_TYPE = Type.getType(float[].class);
+    public static final Type ARRAY_DOUBLE_TYPE = Type.getType(double[].class);
+    public static final Type ARRAY_BOOL_TYPE = Type.getType(boolean[].class);
+    public static final Type ARRAY_GENERIC_TYPE = Type.getType(Object[].class);
 
     private final JetStandardLibrary standardLibrary;
     private final BindingContext bindingContext;
     private final Map<JetExpression, String> classNamesForAnonymousClasses = new HashMap<JetExpression, String>();
     private final Map<String, Integer> anonymousSubclassesCount = new HashMap<String, Integer>();
 
+    private final HashMap<JetType,String> knowTypes = new HashMap<JetType, String>();
+    public static final Type TYPE_FUNCTION1 = Type.getObjectType("jet/Function1");
+
     public JetTypeMapper(JetStandardLibrary standardLibrary, BindingContext bindingContext) {
         this.standardLibrary = standardLibrary;
         this.bindingContext = bindingContext;
+        initKnownTypes();
     }
 
     static String jvmName(PsiClass psiClass) {
@@ -47,7 +77,25 @@ public class JetTypeMapper {
         return type == Type.INT_TYPE || type == Type.SHORT_TYPE || type == Type.BYTE_TYPE || type == Type.CHAR_TYPE;
     }
 
+    public static boolean isPrimitive(Type type) {
+        return type == Type.INT_TYPE
+                || type == Type.SHORT_TYPE
+                || type == Type.BYTE_TYPE
+                || type == Type.CHAR_TYPE
+                || type == Type.SHORT_TYPE
+                || type == Type.FLOAT_TYPE
+                || type == Type.DOUBLE_TYPE
+                || type == Type.LONG_TYPE
+                || type == Type.BOOLEAN_TYPE
+                || type == Type.VOID_TYPE;
+    }
+
     static Type psiTypeToAsm(PsiType type) {
+        if(type instanceof PsiArrayType) {
+            PsiArrayType psiArrayType = (PsiArrayType) type;
+            return Type.getType("[" + psiTypeToAsm(psiArrayType.getComponentType()).getDescriptor());
+        }
+
         if (type instanceof PsiPrimitiveType) {
             if (type == PsiType.VOID) {
                 return Type.VOID_TYPE;
@@ -121,6 +169,7 @@ public class JetTypeMapper {
         }
         else {
             needsReceiver = true;
+            assert containingClass != null;
             if (containingClass.isInterface()) {
                 opcode = Opcodes.INVOKEINTERFACE;
             }
@@ -137,6 +186,28 @@ public class JetTypeMapper {
         return result;
     }
 
+    public static Type getBoxedType(final Type type) {
+        switch (type.getSort()) {
+            case Type.BYTE:
+                return JL_BYTE_TYPE;
+            case Type.BOOLEAN:
+                return JL_BOOLEAN_TYPE;
+            case Type.SHORT:
+                return JL_SHORT_TYPE;
+            case Type.CHAR:
+                return JL_CHAR_TYPE;
+            case Type.INT:
+                return JL_INTEGER_TYPE;
+            case Type.FLOAT:
+                return JL_FLOAT_TYPE;
+            case Type.LONG:
+                return JL_LONG_TYPE;
+            case Type.DOUBLE:
+                return JL_DOUBLE_TYPE;
+        }
+        return type;
+    }
+
     public String jvmName(ClassDescriptor jetClass, OwnerKind kind) {
         PsiElement declaration = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, jetClass);
         if (declaration instanceof PsiClass) {
@@ -147,9 +218,9 @@ public class JetTypeMapper {
             if (parent instanceof JetClassObject) {
                 JetClass containingClass = PsiTreeUtil.getParentOfType(parent, JetClass.class);
                 final ClassDescriptor containingClassDescriptor = bindingContext.get(BindingContext.CLASS, containingClass);
-                return jvmName(containingClassDescriptor, OwnerKind.INTERFACE) + "$$ClassObj";
+                return jvmName(containingClassDescriptor, OwnerKind.IMPLEMENTATION) + "$$ClassObj";
             }
-            String className = classNamesForAnonymousClasses.get(declaration);
+            @SuppressWarnings("SuspiciousMethodCalls") String className = classNamesForAnonymousClasses.get(declaration);
             if (className == null) {
                 throw new UnsupportedOperationException("Unexpected forward reference to anonymous class " + declaration);
             }
@@ -160,29 +231,18 @@ public class JetTypeMapper {
 
     public String jvmName(JetClassObject classObject) {
         final ClassDescriptor descriptor = bindingContext.get(BindingContext.CLASS, classObject.getObjectDeclaration());
-        return jvmName(descriptor,  OwnerKind.IMPLEMENTATION);
-    }
-
-    public boolean isInterface(ClassDescriptor jetClass, OwnerKind kind) {
-        PsiElement declaration = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, jetClass);
-        if (declaration instanceof JetObjectDeclaration) {
-            return false;
-        }
-        return kind == OwnerKind.INTERFACE;
+        return jvmName(descriptor, OwnerKind.IMPLEMENTATION);
     }
 
     private static String jetJvmName(ClassDescriptor jetClass, OwnerKind kind) {
-        if (jetClass.isObject()) {
+        if (jetClass.getKind() == ClassKind.OBJECT) {
             return jvmNameForImplementation(jetClass);
         }
-        if (kind == OwnerKind.INTERFACE) {
-            return jvmNameForInterface(jetClass);
-        }
         else if (kind == OwnerKind.IMPLEMENTATION) {
             return jvmNameForImplementation(jetClass);
         }
-        else if (kind == OwnerKind.DELEGATING_IMPLEMENTATION) {
-            return jvmNameForDelegatingImplementation(jetClass);
+        else if (kind == OwnerKind.TRAIT_IMPL) {
+            return jvmNameForTraitImpl(jetClass);
         }
         else {
             assert false : "Unsuitable kind";
@@ -209,10 +269,6 @@ public class JetTypeMapper {
         return Type.getType("L" + jvmNameForImplementation(classDescriptor) + ";");
     }
 
-    static Type jetDelegatingImplementationType(ClassDescriptor classDescriptor) {
-        return Type.getType("L" + jvmNameForDelegatingImplementation(classDescriptor) + ";");
-    }
-
     public static String jvmName(JetNamespace namespace) {
         return NamespaceCodegen.getJVMClassName(namespace.getFQName());
     }
@@ -226,11 +282,11 @@ public class JetTypeMapper {
     }
 
     public static String jvmNameForImplementation(ClassDescriptor descriptor) {
-        return jvmNameForInterface(descriptor) + "$$Impl";
+        return jvmNameForInterface(descriptor);
     }
 
-    public static String jvmNameForDelegatingImplementation(ClassDescriptor descriptor) {
-        return jvmNameForInterface(descriptor) + "$$DImpl";
+    private static String jvmNameForTraitImpl(ClassDescriptor descriptor) {
+        return jvmNameForInterface(descriptor) + "$$TImpl";
     }
 
     public String getOwner(DeclarationDescriptor descriptor, OwnerKind kind) {
@@ -241,11 +297,14 @@ public class JetTypeMapper {
         else if (descriptor.getContainingDeclaration() instanceof ClassDescriptor) {
             ClassDescriptor classDescriptor = (ClassDescriptor) descriptor.getContainingDeclaration();
             if (kind instanceof OwnerKind.DelegateKind) {
-                kind = OwnerKind.INTERFACE;
-            }
-            else if (classDescriptor.isObject()) {
                 kind = OwnerKind.IMPLEMENTATION;
             }
+            else {
+                assert classDescriptor != null;
+                if (classDescriptor.getKind() == ClassKind.OBJECT) {
+                    kind = OwnerKind.IMPLEMENTATION;
+                }
+            }
             owner = jvmName(classDescriptor, kind);
         }
         else {
@@ -254,74 +313,112 @@ public class JetTypeMapper {
         return owner;
     }
 
-    public Type mapType(final JetType jetType) {
-        return mapType(jetType, OwnerKind.INTERFACE);
-    }
-
-    public Type mapType(@NotNull final JetType jetType, OwnerKind kind) {
+    @NotNull public Type mapReturnType(@NotNull final JetType jetType, OwnerKind kind) {
         if (jetType.equals(JetStandardClasses.getUnitType()) || jetType.equals(JetStandardClasses.getNothingType())) {
             return Type.VOID_TYPE;
         }
+        return mapType(jetType, kind);
+    }
+
+    @NotNull public Type mapReturnType(final JetType jetType) {
+        return mapReturnType(jetType, OwnerKind.IMPLEMENTATION);
+    }
+
+    @NotNull public Type mapType(final JetType jetType) {
+        return mapType(jetType, OwnerKind.IMPLEMENTATION);
+    }
+
+    @NotNull public Type mapType(@NotNull final JetType jetType, OwnerKind kind) {
+        if (jetType.equals(JetStandardClasses.getNothingType()) || jetType.equals(JetStandardClasses.getNullableNothingType())) {
+            return TYPE_NOTHING;
+        }
         if (jetType.equals(standardLibrary.getIntType())) {
             return Type.INT_TYPE;
         }
-        if (jetType.equals(TypeUtils.makeNullable(standardLibrary.getIntType()))) {
-            return Type.getObjectType("java/lang/Integer");
+        if (jetType.equals(standardLibrary.getNullableIntType())) {
+            return JL_INTEGER_TYPE;
         }
         if (jetType.equals(standardLibrary.getLongType())) {
             return Type.LONG_TYPE;
         }
-        if (jetType.equals(TypeUtils.makeNullable(standardLibrary.getLongType()))) {
-            return Type.getObjectType("java/lang/Long");
+        if (jetType.equals(standardLibrary.getNullableLongType())) {
+            return JL_LONG_TYPE;
         }
         if (jetType.equals(standardLibrary.getShortType())) {
             return Type.SHORT_TYPE;
         }
-        if (jetType.equals(TypeUtils.makeNullable(standardLibrary.getShortType()))) {
-            return Type.getObjectType("java/lang/Short");
+        if (jetType.equals(standardLibrary.getNullableShortType())) {
+            return JL_SHORT_TYPE;
         }
         if (jetType.equals(standardLibrary.getByteType())) {
             return Type.BYTE_TYPE;
         }
-        if (jetType.equals(TypeUtils.makeNullable(standardLibrary.getByteType()))) {
-            return Type.getObjectType("java/lang/Byte");
+        if (jetType.equals(standardLibrary.getNullableByteType())) {
+            return JL_BYTE_TYPE;
         }
         if (jetType.equals(standardLibrary.getCharType())) {
             return Type.CHAR_TYPE;
         }
-        if (jetType.equals(TypeUtils.makeNullable(standardLibrary.getCharType()))) {
-            return Type.getObjectType("java/lang/Char");
+        if (jetType.equals(standardLibrary.getNullableCharType())) {
+            return JL_CHAR_TYPE;
         }
         if (jetType.equals(standardLibrary.getFloatType())) {
             return Type.FLOAT_TYPE;
         }
-        if (jetType.equals(TypeUtils.makeNullable(standardLibrary.getFloatType()))) {
-            return Type.getObjectType("java/lang/Float");
+        if (jetType.equals(standardLibrary.getNullableFloatType())) {
+            return JL_FLOAT_TYPE;
         }
         if (jetType.equals(standardLibrary.getDoubleType())) {
             return Type.DOUBLE_TYPE;
         }
-        if (jetType.equals(TypeUtils.makeNullable(standardLibrary.getDoubleType()))) {
-            return Type.getObjectType("java/lang/Double");
+        if (jetType.equals(standardLibrary.getNullableDoubleType())) {
+            return JL_DOUBLE_TYPE;
         }
         if (jetType.equals(standardLibrary.getBooleanType())) {
             return Type.BOOLEAN_TYPE;
         }
-        if (jetType.equals(TypeUtils.makeNullable(standardLibrary.getBooleanType()))) {
-            return Type.getObjectType("java/lang/Boolean");
+        if (jetType.equals(standardLibrary.getNullableBooleanType())) {
+            return JL_BOOLEAN_TYPE;
         }
         if (jetType.equals(standardLibrary.getStringType()) || jetType.equals(standardLibrary.getNullableStringType())) {
             return Type.getType(String.class);
         }
 
+        if(jetType.equals(standardLibrary.getByteArrayType())){
+            return ARRAY_BYTE_TYPE;
+        }
+        if(jetType.equals(standardLibrary.getShortArrayType())){
+            return ARRAY_SHORT_TYPE;
+        }
+        if(jetType.equals(standardLibrary.getIntArrayType())){
+            return ARRAY_INT_TYPE;
+        }
+        if(jetType.equals(standardLibrary.getLongArrayType())){
+            return ARRAY_LONG_TYPE;
+        }
+        if(jetType.equals(standardLibrary.getFloatArrayType())){
+            return ARRAY_FLOAT_TYPE;
+        }
+        if(jetType.equals(standardLibrary.getDoubleArrayType())){
+            return ARRAY_DOUBLE_TYPE;
+        }
+        if(jetType.equals(standardLibrary.getCharArrayType())){
+            return ARRAY_CHAR_TYPE;
+        }
+        if(jetType.equals(standardLibrary.getBooleanArrayType())){
+            return ARRAY_BOOL_TYPE;
+        }
+
         DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
         if (standardLibrary.getArray().equals(descriptor)) {
             if (jetType.getArguments().size() != 1) {
                 throw new UnsupportedOperationException("arrays must have one type argument");
             }
-            TypeProjection memberType = jetType.getArguments().get(0);
-            Type elementType = mapType(memberType.getType());
-            return Type.getType("[" + elementType.getDescriptor());
+            JetType memberType = jetType.getArguments().get(0).getType();
+            if(!isGenericsArray(jetType))
+                return Type.getType("[" + boxType(mapType(memberType, kind)).getDescriptor());
+            else
+                return ARRAY_GENERIC_TYPE;
         }
         if (JetStandardClasses.getAny().equals(descriptor)) {
             return Type.getType(Object.class);
@@ -338,39 +435,33 @@ public class JetTypeMapper {
         throw new UnsupportedOperationException("Unknown type " + jetType);
     }
 
-    public Type boxType(Type asmType) {
+    public static Type boxType(Type asmType) {
         switch (asmType.getSort()) {
             case Type.VOID:
-                return Type.getObjectType("java/lang/Void");
+                return Type.VOID_TYPE;
             case Type.BYTE:
-                return Type.getObjectType("java/lang/Byte");
+                return JL_BYTE_TYPE;
             case Type.BOOLEAN:
-                return Type.getObjectType("java/lang/Boolean");
+                return JL_BOOLEAN_TYPE;
             case Type.SHORT:
-                return Type.getObjectType("java/lang.Short");
+                return JL_SHORT_TYPE;
             case Type.CHAR:
-                return Type.getObjectType("java/lang/Character");
+                return JL_CHAR_TYPE;
             case Type.INT:
-                return Type.getObjectType("java/lang/Integer");
+                return JL_INTEGER_TYPE;
             case Type.FLOAT:
-                return Type.getObjectType("java/lang/Float");
+                return JL_FLOAT_TYPE;
             case Type.LONG:
-                return Type.getObjectType("java/lang/Long");
+                return JL_LONG_TYPE;
             case Type.DOUBLE:
-                return Type.getObjectType("java/lang/Double");
+                return JL_DOUBLE_TYPE;
         }
 
         return asmType;
     }
 
 
-    private static Type getBoxedType(final Type type) {
-        switch (type.getSort()) {
-        }
-        return type;
-    }
-
-    private Method mapSignature(JetNamedFunction f, List<Type> valueParameterTypes) {
+    private Method mapSignature(JetNamedFunction f, List<Type> valueParameterTypes, OwnerKind kind) {
         final JetTypeReference receiverTypeRef = f.getReceiverTypeRef();
         final JetType receiverType = receiverTypeRef == null ? null : bindingContext.get(BindingContext.TYPE, receiverTypeRef);
         final List<JetParameter> parameters = f.getValueParameters();
@@ -378,28 +469,40 @@ public class JetTypeMapper {
         if (receiverType != null) {
             parameterTypes.add(mapType(receiverType));
         }
+        FunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, f);
+        if(kind == OwnerKind.TRAIT_IMPL) {
+            ClassDescriptor containingDeclaration = (ClassDescriptor) functionDescriptor.getContainingDeclaration();
+            JetType jetType = TraitImplBodyCodegen.getSuperClass(containingDeclaration, bindingContext);
+            Type type = mapType(jetType);
+            if(type.getInternalName().equals("java/lang/Object")) {
+                jetType = containingDeclaration.getDefaultType();
+                type = mapType(jetType);
+            }
+            valueParameterTypes.add(type);
+            parameterTypes.add(type);
+        }
         for (JetParameter parameter : parameters) {
             final Type type = mapType(bindingContext.get(BindingContext.TYPE, parameter.getTypeReference()));
             valueParameterTypes.add(type);
             parameterTypes.add(type);
         }
-        for (JetTypeParameter p: f.getTypeParameters()) {
+        for (int n = f.getTypeParameters().size(); n > 0; n--) {
             parameterTypes.add(TYPE_TYPEINFO);
         }
         final JetTypeReference returnTypeRef = f.getReturnTypeRef();
         Type returnType;
         if (returnTypeRef == null) {
-            final FunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, f);
+            assert functionDescriptor != null;
             final JetType type = functionDescriptor.getReturnType();
-            returnType = mapType(type);
+            returnType = mapReturnType(type);
         }
         else {
-            returnType = mapType(bindingContext.get(BindingContext.TYPE, returnTypeRef));
+            returnType = mapReturnType(bindingContext.get(BindingContext.TYPE, returnTypeRef));
         }
         return new Method(f.getName(), returnType, parameterTypes.toArray(new Type[parameterTypes.size()]));
     }
 
-    public CallableMethod mapToCallableMethod(PsiNamedElement declaration) {
+    public CallableMethod mapToCallableMethod(PsiNamedElement declaration, OwnerKind kind) {
         if (declaration instanceof PsiMethod) {
             return mapToCallableMethod((PsiMethod) declaration);
         }
@@ -408,9 +511,10 @@ public class JetTypeMapper {
         }
         JetNamedFunction f = (JetNamedFunction) declaration;
         final FunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, f);
+        assert functionDescriptor != null;
         final DeclarationDescriptor functionParent = functionDescriptor.getContainingDeclaration();
         final List<Type> valueParameterTypes = new ArrayList<Type>();
-        Method descriptor = mapSignature(f, valueParameterTypes);
+        Method descriptor = mapSignature(f, valueParameterTypes, kind);
         String owner;
         int invokeOpcode;
         boolean needsReceiver;
@@ -422,8 +526,8 @@ public class JetTypeMapper {
         }
         else if (functionParent instanceof ClassDescriptor) {
             ClassDescriptor containingClass = (ClassDescriptor) functionParent;
-            owner = jvmName(containingClass, OwnerKind.INTERFACE);
-            invokeOpcode = isInterface(containingClass, OwnerKind.INTERFACE)
+            owner = jvmName(containingClass, OwnerKind.IMPLEMENTATION);
+            invokeOpcode = CodegenUtil.isInterface(containingClass)
                     ? Opcodes.INVOKEINTERFACE
                     : Opcodes.INVOKEVIRTUAL;
             needsReceiver = true;
@@ -442,16 +546,16 @@ public class JetTypeMapper {
     }
 
     public Method mapSignature(String name, FunctionDescriptor f) {
-        final JetType receiverType = f.getReceiverType();
+        final ReceiverDescriptor receiver = f.getReceiver();
         final List<ValueParameterDescriptor> parameters = f.getValueParameters();
         List<Type> parameterTypes = new ArrayList<Type>();
-        if (receiverType != null) {
-            parameterTypes.add(mapType(receiverType));
+        if (receiver.exists()) {
+            parameterTypes.add(mapType(receiver.getType()));
         }
         for (ValueParameterDescriptor parameter : parameters) {
             parameterTypes.add(mapType(parameter.getOutType()));
         }
-        Type returnType = mapType(f.getReturnType());
+        Type returnType = mapReturnType(f.getReturnType());
         return new Method(name, returnType, parameterTypes.toArray(new Type[parameterTypes.size()]));
     }
 
@@ -481,7 +585,7 @@ public class JetTypeMapper {
         answer.append(mapType(type).getDescriptor()); // TODO: type parameter references!
     }
 
-    private void appendTypeParameterSignature(StringBuffer answer, TypeParameterDescriptor p) {
+    private static void appendTypeParameterSignature(StringBuffer answer, TypeParameterDescriptor p) {
         answer.append(p.getName()); // TODO: BOUND!
     }
 
@@ -499,17 +603,12 @@ public class JetTypeMapper {
         return new Method(PropertyCodegen.setterName(descriptor.getName()), Type.VOID_TYPE, new Type[] { paramType });
     }
 
-    private Method mapConstructorSignature(ConstructorDescriptor descriptor, OwnerKind kind, List<Type> valueParameterTypes) {
-        boolean delegate = kind == OwnerKind.DELEGATING_IMPLEMENTATION;
+    private Method mapConstructorSignature(ConstructorDescriptor descriptor, List<Type> valueParameterTypes) {
         List<ValueParameterDescriptor> parameters = descriptor.getOriginal().getValueParameters();
         List<Type> parameterTypes = new ArrayList<Type>();
         ClassDescriptor classDescriptor = descriptor.getContainingDeclaration();
-        final DeclarationDescriptor outerDescriptor = classDescriptor.getContainingDeclaration();
-        if (outerDescriptor instanceof ClassDescriptor) {
-            parameterTypes.add(jvmType((ClassDescriptor) outerDescriptor, OwnerKind.IMPLEMENTATION));
-        }
-        if (delegate) {
-            parameterTypes.add(jetInterfaceType(classDescriptor));
+        if (CodegenUtil.hasThis0(classDescriptor)) {
+            parameterTypes.add(jvmType(CodegenUtil.getOuterClassDescriptor(classDescriptor), OwnerKind.IMPLEMENTATION));
         }
         for (ValueParameterDescriptor parameter : parameters) {
             final Type type = mapType(parameter.getOutType());
@@ -518,7 +617,7 @@ public class JetTypeMapper {
         }
 
         List<TypeParameterDescriptor> typeParameters = classDescriptor.getTypeConstructor().getParameters();
-        for (TypeParameterDescriptor typeParameter : typeParameters) {
+        for (int n = typeParameters.size(); n > 0; n--) {
             parameterTypes.add(TYPE_TYPEINFO);
         }
 
@@ -527,7 +626,7 @@ public class JetTypeMapper {
 
     public CallableMethod mapToCallableMethod(ConstructorDescriptor descriptor, OwnerKind kind) {
         List<Type> valueParameterTypes = new ArrayList<Type>();
-        final Method method = mapConstructorSignature(descriptor, kind, valueParameterTypes);
+        final Method method = mapConstructorSignature(descriptor, valueParameterTypes);
         String owner = jvmName(descriptor.getContainingDeclaration(), kind);
         final CallableMethod result = new CallableMethod(owner, method, Opcodes.INVOKESPECIAL, valueParameterTypes);
         result.setAcceptsTypeArguments(true);
@@ -554,15 +653,15 @@ public class JetTypeMapper {
             return name;
         }
 
-        JetNamedDeclaration container = PsiTreeUtil.getParentOfType(expression, JetNamespace.class, JetClass.class, JetObjectDeclaration.class);
+        @SuppressWarnings("unchecked") JetNamedDeclaration container = PsiTreeUtil.getParentOfType(expression, JetNamespace.class, JetClass.class, JetObjectDeclaration.class);
 
         String baseName;
         if (container instanceof JetNamespace) {
             baseName = NamespaceCodegen.getJVMClassName(((JetNamespace) container).getFQName());
         }
         else {
-            ClassDescriptor aClass = bindingContext.get(BindingContext.CLASS, (JetClassOrObject) container);
-            baseName = JetTypeMapper.jvmNameForInterface(aClass);
+            ClassDescriptor aClass = bindingContext.get(BindingContext.CLASS, container);
+            baseName = jvmNameForInterface(aClass);
         }
 
         Integer count = anonymousSubclassesCount.get(baseName);
@@ -579,10 +678,60 @@ public class JetTypeMapper {
         Set<String> result = new HashSet<String>();
         final ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, jetClass);
         if (classDescriptor != null) {
-            result.add(jvmName(classDescriptor, OwnerKind.INTERFACE));
             result.add(jvmName(classDescriptor, OwnerKind.IMPLEMENTATION));
-            result.add(jvmName(classDescriptor, OwnerKind.DELEGATING_IMPLEMENTATION));
         }
         return result;
     }
+
+    private void initKnownTypes() {
+        knowTypes.put(standardLibrary.getIntType(), "INT_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableIntType(), "NULLABLE_INT_TYPE_INFO");
+        knowTypes.put(standardLibrary.getLongType(), "LONG_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableLongType(), "NULLABLE_LONG_TYPE_INFO");
+        knowTypes.put(standardLibrary.getShortType(),"SHORT_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableShortType(),"NULLABLE_SHORT_TYPE_INFO");
+        knowTypes.put(standardLibrary.getByteType(),"BYTE_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableByteType(),"NULLABLE_BYTE_TYPE_INFO");
+        knowTypes.put(standardLibrary.getCharType(),"CHAR_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableCharType(),"NULLABLE_CHAR_TYPE_INFO");
+        knowTypes.put(standardLibrary.getFloatType(),"FLOAT_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableFloatType(),"NULLABLE_FLOAT_TYPE_INFO");
+        knowTypes.put(standardLibrary.getDoubleType(),"DOUBLE_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableDoubleType(),"NULLABLE_DOUBLE_TYPE_INFO");
+        knowTypes.put(standardLibrary.getBooleanType(),"BOOLEAN_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableBooleanType(),"NULLABLE_BOOLEAN_TYPE_INFO");
+        knowTypes.put(standardLibrary.getStringType(),"STRING_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableStringType(),"NULLABLE_STRING_TYPE_INFO");
+        knowTypes.put(standardLibrary.getTuple0Type(),"TUPLE0_TYPE_INFO");
+        knowTypes.put(standardLibrary.getNullableTuple0Type(),"NULLABLE_TUPLE0_TYPE_INFO");
+
+        knowTypes.put(standardLibrary.getIntArrayType(), "INT_ARRAY_TYPE_INFO");
+        knowTypes.put(standardLibrary.getLongArrayType(), "LONG_ARRAY_TYPE_INFO");
+        knowTypes.put(standardLibrary.getShortArrayType(),"SHORT_ARRAY_TYPE_INFO");
+        knowTypes.put(standardLibrary.getByteArrayType(),"BYTE_ARRAY_TYPE_INFO");
+        knowTypes.put(standardLibrary.getCharArrayType(),"CHAR_ARRAY_TYPE_INFO");
+        knowTypes.put(standardLibrary.getFloatArrayType(),"FLOAT_ARRAY_TYPE_INFO");
+        knowTypes.put(standardLibrary.getDoubleArrayType(),"DOUBLE_ARRAY_TYPE_INFO");
+        knowTypes.put(standardLibrary.getBooleanArrayType(),"BOOLEAN_ARRAY_TYPE_INFO");
+    }
+
+    public String isKnownTypeInfo(JetType jetType) {
+        return knowTypes.get(jetType);
+    }
+
+    public boolean isGenericsArray(JetType type) {
+        DeclarationDescriptor declarationDescriptor = type.getConstructor().getDeclarationDescriptor();
+        if(declarationDescriptor instanceof TypeParameterDescriptor)
+            return true;
+
+        if(standardLibrary.getArray().equals(declarationDescriptor))
+            return isGenericsArray(type.getArguments().get(0).getType());
+
+        return false;
+    }
+
+    public JetType getGenericsElementType(JetType arrayType) {
+        JetType type = arrayType.getArguments().get(0).getType();
+        return isGenericsArray(type) ? type : null;
+    }
 }
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
new file mode 100644
index 00000000000..4974917fb30
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
@@ -0,0 +1,197 @@
+package org.jetbrains.jet.codegen;
+
+import com.intellij.psi.PsiFile;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.java.JavaClassDescriptor;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeProjection;
+import org.jetbrains.jet.lang.types.TypeUtils;
+import org.objectweb.asm.*;
+import org.objectweb.asm.commons.InstructionAdapter;
+
+import java.util.*;
+
+import static org.objectweb.asm.Opcodes.*;
+
+/**
+ * @author max
+ */
+public class NamespaceCodegen {
+    private final ClassVisitor v;
+    private final GenerationState state;
+
+    public NamespaceCodegen(ClassVisitor v, String fqName, GenerationState state, PsiFile sourceFile) {
+        this.v = v;
+        this.state = state;
+
+        v.visit(V1_6,
+                ACC_PUBLIC,
+                getJVMClassName(fqName),
+                null,
+                //"jet/lang/Namespace",
+                "java/lang/Object",
+                new String[0]
+        );
+        // TODO figure something out for a namespace that spans multiple files
+        v.visitSource(sourceFile.getName(), null);
+    }
+
+    public void generate(JetNamespace namespace) {
+        final ClassContext context = ClassContext.STATIC.intoNamespace(state.getBindingContext().get(BindingContext.NAMESPACE, namespace));
+
+        final FunctionCodegen functionCodegen = new FunctionCodegen(context, v, state);
+        final PropertyCodegen propertyCodegen = new PropertyCodegen(context, v, functionCodegen, state);
+        final ClassCodegen classCodegen = state.forClass();
+
+        GenerationState.prepareAnonymousClasses(namespace, state.getTypeMapper());
+
+        for (JetDeclaration declaration : namespace.getDeclarations()) {
+            if (declaration instanceof JetProperty) {
+                propertyCodegen.gen((JetProperty) declaration);
+            }
+            else if (declaration instanceof JetNamedFunction) {
+                try {
+                    functionCodegen.gen((JetNamedFunction) declaration);
+                } catch (Exception e) {
+                    throw new RuntimeException("Failed to generate function " + declaration.getName(), e);
+                }
+            }
+            else if (declaration instanceof JetClassOrObject) {
+                classCodegen.generate(context, (JetClassOrObject) declaration);
+            }
+            else if (declaration instanceof JetNamespace) {
+                JetNamespace childNamespace = (JetNamespace) declaration;
+                state.forNamespace(childNamespace).generate(childNamespace);
+            }
+        }
+
+        if (hasNonConstantPropertyInitializers(namespace)) {
+            generateStaticInitializers(namespace);
+        }
+
+        generateTypeInfoFields(namespace, context);
+    }
+
+    private void generateStaticInitializers(JetNamespace namespace) {
+        MethodVisitor mv = v.visitMethod(ACC_PUBLIC | ACC_STATIC,
+                "<clinit>", "()V", null, null);
+        mv.visitCode();
+
+        FrameMap frameMap = new FrameMap();
+        ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, ClassContext.STATIC, state);
+
+        for (JetDeclaration declaration : namespace.getDeclarations()) {
+            if (declaration instanceof JetProperty) {
+                final JetExpression initializer = ((JetProperty) declaration).getInitializer();
+                if (initializer != null && !(initializer instanceof JetConstantExpression)) {
+                    final PropertyDescriptor descriptor = (PropertyDescriptor) state.getBindingContext().get(BindingContext.VARIABLE, declaration);
+                    codegen.genToJVMStack(initializer);
+                    codegen.intermediateValueForProperty(descriptor, true, false).store(new InstructionAdapter(mv));
+                }
+            }
+        }
+
+        mv.visitInsn(RETURN);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+    }
+
+    private void generateTypeInfoFields(JetNamespace namespace, ClassContext 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();
+                v.visitField(ACC_PRIVATE|ACC_STATIC|ACC_SYNTHETIC, fieldName, "Ljet/typeinfo/TypeInfo;", null, null);
+
+                MethodVisitor mmv = v.visitMethod(ACC_PUBLIC|ACC_STATIC|ACC_SYNTHETIC, "$getCachedTypeInfo$" + e.getValue(), "()Ljet/typeinfo/TypeInfo;", null, null);
+                InstructionAdapter v = new InstructionAdapter(mmv);
+                v.visitFieldInsn(GETSTATIC, jvmClassName, fieldName, "Ljet/typeinfo/TypeInfo;");
+                v.visitInsn(DUP);
+                Label end = new Label();
+                v.visitJumpInsn(IFNONNULL, end);
+
+                v.pop();
+                generateTypeInfo(context, v, e.getKey(), state.getTypeMapper(), e.getKey());
+                v.dup();
+
+                v.visitFieldInsn(PUTSTATIC, jvmClassName, fieldName, "Ljet/typeinfo/TypeInfo;");
+                v.visitLabel(end);
+                v.visitInsn(ARETURN);
+                v.visitMaxs(0, 0);
+                v.visitEnd();
+            }
+        }
+    }
+
+    private static void generateTypeInfo(ClassContext context, InstructionAdapter v, JetType jetType, JetTypeMapper typeMapper, JetType root) {
+        String knownTypeInfo = typeMapper.isKnownTypeInfo(jetType);
+        if(knownTypeInfo != null) {
+            v.getstatic("jet/typeinfo/TypeInfo", knownTypeInfo, "Ljet/typeinfo/TypeInfo;");
+            return;
+        }
+
+        DeclarationDescriptor declarationDescriptor = jetType.getConstructor().getDeclarationDescriptor();
+        if(!jetType.equals(root) && jetType.getArguments().size() == 0 && !(declarationDescriptor instanceof JavaClassDescriptor)) {
+            // TODO: we need some better checks here
+            v.getstatic(typeMapper.mapType(jetType, OwnerKind.IMPLEMENTATION).getInternalName(), "$typeInfo", "Ljet/typeinfo/TypeInfo;");
+            return;
+        }
+
+        boolean hasUnsubstituted = TypeUtils.hasUnsubstitutedTypeParameters(jetType);
+        if(!jetType.equals(root) && !hasUnsubstituted) {
+            int typeInfoConstantIndex = context.getTypeInfoConstantIndex(jetType);
+            v.invokestatic(context.getNamespaceClassName(), "$getCachedTypeInfo$" + typeInfoConstantIndex, "()Ljet/typeinfo/TypeInfo;");
+            return;
+        }
+
+        final Type jvmType = typeMapper.mapType(jetType);
+
+        v.aconst(jvmType);
+        v.iconst(jetType.isNullable() ? 1 : 0);
+        List<TypeProjection> arguments = jetType.getArguments();
+        if (arguments.size() > 0 && !(jvmType.getSort() == Type.ARRAY && jvmType.getElementType().getSort() != Type.OBJECT)) {
+            v.iconst(arguments.size());
+            v.newarray(JetTypeMapper.TYPE_TYPEINFOPROJECTION);
+
+            for (int i = 0, argumentsSize = arguments.size(); i < argumentsSize; i++) {
+                TypeProjection argument = arguments.get(i);
+                v.dup();
+                v.iconst(i);
+                generateTypeInfo(context, v, argument.getType(), typeMapper, root);
+                ExpressionCodegen.genTypeInfoToProjection(v, argument.getProjectionKind());
+                v.astore(JetTypeMapper.TYPE_OBJECT);
+            }
+            v.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z[Ljet/typeinfo/TypeInfoProjection;)Ljet/typeinfo/TypeInfo;");
+        }
+        else {
+            v.invokestatic("jet/typeinfo/TypeInfo", "getTypeInfo", "(Ljava/lang/Class;Z)Ljet/typeinfo/TypeInfo;");
+        }
+    }
+
+    private static boolean hasNonConstantPropertyInitializers(JetNamespace namespace) {
+        for (JetDeclaration declaration : namespace.getDeclarations()) {
+            if (declaration instanceof JetProperty) {
+                final JetExpression initializer = ((JetProperty) declaration).getInitializer();
+                if (initializer != null && !(initializer instanceof JetConstantExpression)) {
+                    return true;
+                }
+
+            }
+        }
+        return false;
+    }
+
+    public void done() {
+        v.visitEnd();
+    }
+
+    public static String getJVMClassName(String fqName) {
+        if (fqName.length() == 0) {
+            return "namespace";
+        }
+        return fqName.replace('.', '/') + "/namespace";
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/codegen/OwnerKind.java b/compiler/backend/src/org/jetbrains/jet/codegen/OwnerKind.java
similarity index 84%
rename from idea/src/org/jetbrains/jet/codegen/OwnerKind.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/OwnerKind.java
index 55c71dde735..f5259b2098b 100644
--- a/idea/src/org/jetbrains/jet/codegen/OwnerKind.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/OwnerKind.java
@@ -11,9 +11,8 @@ public class OwnerKind {
     }
 
     public static final OwnerKind NAMESPACE = new OwnerKind("namespace");
-    public static final OwnerKind INTERFACE = new OwnerKind("interface");
     public static final OwnerKind IMPLEMENTATION = new OwnerKind("implementation");
-    public static final OwnerKind DELEGATING_IMPLEMENTATION = new OwnerKind("delegating implementation");
+    public static final OwnerKind TRAIT_IMPL = new OwnerKind("trait implementation");
 
     public static class DelegateKind extends OwnerKind {
         private final StackValue delegate;
diff --git a/idea/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java
similarity index 84%
rename from idea/src/org/jetbrains/jet/codegen/PropertyCodegen.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java
index 67a3da3e357..6dc17c82643 100644
--- a/idea/src/org/jetbrains/jet/codegen/PropertyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java
@@ -1,9 +1,8 @@
 package org.jetbrains.jet.codegen;
 
 import com.intellij.openapi.util.text.StringUtil;
-import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
-import org.jetbrains.jet.lang.descriptors.PropertySetterDescriptor;
-import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
@@ -36,29 +35,11 @@ public class PropertyCodegen {
             throw new UnsupportedOperationException("expect a property to have a property descriptor");
         }
         final PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
-        if (kind == OwnerKind.NAMESPACE || kind == OwnerKind.IMPLEMENTATION || kind == OwnerKind.DELEGATING_IMPLEMENTATION) {
+        if (kind == OwnerKind.NAMESPACE || kind == OwnerKind.IMPLEMENTATION) {
             generateBackingField(p, propertyDescriptor);
             generateGetter(p, propertyDescriptor);
             generateSetter(p, propertyDescriptor);
         }
-        else if (kind == OwnerKind.INTERFACE) {
-            final JetPropertyAccessor getter = p.getGetter();
-            if ((getter != null && !getter.hasModifier(JetTokens.PRIVATE_KEYWORD) ||
-                 (getter == null && isExternallyAccessible(p)))) {
-                v.visitMethod(Opcodes.ACC_ABSTRACT | Opcodes.ACC_PUBLIC,
-                        getterName(p.getName()),
-                        state.getTypeMapper().mapGetterSignature(propertyDescriptor).getDescriptor(),
-                        null, null);
-            }
-            final JetPropertyAccessor setter = p.getSetter();
-            if ((setter != null && !setter.hasModifier(JetTokens.PRIVATE_KEYWORD) ||
-                (setter == null && isExternallyAccessible(p) && p.isVar()))) {
-                v.visitMethod(Opcodes.ACC_ABSTRACT | Opcodes.ACC_PUBLIC,
-                        setterName(p.getName()),
-                        state.getTypeMapper().mapSetterSignature(propertyDescriptor).getDescriptor(),
-                        null, null);
-            }
-        }
         else if (kind instanceof OwnerKind.DelegateKind) {
             generateDefaultGetter(propertyDescriptor, Opcodes.ACC_PUBLIC);
             if (propertyDescriptor.isVar()) {
@@ -68,7 +49,11 @@ public class PropertyCodegen {
     }
 
     private void generateBackingField(JetProperty p, PropertyDescriptor propertyDescriptor) {
-        if ((boolean) state.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
+        if (state.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
+            DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
+            if(CodegenUtil.isInterface(containingDeclaration))
+                return;
+
             Object value = null;
             final JetExpression initializer = p.getInitializer();
             if (initializer != null) {
@@ -136,14 +121,16 @@ public class PropertyCodegen {
         if (kind == OwnerKind.NAMESPACE) {
             flags |= Opcodes.ACC_STATIC;
         }
-        else if (kind == OwnerKind.INTERFACE) {
+
+        PsiElement psiElement = state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, propertyDescriptor.getContainingDeclaration());
+        boolean isTrait = psiElement instanceof JetClass && ((JetClass) psiElement).isTrait();
+        if(isTrait && !(kind instanceof OwnerKind.DelegateKind))
             flags |= Opcodes.ACC_ABSTRACT;
-        }
 
         final String signature = state.getTypeMapper().mapGetterSignature(propertyDescriptor).getDescriptor();
         String getterName = getterName(propertyDescriptor.getName());
         MethodVisitor mv = v.visitMethod(flags, getterName, signature, null, null);
-        if (kind != OwnerKind.INTERFACE) {
+        if (!isTrait || kind instanceof OwnerKind.DelegateKind) {
             mv.visitCode();
             InstructionAdapter iv = new InstructionAdapter(mv);
             if (kind != OwnerKind.NAMESPACE) {
@@ -176,13 +163,15 @@ public class PropertyCodegen {
         if (kind == OwnerKind.NAMESPACE) {
             flags |= Opcodes.ACC_STATIC;
         }
-        else if (kind == OwnerKind.INTERFACE) {
+
+        PsiElement psiElement = state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, propertyDescriptor.getContainingDeclaration());
+        boolean isTrait = psiElement instanceof JetClass && ((JetClass) psiElement).isTrait();
+        if(isTrait && !(kind instanceof OwnerKind.DelegateKind))
             flags |= Opcodes.ACC_ABSTRACT;
-        }
 
         final String signature = state.getTypeMapper().mapSetterSignature(propertyDescriptor).getDescriptor();
         MethodVisitor mv = v.visitMethod(flags, setterName(propertyDescriptor.getName()), signature, null, null);
-        if (kind != OwnerKind.INTERFACE) {
+        if (!isTrait || kind instanceof OwnerKind.DelegateKind) {
             mv.visitCode();
             InstructionAdapter iv = new InstructionAdapter(mv);
             final Type type = state.getTypeMapper().mapType(propertyDescriptor.getOutType());
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/SignatureUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/SignatureUtil.java
new file mode 100644
index 00000000000..2bcfbc5804d
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/SignatureUtil.java
@@ -0,0 +1,77 @@
+package org.jetbrains.jet.codegen;
+
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.psi.JetClass;
+import org.jetbrains.jet.lang.psi.JetDelegationSpecifier;
+import org.jetbrains.jet.lang.psi.JetTypeParameter;
+import org.jetbrains.jet.lang.psi.JetTypeReference;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeProjection;
+import org.jetbrains.jet.lang.types.Variance;
+
+import java.util.List;
+
+/**
+ * @author alex.tkachman
+ */
+public class SignatureUtil {
+    public static String classToSignature(JetClass type, BindingContext bindingContext, JetTypeMapper typeMapper) {
+        StringBuilder sb = new StringBuilder();
+        genTypeParams(type, sb);
+        List<JetDelegationSpecifier> delegationSpecifiers = type.getDelegationSpecifiers();
+        for (JetDelegationSpecifier specifier : delegationSpecifiers) {
+            JetTypeReference typeReference = specifier.getTypeReference();
+            JetType jetType = bindingContext.get(BindingContext.TYPE, typeReference);
+            genJetType(sb, jetType, typeMapper);
+        }
+        return sb.toString();
+    }
+
+    private static void genJetType(StringBuilder sb, JetType jetType, JetTypeMapper typeMapper) {
+        DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
+        if(descriptor instanceof ClassDescriptor) {
+            JetType defaultType = ((ClassDescriptor) descriptor).getDefaultType();
+            org.objectweb.asm.Type type = typeMapper.mapType(defaultType, OwnerKind.IMPLEMENTATION);
+            if(JetTypeMapper.isPrimitive(type)) {
+                type = JetTypeMapper.boxType(type);
+            }
+            sb.append(type.getDescriptor());
+        }
+        else {
+            sb.append("T");
+            sb.append(descriptor.getContainingDeclaration().getName());
+            sb.append(";");
+            sb.append(descriptor.getName());
+            sb.append(";");
+        }
+        if(!jetType.getArguments().isEmpty()) {
+            sb.append("<");
+            for (TypeProjection typeProjection : jetType.getArguments()) {
+                if(typeProjection.getProjectionKind() == Variance.IN_VARIANCE)
+                    sb.append("in ");
+                if(typeProjection.getProjectionKind() == Variance.OUT_VARIANCE)
+                    sb.append("out ");
+                genJetType(sb, typeProjection.getType(), typeMapper);
+            }
+            sb.append(">");
+        }
+        if(jetType.isNullable())
+            sb.append("?");
+    }
+
+    private static void genTypeParams(JetClass type, StringBuilder sb) {
+        List<JetTypeParameter> parameters = type.getTypeParameterList().getParameters();
+        for(JetTypeParameter param : parameters) {
+            sb.append("T");
+            Variance variance = param.getVariance();
+            if(variance == Variance.IN_VARIANCE)
+                sb.append("in ");
+            else if(variance == Variance.OUT_VARIANCE)
+                sb.append("out ");
+            sb.append(param.getName());
+            sb.append(";");
+        }
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java
similarity index 85%
rename from idea/src/org/jetbrains/jet/codegen/StackValue.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java
index e37c5946d28..7a7c280f8e1 100644
--- a/idea/src/org/jetbrains/jet/codegen/StackValue.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java
@@ -13,12 +13,24 @@ import org.objectweb.asm.commons.Method;
  * @author yole
  */
 public abstract class StackValue {
-    protected final Type type;
+    public final Type type;
 
     public StackValue(Type type) {
         this.type = type;
     }
 
+    public static void valueOf(InstructionAdapter instructionAdapter, final Type type) {
+        if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
+            return;
+        }
+        if (type == Type.VOID_TYPE) {
+            instructionAdapter.aconst(null);
+        } else {
+            Type boxed = JetTypeMapper.getBoxedType(type);
+            instructionAdapter.invokestatic(boxed.getInternalName(), "valueOf", "(" + type.getDescriptor() + ")" + boxed.getDescriptor());
+        }
+    }
+
     public abstract void put(Type type, InstructionAdapter v);
 
     public void store(InstructionAdapter v) {
@@ -48,8 +60,7 @@ public abstract class StackValue {
     }
 
     public static StackValue onStack(Type type) {
-        assert type != Type.VOID_TYPE;
-        return new OnStack(type);
+        return type == Type.VOID_TYPE ? none() : new OnStack(type);
     }
 
     public static StackValue constant(Object value, Type type) {
@@ -64,8 +75,8 @@ public abstract class StackValue {
         return new Invert(stackValue);
     }
 
-    public static StackValue arrayElement(Type type) {
-        return new ArrayElement(type);
+    public static StackValue arrayElement(Type type, boolean unbox) {
+        return new ArrayElement(type, unbox);
     }
 
     public static StackValue collectionElement(Type type, CallableMethod getter, CallableMethod setter) {
@@ -157,8 +168,26 @@ public abstract class StackValue {
     protected void coerce(Type type, InstructionAdapter v) {
         if (type.equals(this.type)) return;
 
-        if (type.getSort() == Type.OBJECT && this.type.getSort() == Type.OBJECT) {
-        //    v.checkcast(type);
+        if (type.getSort() == Type.VOID && this.type.getSort() != Type.VOID) {
+            if(this.type.getSize() == 1)
+                v.pop();
+            else
+                v.pop2();
+        }
+        else if (type.getSort() != Type.VOID && this.type.getSort() == Type.VOID) {
+            if(type.getSort() == Type.OBJECT)
+                v.visitFieldInsn(Opcodes.GETSTATIC, "jet/Tuple0", "INSTANCE", "Ljet/Tuple0;");
+            else if(type == Type.LONG_TYPE)
+                v.lconst(0);
+            else if(type == Type.FLOAT_TYPE)
+                v.fconst(0);
+            else if(type == Type.DOUBLE_TYPE)
+                v.dconst(0);
+            else
+                v.iconst(0);
+        }
+        else if (type.getSort() == Type.OBJECT && this.type.equals(JetTypeMapper.TYPE_OBJECT) || type.getSort() == Type.ARRAY) {
+                v.checkcast(type);
         }
         else if (type.getSort() == Type.OBJECT) {
             box(this.type, type, v);
@@ -166,10 +195,10 @@ public abstract class StackValue {
         else if (this.type.getSort() == Type.OBJECT && type.getSort() <= Type.DOUBLE) {
             if (this.type.equals(JetTypeMapper.TYPE_OBJECT)) {
                 if (type.getSort() == Type.BOOLEAN) {
-                    v.checkcast(Type.getObjectType("java/lang/Boolean"));
+                    v.checkcast(JetTypeMapper.JL_BOOLEAN_TYPE);
                 }
                 else {
-                    v.checkcast(Type.getObjectType("java/lang/Number"));
+                    v.checkcast(JetTypeMapper.JL_NUMBER_TYPE);
                 }
             }
             unbox(type, v);
@@ -190,6 +219,22 @@ public abstract class StackValue {
         v.mark(end);
     }
 
+    public static StackValue none() {
+        return None.INSTANCE;
+    }
+    
+    private static class None extends StackValue {
+        public static None INSTANCE = new None();
+        private None() {
+            super(Type.VOID_TYPE);
+        }
+
+        @Override
+        public void put(Type type, InstructionAdapter v) {
+            coerce(type, v);
+        }
+    }
+
     public static class Local extends StackValue {
         private final int index;
 
@@ -242,14 +287,26 @@ public abstract class StackValue {
 
         @Override
         public void put(Type type, InstructionAdapter v) {
-            v.aconst(value);
+            if(value instanceof Integer)
+                v.iconst((Integer) value);
+            else
+            if(value instanceof Long)
+                v.lconst((Long) value);
+            else
+            if(value instanceof Float)
+                v.fconst((Float) value);
+            else
+            if(value instanceof Double)
+                v.dconst((Double) value);
+            else
+                v.aconst(value);
             coerce(type, v);
         }
 
         @Override
         public void condJump(Label label, boolean jumpIfFalse, InstructionAdapter v) {
             if (value instanceof Boolean) {
-                boolean boolValue = ((Boolean) value).booleanValue();
+                boolean boolValue = (Boolean) value;
                 if (boolValue ^ jumpIfFalse) {
                     v.goTo(label);
                 }
@@ -367,18 +424,23 @@ public abstract class StackValue {
     }
 
     private static class ArrayElement extends StackValue {
-        public ArrayElement(Type type) {
+        private Type boxed;
+
+        public ArrayElement(Type type, boolean unbox) {
             super(type);
+            this.boxed = unbox ? JetTypeMapper.boxType(type) : type;
         }
 
         @Override
         public void put(Type type, InstructionAdapter v) {
-            v.aload(type);    // assumes array and index are on the stack
+            v.aload(boxed);    // assumes array and index are on the stack
+            onStack(boxed).coerce(type, v);
         }
 
         @Override
         public void store(InstructionAdapter v) {
-            v.astore(type);   // assumes array and index are on the stack
+            onStack(type).coerce(boxed, v);
+            v.astore(boxed);
         }
 
         @Override
@@ -408,6 +470,7 @@ public abstract class StackValue {
                 throw new UnsupportedOperationException("no getter specified");
             }
             getter.invoke(v);
+            coerce(type, v);
         }
 
         @Override
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/TraitImplBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/TraitImplBodyCodegen.java
new file mode 100644
index 00000000000..86a07215e04
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/TraitImplBodyCodegen.java
@@ -0,0 +1,64 @@
+package org.jetbrains.jet.codegen;
+
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.types.JetStandardClasses;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lexer.JetTokens;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TraitImplBodyCodegen extends ClassBodyCodegen {
+    public TraitImplBodyCodegen(JetClassOrObject aClass, ClassContext context, ClassVisitor v, GenerationState state) {
+        super(aClass, context, v, state);
+    }
+
+    //todo not needed when frontend will be able to calculate properly
+    static JetType getSuperClass(ClassDescriptor myClassDescr, BindingContext bindingContext) {
+        JetClassOrObject myClass = (JetClassOrObject) bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, myClassDescr);
+        List<JetDelegationSpecifier> delegationSpecifiers = myClass.getDelegationSpecifiers();
+
+        for (JetDelegationSpecifier specifier : delegationSpecifiers) {
+            if (specifier instanceof JetDelegatorToSuperClass || specifier instanceof JetDelegatorToSuperCall) {
+                JetType superType = bindingContext.get(BindingContext.TYPE, specifier.getTypeReference());
+                ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
+                final PsiElement declaration = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, superClassDescriptor);
+                if (declaration != null) {
+                    if (declaration instanceof PsiClass) {
+                        if (!((PsiClass) declaration).isInterface()) {
+                            return superClassDescriptor.getDefaultType();
+                        }
+                    }
+                    else if(declaration instanceof JetClass) {
+                        if(!((JetClass) declaration).isTrait()) {
+                            return superClassDescriptor.getDefaultType();
+                        }
+                    }
+                }
+            }
+        }
+        return JetStandardClasses.getAnyType();
+    }
+
+    @Override
+    protected void generateDeclaration() {
+        v.visit(Opcodes.V1_6,
+                Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL,
+                jvmName(),
+                null,
+                "java/lang/Object",
+                new String[0]
+        );
+        v.visitSource(myClass.getContainingFile().getName(), null);
+    }
+
+    private String jvmName() {
+        return state.getTypeMapper().jvmName(descriptor, OwnerKind.TRAIT_IMPL);
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.java
similarity index 83%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.java
index 24b58ea2fed..ee728bb2fb6 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.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.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.objectweb.asm.commons.InstructionAdapter;
 
@@ -15,9 +16,10 @@ import java.util.List;
  */
 public class ArraySize implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
-        codegen.ensureReceiverOnStack(element, null, JetTypeMapper.TYPE_OBJECT);
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
+        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         v.arraylength();
+
         return StackValue.onStack(Type.INT_TYPE);
     }
 }
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java
similarity index 79%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java
index 8cc3fa47fa1..a34e333845c 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java
@@ -2,7 +2,6 @@ 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;
@@ -21,16 +20,16 @@ public class BinaryOp implements IntrinsicMethod {
     }
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         if (arguments.size() == 1) {
             // intrinsic is called as an ordinary function
-            codegen.ensureReceiverOnStack(element, null, expectedType);
+            if (receiver != null) {
+                receiver.put(expectedType, v);
+            }
             codegen.gen(arguments.get(0), expectedType);
         }
         else {
-            if (!haveReceiver) {
-                codegen.gen(arguments.get(0), expectedType);
-            }
+            codegen.gen(arguments.get(0), expectedType);
             codegen.gen(arguments.get(1), expectedType);
         }
         v.visitInsn(expectedType.getOpcode(opcode));
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/Concat.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
similarity index 64%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
index 3690e2b2b12..6ed6cb5dd29 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
@@ -14,16 +14,18 @@ import java.util.List;
  */
 public class Concat implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         codegen.generateStringBuilderConstructor();
-        if (haveReceiver) {
-            v.swap();
-            codegen.invokeAppendMethod(codegen.expressionType(arguments.get(0)));
-        }
-        else {
+        if (receiver == null) {                                    // LHS.plus(RHS)
+            v.swap();                                                              // StringBuilder LHS
+            codegen.invokeAppendMethod(codegen.expressionType(arguments.get(0)));  // StringBuilder(LHS)
             codegen.invokeAppend(arguments.get(0));
         }
-        codegen.invokeAppend(arguments.get(1));
+        else {                                                     // LHS + RHS
+            codegen.invokeAppend(arguments.get(0));                                // StringBuilder(LHS)
+            codegen.invokeAppend(arguments.get(1));
+        }
+        
         v.invokevirtual(ExpressionCodegen.CLASS_STRING_BUILDER, "toString", "()Ljava/lang/String;");
         return StackValue.onStack(Type.getObjectType("java/lang/String"));
     }
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/Increment.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Increment.java
similarity index 85%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/Increment.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Increment.java
index e8679429e4e..dfb68c2fd42 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/Increment.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Increment.java
@@ -22,7 +22,7 @@ public class Increment implements IntrinsicMethod {
     }
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         final JetExpression operand = arguments.get(0);
         if (operand instanceof JetReferenceExpression) {
             final int index = codegen.indexOfLocal((JetReferenceExpression) operand);
@@ -31,17 +31,17 @@ public class Increment implements IntrinsicMethod {
                 return StackValue.local(index, expectedType);
             }
         }
-        StackValue value = codegen.generateIntermediateValue(operand);
+        StackValue value = codegen.genQualified(receiver, operand);
         value.dupReceiver(v, 0);
         value.put(expectedType, v);
         if (expectedType == Type.LONG_TYPE) {
-            v.aconst(Long.valueOf(myDelta));
+            v.lconst(myDelta);
         }
         else if (expectedType == Type.FLOAT_TYPE) {
-            v.aconst(Float.valueOf(myDelta));
+            v.fconst(myDelta);
         }
         else if (expectedType == Type.DOUBLE_TYPE) {
-            v.aconst(Double.valueOf(myDelta));
+            v.dconst(myDelta);
         }
         else {
             v.aconst(myDelta);
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java
similarity index 93%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java
index 2c3d1a6dc07..de9e5a4f847 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java
@@ -14,5 +14,5 @@ import java.util.List;
  * @author yole
  */
 public interface IntrinsicMethod extends Callable {
-    StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver);
+    StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver);
 }
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
similarity index 83%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
index 6e4fbff5a21..ce4c0e29b46 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
@@ -7,7 +7,7 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.search.ProjectScope;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
 import org.jetbrains.jet.lang.types.TypeProjection;
@@ -29,6 +29,7 @@ public class IntrinsicMethods {
     private static final IntrinsicMethod DEC = new Increment(-1);
 
     private static final List<String> PRIMITIVE_NUMBER_TYPES = ImmutableList.of("Boolean", "Byte", "Char", "Short", "Int", "Float", "Long", "Double");
+    public static final ArraySize ARRAY_SIZE = new ArraySize();
 
     private final Project myProject;
     private final JetStandardLibrary myStdLib;
@@ -41,7 +42,6 @@ public class IntrinsicMethods {
         for (String method : primitiveCastMethods) {
             declareIntrinsicProperty("Number", method, NUMBER_CAST);
         }
-        declareIntrinsicProperty("Array", "size", new ArraySize());
 
         for (String type : PRIMITIVE_NUMBER_TYPES) {
             declareIntrinsicFunction(type, "minus", 0, UNARY_MINUS);
@@ -51,7 +51,7 @@ public class IntrinsicMethods {
             declareIntrinsicFunction(type, "dec", 0, DEC);
         }
 
-        final FunctionGroup typeInfoFunctionGroup = stdlib.getTypeInfoFunctionGroup();
+        final Set<FunctionDescriptor> typeInfoFunctionGroup = stdlib.getTypeInfoFunctions();
         declareOverload(typeInfoFunctionGroup, 0, TYPEINFO);
         declareOverload(typeInfoFunctionGroup, 1, VALUE_TYPEINFO);
 
@@ -72,6 +72,21 @@ public class IntrinsicMethods {
         declareIntrinsicFunction("String", "plus", 1, new Concat());
 
         declareIntrinsicStringMethods();
+        declareIntrinsicProperty("String", "length", new StringLength());
+
+        declareArrayMethods();
+    }
+
+    private void declareArrayMethods() {
+        declareIntrinsicProperty("Array", "size", ARRAY_SIZE);
+        declareIntrinsicProperty("ByteArray", "size", ARRAY_SIZE);
+        declareIntrinsicProperty("ShortArray", "size", ARRAY_SIZE);
+        declareIntrinsicProperty("IntArray", "size", ARRAY_SIZE);
+        declareIntrinsicProperty("LongArray", "size", ARRAY_SIZE);
+        declareIntrinsicProperty("FloatArray", "size", ARRAY_SIZE);
+        declareIntrinsicProperty("DoubleArray", "size", ARRAY_SIZE);
+        declareIntrinsicProperty("CharArray", "size", ARRAY_SIZE);
+        declareIntrinsicProperty("BooleanArray", "size", ARRAY_SIZE);
     }
 
     private void declareIntrinsicStringMethods() {
@@ -107,12 +122,12 @@ public class IntrinsicMethods {
 
     private void declareIntrinsicFunction(String className, String functionName, int arity, IntrinsicMethod implementation) {
         JetScope memberScope = getClassMemberScope(className);
-        final FunctionGroup group = memberScope.getFunctionGroup(functionName);
+        final Set<FunctionDescriptor> group = memberScope.getFunctions(functionName);
         declareOverload(group, arity, implementation);
     }
 
-    private void declareOverload(FunctionGroup group, int arity, IntrinsicMethod implementation) {
-        for (FunctionDescriptor descriptor : group.getFunctionDescriptors()) {
+    private void declareOverload(Set<FunctionDescriptor> group, int arity, IntrinsicMethod implementation) {
+        for (FunctionDescriptor descriptor : group) {
             if (descriptor.getValueParameters().size() == arity) {
                 myMethods.put(descriptor.getOriginal(), implementation);
             }
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/Inv.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Inv.java
similarity index 84%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/Inv.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Inv.java
index 119d53330fe..fd6a663f964 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/Inv.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Inv.java
@@ -14,9 +14,9 @@ import java.util.List;
  */
 public class Inv implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
-        codegen.putTopOfStack(expectedType);
-        v.aconst(-1);
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
+        receiver.put(expectedType, v);
+        v.iconst(-1);
         v.xor(expectedType);
         return StackValue.onStack(expectedType);
     }
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/Not.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Not.java
similarity index 77%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/Not.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Not.java
index 43a66296b6d..03de6fa61df 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/Not.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Not.java
@@ -14,13 +14,13 @@ import java.util.List;
  */
 public class Not implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         final StackValue stackValue;
         if (arguments.size() == 1) {
-            stackValue = codegen.generateIntermediateValue(arguments.get(0));
+            stackValue = codegen.gen(arguments.get(0));
         }
         else {
-            stackValue = codegen.getReceiverAsStackValue(element, null, expectedType);
+            stackValue = receiver;
         }
         return StackValue.not(stackValue);
     }
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java
similarity index 87%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java
index 39157140861..4690ab1137b 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java
@@ -14,8 +14,8 @@ import java.util.List;
  */
 public class NumberCast implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
-        codegen.putTopOfStack(expectedType);
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
+        receiver.put(expectedType, v);
         return StackValue.onStack(expectedType);
     }
 }
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java
similarity index 86%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java
index e6305f828c5..1025f23c5a6 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java
@@ -24,9 +24,9 @@ public class PsiMethodCall implements IntrinsicMethod {
 
     @Override
     public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element,
-                               List<JetExpression> arguments, boolean haveReceiver) {
-        final CallableMethod callableMethod = codegen.getTypeMapper().mapToCallableMethod(myMethod);
-        codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, haveReceiver);
+                               List<JetExpression> arguments, StackValue receiver) {
+        final CallableMethod callableMethod = codegen.getTypeMapper().mapToCallableMethod(myMethod, null);
+        codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, receiver);
         return StackValue.onStack(callableMethod.getSignature().getReturnType());
     }
 }
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/RangeTo.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/RangeTo.java
similarity index 97%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/RangeTo.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/RangeTo.java
index bc95012cea9..79953a13b0f 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/RangeTo.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/RangeTo.java
@@ -21,7 +21,7 @@ public class RangeTo implements IntrinsicMethod {
     private static final String CLASS_INT_RANGE = "jet/IntRange";
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         JetBinaryExpression expression = (JetBinaryExpression) element;
         final Type leftType = codegen.expressionType(expression.getLeft());
         if (JetTypeMapper.isIntPrimitive(leftType)) {
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringLength.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringLength.java
new file mode 100644
index 00000000000..04a254df114
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringLength.java
@@ -0,0 +1,23 @@
+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 StringLength 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.invokevirtual("java/lang/String", "length", "()I");
+        return StackValue.onStack(Type.INT_TYPE);
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/TypeInfo.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/TypeInfo.java
similarity index 95%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/TypeInfo.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/TypeInfo.java
index 65fd6e0acce..f2003df90c6 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/TypeInfo.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/TypeInfo.java
@@ -17,7 +17,7 @@ import java.util.List;
  */
 public class TypeInfo implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         final List<JetTypeProjection> typeArguments = ((JetCallExpression) element).getTypeArguments();
         if (typeArguments.size() != 1) {
             throw new UnsupportedOperationException("one type argument expected");
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java
similarity index 86%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java
index a04cfb7cb4a..b84d3f79fdf 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java
@@ -14,12 +14,12 @@ import java.util.List;
  */
 public class UnaryMinus implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         if (arguments.size() == 1) {
             codegen.gen(arguments.get(0), expectedType);
         }
         else {
-            codegen.ensureReceiverOnStack(element, null, expectedType);
+            receiver.put(expectedType, v);
         }
         v.neg(expectedType);
         return StackValue.onStack(expectedType);
diff --git a/idea/src/org/jetbrains/jet/codegen/intrinsics/ValueTypeInfo.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ValueTypeInfo.java
similarity index 94%
rename from idea/src/org/jetbrains/jet/codegen/intrinsics/ValueTypeInfo.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ValueTypeInfo.java
index 04fdfbaf796..3c9c43d97f7 100644
--- a/idea/src/org/jetbrains/jet/codegen/intrinsics/ValueTypeInfo.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ValueTypeInfo.java
@@ -15,7 +15,7 @@ import java.util.List;
  */
 public class ValueTypeInfo implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         codegen.gen(arguments.get(0), JetTypeMapper.TYPE_JET_OBJECT);
         v.invokeinterface("jet/JetObject", "getTypeInfo", "()Ljet/typeinfo/TypeInfo;");
         return StackValue.onStack(JetTypeMapper.TYPE_TYPEINFO);
diff --git a/compiler/frontend.java/frontend.java.iml b/compiler/frontend.java/frontend.java.iml
new file mode 100644
index 00000000000..ec086b20ffc
--- /dev/null
+++ b/compiler/frontend.java/frontend.java.iml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="IDEA 10.x" jdkType="IDEA JDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module" module-name="frontend" />
+  </component>
+</module>
+
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java
similarity index 68%
rename from idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java
rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java
index eae0a7a704a..f1fed5d2201 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java
@@ -1,15 +1,19 @@
 package org.jetbrains.jet.lang.resolve.java;
 
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -19,16 +23,31 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
     private TypeConstructor typeConstructor;
     private JavaClassMembersScope unsubstitutedMemberScope;
     private JetType classObjectType;
-    private final WritableFunctionGroup constructors = new WritableFunctionGroup("<init>");
+    private final Set<FunctionDescriptor> constructors = Sets.newLinkedHashSet();
+    private Modality modality;
+    private Visibility visibility;
+    private JetType superclassType;
+    private final ClassKind kind;
+    private ClassReceiver implicitReceiver;
 
-    public JavaClassDescriptor(DeclarationDescriptor containingDeclaration) {
+
+    public JavaClassDescriptor(DeclarationDescriptor containingDeclaration, @NotNull ClassKind kind) {
         super(containingDeclaration);
+        this.kind = kind;
     }
 
     public void setTypeConstructor(TypeConstructor typeConstructor) {
         this.typeConstructor = typeConstructor;
     }
 
+    public void setModality(Modality modality) {
+        this.modality = modality;
+    }
+
+    public void setVisibility(Visibility visibility) {
+        this.visibility = visibility;
+    }
+
     public void setUnsubstitutedMemberScope(JavaClassMembersScope memberScope) {
         this.unsubstitutedMemberScope = memberScope;
     }
@@ -48,7 +67,7 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
     }
 
     public void addConstructor(ConstructorDescriptor constructorDescriptor) {
-        this.constructors.addFunction(constructorDescriptor);
+        this.constructors.add(constructorDescriptor);
     }
 
     private TypeSubstitutor createTypeSubstitutor(List<TypeProjection> typeArguments) {
@@ -70,10 +89,17 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
 
     @NotNull
     @Override
-    public FunctionGroup getConstructors() {
-//        assert typeArguments.size() == typeConstructor.getParameters().size();
-//        if (typeArguments.isEmpty()) return constructors;
-//        return new LazySubstitutingFunctionGroup(createTypeSubstitutor(typeArguments), constructors);
+    public JetType getSuperclassType() {
+        return superclassType;
+    }
+
+    public void setSuperclassType(@NotNull JetType superclassType) {
+        this.superclassType = superclassType;
+    }
+
+    @NotNull
+    @Override
+    public Set<FunctionDescriptor> getConstructors() {
         return constructors;
     }
 
@@ -111,13 +137,26 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
     }
 
     @Override
-    public boolean isObject() {
+    public boolean isClassObjectAValue() {
         return false;
     }
 
+    @NotNull
     @Override
-    public boolean isClassObjectAValue() {
-        return false;
+    public ClassKind getKind() {
+        return kind;
+    }
+
+    @Override
+    @NotNull
+    public Modality getModality() {
+        return modality;
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
     }
 
     @Override
@@ -129,4 +168,13 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
     public String toString() {
         return "java class " + typeConstructor;
     }
+
+    @NotNull
+    @Override
+    public ReceiverDescriptor getImplicitReceiver() {
+        if (implicitReceiver == null) {
+            implicitReceiver = new ClassReceiver(this);
+        }
+        return implicitReceiver;
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java
similarity index 76%
rename from idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java
rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java
index 4fb1ef331d1..c5485602ba5 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java
@@ -5,12 +5,14 @@ import com.google.common.collect.Sets;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.Collection;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -20,7 +22,7 @@ public class JavaClassMembersScope implements JetScope {
     private final JavaSemanticServices semanticServices;
     private final boolean staticMembers;
     private final DeclarationDescriptor containingDeclaration;
-    private final Map<String, FunctionGroup> functionGroups = Maps.newHashMap();
+    private final Map<String, Set<FunctionDescriptor>> functionGroups = Maps.newHashMap();
     private final Map<String, VariableDescriptor> variables = Maps.newHashMap();
     private final Map<String, ClassifierDescriptor> classifiers = Maps.newHashMap();
     private Collection<DeclarationDescriptor> allDescriptors;
@@ -64,17 +66,12 @@ public class JavaClassMembersScope implements JetScope {
         return classifierDescriptor;
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (allDescriptors == null) {
             allDescriptors = Sets.newHashSet();
-            TypeSubstitutor substitutorForGenericSupertypes;
-            if (containingDeclaration instanceof ClassDescriptor) {
-                substitutorForGenericSupertypes = semanticServices.getDescriptorResolver().createSubstitutorForGenericSupertypes((ClassDescriptor) containingDeclaration);
-            }
-            else {
-                substitutorForGenericSupertypes = TypeSubstitutor.EMPTY;
-            }
+            TypeSubstitutor substitutorForGenericSupertypes = getTypeSubstitutorForSupertypes();
 
             for (HierarchicalMethodSignature signature : psiClass.getVisibleSignatures()) {
                 PsiMethod method = signature.getMethod();
@@ -88,6 +85,9 @@ public class JavaClassMembersScope implements JetScope {
             }
 
             for (PsiField field : psiClass.getAllFields()) {
+                if (field.hasModifierProperty(PsiModifier.STATIC) != staticMembers) {
+                    continue;
+                }
                 VariableDescriptor variableDescriptor = semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor(containingDeclaration, field);
                 allDescriptors.add(variableDescriptor);
             }
@@ -95,6 +95,17 @@ public class JavaClassMembersScope implements JetScope {
         return allDescriptors;
     }
 
+    private TypeSubstitutor getTypeSubstitutorForSupertypes() {
+        TypeSubstitutor substitutorForGenericSupertypes;
+        if (containingDeclaration instanceof ClassDescriptor) {
+            substitutorForGenericSupertypes = semanticServices.getDescriptorResolver().createSubstitutorForGenericSupertypes((ClassDescriptor) containingDeclaration);
+        }
+        else {
+            substitutorForGenericSupertypes = TypeSubstitutor.EMPTY;
+        }
+        return substitutorForGenericSupertypes;
+    }
+
     private ClassifierDescriptor doGetClassifierDescriptor(String name) {
         // TODO : suboptimal, walk the list only once
         for (PsiClass innerClass : psiClass.getAllInnerClasses()) {
@@ -123,13 +134,13 @@ public class JavaClassMembersScope implements JetScope {
             return null;
         }
 
-        return semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor((ClassDescriptor) containingDeclaration, field);
+        return semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor(containingDeclaration, field);
     }
 
     @NotNull
     @Override
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        FunctionGroup functionGroup = functionGroups.get(name);
+    public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        Set<FunctionDescriptor> functionGroup = functionGroups.get(name);
         if (functionGroup == null) {
             functionGroup = semanticServices.getDescriptorResolver().resolveFunctionGroup(
                     containingDeclaration,
@@ -149,7 +160,12 @@ public class JavaClassMembersScope implements JetScope {
 
     @NotNull
     @Override
-    public JetType getThisType() {
-        return null;
+    public ReceiverDescriptor getImplicitReceiver() {
+        throw new UnsupportedOperationException(); // Should never occur, we don't sit in a Java class...
+    }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+        throw new UnsupportedOperationException(); // Should never occur, we don't sit in a Java class...
     }
 }
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDefaultImports.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDefaultImports.java
new file mode 100644
index 00000000000..f6d6f2f001d
--- /dev/null
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDefaultImports.java
@@ -0,0 +1,23 @@
+package org.jetbrains.jet.lang.resolve.java;
+
+import com.intellij.openapi.project.Project;
+import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.ImportingStrategy;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+
+/**
+ * @author abreslav
+ */
+public class JavaDefaultImports {
+    public static final ImportingStrategy JAVA_DEFAULT_IMPORTS = new ImportingStrategy() {
+        @Override
+        public void addImports(Project project, JetSemanticServices semanticServices, BindingTrace trace, WritableScope rootScope) {
+//            scope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace("").getMemberScope());
+//            scope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace("java.lang").getMemberScope());
+            JavaSemanticServices javaSemanticServices = new JavaSemanticServices(project, semanticServices, trace);
+            rootScope.importScope(new JavaPackageScope("", null, javaSemanticServices));
+            rootScope.importScope(new JavaPackageScope("java.lang", null, javaSemanticServices));
+        }
+    };
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
similarity index 68%
rename from idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
index 3c3b4dea8d2..738ee857c9d 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
@@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
 import com.intellij.psi.search.GlobalSearchScope;
@@ -10,6 +11,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.*;
@@ -18,12 +20,14 @@ import java.util.*;
  * @author abreslav
  */
 public class JavaDescriptorResolver {
+    
+    public static String JAVA_ROOT = "<java_root>";
+
+    /*package*/ static final DeclarationDescriptor JAVA_METHOD_TYPE_PARAMETER_PARENT = new DeclarationDescriptorImpl(null, Collections.<AnnotationDescriptor>emptyList(), "<java_generic_method>") {
 
-    /*package*/ static final DeclarationDescriptor JAVA_ROOT = new DeclarationDescriptorImpl(null, Collections.<AnnotationDescriptor>emptyList(), "<java_root>") {
-        @NotNull
         @Override
         public DeclarationDescriptor substitute(TypeSubstitutor substitutor) {
-            throw new UnsupportedOperationException(); // TODO
+            throw new UnsupportedOperationException();
         }
 
         @Override
@@ -36,7 +40,7 @@ public class JavaDescriptorResolver {
         @NotNull
         @Override
         public DeclarationDescriptor substitute(TypeSubstitutor substitutor) {
-            throw new UnsupportedOperationException(); // TODO
+            throw new UnsupportedOperationException();
         }
 
         @Override
@@ -49,7 +53,7 @@ public class JavaDescriptorResolver {
     protected final Map<PsiTypeParameter, TypeParameterDescriptor> typeParameterDescriptorCache = Maps.newHashMap();
     protected final Map<PsiMethod, FunctionDescriptor> methodDescriptorCache = Maps.newHashMap();
     protected final Map<PsiField, VariableDescriptor> fieldDescriptorCache = Maps.newHashMap();
-    protected final Map<String, NamespaceDescriptor> namespaceDescriptorCache = new HashMap<String, NamespaceDescriptor>();
+    protected final Map<PsiPackage, NamespaceDescriptor> namespaceDescriptorCache = Maps.newHashMap();
     protected final JavaPsiFacade javaFacade;
     protected final GlobalSearchScope javaSearchScope;
     protected final JavaSemanticServices semanticServices;
@@ -90,7 +94,7 @@ public class JavaDescriptorResolver {
 
         String name = psiClass.getName();
         JavaClassDescriptor classDescriptor = new JavaClassDescriptor(
-                JAVA_ROOT
+                resolveParentDescriptor(psiClass), psiClass.isInterface() ? ClassKind.TRAIT : ClassKind.CLASS
         );
         classDescriptor.setName(name);
 
@@ -106,11 +110,27 @@ public class JavaDescriptorResolver {
                 supertypes
 
         ));
+        classDescriptor.setModality(Modality.convertFromFlags(
+                psiClass.hasModifierProperty(PsiModifier.ABSTRACT) || psiClass.isInterface(),
+                !psiClass.hasModifierProperty(PsiModifier.FINAL))
+        );
+        classDescriptor.setVisibility(resolveVisibilityFromPsiModifiers(semanticServices.getTrace(), psiClass));
         classDescriptorCache.put(psiClass.getQualifiedName(), classDescriptor);
         classDescriptor.setUnsubstitutedMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, false));
         classDescriptor.setClassObjectMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, true));
         // UGLY HACK
         supertypes.addAll(getSupertypes(psiClass));
+        if (psiClass.isInterface()) {
+            classDescriptor.setSuperclassType(JetStandardClasses.getAnyType()); // TODO : Make it java.lang.Object
+        }
+        else {
+            PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes();
+            assert extendsListTypes.length == 0 || extendsListTypes.length == 1;
+            JetType superclassType = extendsListTypes.length == 0
+                                            ? JetStandardClasses.getAnyType()
+                                            : semanticServices.getTypeTransformer().transformToType(extendsListTypes[0]);
+            classDescriptor.setSuperclassType(superclassType);
+        }
 
         PsiMethod[] psiConstructors = psiClass.getConstructors();
 
@@ -120,7 +140,7 @@ public class JavaDescriptorResolver {
                         classDescriptor,
                         Collections.<AnnotationDescriptor>emptyList(),
                         false);
-                constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList());
+                constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), Modality.FINAL, classDescriptor.getVisibility());
                 constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
                 classDescriptor.addConstructor(constructorDescriptor);
                 semanticServices.getTrace().record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
@@ -132,7 +152,8 @@ public class JavaDescriptorResolver {
                         classDescriptor,
                         Collections.<AnnotationDescriptor>emptyList(), // TODO
                         false);
-                constructorDescriptor.initialize(typeParameters, resolveParameterDescriptors(constructorDescriptor, constructor.getParameterList().getParameters()));
+                constructorDescriptor.initialize(typeParameters, resolveParameterDescriptors(constructorDescriptor, constructor.getParameterList().getParameters()), Modality.FINAL,
+                                                 resolveVisibilityFromPsiModifiers(semanticServices.getTrace(), constructor));
                 constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
                 classDescriptor.addConstructor(constructorDescriptor);
                 semanticServices.getTrace().record(BindingContext.CONSTRUCTOR, constructor, constructorDescriptor);
@@ -144,6 +165,17 @@ public class JavaDescriptorResolver {
         return classDescriptor;
     }
 
+    private DeclarationDescriptor resolveParentDescriptor(PsiClass psiClass) {
+        PsiClass containingClass = psiClass.getContainingClass();
+        if (containingClass != null) {
+            return resolveClass(psiClass);
+        }
+        
+        PsiJavaFile containingFile = (PsiJavaFile) psiClass.getContainingFile();
+        String packageName = containingFile.getPackageName();
+        return resolveNamespace(packageName);
+    }
+
     private List<TypeParameterDescriptor> resolveTypeParameters(@NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameter[] typeParameters) {
         List<TypeParameterDescriptor> result = Lists.newArrayList();
         for (PsiTypeParameter typeParameter : typeParameters) {
@@ -204,7 +236,15 @@ public class JavaDescriptorResolver {
     }
 
     public NamespaceDescriptor resolveNamespace(String qualifiedName) {
-        NamespaceDescriptor namespaceDescriptor = namespaceDescriptorCache.get(qualifiedName);
+        PsiPackage psiPackage = javaFacade.findPackage(qualifiedName);
+        if (psiPackage == null) {
+            return null;
+        }
+        return resolveNamespace(psiPackage);
+    }
+
+    private NamespaceDescriptor resolveNamespace(@NotNull PsiPackage psiPackage) {
+        NamespaceDescriptor namespaceDescriptor = namespaceDescriptorCache.get(psiPackage);
         if (namespaceDescriptor == null) {
             // TODO : packages
 
@@ -213,31 +253,37 @@ public class JavaDescriptorResolver {
 //                namespaceDescriptor = createJavaNamespaceDescriptor(psiClass);
 //            }
 //            else {
-                PsiPackage psiPackage = javaFacade.findPackage(qualifiedName);
-                if (psiPackage == null) {
-                    return null;
-                }
                 namespaceDescriptor = createJavaNamespaceDescriptor(psiPackage);
 //            }
-            namespaceDescriptorCache.put(qualifiedName, namespaceDescriptor);
+            namespaceDescriptorCache.put(psiPackage, namespaceDescriptor);
         }
         return namespaceDescriptor;
     }
 
-    private NamespaceDescriptor createJavaNamespaceDescriptor(PsiPackage psiPackage) {
+    private NamespaceDescriptor createJavaNamespaceDescriptor(@NotNull PsiPackage psiPackage) {
+        String name = psiPackage.getName();
         JavaNamespaceDescriptor namespaceDescriptor = new JavaNamespaceDescriptor(
-                JAVA_ROOT,
+                resolveParentDescriptor(psiPackage),
                 Collections.<AnnotationDescriptor>emptyList(), // TODO
-                psiPackage.getName()
+                name == null ? JAVA_ROOT : name
         );
+
         namespaceDescriptor.setMemberScope(new JavaPackageScope(psiPackage.getQualifiedName(), namespaceDescriptor, semanticServices));
         semanticServices.getTrace().record(BindingContext.NAMESPACE, psiPackage, namespaceDescriptor);
         return namespaceDescriptor;
     }
 
+    private DeclarationDescriptor resolveParentDescriptor(@NotNull PsiPackage psiPackage) {
+        PsiPackage parentPackage = psiPackage.getParentPackage();
+        if (parentPackage == null) {
+            return null;
+        }
+        return resolveNamespace(parentPackage);
+    }
+
     private NamespaceDescriptor createJavaNamespaceDescriptor(@NotNull final PsiClass psiClass) {
         JavaNamespaceDescriptor namespaceDescriptor = new JavaNamespaceDescriptor(
-                JAVA_ROOT,
+                resolveParentDescriptor(psiClass),
                 Collections.<AnnotationDescriptor>emptyList(), // TODO
                 psiClass.getName()
         );
@@ -275,7 +321,8 @@ public class JavaDescriptorResolver {
         PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
                 containingDeclaration,
                 Collections.<AnnotationDescriptor>emptyList(),
-                new MemberModifiers(false, false, false),
+                Modality.FINAL,
+                resolveVisibilityFromPsiModifiers(semanticServices.getTrace(), field),
                 !isFinal,
                 null,
                 field.getName(),
@@ -287,27 +334,38 @@ public class JavaDescriptorResolver {
     }
 
     @NotNull
-    public FunctionGroup resolveFunctionGroup(@NotNull DeclarationDescriptor owner, @NotNull PsiClass psiClass, @Nullable ClassDescriptor classDescriptor, @NotNull String methodName, boolean staticMembers) {
-        WritableFunctionGroup writableFunctionGroup = new WritableFunctionGroup(methodName);
+    public Set<FunctionDescriptor> resolveFunctionGroup(@NotNull DeclarationDescriptor owner, @NotNull PsiClass psiClass, @Nullable ClassDescriptor classDescriptor, @NotNull String methodName, boolean staticMembers) {
+        Set<FunctionDescriptor> writableFunctionGroup = Sets.newLinkedHashSet();
         final Collection<HierarchicalMethodSignature> signatures = psiClass.getVisibleSignatures();
         TypeSubstitutor typeSubstitutor = createSubstitutorForGenericSupertypes(classDescriptor);
         for (HierarchicalMethodSignature signature: signatures) {
-            PsiMethod method = signature.getMethod();
-            if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) {
-                continue;
-            }
-            if (!methodName.equals(method.getName())) {
+            if (!methodName.equals(signature.getName())) {
                  continue;
             }
 
-            FunctionDescriptor substitutedFunctionDescriptor = resolveMethodToFunctionDescriptor(owner, psiClass, typeSubstitutor, method);
+            FunctionDescriptor substitutedFunctionDescriptor = resolveHierarchicalSignatureToFunction(owner, psiClass, staticMembers, typeSubstitutor, signature);
             if (substitutedFunctionDescriptor != null) {
-                writableFunctionGroup.addFunction(substitutedFunctionDescriptor);
+                writableFunctionGroup.add(substitutedFunctionDescriptor);
             }
         }
         return writableFunctionGroup;
     }
 
+    @Nullable
+    private FunctionDescriptor resolveHierarchicalSignatureToFunction(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers, TypeSubstitutor typeSubstitutor, HierarchicalMethodSignature signature) {
+        PsiMethod method = signature.getMethod();
+        if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) {
+                return null;
+        }
+        FunctionDescriptor functionDescriptor = resolveMethodToFunctionDescriptor(owner, psiClass, typeSubstitutor, method);
+//        if (functionDescriptor != null && !staticMembers) {
+//            for (HierarchicalMethodSignature superSignature : signature.getSuperSignatures()) {
+//                ((FunctionDescriptorImpl) functionDescriptor).addOverriddenFunction(resolveHierarchicalSignatureToFunction(owner, superSignature.getMethod().getContainingClass(), false, typeSubstitutor, superSignature));
+//            }
+//        }
+        return functionDescriptor;
+    }
+
     public TypeSubstitutor createSubstitutorForGenericSupertypes(ClassDescriptor classDescriptor) {
         TypeSubstitutor typeSubstitutor;
         if (classDescriptor != null) {
@@ -343,7 +401,9 @@ public class JavaDescriptorResolver {
                 null,
                 resolveTypeParameters(functionDescriptorImpl, method.getTypeParameters()),
                 semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptorImpl, parameters),
-                semanticServices.getTypeTransformer().transformToType(returnType)
+                semanticServices.getTypeTransformer().transformToType(returnType),
+                Modality.convertFromFlags(method.hasModifierProperty(PsiModifier.ABSTRACT), !method.hasModifierProperty(PsiModifier.FINAL)),
+                resolveVisibilityFromPsiModifiers(semanticServices.getTrace(), method)
         );
         semanticServices.getTrace().record(BindingContext.FUNCTION, method, functionDescriptorImpl);
         FunctionDescriptor substitutedFunctionDescriptor = functionDescriptorImpl;
@@ -352,4 +412,37 @@ public class JavaDescriptorResolver {
         }
         return substitutedFunctionDescriptor;
     }
+
+    private static Visibility resolveVisibilityFromPsiModifiers(BindingTrace trace, PsiModifierListOwner modifierListOwner) {
+        //TODO report error
+        return modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC) ? Visibility.PUBLIC :
+                                        (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE) ? Visibility.PRIVATE :
+                                        (modifierListOwner.hasModifierProperty(PsiModifier.PROTECTED) ? Visibility.PROTECTED : Visibility.INTERNAL));
+    }
+
+    public TypeParameterDescriptor resolveTypeParameter(PsiTypeParameter typeParameter) {
+        PsiTypeParameterListOwner owner = typeParameter.getOwner();
+        if (owner instanceof PsiClass) {
+            PsiClass psiClass = (PsiClass) owner;
+            return resolveTypeParameter(resolveClass(psiClass), typeParameter);
+        }
+        if (owner instanceof PsiMethod) {
+            PsiMethod psiMethod = (PsiMethod) owner;
+            PsiClass containingClass = psiMethod.getContainingClass();
+            DeclarationDescriptor ownerOwner;
+            TypeSubstitutor substitutorForGenericSupertypes;
+            if (psiMethod.hasModifierProperty(PsiModifier.STATIC)) {
+                substitutorForGenericSupertypes = TypeSubstitutor.EMPTY;
+                return resolveTypeParameter(JAVA_METHOD_TYPE_PARAMETER_PARENT, typeParameter);
+            }
+            else {
+                ClassDescriptor classDescriptor = resolveClass(containingClass);
+                ownerOwner = classDescriptor;
+                substitutorForGenericSupertypes = semanticServices.getDescriptorResolver().createSubstitutorForGenericSupertypes(classDescriptor);
+            }
+            FunctionDescriptor functionDescriptor = resolveMethodToFunctionDescriptor(ownerOwner, containingClass, substitutorForGenericSupertypes, psiMethod);
+            return resolveTypeParameter(functionDescriptor, typeParameter);
+        }
+        throw new IllegalStateException("Unknown parent type: " + owner);
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java
similarity index 94%
rename from idea/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java
rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java
index 7868f2a9127..3443ebf0f79 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java
@@ -4,7 +4,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.AbstractNamespaceDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.List;
 
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java
similarity index 76%
rename from idea/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java
rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java
index d1743442346..2b69b86e161 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java
@@ -2,7 +2,10 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.JetScopeImpl;
+import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
+
+import java.util.Collections;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -31,13 +34,8 @@ public class JavaPackageScope extends JetScopeImpl {
 
     @NotNull
     @Override
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        ClassifierDescriptor classifier = getClassifier(name);
-        if (classifier instanceof ClassDescriptor) {
-            ClassDescriptor classDescriptor = (ClassDescriptor) classifier;
-            return classDescriptor.getConstructors();
-        }
-        return FunctionGroup.EMPTY;
+    public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        return Collections.emptySet();
     }
 
     @NotNull
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java
rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java
similarity index 88%
rename from idea/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java
rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java
index a895094dbca..3f19264e915 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java
@@ -70,7 +70,7 @@ public class JavaTypeTransformer {
 
                 if (psiClass instanceof PsiTypeParameter) {
                     PsiTypeParameter typeParameter = (PsiTypeParameter) psiClass;
-                    TypeParameterDescriptor typeParameterDescriptor = resolver.resolveTypeParameter(JavaDescriptorResolver.JAVA_ROOT, typeParameter);
+                    TypeParameterDescriptor typeParameterDescriptor = resolver.resolveTypeParameter(typeParameter);
                     return typeParameterDescriptor.getDefaultType();
                 }
                 else {
@@ -114,7 +114,14 @@ public class JavaTypeTransformer {
 
             @Override
             public JetType visitArrayType(PsiArrayType arrayType) {
-                JetType type = transformToType(arrayType.getComponentType());
+                PsiType componentType = arrayType.getComponentType();
+                if(componentType instanceof PsiPrimitiveType) {
+                    JetType jetType = getPrimitiveTypesMap().get("[" + componentType.getCanonicalText());
+                    if(jetType != null)
+                        return TypeUtils.makeNullable(jetType);
+                }
+
+                JetType type = transformToType(componentType);
                 return TypeUtils.makeNullable(standardLibrary.getArrayType(type));
             }
 
@@ -136,6 +143,14 @@ public class JavaTypeTransformer {
             primitiveTypesMap.put("float", standardLibrary.getFloatType());
             primitiveTypesMap.put("double", standardLibrary.getDoubleType());
             primitiveTypesMap.put("boolean", standardLibrary.getBooleanType());
+            primitiveTypesMap.put("[byte", standardLibrary.getByteArrayType());
+            primitiveTypesMap.put("[short", standardLibrary.getShortArrayType());
+            primitiveTypesMap.put("[char", standardLibrary.getCharArrayType());
+            primitiveTypesMap.put("[int", standardLibrary.getIntArrayType());
+            primitiveTypesMap.put("[long", standardLibrary.getLongArrayType());
+            primitiveTypesMap.put("[float", standardLibrary.getFloatArrayType());
+            primitiveTypesMap.put("[double", standardLibrary.getDoubleArrayType());
+            primitiveTypesMap.put("[boolean", standardLibrary.getBooleanArrayType());
             primitiveTypesMap.put("void", JetStandardClasses.getUnitType());
             primitiveTypesMap.put("java.lang.Byte", TypeUtils.makeNullable(standardLibrary.getByteType()));
             primitiveTypesMap.put("java.lang.Short", TypeUtils.makeNullable(standardLibrary.getShortType()));
diff --git a/idea/buildLexer.xml b/compiler/frontend/buildLexer.xml
similarity index 97%
rename from idea/buildLexer.xml
rename to compiler/frontend/buildLexer.xml
index 5f9bb7afa20..3d16ff1da25 100644
--- a/idea/buildLexer.xml
+++ b/compiler/frontend/buildLexer.xml
@@ -1,4 +1,4 @@
-<project name="Lexer" default="lexer">
+<project name="JetLexer" default="lexer">
     <property name="home" value="${basedir}"/>
     <property file="${home}/idea.properties"/>
 
diff --git a/compiler/frontend/frontend.iml b/compiler/frontend/frontend.iml
new file mode 100644
index 00000000000..538b9791539
--- /dev/null
+++ b/compiler/frontend/frontend.iml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="IDEA 10.x" jdkType="IDEA JDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
+
diff --git a/idea/src/jet/Library.jet b/compiler/frontend/src/jet/Library.jet
similarity index 89%
rename from idea/src/jet/Library.jet
rename to compiler/frontend/src/jet/Library.jet
index 211e49cf2db..f11575b99d3 100644
--- a/idea/src/jet/Library.jet
+++ b/compiler/frontend/src/jet/Library.jet
@@ -40,27 +40,83 @@ fun Any?.equals(other : Any?) : Boolean// = this === other
 // Returns "null" for null
 fun Any?.toString() : String// = this === other
 
-class Iterator<out T> {
+trait Iterator<out T> {
   fun next() : T
-  abstract val hasNext : Boolean
+  abstract fun hasNext() : Boolean
 }
 
-class Iterable<out T> {
+trait Iterable<out T> {
   fun iterator() : Iterator<T>
 }
 
-class Array<T>(val size : Int) {
+class Array<T>(val size : Int, init : fun(Int) : T = null ) {
   fun get(index : Int) : T
   fun set(index : Int, value : T) : Unit
 
   fun iterator() : Iterator<T>
 }
 
-virtual class Comparable<in T> {
+class ByteArray(val size : Int) {
+  fun get(index : Int) : Byte
+  fun set(index : Int, value : Byte) : Unit
+
+  fun iterator() : Iterator<Byte>
+}
+
+class ShortArray(val size : Int) {
+  fun get(index : Int) : Short
+  fun set(index : Int, value : Short) : Unit
+
+  fun iterator() : Iterator<Short>
+}
+
+class IntArray(val size : Int) {
+  fun get(index : Int) : Int
+  fun set(index : Int, value : Int) : Unit
+
+  fun iterator() : Iterator<Int>
+}
+
+class LongArray(val size : Int) {
+  fun get(index : Int) : Long
+  fun set(index : Int, value : Long) : Unit
+
+  fun iterator() : Iterator<Long>
+}
+
+class FloatArray(val size : Int) {
+  fun get(index : Int) : Float
+  fun set(index : Int, value : Float) : Unit
+
+  fun iterator() : Iterator<Float>
+}
+
+class DoubleArray(val size : Int) {
+  fun get(index : Int) : Double
+  fun set(index : Int, value : Double) : Unit
+
+  fun iterator() : Iterator<Double>
+}
+
+class CharArray(val size : Int) {
+  fun get(index : Int) : Char
+  fun set(index : Int, value : Char) : Unit
+
+  fun iterator() : Iterator<Char>
+}
+
+class BooleanArray(val size : Int) {
+  fun get(index : Int) : Boolean
+  fun set(index : Int, value : Boolean) : Unit
+
+  fun iterator() : Iterator<Boolean>
+}
+
+trait Comparable<in T> {
   fun compareTo(other : T) : Int
 }
 
-virtual class Hashable {
+trait Hashable {
   fun hashCode() : Int
   fun equals(other : Any?) : Boolean
 }
@@ -92,11 +148,11 @@ class String() : Comparable<String> {
   fun trim(): String
 }
 
-class Range<in T : Comparable<T>> {
+trait Range<in T : Comparable<T>> {
   fun contains(item : T) : Boolean
 }
 
-class IntRange<T : Comparable<T>> : Range<T>, Iterable<T> {
+class IntRange<T : Comparable<T>>(val start : Int, val end : Int) : Range<T>, Iterable<T> {
 
 }
 
@@ -118,7 +174,7 @@ abstract class Number : Hashable {
 }
 
 class Double : Number, Comparable<Double>  {
-  fun compareTo(other : Double)  : Int
+  override fun compareTo(other : Double)  : Int
   fun compareTo(other : Float)  : Int
   fun compareTo(other : Long)   : Int
   fun compareTo(other : Int)    : Int
@@ -181,7 +237,7 @@ class Double : Number, Comparable<Double>  {
 
 class Float : Number, Comparable<Float>  {
   fun compareTo(other : Double) : Int
-  fun compareTo(other : Float) : Int
+  override fun compareTo(other : Float) : Int
   fun compareTo(other : Long)   : Int
   fun compareTo(other : Int)    : Int
   fun compareTo(other : Short)  : Int
@@ -245,7 +301,7 @@ class Float : Number, Comparable<Float>  {
 class Long : Number, Comparable<Long> {
   fun compareTo(other : Double) : Int
   fun compareTo(other : Float)  : Int
-  fun compareTo(other : Long)   : Int
+  override fun compareTo(other : Long)   : Int
   fun compareTo(other : Int)    : Int
   fun compareTo(other : Short)  : Int
   fun compareTo(other : Byte)   : Int
@@ -317,7 +373,7 @@ class Int : Number, Comparable<Int> {
   fun compareTo(other : Double) : Int
   fun compareTo(other : Float)  : Int
   fun compareTo(other : Long)   : Int
-  fun compareTo(other : Int)    : Int
+  override fun compareTo(other : Int)    : Int
   fun compareTo(other : Short)  : Int
   fun compareTo(other : Byte)   : Int
   fun compareTo(other : Char)   : Int
@@ -390,7 +446,7 @@ class Char : Number, Comparable<Char> {
   fun compareTo(other : Long)    : Int
   fun compareTo(other : Int)    : Int
   fun compareTo(other : Short)  : Int
-  fun compareTo(other : Char)  : Int
+  override fun compareTo(other : Char)  : Int
   fun compareTo(other : Byte)   : Int
 
   fun plus(other : Double) : Double
@@ -452,7 +508,7 @@ class Short : Number, Comparable<Short> {
   fun compareTo(other : Float)  : Int
   fun compareTo(other : Long)    : Int
   fun compareTo(other : Int)    : Int
-  fun compareTo(other : Short)    : Int
+  override fun compareTo(other : Short)    : Int
   fun compareTo(other : Byte)   : Int
   fun compareTo(other : Char)   : Int
 
@@ -517,7 +573,7 @@ class Byte : Number, Comparable<Byte> {
   fun compareTo(other : Int)    : Int
   fun compareTo(other : Short)  : Int
   fun compareTo(other : Char)   : Int
-  fun compareTo(other : Byte)   : Int
+  override fun compareTo(other : Byte)   : Int
 
   fun plus(other : Double) : Double
   fun plus(other : Float)  : Float
diff --git a/idea/src/org/jetbrains/jet/JetNodeType.java b/compiler/frontend/src/org/jetbrains/jet/JetNodeType.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/JetNodeType.java
rename to compiler/frontend/src/org/jetbrains/jet/JetNodeType.java
diff --git a/idea/src/org/jetbrains/jet/JetNodeTypes.java b/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java
similarity index 96%
rename from idea/src/org/jetbrains/jet/JetNodeTypes.java
rename to compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java
index a9add75e4e2..9656239e4a2 100644
--- a/idea/src/org/jetbrains/jet/JetNodeTypes.java
+++ b/compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java
@@ -29,7 +29,7 @@ public interface JetNodeTypes {
     JetNodeType DELEGATOR_BY                        = new JetNodeType("DELEGATOR_BY", JetDelegatorByExpressionSpecifier.class);
     JetNodeType DELEGATOR_SUPER_CALL                = new JetNodeType("DELEGATOR_SUPER_CALL", JetDelegatorToSuperCall.class);
     JetNodeType DELEGATOR_SUPER_CLASS               = new JetNodeType("DELEGATOR_SUPER_CLASS", JetDelegatorToSuperClass.class);
-    JetNodeType CONSTRUCTOR_CALLEE = new JetNodeType("CONSTRUCTOR_CALLEE", JetConstructorCalleeExpression.class);
+    JetNodeType CONSTRUCTOR_CALLEE                  = new JetNodeType("CONSTRUCTOR_CALLEE", JetConstructorCalleeExpression.class);
     JetNodeType VALUE_PARAMETER_LIST                = new JetNodeType("VALUE_PARAMETER_LIST", JetParameterList.class);
     JetNodeType VALUE_PARAMETER                     = new JetNodeType("VALUE_PARAMETER", JetParameter.class);
 
@@ -44,6 +44,7 @@ public interface JetNodeTypes {
     JetNodeType TYPE_ARGUMENT_LIST                  = new JetNodeType("TYPE_ARGUMENT_LIST", JetTypeArgumentList.class);
     JetNodeType VALUE_ARGUMENT_LIST                 = new JetNodeType("VALUE_ARGUMENT_LIST", JetValueArgumentList.class);
     JetNodeType VALUE_ARGUMENT                      = new JetNodeType("VALUE_ARGUMENT", JetValueArgument.class);
+    JetNodeType VALUE_ARGUMENT_NAME                 = new JetNodeType("VALUE_ARGUMENT_NAME", JetValueArgumentName.class);
     JetNodeType TYPE_REFERENCE                      = new JetNodeType("TYPE_REFERENCE", JetTypeReference.class);
     JetNodeType LABELED_TUPLE_ENTRY                 = new JetNodeType("LABELED_TUPLE_ENTRY");
     JetNodeType LABELED_TUPLE_TYPE_ENTRY            = new JetNodeType("LABELED_TUPLE_TYPE_ENTRY");
@@ -116,10 +117,10 @@ public interface JetNodeTypes {
     JetNodeType CALL_EXPRESSION           = new JetNodeType("CALL_EXPRESSION", JetCallExpression.class);
     JetNodeType ARRAY_ACCESS_EXPRESSION   = new JetNodeType("ARRAY_ACCESS_EXPRESSION", JetArrayAccessExpression.class);
     JetNodeType INDICES                   = new JetNodeType("INDICES", JetContainerNode.class);
-    JetNodeType DOT_QUALIFIED_EXPRESSION = new JetNodeType("DOT_QUALIFIED_EXPRESSION", JetDotQualifiedExpression.class);
+    JetNodeType DOT_QUALIFIED_EXPRESSION  = new JetNodeType("DOT_QUALIFIED_EXPRESSION", JetDotQualifiedExpression.class);
     JetNodeType HASH_QUALIFIED_EXPRESSION = new JetNodeType("HASH_QUALIFIED_EXPRESSION", JetHashQualifiedExpression.class);
     JetNodeType SAFE_ACCESS_EXPRESSION    = new JetNodeType("SAFE_ACCESS_EXPRESSION", JetSafeQualifiedExpression.class);
-    JetNodeType PREDICATE_EXPRESSION       = new JetNodeType("PREDICATE_EXPRESSION", JetPredicateExpression.class);
+    JetNodeType PREDICATE_EXPRESSION      = new JetNodeType("PREDICATE_EXPRESSION", JetPredicateExpression.class);
 
     JetNodeType OBJECT_LITERAL            = new JetNodeType("OBJECT_LITERAL", JetObjectLiteralExpression.class);
     JetNodeType ROOT_NAMESPACE            = new JetNodeType("ROOT_NAMESPACE", JetRootNamespaceExpression.class);
diff --git a/idea/src/org/jetbrains/jet/lang/JetSemanticServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java
similarity index 90%
rename from idea/src/org/jetbrains/jet/lang/JetSemanticServices.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java
index ee82fb84c52..6d94973a3d4 100644
--- a/idea/src/org/jetbrains/jet/lang/JetSemanticServices.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java
@@ -25,13 +25,11 @@ public class JetSemanticServices {
 
     private final JetStandardLibrary standardLibrary;
     private final JetTypeChecker typeChecker;
-    private final OverloadResolver overloadResolver;
     private final JetControlFlowDataTraceFactory flowDataTraceFactory;
 
     private JetSemanticServices(JetStandardLibrary standardLibrary, JetControlFlowDataTraceFactory flowDataTraceFactory) {
         this.standardLibrary = standardLibrary;
         this.typeChecker = new JetTypeChecker(standardLibrary);
-        this.overloadResolver = new OverloadResolver(typeChecker);
         this.flowDataTraceFactory = flowDataTraceFactory;
     }
 
@@ -55,9 +53,4 @@ public class JetSemanticServices {
         return typeChecker;
     }
 
-    @NotNull
-    public OverloadResolver getOverloadResolver() {
-        return overloadResolver;
-    }
-
-}
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/BlockInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/BlockInfo.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/BlockInfo.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/BlockInfo.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/BreakableBlockInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/BreakableBlockInfo.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/BreakableBlockInfo.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/BreakableBlockInfo.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/GenerationTrigger.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/GenerationTrigger.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/GenerationTrigger.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/GenerationTrigger.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
similarity index 84%
rename from idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
index 828d5394a46..5c6a6707b46 100644
--- a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
@@ -3,7 +3,6 @@ package org.jetbrains.jet.lang.cfg;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -12,6 +11,8 @@ import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.*;
 
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+
 /**
 * @author abreslav
 */
@@ -19,21 +20,19 @@ public class JetControlFlowProcessor {
 
     private final Map<String, Stack<JetElement>> labeledElements = new HashMap<String, Stack<JetElement>>();
 
-    private final JetSemanticServices semanticServices;
     private final JetControlFlowBuilder builder;
     private final BindingTrace trace;
 
-    public JetControlFlowProcessor(JetSemanticServices semanticServices, BindingTrace trace, JetControlFlowBuilder builder) {
-        this.semanticServices = semanticServices;
+    public JetControlFlowProcessor(BindingTrace trace, JetControlFlowBuilder builder) {
         this.builder = builder;
         this.trace = trace;
     }
 
     public void generate(@NotNull JetElement subroutineElement, @NotNull JetExpression body) {
-        generateSubroutineControlFlow(subroutineElement, Collections.singletonList(body), false);
+        generateSubroutineControlFlow(subroutineElement, Collections.singletonList(body));
     }
 
-    public void generateSubroutineControlFlow(@NotNull JetElement subroutineElement, @NotNull List<? extends JetElement> body, boolean preferBlocks) {
+    public void generateSubroutineControlFlow(@NotNull JetElement subroutineElement, @NotNull List<? extends JetElement> body) {
         if (subroutineElement instanceof JetNamedDeclaration) {
             JetNamedDeclaration namedDeclaration = (JetNamedDeclaration) subroutineElement;
             enterLabeledElement(JetPsiUtil.safeName(namedDeclaration.getName()), namedDeclaration);
@@ -41,7 +40,7 @@ public class JetControlFlowProcessor {
         boolean functionLiteral = subroutineElement instanceof JetFunctionLiteralExpression;
         builder.enterSubroutine(subroutineElement, functionLiteral);
         for (JetElement statement : body) {
-            statement.accept(new CFPVisitor(preferBlocks, false));
+            statement.accept(new CFPVisitor(false));
         }
         builder.exitSubroutine(subroutineElement, functionLiteral);
     }
@@ -77,12 +76,13 @@ public class JetControlFlowProcessor {
         Stack<JetElement> stack = labeledElements.get(labelName);
         if (stack == null || stack.isEmpty()) {
             if (reportUnresolved) {
-                trace.getErrorHandler().unresolvedReference(labelExpression);
+                trace.report(UNRESOLVED_REFERENCE.on(labelExpression));
             }
             return null;
         }
         else if (stack.size() > 1) {
-            trace.getErrorHandler().genericWarning(labelExpression.getNode(), "There is more than one label with such a name in this scope");
+//            trace.getErrorHandler().genericWarning(labelExpression.getNode(), "There is more than one label with such a name in this scope");
+            trace.report(LABEL_NAME_CLASH.on(labelExpression));
         }
 
         JetElement result = stack.peek();
@@ -91,22 +91,22 @@ public class JetControlFlowProcessor {
     }
 
     private class CFPVisitor extends JetVisitorVoid {
-        private final boolean preferBlock;
+//        private final boolean preferBlock;
         private final boolean inCondition;
 
-        private CFPVisitor(boolean preferBlock, boolean inCondition) {
-            this.preferBlock = preferBlock;
+        private CFPVisitor(boolean inCondition) {
+//            this.preferBlock = preferBlock;
             this.inCondition = inCondition;
         }
 
-        private void value(@Nullable JetElement element, boolean preferBlock, boolean inCondition) {
+        private void value(@Nullable JetElement element, boolean inCondition) {
             if (element == null) return;
             CFPVisitor visitor;
-            if (this.preferBlock == preferBlock && this.inCondition == inCondition) {
+            if (this.inCondition == inCondition) {
                 visitor = this;
             }
             else {
-                visitor = new CFPVisitor(preferBlock, inCondition);
+                visitor = new CFPVisitor(inCondition);
             }
             element.accept(visitor);
             exitElement(element);
@@ -116,7 +116,7 @@ public class JetControlFlowProcessor {
         public void visitParenthesizedExpression(JetParenthesizedExpression expression) {
             JetExpression innerExpression = expression.getExpression();
             if (innerExpression != null) {
-                value(innerExpression, false, inCondition);
+                value(innerExpression, inCondition);
             }
         }
 
@@ -154,7 +154,7 @@ public class JetControlFlowProcessor {
             JetExpression deparenthesized = JetPsiUtil.deparenthesize(labeledExpression);
             if (deparenthesized != null) {
                 enterLabeledElement(labelName, deparenthesized);
-                value(labeledExpression, false, inCondition);
+                value(labeledExpression, inCondition);
             }
         }
 
@@ -163,11 +163,11 @@ public class JetControlFlowProcessor {
             IElementType operationType = expression.getOperationReference().getReferencedNameElementType();
             JetExpression right = expression.getRight();
             if (operationType == JetTokens.ANDAND) {
-                value(expression.getLeft(), false, true);
+                value(expression.getLeft(), true);
                 Label resultLabel = builder.createUnboundLabel();
                 builder.jumpOnFalse(resultLabel);
                 if (right != null) {
-                    value(right, false, true);
+                    value(right, true);
                 }
                 builder.bindLabel(resultLabel);
                 if (!inCondition) {
@@ -175,11 +175,11 @@ public class JetControlFlowProcessor {
                 }
             }
             else if (operationType == JetTokens.OROR) {
-                value(expression.getLeft(), false, true);
+                value(expression.getLeft(), true);
                 Label resultLabel = builder.createUnboundLabel();
                 builder.jumpOnTrue(resultLabel);
                 if (right != null) {
-                    value(right, false, true);
+                    value(right, true);
                 }
                 builder.bindLabel(resultLabel);
                 if (!inCondition) {
@@ -189,7 +189,7 @@ public class JetControlFlowProcessor {
             else if (operationType == JetTokens.EQ) {
                 JetExpression left = JetPsiUtil.deparenthesize(expression.getLeft());
                 if (right != null) {
-                    value(right, false, false);
+                    value(right, false);
                 }
                 if (left instanceof JetSimpleNameExpression) {
                     builder.write(expression, left);
@@ -201,8 +201,8 @@ public class JetControlFlowProcessor {
                     assert !(left instanceof JetPredicateExpression) : left; // TODO
                     assert !(left instanceof JetHashQualifiedExpression) : left; // TODO
                     JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) left;
-                    value(qualifiedExpression.getReceiverExpression(), false, false);
-                    value(expression.getOperationReference(), false, false);
+                    value(qualifiedExpression.getReceiverExpression(), false);
+                    value(expression.getOperationReference(), false);
                     builder.write(expression, left);
                 } else {
                     builder.unsupported(expression); // TODO
@@ -211,13 +211,13 @@ public class JetControlFlowProcessor {
             else if (JetTypeInferrer.assignmentOperationNames.containsKey(operationType)) {
                 JetExpression left = JetPsiUtil.deparenthesize(expression.getLeft());
                 if (left != null) {
-                    value(left, false, false);
+                    value(left, false);
                 }
                 if (right != null) {
-                    value(right, false, false);
+                    value(right, false);
                 }
                 if (left instanceof JetSimpleNameExpression || left instanceof JetArrayAccessExpression) {
-                    value(expression.getOperationReference(), false, false);
+                    value(expression.getOperationReference(), false);
                     builder.write(expression, left);
                 }
                 else if (left != null) {
@@ -225,21 +225,21 @@ public class JetControlFlowProcessor {
                 }
             }
             else {
-                value(expression.getLeft(), false, false);
+                value(expression.getLeft(), false);
                 if (right != null) {
-                    value(right, false, false);
+                    value(right, false);
                 }
-                value(expression.getOperationReference(), false, false);
+                value(expression.getOperationReference(), false);
                 builder.read(expression);
             }
         }
 
         private void visitAssignToArrayAccess(JetBinaryExpression expression, JetArrayAccessExpression arrayAccessExpression) {
             for (JetExpression index : arrayAccessExpression.getIndexExpressions()) {
-                value(index, false, false);
+                value(index, false);
             }
-            value(arrayAccessExpression.getArrayExpression(), false, false);
-            value(expression.getOperationReference(), false, false);
+            value(arrayAccessExpression.getArrayExpression(), false);
+            value(expression.getOperationReference(), false);
             builder.write(expression, arrayAccessExpression); // TODO : ???
         }
 
@@ -254,8 +254,8 @@ public class JetControlFlowProcessor {
                 visitLabeledExpression(referencedName.substring(1), baseExpression);
             }
             else {
-                value(baseExpression, false, false);
-                value(operationSign, false, false);
+                value(baseExpression, false);
+                value(operationSign, false);
 
                 boolean incrementOrDecrement = isIncrementOrDecrement(operationType);
                 if (incrementOrDecrement) {
@@ -275,13 +275,13 @@ public class JetControlFlowProcessor {
         public void visitIfExpression(JetIfExpression expression) {
             JetExpression condition = expression.getCondition();
             if (condition != null) {
-                value(condition, false, true);
+                value(condition, true);
             }
             Label elseLabel = builder.createUnboundLabel();
             builder.jumpOnFalse(elseLabel);
             JetExpression thenBranch = expression.getThen();
             if (thenBranch != null) {
-                value(thenBranch, true, inCondition);
+                value(thenBranch, inCondition);
             }
             else {
                 builder.readUnit(expression);
@@ -291,7 +291,7 @@ public class JetControlFlowProcessor {
             builder.bindLabel(elseLabel);
             JetExpression elseBranch = expression.getElse();
             if (elseBranch != null) {
-                value(elseBranch, true, inCondition);
+                value(elseBranch, inCondition);
             }
             else {
                 builder.readUnit(expression);
@@ -311,7 +311,7 @@ public class JetControlFlowProcessor {
                         // This checks are needed for the case of having e.g. return inside finally: 'try {return} finally{return}'
                         if (working) return;
                         working = true;
-                        value(finallyBlock.getFinalExpression(), true, inCondition);
+                        value(finallyBlock.getFinalExpression(), inCondition);
                         working = false;
                     }
                 });
@@ -319,7 +319,7 @@ public class JetControlFlowProcessor {
 
             Label onException = builder.createUnboundLabel();
             builder.nondeterministicJump(onException);
-            value(expression.getTryBlock(), true, inCondition);
+            value(expression.getTryBlock(), inCondition);
 
             List<JetCatchClause> catchClauses = expression.getCatchClauses();
             if (!catchClauses.isEmpty()) {
@@ -331,7 +331,7 @@ public class JetControlFlowProcessor {
                     JetCatchClause catchClause = iterator.next();
                     JetExpression catchBody = catchClause.getCatchBody();
                     if (catchBody != null) {
-                        value(catchBody, true, false);
+                        value(catchBody, false);
                     }
                     if (iterator.hasNext()) {
                         builder.nondeterministicJump(afterCatches);
@@ -345,7 +345,7 @@ public class JetControlFlowProcessor {
 
             if (finallyBlock != null) {
                 builder.exitTryFinally();
-                value(finallyBlock.getFinalExpression(), true, inCondition);
+                value(finallyBlock.getFinalExpression(), inCondition);
             }
         }
 
@@ -356,14 +356,14 @@ public class JetControlFlowProcessor {
             builder.bindLabel(loopInfo.getConditionEntryPoint());
             JetExpression condition = expression.getCondition();
             if (condition != null) {
-                value(condition, false, true);
+                value(condition, true);
             }
             builder.jumpOnFalse(loopInfo.getExitPoint());
 
             builder.bindLabel(loopInfo.getBodyEntryPoint());
             JetExpression body = expression.getBody();
             if (body != null) {
-                value(body, true, false);
+                value(body, false);
             }
             builder.jump(loopInfo.getEntryPoint());
             builder.exitLoop(expression);
@@ -377,12 +377,12 @@ public class JetControlFlowProcessor {
             builder.bindLabel(loopInfo.getBodyEntryPoint());
             JetExpression body = expression.getBody();
             if (body != null) {
-                value(body, true, false);
+                value(body, false);
             }
             builder.bindLabel(loopInfo.getConditionEntryPoint());
             JetExpression condition = expression.getCondition();
             if (condition != null) {
-                value(condition, false, true);
+                value(condition, true);
             }
             builder.jumpOnTrue(loopInfo.getEntryPoint());
             builder.exitLoop(expression);
@@ -393,7 +393,7 @@ public class JetControlFlowProcessor {
         public void visitForExpression(JetForExpression expression) {
             JetExpression loopRange = expression.getLoopRange();
             if (loopRange != null) {
-                value(loopRange, false, false);
+                value(loopRange, false);
             }
             // TODO : primitive cases
             Label loopExitPoint = builder.createUnboundLabel();
@@ -407,7 +407,7 @@ public class JetControlFlowProcessor {
             builder.bindLabel(loopInfo.getBodyEntryPoint());
             JetExpression body = expression.getBody();
             if (body != null) {
-                value(body, true, false);
+                value(body, false);
             }
 
             builder.nondeterministicJump(loopInfo.getEntryPoint());
@@ -439,14 +439,16 @@ public class JetControlFlowProcessor {
                 assert targetLabel != null;
                 loop = resolveLabel(labelName, targetLabel, true);
                 if (!isLoop(loop)) {
-                    trace.getErrorHandler().genericError(expression.getNode(), "The label '" + targetLabel.getText() + "' does not denote a loop");
+//                    trace.getErrorHandler().genericError(expression.getNode(), "The label '" + targetLabel.getText() + "' does not denote a loop");
+                    trace.report(NOT_A_LOOP_LABEL.on(expression, targetLabel.getText()));
                     loop = null;
                 }
             }
             else {
                 loop = builder.getCurrentLoop();
                 if (loop == null) {
-                    trace.getErrorHandler().genericError(expression.getNode(), "'break' and 'continue' are only allowed inside a loop");
+//                    trace.getErrorHandler().genericError(expression.getNode(), "'break' and 'continue' are only allowed inside a loop");
+                    trace.report(BREAK_OR_CONTINUE_OUTSIDE_A_LOOP.on(expression));
                 }
             }
             return loop;
@@ -462,7 +464,7 @@ public class JetControlFlowProcessor {
         public void visitReturnExpression(JetReturnExpression expression) {
             JetExpression returnedExpression = expression.getReturnedExpression();
             if (returnedExpression != null) {
-                value(returnedExpression, false, false);
+                value(returnedExpression, false);
             }
             JetSimpleNameExpression labelElement = expression.getTargetLabel();
             JetElement subroutine;
@@ -487,8 +489,12 @@ public class JetControlFlowProcessor {
 
         @Override
         public void visitBlockExpression(JetBlockExpression expression) {
-            for (JetElement statement : expression.getStatements()) {
-                value(statement, true, false);
+            List<JetElement> statements = expression.getStatements();
+            for (JetElement statement : statements) {
+                value(statement, false);
+            }
+            if (statements.isEmpty()) {
+                builder.readUnit(expression);
             }
         }
 
@@ -506,52 +512,42 @@ public class JetControlFlowProcessor {
             JetBlockExpression bodyExpression = expression.getFunctionLiteral().getBodyExpression();
             if (bodyExpression != null) {
                 List<JetElement> statements = bodyExpression.getStatements();
-                if (preferBlock && !functionLiteral.hasParameterSpecification()) {
-                    for (JetElement statement : statements) {
-                        value(statement, true, false);
-                    }
-                    if (statements.isEmpty()) {
-                        builder.readUnit(expression);
-                    }
-                }
-                else {
-                    generateSubroutineControlFlow(expression, statements, true);
-                }
+                generateSubroutineControlFlow(expression, statements);
             }
         }
 
         @Override
         public void visitQualifiedExpression(JetQualifiedExpression expression) {
-            value(expression.getReceiverExpression(), false, false);
+            value(expression.getReceiverExpression(), false);
             JetExpression selectorExpression = expression.getSelectorExpression();
             if (selectorExpression != null) {
-                value(selectorExpression, false, false);
+                value(selectorExpression, false);
             }
             builder.read(expression);
         }
 
-        private void visitCall(JetCall call) {
-            for (JetValueArgument argument : call.getValueArguments()) {
+        private void visitCall(JetCallElement call) {
+            for (ValueArgument argument : call.getValueArguments()) {
                 JetExpression argumentExpression = argument.getArgumentExpression();
                 if (argumentExpression != null) {
-                    value(argumentExpression, false, false);
+                    value(argumentExpression, false);
                 }
             }
 
             for (JetExpression functionLiteral : call.getFunctionLiteralArguments()) {
-                value(functionLiteral, false, false);
+                value(functionLiteral, false);
             }
         }
 
         @Override
         public void visitCallExpression(JetCallExpression expression) {
             for (JetTypeProjection typeArgument : expression.getTypeArguments()) {
-                value(typeArgument, false, false);
+                value(typeArgument, false);
             }
 
             visitCall(expression);
 
-            value(expression.getCalleeExpression(), false, false);
+            value(expression.getCalleeExpression(), false);
             builder.read(expression);
         }
 
@@ -567,7 +563,7 @@ public class JetControlFlowProcessor {
         public void visitProperty(JetProperty property) {
             JetExpression initializer = property.getInitializer();
             if (initializer != null) {
-                value(initializer, false, false);
+                value(initializer, false);
                 builder.write(property, property);
             }
         }
@@ -575,7 +571,7 @@ public class JetControlFlowProcessor {
         @Override
         public void visitTupleExpression(JetTupleExpression expression) {
             for (JetExpression entry : expression.getEntries()) {
-                value(entry, false, false);
+                value(entry, false);
             }
             builder.read(expression);
         }
@@ -584,7 +580,7 @@ public class JetControlFlowProcessor {
         public void visitBinaryWithTypeRHSExpression(JetBinaryExpressionWithTypeRHS expression) {
             IElementType operationType = expression.getOperationSign().getReferencedNameElementType();
             if (operationType == JetTokens.COLON || operationType == JetTokens.AS_KEYWORD || operationType == JetTokens.AS_SAFE) {
-                value(expression.getLeft(), false, false);
+                value(expression.getLeft(), false);
                 builder.read(expression);
             }
             else {
@@ -596,7 +592,7 @@ public class JetControlFlowProcessor {
         public void visitThrowExpression(JetThrowExpression expression) {
             JetExpression thrownExpression = expression.getThrownExpression();
             if (thrownExpression != null) {
-                value(thrownExpression, false, false);
+                value(thrownExpression, false);
             }
             builder.jumpToError(expression);
         }
@@ -604,16 +600,16 @@ public class JetControlFlowProcessor {
         @Override
         public void visitArrayAccessExpression(JetArrayAccessExpression expression) {
             for (JetExpression index : expression.getIndexExpressions()) {
-                value(index, false, false);
+                value(index, false);
             }
-            value(expression.getArrayExpression(), false, false);
+            value(expression.getArrayExpression(), false);
             // TODO : read 'get' or 'set' function
             builder.read(expression);
         }
 
         @Override
         public void visitIsExpression(JetIsExpression expression) {
-            value(expression.getLeftHandSide(), false, inCondition);
+            value(expression.getLeftHandSide(), inCondition);
             // TODO : builder.read(expression.getPattern());
             builder.read(expression);
         }
@@ -624,7 +620,7 @@ public class JetControlFlowProcessor {
             // TODO : else must be the last
             JetExpression subjectExpression = expression.getSubjectExpression();
             if (subjectExpression != null) {
-                value(subjectExpression, false, inCondition);
+                value(subjectExpression, inCondition);
             }
 
             Label doneLabel = builder.createUnboundLabel();
@@ -635,7 +631,8 @@ public class JetControlFlowProcessor {
 
                 if (whenEntry.isElse()) {
                     if (iterator.hasNext()) {
-                        trace.getErrorHandler().genericError(whenEntry.getNode(), "'else' entry must be the last one in a when-expression");
+//                        trace.getErrorHandler().genericError(whenEntry.getNode(), "'else' entry must be the last one in a when-expression");
+                        trace.report(ELSE_MISPLACED_IN_WHEN.on(whenEntry));
                     }
                 }
 
@@ -649,13 +646,13 @@ public class JetControlFlowProcessor {
 
                         @Override
                         public void visitWhenConditionCall(JetWhenConditionCall condition) {
-                            value(condition.getCallSuffixExpression(), false, inCondition); // TODO : inCondition?
+                            value(condition.getCallSuffixExpression(), inCondition); // TODO : inCondition?
                         }
 
                         @Override
                         public void visitWhenConditionInRange(JetWhenConditionInRange condition) {
-                            value(condition.getRangeExpression(), false, inCondition); // TODO : inCondition?
-                            value(condition.getOperationReference(), false, inCondition); // TODO : inCondition?
+                            value(condition.getRangeExpression(), inCondition); // TODO : inCondition?
+                            value(condition.getOperationReference(), inCondition); // TODO : inCondition?
                             // TODO : read the call to contains()...
                         }
 
@@ -676,7 +673,7 @@ public class JetControlFlowProcessor {
 
                                     @Override
                                     public void visitExpressionPattern(JetExpressionPattern pattern) {
-                                        value(pattern.getExpression(), false, inCondition);
+                                        value(pattern.getExpression(), inCondition);
                                     }
 
                                     @Override
@@ -686,7 +683,7 @@ public class JetControlFlowProcessor {
 
                                     @Override
                                     public void visitDecomposerPattern(JetDecomposerPattern pattern) {
-                                        value(pattern.getDecomposerExpression(), false, inCondition);
+                                        value(pattern.getDecomposerExpression(), inCondition);
                                         pattern.getArgumentList().accept(this);
                                     }
 
@@ -719,7 +716,7 @@ public class JetControlFlowProcessor {
                 builder.nondeterministicJump(nextLabel);
 
                 builder.bindLabel(bodyLabel);
-                value(whenEntry.getExpression(), true, inCondition);
+                value(whenEntry.getExpression(), inCondition);
                 builder.jump(doneLabel);
                 builder.bindLabel(nextLabel);
                 nextLabel = builder.createUnboundLabel();
@@ -741,17 +738,17 @@ public class JetControlFlowProcessor {
 //                    }
 //                }
 //            }
-            value(expression.getObjectDeclaration(), false, inCondition);
+            value(expression.getObjectDeclaration(), inCondition);
             builder.read(expression);
         }
 
         @Override
         public void visitObjectDeclaration(JetObjectDeclaration declaration) {
             for (JetDelegationSpecifier delegationSpecifier : declaration.getDelegationSpecifiers()) {
-                value(delegationSpecifier, false, inCondition);
+                value(delegationSpecifier, inCondition);
             }
             for (JetDeclaration jetDeclaration : declaration.getDeclarations()) {
-                FOR_LOCAL_CLASSES.value(jetDeclaration, false, false);
+                FOR_LOCAL_CLASSES.value(jetDeclaration, false);
             }
         }
 
@@ -760,7 +757,7 @@ public class JetControlFlowProcessor {
             for (JetStringTemplateEntry entry : expression.getEntries()) {
                 if (entry instanceof JetStringTemplateEntryWithExpression) {
                     JetStringTemplateEntryWithExpression entryWithExpression = (JetStringTemplateEntryWithExpression) entry;
-                    value(entryWithExpression.getExpression(), true, false);
+                    value(entryWithExpression.getExpression(), false);
                 }
             }
             builder.read(expression);
@@ -777,7 +774,7 @@ public class JetControlFlowProcessor {
         }
     }
 
-    private final CFPVisitor FOR_LOCAL_CLASSES = new CFPVisitor(false, false) {
+    private final CFPVisitor FOR_LOCAL_CLASSES = new CFPVisitor(false) {
         @Override
         public void visitNamedFunction(JetNamedFunction function) {
             // Nothing
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/Label.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/Label.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/Label.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/Label.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/LoopInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/LoopInfo.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/LoopInfo.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/LoopInfo.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/AbstractJumpInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/AbstractJumpInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/AbstractJumpInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/AbstractJumpInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ConditionalJumpInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ConditionalJumpInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ConditionalJumpInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ConditionalJumpInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/FunctionLiteralValueInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/FunctionLiteralValueInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/FunctionLiteralValueInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/FunctionLiteralValueInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Instruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/Instruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Instruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/Instruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionImpl.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionImpl.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionVisitor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionVisitor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionVisitor.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionWithNext.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionWithNext.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionWithNext.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/InstructionWithNext.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowDataTraceFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowDataTraceFactory.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowDataTraceFactory.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowDataTraceFactory.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetElementInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetElementInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetElementInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetElementInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetElementInstructionImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetElementInstructionImpl.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetElementInstructionImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetElementInstructionImpl.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetPseudocodeTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetPseudocodeTrace.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/JetPseudocodeTrace.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetPseudocodeTrace.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/NondeterministicJumpInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/NondeterministicJumpInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/NondeterministicJumpInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/NondeterministicJumpInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Pseudocode.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/Pseudocode.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/Pseudocode.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/Pseudocode.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReadUnitValueInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ReadUnitValueInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReadUnitValueInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ReadUnitValueInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReadValueInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ReadValueInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReadValueInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ReadValueInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnNoValueInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnNoValueInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnNoValueInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnNoValueInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnValueInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnValueInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnValueInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/ReturnValueInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineEnterInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineEnterInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineEnterInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineEnterInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineExitInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineExitInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineExitInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/SubroutineExitInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/UnconditionalJumpInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/UnconditionalJumpInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/UnconditionalJumpInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/UnconditionalJumpInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/UnsupportedElementInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/UnsupportedElementInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/UnsupportedElementInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/UnsupportedElementInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/cfg/pseudocode/WriteValueInstruction.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/WriteValueInstruction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/cfg/pseudocode/WriteValueInstruction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/WriteValueInstruction.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/AbstractNamespaceDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/AbstractNamespaceDescriptorImpl.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/AbstractNamespaceDescriptorImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/AbstractNamespaceDescriptorImpl.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/Annotation.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Annotation.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/Annotation.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Annotation.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableDescriptor.java
similarity index 52%
rename from idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableDescriptor.java
index 48c2622d412..47eac9f2bee 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableDescriptor.java
@@ -1,7 +1,8 @@
 package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ImplicitReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
@@ -9,31 +10,28 @@ import java.util.List;
 import java.util.Set;
 
 /**
- * @author abreslav
- */
-public interface FunctionDescriptor extends DeclarationDescriptor {
-    @Override
+* @author abreslav
+*/
+public interface CallableDescriptor extends DeclarationDescriptor {
     @NotNull
-    DeclarationDescriptor getContainingDeclaration();
-
-    @Nullable
-    JetType getReceiverType();
+    ReceiverDescriptor getReceiver();
 
     @NotNull
     List<TypeParameterDescriptor> getTypeParameters();
 
-    @NotNull
-    List<ValueParameterDescriptor> getValueParameters();
-
     @NotNull
     JetType getReturnType();
 
     @NotNull
-    FunctionDescriptor getOriginal();
+    @Override
+    CallableDescriptor getOriginal();
 
     @Override
-    FunctionDescriptor substitute(TypeSubstitutor substitutor);
+    CallableDescriptor substitute(TypeSubstitutor substitutor);
 
     @NotNull
-    Set<? extends FunctionDescriptor> getOverriddenFunctions();
+    List<ValueParameterDescriptor> getValueParameters();
+
+    @NotNull
+    Set<? extends CallableDescriptor> getOverriddenDescriptors();
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableMemberDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableMemberDescriptor.java
new file mode 100644
index 00000000000..db805687a7b
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableMemberDescriptor.java
@@ -0,0 +1,17 @@
+package org.jetbrains.jet.lang.descriptors;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Set;
+
+/**
+ * @author abreslav
+ */
+public interface CallableMemberDescriptor extends CallableDescriptor, MemberDescriptor {
+    @NotNull
+    @Override
+    Set<? extends CallableMemberDescriptor> getOverriddenDescriptors();
+
+    @NotNull
+    CallableMemberDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract);
+}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java
similarity index 63%
rename from idea/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java
index 6058eec9ff8..1b7057a76d4 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java
@@ -2,12 +2,14 @@ package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeProjection;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -17,8 +19,14 @@ public interface ClassDescriptor extends ClassifierDescriptor {
     @NotNull
     JetScope getMemberScope(List<TypeProjection> typeArguments);
 
+    /**
+     * @return the superclass for a class descriptor, and the required class fro a trait descriptor
+     */
     @NotNull
-    FunctionGroup getConstructors();
+    JetType getSuperclassType();
+
+    @NotNull
+    Set<FunctionDescriptor> getConstructors();
 
     @Nullable
     ConstructorDescriptor getUnsubstitutedPrimaryConstructor();
@@ -42,5 +50,15 @@ public interface ClassDescriptor extends ClassifierDescriptor {
     @Nullable
     JetType getClassObjectType();
 
-    boolean isObject();
+    @NotNull
+    ClassKind getKind();
+
+    @NotNull
+    Modality getModality();
+    
+    @NotNull
+    Visibility getVisibility();
+
+    @NotNull
+    ReceiverDescriptor getImplicitReceiver();
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java
similarity index 56%
rename from idea/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java
index ad23db0bb23..962ec21cd3f 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java
@@ -3,13 +3,16 @@ package org.jetbrains.jet.lang.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -18,8 +21,10 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl
     private TypeConstructor typeConstructor;
 
     private JetScope memberDeclarations;
-    private FunctionGroup constructors;
+    private Set<FunctionDescriptor> constructors;
     private ConstructorDescriptor primaryConstructor;
+    private JetType superclassType;
+    private ReceiverDescriptor implicitReceiver;
 
     public ClassDescriptorImpl(
             @NotNull DeclarationDescriptor containingDeclaration,
@@ -28,20 +33,41 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl
         super(containingDeclaration, annotations, name);
     }
 
+    public final ClassDescriptorImpl initialize(boolean sealed,
+                                            @NotNull List<TypeParameterDescriptor> typeParameters,
+                                            @NotNull Collection<JetType> supertypes,
+                                            @NotNull JetScope memberDeclarations,
+                                            @NotNull Set<FunctionDescriptor> constructors,
+                                            @Nullable ConstructorDescriptor primaryConstructor) {
+        return initialize(sealed, typeParameters, supertypes, memberDeclarations, constructors, primaryConstructor, getClassType(supertypes));
+    }
+
     public final ClassDescriptorImpl initialize(boolean sealed,
                                                 @NotNull List<TypeParameterDescriptor> typeParameters,
-                                                @NotNull Collection<JetType> superclasses,
+                                                @NotNull Collection<JetType> supertypes,
                                                 @NotNull JetScope memberDeclarations,
-                                                @NotNull FunctionGroup constructors,
-                                                @Nullable ConstructorDescriptor primaryConstructor) {
-        this.typeConstructor = new TypeConstructorImpl(this, getAnnotations(), sealed, getName(), typeParameters, superclasses);
+                                                @NotNull Set<FunctionDescriptor> constructors,
+                                                @Nullable ConstructorDescriptor primaryConstructor,
+                                                @Nullable JetType superclassType) {
+        this.typeConstructor = new TypeConstructorImpl(this, getAnnotations(), sealed, getName(), typeParameters, supertypes);
         this.memberDeclarations = memberDeclarations;
         this.constructors = constructors;
         this.primaryConstructor = primaryConstructor;
-//        assert !constructors.isEmpty() || primaryConstructor == null;
+        this.superclassType = superclassType;
         return this;
     }
 
+    @NotNull
+    private JetType getClassType(@NotNull Collection<JetType> types) {
+        for (JetType type : types) {
+            ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(type);
+            if (classDescriptor != null) {
+                return type;
+            }
+        }
+        return JetStandardClasses.getAnyType();
+    }
+
     public void setPrimaryConstructor(@NotNull ConstructorDescriptor primaryConstructor) {
         this.primaryConstructor = primaryConstructor;
     }
@@ -63,6 +89,12 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl
         return new SubstitutingScope(memberDeclarations, TypeSubstitutor.create(substitutionContext));
     }
 
+    @NotNull
+    @Override
+    public JetType getSuperclassType() {
+        return superclassType;
+    }
+
     @NotNull
     @Override
     public JetType getDefaultType() {
@@ -71,13 +103,8 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl
 
     @NotNull
     @Override
-    public FunctionGroup getConstructors() {
-//        assert typeArguments.size() == getTypeConstructor().getParameters().size() : "Argument list length mismatch for " + getName();
-//        if (typeArguments.size() == 0) {
-//            return constructors;
-//        }
-//        Map<TypeConstructor, TypeProjection> substitutionContext = TypeUtils.buildSubstitutionContext(getTypeConstructor().getParameters(), typeArguments);
-        return constructors;// LazySubstitutingFunctionGroup(TypeSubstitutor.create(substitutionContext), constructors);
+    public Set<FunctionDescriptor> getConstructors() {
+        return constructors;
     }
 
     @NotNull
@@ -91,9 +118,10 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl
         return null;
     }
 
+    @NotNull
     @Override
-    public boolean isObject() {
-        return false;
+    public ClassKind getKind() {
+        return ClassKind.CLASS;
     }
 
     @Override
@@ -115,4 +143,25 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl
     public boolean hasConstructors() {
         return !constructors.isEmpty();
     }
+
+    @Override
+    @NotNull
+    public Modality getModality() {
+        return Modality.FINAL;
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return Visibility.PUBLIC;
+    }
+
+    @NotNull
+    @Override
+    public ReceiverDescriptor getImplicitReceiver() {
+        if (implicitReceiver == null) {
+            implicitReceiver = new ClassReceiver(this);
+        }
+        return implicitReceiver;
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassKind.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassKind.java
new file mode 100644
index 00000000000..344a7db0646
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassKind.java
@@ -0,0 +1,12 @@
+package org.jetbrains.jet.lang.descriptors;
+
+/**
+ * @author abreslav
+ */
+public enum ClassKind {
+    CLASS,
+    TRAIT,
+    ENUM_CLASS,
+    ANNOTATION_CLASS,
+    OBJECT
+}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ClassifierDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassifierDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/ClassifierDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassifierDescriptor.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java
similarity index 79%
rename from idea/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java
index f6642f22907..5afac7ed85c 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java
@@ -28,13 +28,13 @@ public class ConstructorDescriptorImpl extends FunctionDescriptorImpl implements
 
     @Override
     @Deprecated
-    public FunctionDescriptorImpl initialize(@Nullable JetType receiverType, @NotNull List<TypeParameterDescriptor> typeParameters, @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters, @Nullable JetType unsubstitutedReturnType) {
+    public FunctionDescriptorImpl initialize(@Nullable JetType receiverType, @NotNull List<TypeParameterDescriptor> typeParameters, @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters, @Nullable JetType unsubstitutedReturnType, Modality modality, @NotNull Visibility visibility) {
         assert receiverType == null;
-        return super.initialize(null, typeParameters, unsubstitutedValueParameters, unsubstitutedReturnType);
+        return super.initialize(null, typeParameters, unsubstitutedValueParameters, unsubstitutedReturnType, modality, visibility);
     }
 
-    public ConstructorDescriptorImpl initialize(@NotNull List<TypeParameterDescriptor> typeParameters, @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters) {
-        super.initialize(null, typeParameters, unsubstitutedValueParameters, null);
+    public ConstructorDescriptorImpl initialize(@NotNull List<TypeParameterDescriptor> typeParameters, @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters, Modality modality, Visibility visibility) {
+        super.initialize(null, typeParameters, unsubstitutedValueParameters, null, modality, visibility);
         return this;
     }
 
@@ -62,8 +62,8 @@ public class ConstructorDescriptorImpl extends FunctionDescriptorImpl implements
 
     @NotNull
     @Override
-    public Set<? extends FunctionDescriptor> getOverriddenFunctions() {
-        return null;
+    public Set<? extends FunctionDescriptor> getOverriddenDescriptors() {
+        return Collections.emptySet();
     }
 
     @Override
@@ -78,4 +78,10 @@ public class ConstructorDescriptorImpl extends FunctionDescriptorImpl implements
                 Collections.<AnnotationDescriptor>emptyList(), // TODO
                 isPrimary);
     }
+
+    @NotNull
+    @Override
+    public ConstructorDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract) {
+        throw new UnsupportedOperationException("Constructors should not be copied for overriding");
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptor.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java
similarity index 93%
rename from idea/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java
index 4574e5c9408..defab1eca28 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java
@@ -16,7 +16,7 @@ public abstract class DeclarationDescriptorImpl extends AnnotatedImpl implements
     private final String name;
     private final DeclarationDescriptor containingDeclaration;
 
-    public DeclarationDescriptorImpl(@Nullable DeclarationDescriptor containingDeclaration, List<AnnotationDescriptor> annotations, String name) {
+    public DeclarationDescriptorImpl(@Nullable DeclarationDescriptor containingDeclaration, @NotNull List<AnnotationDescriptor> annotations, @NotNull String name) {
         super(annotations);
         this.name = name;
         this.containingDeclaration = containingDeclaration;
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ExtensionDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ExtensionDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/ExtensionDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ExtensionDescriptor.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java
new file mode 100644
index 00000000000..e69f6d3cbe2
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java
@@ -0,0 +1,30 @@
+package org.jetbrains.jet.lang.descriptors;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
+
+import java.util.Set;
+
+/**
+ * @author abreslav
+ */
+public interface FunctionDescriptor extends CallableMemberDescriptor {
+    @Override
+    @NotNull
+    DeclarationDescriptor getContainingDeclaration();
+
+    @NotNull
+    @Override
+    FunctionDescriptor getOriginal();
+
+    @Override
+    FunctionDescriptor substitute(TypeSubstitutor substitutor);
+
+    @Override
+    @NotNull
+    Set<? extends FunctionDescriptor> getOverriddenDescriptors();
+
+    @NotNull
+    @Override
+    FunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract);
+}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java
similarity index 58%
rename from idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java
index 16992f967e8..a6c3f0b9872 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java
@@ -1,17 +1,23 @@
 package org.jetbrains.jet.lang.descriptors;
 
+import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.DescriptorSubstitutor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 import org.jetbrains.jet.lang.types.Variance;
 
-import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
+import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER;
+
 /**
  * @author abreslav
  */
@@ -20,9 +26,11 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
     private List<TypeParameterDescriptor> typeParameters;
     private List<ValueParameterDescriptor> unsubstitutedValueParameters;
     private JetType unsubstitutedReturnType;
-    private JetType receiverType;
+    private ReceiverDescriptor receiver;
 
-    private final Set<FunctionDescriptor> overriddenFunctions = Sets.newHashSet();
+    private Modality modality;
+    private Visibility visibility;
+    private final Set<FunctionDescriptor> overriddenFunctions = Sets.newLinkedHashSet();
     private final FunctionDescriptor original;
 
     public FunctionDescriptorImpl(
@@ -45,11 +53,15 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
             @Nullable JetType receiverType,
             @NotNull List<TypeParameterDescriptor> typeParameters,
             @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters,
-            @Nullable JetType unsubstitutedReturnType) {
-        this.receiverType = receiverType;
+            @Nullable JetType unsubstitutedReturnType,
+            @Nullable Modality modality,
+            @NotNull Visibility visibility) {
         this.typeParameters = typeParameters;
         this.unsubstitutedValueParameters = unsubstitutedValueParameters;
         this.unsubstitutedReturnType = unsubstitutedReturnType;
+        this.modality = modality;
+        this.visibility = visibility;
+        this.receiver = receiverType == null ? NO_RECEIVER : new ExtensionReceiver(this, receiverType);
         return this;
     }
 
@@ -57,17 +69,30 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
         this.unsubstitutedReturnType = unsubstitutedReturnType;
     }
 
+    @NotNull
     @Override
-    public JetType getReceiverType() {
-        return receiverType;
+    public ReceiverDescriptor getReceiver() {
+        return receiver;
     }
 
     @NotNull
     @Override
-    public Set<? extends FunctionDescriptor> getOverriddenFunctions() {
+    public Set<? extends FunctionDescriptor> getOverriddenDescriptors() {
         return overriddenFunctions;
     }
 
+    @NotNull
+    @Override
+    public Modality getModality() {
+        return modality;
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
     public void addOverriddenFunction(@NotNull FunctionDescriptor overriddenFunction) {
         overriddenFunctions.add(overriddenFunction);
     }
@@ -97,17 +122,18 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
     }
 
     @Override
-    public final FunctionDescriptor substitute(TypeSubstitutor substitutor) {
-        if (substitutor.isEmpty()) {
+    public final FunctionDescriptor substitute(TypeSubstitutor originalSubstitutor) {
+        if (originalSubstitutor.isEmpty()) {
             return this;
         }
-        FunctionDescriptorImpl substitutedDescriptor;
-        substitutedDescriptor = createSubstitutedCopy();
+        FunctionDescriptorImpl substitutedDescriptor = createSubstitutedCopy();
+
+        List<TypeParameterDescriptor> substitutedTypeParameters = Lists.newArrayList();
+        TypeSubstitutor substitutor = DescriptorSubstitutor.substituteTypeParameters(getTypeParameters(), originalSubstitutor, substitutedDescriptor, substitutedTypeParameters);
 
-        JetType receiverType = getReceiverType();
         JetType substitutedReceiverType = null;
-        if (receiverType != null) {
-            substitutedReceiverType = substitutor.substitute(receiverType, Variance.IN_VARIANCE);
+        if (receiver != NO_RECEIVER) {
+            substitutedReceiverType = substitutor.substitute(getReceiver().getType(), Variance.IN_VARIANCE);
             if (substitutedReceiverType == null) {
                 return null;
             }
@@ -125,10 +151,15 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
 
         substitutedDescriptor.initialize(
                 substitutedReceiverType,
-                Collections.<TypeParameterDescriptor>emptyList(), // TODO : questionable
+                substitutedTypeParameters,
                 substitutedValueParameters,
-                substitutedReturnType
+                substitutedReturnType,
+                modality,
+                visibility
         );
+        for (FunctionDescriptor overriddenFunction : overriddenFunctions) {
+            substitutedDescriptor.addOverriddenFunction(overriddenFunction);
+        }
         return substitutedDescriptor;
     }
 
@@ -145,4 +176,18 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
         return visitor.visitFunctionDescriptor(this, data);
     }
 
+    @NotNull
+    @Override
+    public FunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract) {
+        FunctionDescriptorImpl copy = new FunctionDescriptorImpl(newOwner, Lists.newArrayList(getAnnotations()), getName());
+        copy.initialize(
+                getReceiver().exists() ? getReceiver().getType() : null,
+                DescriptorUtils.copyTypeParameters(copy, typeParameters),
+                DescriptorUtils.copyValueParameters(copy, unsubstitutedValueParameters),
+                unsubstitutedReturnType,
+                DescriptorUtils.convertModality(modality, makeNonAbstract),
+                visibility
+        );
+        return copy;
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java
new file mode 100644
index 00000000000..07a14eece99
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java
@@ -0,0 +1,112 @@
+package org.jetbrains.jet.lang.descriptors;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.TraceBasedRedeclarationHandler;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.*;
+
+import java.util.*;
+
+/**
+ * @author abreslav
+ */
+public class FunctionDescriptorUtil {
+    /** @return Minimal number of arguments to be passed */
+    public static int getMinimumArity(@NotNull FunctionDescriptor functionDescriptor) {
+        int result = 0;
+        for (ValueParameterDescriptor valueParameter : functionDescriptor.getValueParameters()) {
+            if (valueParameter.hasDefaultValue()) {
+                break;
+            }
+            result++;
+        }
+        return result;
+    }
+
+    /**
+     * @return Maximum number of arguments that can be passed. -1 if unbound (vararg)
+     */
+    public static int getMaximumArity(@NotNull FunctionDescriptor functionDescriptor) {
+        List<ValueParameterDescriptor> unsubstitutedValueParameters = functionDescriptor.getValueParameters();
+        if (unsubstitutedValueParameters.isEmpty()) {
+            return 0;
+        }
+        // TODO : check somewhere that vararg is only the last one, and that varargs do not have default values
+
+        ValueParameterDescriptor lastParameter = unsubstitutedValueParameters.get(unsubstitutedValueParameters.size() - 1);
+        if (lastParameter.isVararg()) {
+            return -1;
+        }
+        return unsubstitutedValueParameters.size();
+    }
+
+    public static Map<TypeConstructor, TypeProjection> createSubstitutionContext(@NotNull FunctionDescriptor functionDescriptor, List<JetType> typeArguments) {
+        if (functionDescriptor.getTypeParameters().isEmpty()) return Collections.emptyMap();
+
+        Map<TypeConstructor, TypeProjection> result = new HashMap<TypeConstructor, TypeProjection>();
+
+        int typeArgumentsSize = typeArguments.size();
+        List<TypeParameterDescriptor> typeParameters = functionDescriptor.getTypeParameters();
+        assert typeArgumentsSize == typeParameters.size();
+        for (int i = 0; i < typeArgumentsSize; i++) {
+            TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i);
+            JetType typeArgument = typeArguments.get(i);
+            result.put(typeParameterDescriptor.getTypeConstructor(), new TypeProjection(typeArgument));
+        }
+        return result;
+    }
+
+    @Nullable
+    public static List<ValueParameterDescriptor> getSubstitutedValueParameters(FunctionDescriptor substitutedDescriptor, @NotNull FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) {
+        List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>();
+        List<ValueParameterDescriptor> unsubstitutedValueParameters = functionDescriptor.getValueParameters();
+        for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
+            ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i);
+            // TODO : Lazy?
+            JetType substitutedType = substitutor.substitute(unsubstitutedValueParameter.getOutType(), Variance.IN_VARIANCE);
+            if (substitutedType == null) return null;
+            result.add(new ValueParameterDescriptorImpl(
+                    substitutedDescriptor,
+                    unsubstitutedValueParameter,
+                    unsubstitutedValueParameter.getAnnotations(),
+                    unsubstitutedValueParameter.getInType() == null ? null : substitutedType,
+                    substitutedType
+            ));
+        }
+        return result;
+    }
+
+    @Nullable
+    public static JetType getSubstitutedReturnType(@NotNull FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) {
+        return substitutor.substitute(functionDescriptor.getReturnType(), Variance.OUT_VARIANCE);
+    }
+
+    @Nullable
+    public static FunctionDescriptor substituteFunctionDescriptor(@NotNull List<JetType> typeArguments, @NotNull FunctionDescriptor functionDescriptor) {
+        Map<TypeConstructor, TypeProjection> substitutionContext = createSubstitutionContext(functionDescriptor, typeArguments);
+        return functionDescriptor.substitute(TypeSubstitutor.create(substitutionContext));
+    }
+
+    @NotNull
+    public static JetScope getFunctionInnerScope(@NotNull JetScope outerScope, @NotNull FunctionDescriptor descriptor, @NotNull BindingTrace trace) {
+        WritableScope parameterScope = new WritableScopeImpl(outerScope, descriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Function inner scope");
+        ReceiverDescriptor receiver = descriptor.getReceiver();
+        if (receiver.exists()) {
+            parameterScope.setImplicitReceiver(receiver);
+        }
+        for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) {
+            parameterScope.addTypeParameterDescriptor(typeParameter);
+        }
+        for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getValueParameters()) {
+            parameterScope.addVariableDescriptor(valueParameterDescriptor);
+        }
+        parameterScope.addLabeledDeclaration(descriptor);
+        return parameterScope;
+    }
+
+}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java
similarity index 61%
rename from idea/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java
index d775e23119d..1ac7c0efcf6 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java
@@ -3,12 +3,14 @@ package org.jetbrains.jet.lang.descriptors;
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.Collection;
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -16,27 +18,41 @@ import java.util.List;
 public class LazySubstitutingClassDescriptor implements ClassDescriptor {
 
     private final ClassDescriptor original;
+    private final TypeSubstitutor originalSubstitutor;
+    private TypeSubstitutor newSubstitutor;
+    private List<TypeParameterDescriptor> typeParameters;
     private TypeConstructor typeConstructor;
-    private final TypeSubstitutor substitutor;
+    private JetType superclassType;
 
     public LazySubstitutingClassDescriptor(ClassDescriptor descriptor, TypeSubstitutor substitutor) {
         this.original = descriptor;
-        this.substitutor = substitutor;
+        this.originalSubstitutor = substitutor;
     }
 
+    private TypeSubstitutor getSubstitutor() {
+        if (newSubstitutor == null) {
+            if (originalSubstitutor.isEmpty()) {
+                newSubstitutor = originalSubstitutor;
+            }
+            else {
+                typeParameters = Lists.newArrayList();
+                newSubstitutor = DescriptorSubstitutor.substituteTypeParameters(original.getTypeConstructor().getParameters(), originalSubstitutor, this, typeParameters);
+            }
+        }
+        return newSubstitutor;
+    }
+    
     @NotNull
     @Override
     public TypeConstructor getTypeConstructor() {
         TypeConstructor originalTypeConstructor = original.getTypeConstructor();
-        if (substitutor.isEmpty()) {
+        if (originalSubstitutor.isEmpty()) {
             return originalTypeConstructor;
         }
 
         if (typeConstructor == null) {
-            List<TypeParameterDescriptor> parameters = Lists.newArrayList();
-            for (TypeParameterDescriptor parameterDescriptor : originalTypeConstructor.getParameters()) {
-                parameters.add(parameterDescriptor.substitute(substitutor));
-            }
+            TypeSubstitutor substitutor = getSubstitutor();
+
             Collection<JetType> supertypes = Lists.newArrayList();
             for (JetType supertype : originalTypeConstructor.getSupertypes()) {
                 supertypes.add(substitutor.substitute(supertype, Variance.INVARIANT));
@@ -47,7 +63,7 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
                     originalTypeConstructor.getAnnotations(),
                     originalTypeConstructor.isSealed(),
                     originalTypeConstructor.toString(),
-                    parameters,
+                    typeParameters,
                     supertypes
             );
         }
@@ -59,10 +75,19 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
     @Override
     public JetScope getMemberScope(List<TypeProjection> typeArguments) {
         JetScope memberScope = original.getMemberScope(typeArguments);
-        if (substitutor.isEmpty()) {
+        if (originalSubstitutor.isEmpty()) {
             return memberScope;
         }
-        return new SubstitutingScope(memberScope, substitutor); // TODO : compose substitutors
+        return new SubstitutingScope(memberScope, getSubstitutor());
+    }
+
+    @NotNull
+    @Override
+    public JetType getSuperclassType() {
+        if (superclassType == null) {
+            superclassType = getSubstitutor().substitute(original.getSuperclassType(), Variance.INVARIANT);
+        }
+        return superclassType;
     }
 
     @NotNull
@@ -73,7 +98,13 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public FunctionGroup getConstructors() {
+    public ReceiverDescriptor getImplicitReceiver() {
+        throw new UnsupportedOperationException(); // TODO
+    }
+
+    @NotNull
+    @Override
+    public Set<FunctionDescriptor> getConstructors() {
         throw new UnsupportedOperationException(); // TODO
     }
 
@@ -113,7 +144,8 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
     @NotNull
     @Override
     public ClassDescriptor substitute(TypeSubstitutor substitutor) {
-        throw new UnsupportedOperationException(); // TODO
+        if (substitutor.isEmpty()) return this;
+        return new LazySubstitutingClassDescriptor(this, TypeSubstitutor.create(substitutor.getSubstitution(), getSubstitutor().getSubstitution()));
     }
 
     @Override
@@ -121,9 +153,22 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
         return original.getClassObjectType();
     }
 
+    @NotNull
     @Override
-    public boolean isObject() {
-        return original.isObject();
+    public ClassKind getKind() {
+        return original.getKind();
+    }
+
+    @Override
+    @NotNull
+    public Modality getModality() {
+        return original.getModality();
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return original.getVisibility();
     }
 
     @Override
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/LocalVariableDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LocalVariableDescriptor.java
similarity index 90%
rename from idea/src/org/jetbrains/jet/lang/descriptors/LocalVariableDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LocalVariableDescriptor.java
index 9cc0de63485..171bb870095 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/LocalVariableDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LocalVariableDescriptor.java
@@ -12,6 +12,7 @@ import java.util.List;
  * @author abreslav
  */
 public class LocalVariableDescriptor extends VariableDescriptorImpl {
+    private boolean isVar;
     public LocalVariableDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull List<AnnotationDescriptor> annotations,
@@ -19,6 +20,7 @@ public class LocalVariableDescriptor extends VariableDescriptorImpl {
             @Nullable JetType type,
             boolean mutable) {
         super(containingDeclaration, annotations, name, mutable ? type : null, type);
+        isVar = mutable;
     }
 
     @NotNull
@@ -31,4 +33,9 @@ public class LocalVariableDescriptor extends VariableDescriptorImpl {
     public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
         return visitor.visitLocalVariableDescriptor(this, data);
     }
+
+    @Override
+    public boolean isVar() {
+        return isVar;
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java
similarity index 68%
rename from idea/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java
index 97b8814acff..5327b981133 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java
@@ -7,5 +7,8 @@ import org.jetbrains.annotations.NotNull;
  */
 public interface MemberDescriptor {
     @NotNull
-    MemberModifiers getModifiers();
+    Modality getModality();
+    
+    @NotNull
+    Visibility getVisibility();
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Modality.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Modality.java
new file mode 100644
index 00000000000..33e2f6e8235
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Modality.java
@@ -0,0 +1,26 @@
+package org.jetbrains.jet.lang.descriptors;
+
+/**
+ * @author abreslav
+ */
+public enum Modality {
+    FINAL(false),
+    OPEN(true),
+    ABSTRACT(true);
+
+    private final boolean overridable;
+
+    private Modality(boolean overridable) {
+        this.overridable = overridable;
+    }
+
+    public boolean isOverridable() {
+        return overridable;
+    }
+    
+    public static Modality convertFromFlags(boolean _abstract, boolean open) {
+        if (_abstract) return ABSTRACT;
+        if (open) return OPEN;
+        return FINAL;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java
similarity index 69%
rename from idea/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java
index 7686e45aad8..d9a993b4155 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java
@@ -6,6 +6,12 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 
@@ -16,13 +22,15 @@ import java.util.*;
  */
 public class MutableClassDescriptor extends MutableDeclarationDescriptor implements ClassDescriptor, NamespaceLike {
     private ConstructorDescriptor primaryConstructor;
-    private final WritableFunctionGroup constructors = new WritableFunctionGroup("<init>");
-    private final Set<FunctionDescriptor> functions = Sets.newHashSet();
+    private final Set<FunctionDescriptor> constructors = Sets.newLinkedHashSet();
+    private final Set<CallableMemberDescriptor> callableMembers = Sets.newHashSet();
     private final Set<PropertyDescriptor> properties = Sets.newHashSet();
+    private final Set<FunctionDescriptor> functions = Sets.newHashSet();
     private List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
     private Collection<JetType> supertypes = Lists.newArrayList();
 
-    private boolean open;
+    private Modality modality;
+    private Visibility visibility;
     private TypeConstructor typeConstructor;
     private final WritableScope scopeForMemberResolution;
     private final WritableScope scopeForMemberLookup;
@@ -31,18 +39,21 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     private MutableClassDescriptor classObjectDescriptor;
     private JetType classObjectType;
     private JetType defaultType;
-    private final boolean isObject;
+    private final ClassKind kind;
+    private JetType superclassType;
+    private ClassReceiver implicitReceiver;
 
-    public MutableClassDescriptor(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope outerScope) {
-        this(trace, containingDeclaration, outerScope, false);
-    }
+//    public MutableClassDescriptor(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope outerScope) {
+//        this(trace, containingDeclaration, outerScope, ClassKind.CLASS);
+//    }
 
-    public MutableClassDescriptor(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope outerScope, boolean isObject) {
+    public MutableClassDescriptor(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope outerScope, ClassKind kind) {
         super(containingDeclaration);
-        this.scopeForMemberLookup = new WritableScopeImpl(JetScope.EMPTY, this, trace.getErrorHandler()).setDebugName("MemberLookup");
-        this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, trace.getErrorHandler()).setDebugName("SupertypeResolution");
-        this.scopeForMemberResolution = new WritableScopeImpl(new ChainedScope(this, scopeForMemberLookup, scopeForSupertypeResolution), this, trace.getErrorHandler()).setDebugName("MemberResolution");
-        this.isObject = isObject;
+        TraceBasedRedeclarationHandler redeclarationHandler = new TraceBasedRedeclarationHandler(trace);
+        this.scopeForMemberLookup = new WritableScopeImpl(JetScope.EMPTY, this, redeclarationHandler).setDebugName("MemberLookup");
+        this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, redeclarationHandler).setDebugName("SupertypeResolution");
+        this.scopeForMemberResolution = new WritableScopeImpl(scopeForSupertypeResolution, this, redeclarationHandler).setDebugName("MemberResolution");
+        this.kind = kind;
     }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -50,7 +61,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     @Override
     public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
         if (this.classObjectDescriptor != null) return ClassObjectStatus.DUPLICATE;
-        assert classObjectDescriptor.isObject();
+        assert classObjectDescriptor.getKind() == ClassKind.OBJECT;
         this.classObjectDescriptor = classObjectDescriptor;
         return ClassObjectStatus.OK;
     }
@@ -74,8 +85,8 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
 
     public void addConstructor(@NotNull ConstructorDescriptor constructorDescriptor) {
         assert constructorDescriptor.getContainingDeclaration() == this;
-//        assert constructorDescriptor.getTypeParameters().size() == getTypeConstructor().getParameters().size();
-        constructors.addFunction(constructorDescriptor);
+//        assert constructorDescriptor.getTypeParameters().size() == getTypeConstructor().getValueParameters().size();
+        constructors.add(constructorDescriptor);
         if (defaultType != null) {
 //            constructorDescriptor.getTypeParameters().addAll(typeParameters);
             ((ConstructorDescriptorImpl) constructorDescriptor).setReturnType(getDefaultType());
@@ -85,7 +96,22 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     @Override
     public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
         properties.add(propertyDescriptor);
+        callableMembers.add(propertyDescriptor);
         scopeForMemberLookup.addVariableDescriptor(propertyDescriptor);
+        scopeForMemberResolution.addVariableDescriptor(propertyDescriptor);
+    }
+
+    @Override
+    public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
+        functions.add(functionDescriptor);
+        callableMembers.add(functionDescriptor);
+        scopeForMemberLookup.addFunctionDescriptor(functionDescriptor);
+        scopeForMemberResolution.addFunctionDescriptor(functionDescriptor);
+    }
+
+    @NotNull
+    public Set<FunctionDescriptor> getFunctions() {
+        return functions;
     }
 
     @NotNull
@@ -93,15 +119,9 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
         return properties;
     }
 
-    @Override
-    public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
-        functions.add(functionDescriptor);
-        scopeForMemberLookup.addFunctionDescriptor(functionDescriptor);
-    }
-
     @NotNull
-    public Set<FunctionDescriptor> getFunctions() {
-        return functions;
+    public Set<CallableMemberDescriptor> getCallableMembers() {
+        return callableMembers;
     }
 
     @Override
@@ -117,11 +137,13 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     @Override
     public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
         scopeForMemberLookup.addClassifierDescriptor(classDescriptor);
+        scopeForMemberResolution.addClassifierDescriptor(classDescriptor);
     }
 
     public void addSupertype(@NotNull JetType supertype) {
-        scopeForMemberLookup.importScope(supertype.getMemberScope());
-        supertypes.add(supertype);
+        if (!ErrorUtils.isErrorType(supertype)) {
+            supertypes.add(supertype);
+        }
     }
 
     public void setTypeParameterDescriptors(List<TypeParameterDescriptor> typeParameters) {
@@ -139,14 +161,6 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
         scopeForMemberResolution.addLabeledDeclaration(this);
     }
 
-    public boolean isOpen() {
-        return open;
-    }
-
-    public void setOpen(boolean open) {
-        this.open = open;
-    }
-
     @NotNull
     @Override
     public TypeConstructor getTypeConstructor() {
@@ -158,17 +172,22 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
         this.typeConstructor = new TypeConstructorImpl(
                 this,
                 Collections.<AnnotationDescriptor>emptyList(), // TODO : pass annotations from the class?
-                !open,
+                !modality.isOverridable(),
                 getName(),
                 typeParameters,
                 supertypes);
-        scopeForMemberResolution.setThisType(getDefaultType());
-        for (FunctionDescriptor functionDescriptor : constructors.getFunctionDescriptors()) {
-//            functionDescriptor.getTypeParameters().addAll(typeParameters);
+        scopeForMemberResolution.setImplicitReceiver(new ClassReceiver(this));
+        for (FunctionDescriptor functionDescriptor : constructors) {
             ((ConstructorDescriptorImpl) functionDescriptor).setReturnType(getDefaultType());
         }
     }
 
+    public void addSupertypesToScopeForMemberLookup() {
+        for (JetType supertype : supertypes) {
+            scopeForMemberLookup.importScope(supertype.getMemberScope());
+        }
+    }
+
     @NotNull
     @Override
     public JetScope getMemberScope(List<TypeProjection> typeArguments) {
@@ -191,15 +210,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
 
     @NotNull
     @Override
-    public FunctionGroup getConstructors() {
-        // TODO : Duplicates ClassDescriptorImpl
-//        assert typeArguments.size() == getTypeConstructor().getParameters().size();
-
-//        if (typeArguments.size() == 0) {
-//            return constructors;
-//        }
-//        Map<TypeConstructor, TypeProjection> substitutionContext = TypeUtils.buildSubstitutionContext(getTypeConstructor().getParameters(), typeArguments);
-//        return new LazySubstitutingFunctionGroup(TypeSubstitutor.create(substitutionContext), constructors);
+    public Set<FunctionDescriptor> getConstructors() {
         return constructors;
     }
 
@@ -250,13 +261,58 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
         return !constructors.isEmpty();
     }
 
+    @NotNull
     @Override
-    public boolean isObject() {
-        return isObject;
+    public ClassKind getKind() {
+        return kind;
+    }
+
+    @NotNull
+    @Override
+    public JetType getSuperclassType() {
+        return superclassType;
+    }
+
+    public void setSuperclassType(@NotNull JetType superclassType) {
+        this.superclassType = superclassType;
+    }
+
+
+    public void setModality(Modality modality) {
+        this.modality = modality;
+    }
+
+    public void setVisibility(Visibility visibility) {
+        this.visibility = visibility;
+    }
+
+    @Override
+    @NotNull
+    public Modality getModality() {
+        return modality;
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
     }
 
     @Override
     public String toString() {
         return DescriptorRenderer.TEXT.render(this) + "[" + getClass().getCanonicalName() + "@" + System.identityHashCode(this) + "]";
     }
+
+    public Collection<JetType> getSupertypes() {
+        return supertypes;
+    }
+
+    @NotNull
+    @Override
+    public ReceiverDescriptor getImplicitReceiver() {
+        if (implicitReceiver == null) {
+            implicitReceiver = new ClassReceiver(this);
+        }
+        return implicitReceiver;
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/MutableDeclarationDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableDeclarationDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/MutableDeclarationDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableDeclarationDescriptor.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/MutableValueParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableValueParameterDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/MutableValueParameterDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableValueParameterDescriptor.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/Named.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Named.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/Named.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Named.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptor.java
similarity index 88%
rename from idea/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptor.java
index f3d8c867e00..e28ddec1d21 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptor.java
@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.NamespaceType;
 
 /**
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java
similarity index 96%
rename from idea/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java
index 3c63b6c15e5..16016715a4d 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java
@@ -3,7 +3,7 @@ package org.jetbrains.jet.lang.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import java.util.List;
 
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/NamespaceLike.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceLike.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/NamespaceLike.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceLike.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java
similarity index 53%
rename from idea/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java
index a24561ec27a..023a235c3d8 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java
@@ -13,23 +13,35 @@ import java.util.List;
 public abstract class PropertyAccessorDescriptor extends DeclarationDescriptorImpl implements FunctionDescriptor, MemberDescriptor {
 
     private final boolean hasBody;
-    private final MemberModifiers modifiers;
+    private final boolean isDefault;
+    private final Modality modality;
+    private final Visibility visibility;
+    private final PropertyDescriptor correspondingProperty;
 
-    protected PropertyAccessorDescriptor(
-            @NotNull MemberModifiers modifiers,
+    public PropertyAccessorDescriptor(
+            @NotNull Modality modality,
+            @NotNull Visibility visibility,
             @NotNull PropertyDescriptor correspondingProperty,
             @NotNull List<AnnotationDescriptor> annotations,
             @NotNull String name,
-            boolean hasBody) {
+            boolean hasBody,
+            boolean isDefault) {
         super(correspondingProperty.getContainingDeclaration(), annotations, name);
-        this.modifiers = modifiers;
+        this.modality = modality;
+        this.visibility = visibility;
+        this.correspondingProperty = correspondingProperty;
         this.hasBody = hasBody;
+        this.isDefault = isDefault;
     }
 
     public boolean hasBody() {
         return hasBody;
     }
 
+    public boolean isDefault() {
+        return isDefault;
+    }
+
     @NotNull
     @Override
     public PropertyAccessorDescriptor getOriginal() {
@@ -50,7 +62,24 @@ public abstract class PropertyAccessorDescriptor extends DeclarationDescriptorIm
 
     @NotNull
     @Override
-    public MemberModifiers getModifiers() {
-        return modifiers;
+    public Modality getModality() {
+        return modality;
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
+    @NotNull
+    public PropertyDescriptor getCorrespondingProperty() {
+        return correspondingProperty;
+    }
+
+    @NotNull
+    @Override
+    public PropertyAccessorDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract) {
+        throw new UnsupportedOperationException("Accessors must be copied by the corresponding property");
     }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
similarity index 51%
rename from idea/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
index 552f257ade8..5c6c5212c78 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
@@ -1,23 +1,30 @@
 package org.jetbrains.jet.lang.descriptors;
 
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 import org.jetbrains.jet.lang.types.Variance;
 
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author abreslav
  */
-public class PropertyDescriptor extends VariableDescriptorImpl implements MemberDescriptor {
+public class PropertyDescriptor extends VariableDescriptorImpl implements CallableMemberDescriptor {
 
-    private final MemberModifiers memberModifiers;
+    private final Modality modality;
+    private final Visibility visibility;
     private final boolean isVar;
-    private final JetType receiverType;
+    private final ReceiverDescriptor receiver;
+    private final Set<PropertyDescriptor> overriddenProperties = Sets.newLinkedHashSet();
     private final List<TypeParameterDescriptor> typeParemeters = Lists.newArrayListWithCapacity(0);
     private final PropertyDescriptor original;
     private PropertyGetterDescriptor getter;
@@ -27,7 +34,8 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
             @Nullable PropertyDescriptor original,
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull List<AnnotationDescriptor> annotations,
-            @NotNull MemberModifiers memberModifiers,
+            @NotNull Modality modality,
+            @NotNull Visibility visibility,
             boolean isVar,
             @Nullable JetType receiverType,
             @NotNull String name,
@@ -37,21 +45,23 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
         assert !isVar || inType != null;
 //        assert outType != null;
         this.isVar = isVar;
-        this.memberModifiers = memberModifiers;
-        this.receiverType = receiverType;
-        this.original = original == null ? this : original;
+        this.modality = modality;
+        this.visibility = visibility;
+        this.receiver = receiverType == null ? ReceiverDescriptor.NO_RECEIVER : new ExtensionReceiver(this, receiverType);
+        this.original = original == null ? this : original.getOriginal();
     }
 
     public PropertyDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull List<AnnotationDescriptor> annotations,
-            @NotNull MemberModifiers memberModifiers,
+            @NotNull Modality modality,
+            @NotNull Visibility visibility,
             boolean isVar,
             @Nullable JetType receiverType,
             @NotNull String name,
             @Nullable JetType inType,
             @NotNull JetType outType) {
-        this(null, containingDeclaration, annotations, memberModifiers, isVar, receiverType, name, inType, outType);
+        this(null, containingDeclaration, annotations, modality, visibility, isVar, receiverType, name, inType, outType);
     }
 
     private PropertyDescriptor(
@@ -63,7 +73,8 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
                 original,
                 original.getContainingDeclaration(),
                 original.getAnnotations(), // TODO : substitute?
-                original.getModifiers(),
+                original.getModality(),
+                original.getVisibility(),
                 original.isVar,
                 receiverType,
                 original.getName(),
@@ -78,13 +89,20 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
     }
 
     @NotNull
-    public List<TypeParameterDescriptor> getTypeParemeters() {
+    @Override
+    public List<TypeParameterDescriptor> getTypeParameters() {
         return typeParemeters;
     }
 
-    @Nullable
-    public JetType getReceiverType() {
-        return receiverType;
+    @NotNull
+    public ReceiverDescriptor getReceiver() {
+        return receiver;
+    }
+
+    @NotNull
+    @Override
+    public JetType getReturnType() {
+        return getOutType();
     }
 
 
@@ -94,8 +112,14 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
 
     @NotNull
     @Override
-    public MemberModifiers getModifiers() {
-        return memberModifiers;
+    public Modality getModality() {
+        return modality;
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
     }
 
     @Nullable
@@ -110,7 +134,7 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
 
     @NotNull
     @Override
-    public VariableDescriptor substitute(TypeSubstitutor substitutor) {
+    public PropertyDescriptor substitute(TypeSubstitutor substitutor) {
         JetType originalInType = getInType();
         JetType inType = originalInType == null ? null : substitutor.substitute(originalInType, Variance.IN_VARIANCE);
         JetType originalOutType = getOutType();
@@ -118,10 +142,9 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
         if (inType == null && outType == null) {
             return null; // TODO : tell the user that the property was projected out
         }
-        JetType receiverType = getReceiverType();
         return new PropertyDescriptor(
                 this,
-                receiverType == null ? null : substitutor.substitute(receiverType, Variance.IN_VARIANCE),
+                receiver.exists() ? substitutor.substitute(receiver.getType(), Variance.IN_VARIANCE) : null,
                 inType,
                 outType
         );
@@ -137,4 +160,36 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
     public PropertyDescriptor getOriginal() {
         return original;
     }
+
+    public void addOverriddenDescriptor(PropertyDescriptor overridden) {
+        overriddenProperties.add(overridden);
+    }
+
+    @NotNull
+    @Override
+    public Set<? extends PropertyDescriptor> getOverriddenDescriptors() {
+        return overriddenProperties;
+
+    }
+    @NotNull
+    @Override
+    public PropertyDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract) {
+        PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
+                newOwner,
+                Lists.newArrayList(getAnnotations()),
+                DescriptorUtils.convertModality(modality, makeNonAbstract), visibility, isVar,
+                receiver.exists() ? receiver.getType() : null, getName(), getInType(), getOutType());
+        PropertyGetterDescriptor newGetter = getter == null ? null : new PropertyGetterDescriptor(
+                propertyDescriptor, Lists.newArrayList(getter.getAnnotations()),
+                DescriptorUtils.convertModality(getter.getModality(), makeNonAbstract), getter.getVisibility(),
+                getter.getReturnType(),
+                getter.hasBody(), getter.isDefault());
+        PropertySetterDescriptor newSetter = setter == null ? null : new PropertySetterDescriptor(
+                        DescriptorUtils.convertModality(setter.getModality(), makeNonAbstract), setter.getVisibility(),
+                        propertyDescriptor,
+                        Lists.newArrayList(setter.getAnnotations()),
+                        setter.hasBody(), setter.isDefault());;
+        propertyDescriptor.initialize(DescriptorUtils.copyTypeParameters(propertyDescriptor, getTypeParameters()), newGetter, newSetter);
+        return propertyDescriptor;
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java
similarity index 66%
rename from idea/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java
index e434436c598..747a27e64a7 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java
@@ -4,6 +4,7 @@ import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 
 import java.util.Collections;
@@ -17,14 +18,14 @@ public class PropertyGetterDescriptor extends PropertyAccessorDescriptor {
     private final Set<PropertyGetterDescriptor> overriddenGetters = Sets.newHashSet();
     private JetType returnType;
 
-    public PropertyGetterDescriptor(@NotNull MemberModifiers modifiers, @NotNull PropertyDescriptor correspondingProperty, @NotNull List<AnnotationDescriptor> annotations, @Nullable JetType returnType, boolean hasBody) {
-        super(modifiers, correspondingProperty, annotations, "get-" + correspondingProperty.getName(), hasBody);
+    public PropertyGetterDescriptor(@NotNull PropertyDescriptor correspondingProperty, @NotNull List<AnnotationDescriptor> annotations, @NotNull Modality modality, @NotNull Visibility visibility, @Nullable JetType returnType, boolean hasBody, boolean isDefault) {
+        super(modality, visibility, correspondingProperty, annotations, "get-" + correspondingProperty.getName(), hasBody, isDefault);
         this.returnType = returnType == null ? correspondingProperty.getOutType() : returnType;
     }
 
     @NotNull
     @Override
-    public Set<? extends FunctionDescriptor> getOverriddenFunctions() {
+    public Set<? extends FunctionDescriptor> getOverriddenDescriptors() {
         return overriddenGetters;
     }
 
@@ -32,9 +33,10 @@ public class PropertyGetterDescriptor extends PropertyAccessorDescriptor {
         overriddenGetters.add(overriddenGetter);
     }
 
+    @NotNull
     @Override
-    public JetType getReceiverType() {
-        return null; // TODO
+    public ReceiverDescriptor getReceiver() {
+        return getCorrespondingProperty().getReceiver();
     }
 
     @NotNull
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java
similarity index 71%
rename from idea/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java
index 2e31121f278..13752d9743c 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java
@@ -3,6 +3,7 @@ package org.jetbrains.jet.lang.descriptors;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetType;
 
@@ -18,8 +19,8 @@ public class PropertySetterDescriptor extends PropertyAccessorDescriptor {
     private MutableValueParameterDescriptor parameter;
     private final Set<PropertySetterDescriptor> overriddenSetters = Sets.newHashSet();
 
-    public PropertySetterDescriptor(@NotNull MemberModifiers modifiers, @NotNull PropertyDescriptor correspondingProperty, @NotNull List<AnnotationDescriptor> annotations, boolean hasBody) {
-        super(modifiers, correspondingProperty, annotations, "set-" + correspondingProperty.getName(), hasBody);
+    public PropertySetterDescriptor(@NotNull Modality modality, @NotNull Visibility visibility, @NotNull PropertyDescriptor correspondingProperty, @NotNull List<AnnotationDescriptor> annotations, boolean hasBody, boolean isDefault) {
+        super(modality, visibility, correspondingProperty, annotations, "set-" + correspondingProperty.getName(), hasBody, isDefault);
     }
 
     public void initialize(@NotNull MutableValueParameterDescriptor parameter) {
@@ -33,7 +34,7 @@ public class PropertySetterDescriptor extends PropertyAccessorDescriptor {
 
     @NotNull
     @Override
-    public Set<? extends FunctionDescriptor> getOverriddenFunctions() {
+    public Set<? extends FunctionDescriptor> getOverriddenDescriptors() {
         return overriddenSetters;
     }
 
@@ -41,9 +42,10 @@ public class PropertySetterDescriptor extends PropertyAccessorDescriptor {
         overriddenSetters.add(overriddenSetter);
     }
 
+    @NotNull
     @Override
-    public JetType getReceiverType() {
-        return null; // TODO
+    public ReceiverDescriptor getReceiver() {
+        return getCorrespondingProperty().getReceiver();
     }
 
     @NotNull
@@ -62,5 +64,4 @@ public class PropertySetterDescriptor extends PropertyAccessorDescriptor {
     public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
         return visitor.visitPropertySetterDescriptor(this, data);
     }
-
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java
similarity index 91%
rename from idea/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java
index 92d0f3dc4d9..f67fa35e749 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java
@@ -1,10 +1,11 @@
 package org.jetbrains.jet.lang.descriptors;
 
+import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.LazyScopeAdapter;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 
@@ -103,8 +104,9 @@ public class TypeParameterDescriptor extends DeclarationDescriptorImpl implement
 
     @NotNull
     @Override
+    @Deprecated // Use the static method TypeParameterDescriptor.substitute()
     public TypeParameterDescriptor substitute(TypeSubstitutor substitutor) {
-        throw new UnsupportedOperationException(); // TODO
+        throw new UnsupportedOperationException();
     }
 
     @Override
@@ -156,4 +158,9 @@ public class TypeParameterDescriptor extends DeclarationDescriptorImpl implement
     public int getIndex() {
         return index;
     }
+    
+    @NotNull
+    public TypeParameterDescriptor copy(@NotNull DeclarationDescriptor newOwner) {
+        return new TypeParameterDescriptor(newOwner, Lists.newArrayList(getAnnotations()), variance, getName(), index);
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java
similarity index 79%
rename from idea/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java
index 0f76ee969ab..ba7131b36c0 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java
@@ -20,4 +20,10 @@ public interface ValueParameterDescriptor extends VariableDescriptor {
     @Override
     @NotNull
     JetType getOutType();
+
+    @Override
+    ValueParameterDescriptor getOriginal();
+
+    @NotNull
+    ValueParameterDescriptor copy(DeclarationDescriptor newOwner);
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java
similarity index 65%
rename from idea/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java
index 1cb7663d839..8b13a526dc7 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java
@@ -1,5 +1,6 @@
 package org.jetbrains.jet.lang.descriptors;
 
+import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
@@ -16,6 +17,7 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
     private final boolean isVararg;
     private final boolean isVar;
     private final int index;
+    private final ValueParameterDescriptor original;
 
     public ValueParameterDescriptorImpl(
             @NotNull DeclarationDescriptor containingDeclaration,
@@ -27,6 +29,7 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
             boolean hasDefaultValue,
             boolean isVararg) {
         super(containingDeclaration, annotations, name, inType, outType);
+        this.original = this;
         this.index = index;
         this.hasDefaultValue = hasDefaultValue;
         this.isVararg = isVararg;
@@ -35,17 +38,17 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
 
     public ValueParameterDescriptorImpl(
             @NotNull DeclarationDescriptor containingDeclaration,
-            int index,
+            @NotNull ValueParameterDescriptor original,
             @NotNull List<AnnotationDescriptor> annotations,
-            @NotNull String name,
-            boolean isVar,
-            boolean hasDefaultValue,
-            boolean isVararg) {
-        super(containingDeclaration, annotations, name, null, null);
-        this.index = index;
-        this.hasDefaultValue = hasDefaultValue;
-        this.isVararg = isVararg;
-        this.isVar = isVar;
+            @Nullable JetType inType,
+            @NotNull JetType outType
+            ) {
+        super(containingDeclaration, annotations, original.getName(), inType, outType);
+        this.original = original;
+        this.index = original.getIndex();
+        this.hasDefaultValue = original.hasDefaultValue();
+        this.isVararg = original.isVararg();
+        this.isVar = inType != null;
     }
 
     @Override
@@ -61,12 +64,6 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
     @Override
     public int getIndex() {
         return index;
-//        final JetDeclaration element = getPsiElement();
-//        final PsiElement parent = element.getParent();
-//        if (parent instanceof JetParameterList) {
-//            return ((JetParameterList) parent).getParameters().indexOf(element);
-//        }
-//        throw new IllegalStateException("couldn't find index for parameter");
     }
 
     @Override
@@ -86,7 +83,13 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
 
     @NotNull
     @Override
-    public VariableDescriptor substitute(TypeSubstitutor substitutor) {
+    public ValueParameterDescriptor getOriginal() {
+        return original == this ? this : original.getOriginal();
+    }
+
+    @NotNull
+    @Override
+    public ValueParameterDescriptor substitute(TypeSubstitutor substitutor) {
         throw new UnsupportedOperationException(); // TODO
     }
 
@@ -94,4 +97,15 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
     public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
         return visitor.visitValueParameterDescriptor(this, data);
     }
+
+    @Override
+    public boolean isVar() {
+        return isVar;
+    }
+
+    @NotNull
+    @Override
+    public ValueParameterDescriptor copy(@NotNull DeclarationDescriptor newOwner) {
+        return new ValueParameterDescriptorImpl(newOwner, index, Lists.newArrayList(getAnnotations()), getName(), getInType(), getOutType(), hasDefaultValue, isVararg);
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java
similarity index 84%
rename from idea/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java
index d465257af93..88462653cfc 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java
@@ -16,7 +16,7 @@ public class VariableAsFunctionDescriptor extends FunctionDescriptorImpl {
         assert outType != null;
         assert JetStandardClasses.isFunctionType(outType);
         VariableAsFunctionDescriptor result = new VariableAsFunctionDescriptor(variableDescriptor);
-        result.initialize(JetStandardClasses.getReceiverType(outType), Collections.<TypeParameterDescriptor>emptyList(), JetStandardClasses.getValueParameters(result, outType), JetStandardClasses.getReturnType(outType));
+        result.initialize(JetStandardClasses.getReceiverType(outType), Collections.<TypeParameterDescriptor>emptyList(), JetStandardClasses.getValueParameters(result, outType), JetStandardClasses.getReturnType(outType), Modality.FINAL, Visibility.LOCAL);
         return result;
     }
 
@@ -31,4 +31,10 @@ public class VariableAsFunctionDescriptor extends FunctionDescriptorImpl {
     public VariableDescriptor getVariableDescriptor() {
         return variableDescriptor;
     }
-}
+
+    @NotNull
+    @Override
+    public VariableAsFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract) {
+        throw new UnsupportedOperationException("Should not be copied for overriding");
+    }
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java
similarity index 90%
rename from idea/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java
index c79eabb9fe8..fc883d59508 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java
@@ -8,7 +8,7 @@ import org.jetbrains.jet.lang.types.TypeSubstitutor;
 /**
  * @author abreslav
  */
-public interface VariableDescriptor extends DeclarationDescriptor {
+public interface VariableDescriptor extends CallableDescriptor {
     /**
      * @return <code>null</code> for write-only variables (i.e. properties), variable value type otherwise
      */
@@ -29,4 +29,6 @@ public interface VariableDescriptor extends DeclarationDescriptor {
     @NotNull
     @Override
     VariableDescriptor substitute(TypeSubstitutor substitutor);
+
+    boolean isVar();
 }
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java
similarity index 57%
rename from idea/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java
index d4b01df9815..c941fae9605 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java
@@ -3,9 +3,12 @@ package org.jetbrains.jet.lang.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 
+import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -44,4 +47,40 @@ public abstract class VariableDescriptorImpl extends DeclarationDescriptorImpl i
     protected void setOutType(JetType outType) {
         this.outType = outType;
     }
+
+    @Override
+    @NotNull
+    public VariableDescriptor getOriginal() {
+        return (VariableDescriptor) super.getOriginal();
+    }
+
+    @NotNull
+    @Override
+    public List<ValueParameterDescriptor> getValueParameters() {
+        return Collections.emptyList();
+    }
+
+    @NotNull
+    @Override
+    public Set<? extends CallableDescriptor> getOverriddenDescriptors() {
+        return Collections.emptySet();
+    }
+
+    @NotNull
+    @Override
+    public List<TypeParameterDescriptor> getTypeParameters() {
+        return Collections.emptyList();
+    }
+
+    @NotNull
+    @Override
+    public ReceiverDescriptor getReceiver() {
+        return ReceiverDescriptor.NO_RECEIVER;
+    }
+
+    @NotNull
+    @Override
+    public JetType getReturnType() {
+        return getOutType();
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java
new file mode 100644
index 00000000000..e2c5364dfe3
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java
@@ -0,0 +1,23 @@
+package org.jetbrains.jet.lang.descriptors;
+
+/**
+ * @author svtk
+ */
+public enum Visibility {
+    PRIVATE(false),
+    PROTECTED(true),
+    INTERNAL(false),
+    PUBLIC(true),
+    INTERNAL_PROTECTED(false),
+    LOCAL(false);
+
+    private final boolean isAPI;
+
+    private Visibility(boolean visibleOutside) {
+        isAPI = visibleOutside;
+    }
+
+    public boolean isAPI() {
+        return isAPI;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/annotations/Annotated.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/annotations/Annotated.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/annotations/Annotated.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/annotations/Annotated.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotatedImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotatedImpl.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotatedImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotatedImpl.java
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationArgumentVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationArgumentVisitor.java
similarity index 93%
rename from idea/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationArgumentVisitor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationArgumentVisitor.java
index 70057d05f38..6443c23e9cb 100644
--- a/idea/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationArgumentVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationArgumentVisitor.java
@@ -19,6 +19,8 @@ public interface AnnotationArgumentVisitor<R, D> {
 
     R visitDoubleValue(DoubleValue value, D data);
 
+    R visitFloatValue(FloatValue value, D data);
+
     R visitBooleanValue(BooleanValue value, D data);
 
     R visitCharValue(CharValue value, D data);
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptor.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnosticFactory.java
new file mode 100644
index 00000000000..5b6e97783a1
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnosticFactory.java
@@ -0,0 +1,39 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class AbstractDiagnosticFactory implements DiagnosticFactory {
+    
+    private String name = null;
+    
+    /*package*/ void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @NotNull
+    @Override
+    public TextRange getTextRange(@NotNull Diagnostic diagnostic) {
+        return ((DiagnosticWithTextRange) diagnostic).getTextRange();
+    }
+
+    @NotNull
+    @Override
+    public PsiFile getPsiFile(@NotNull Diagnostic diagnostic) {
+        return ((DiagnosticWithTextRange) diagnostic).getPsiFile();
+    }
+
+    @Override
+    public String toString() {
+        return getName();
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java
new file mode 100644
index 00000000000..f3cc1e2a67d
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java
@@ -0,0 +1,29 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.resolve.DescriptorRenderer;
+
+import java.util.Collection;
+
+/**
+* @author abreslav
+*/
+public class AmbiguousDescriptorDiagnosticFactory extends ParameterizedDiagnosticFactory1<Collection<? extends CallableDescriptor>> {
+    public static AmbiguousDescriptorDiagnosticFactory create(String messageTemplate) {
+        return new AmbiguousDescriptorDiagnosticFactory(messageTemplate);
+    }
+
+    public AmbiguousDescriptorDiagnosticFactory(String messageTemplate) {
+        super(Severity.ERROR, messageTemplate);
+    }
+
+    @Override
+    protected String makeMessageFor(@NotNull Collection<? extends CallableDescriptor> argument) {
+        StringBuilder stringBuilder = new StringBuilder("\n");
+        for (CallableDescriptor descriptor : argument) {
+            stringBuilder.append(DescriptorRenderer.TEXT.render(descriptor)).append("\n");
+        }
+        return stringBuilder.toString();
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Diagnostic.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Diagnostic.java
new file mode 100644
index 00000000000..12531a8c59e
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Diagnostic.java
@@ -0,0 +1,18 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+* @author abreslav
+*/
+public interface Diagnostic {
+
+    @NotNull
+    DiagnosticFactory getFactory();
+
+    @NotNull
+    String getMessage();
+
+    @NotNull
+    Severity getSeverity();
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory.java
new file mode 100644
index 00000000000..42621e20bfc
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory.java
@@ -0,0 +1,19 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+* @author abreslav
+*/
+public interface DiagnosticFactory {
+    @NotNull
+    TextRange getTextRange(@NotNull Diagnostic diagnostic);
+
+    @NotNull
+    PsiFile getPsiFile(@NotNull Diagnostic diagnostic);
+    
+    @NotNull
+    String getName();
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithMessageFormat.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithMessageFormat.java
new file mode 100644
index 00000000000..3657beb122d
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithMessageFormat.java
@@ -0,0 +1,22 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import java.text.MessageFormat;
+
+/**
+* @author abreslav
+*/
+public abstract class DiagnosticFactoryWithMessageFormat extends DiagnosticFactoryWithSeverity {
+    protected final MessageFormat messageFormat;
+    protected final Renderer renderer;
+
+    public DiagnosticFactoryWithMessageFormat(Severity severity, String message) {
+        this(severity, message, Renderer.TO_STRING);
+    }
+
+    public DiagnosticFactoryWithMessageFormat(Severity severity, String message, Renderer renderer) {
+        super(severity);
+        this.messageFormat = new MessageFormat(message);
+        this.renderer = renderer;
+    }
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement1.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement1.java
new file mode 100644
index 00000000000..85e90747a9a
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement1.java
@@ -0,0 +1,48 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author svtk
+ */
+public abstract class DiagnosticFactoryWithPsiElement1<T extends PsiElement, A> extends DiagnosticFactoryWithMessageFormat {
+
+    protected DiagnosticFactoryWithPsiElement1(Severity severity, String message, Renderer renderer) {
+        super(severity, message, renderer);
+    }
+
+    protected DiagnosticFactoryWithPsiElement1(Severity severity, String message) {
+        super(severity, message);
+    }
+
+    protected String makeMessage(@NotNull A argument) {
+        return messageFormat.format(new Object[]{makeMessageFor(argument)});
+    }
+
+    protected String makeMessageFor(A argument) {
+        return renderer.render(argument);
+    }
+
+    @NotNull
+    public DiagnosticWithPsiElement<T> on(@NotNull T elementToMark, @NotNull A argument) {
+        return on(elementToMark, elementToMark.getTextRange(), argument);
+    }
+
+    @NotNull
+    public DiagnosticWithPsiElement<T> on(@NotNull T elementToBlame, @NotNull ASTNode nodeToMark, @NotNull A argument) {
+        return on(elementToBlame, nodeToMark.getTextRange(), argument);
+    }
+
+    @NotNull
+    public DiagnosticWithPsiElement<T> on(@NotNull T elementToBlame, @NotNull PsiElement elementToMark, @NotNull A argument) {
+        return on(elementToBlame, elementToMark.getTextRange(), argument);
+    }
+    
+    @NotNull
+    protected DiagnosticWithPsiElement<T> on(@NotNull T elementToBlame, @NotNull TextRange textRangeToMark, @NotNull A argument) {
+        return new DiagnosticWithPsiElementImpl<T>(this, severity, makeMessage(argument), elementToBlame, textRangeToMark);
+    }
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement2.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement2.java
new file mode 100644
index 00000000000..ccc2b4b10d0
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement2.java
@@ -0,0 +1,46 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public abstract class DiagnosticFactoryWithPsiElement2<T extends PsiElement, A, B> extends DiagnosticFactoryWithMessageFormat {
+
+    protected DiagnosticFactoryWithPsiElement2(Severity severity, String message, Renderer renderer) {
+        super(severity, message, renderer);
+    }
+
+    protected DiagnosticFactoryWithPsiElement2(Severity severity, String message) {
+        super(severity, message);
+    }
+
+    protected String makeMessage(@NotNull A a, @NotNull B b) {
+        return messageFormat.format(new Object[] {makeMessageForA(a), makeMessageForB(b)});
+    }
+
+    protected String makeMessageForA(@NotNull A a) {
+        return renderer.render(a);
+    }
+
+    protected String makeMessageForB(@NotNull B b) {
+        return renderer.render(b);
+    }
+
+    @NotNull
+    public DiagnosticWithPsiElement<T> on(@NotNull T elementToMark, @NotNull A a, @NotNull B b) {
+        return on(elementToMark, elementToMark.getNode(), a, b);
+    }
+    
+    @NotNull
+    public DiagnosticWithPsiElement<T> on(@NotNull T elementToBlame, @NotNull ASTNode nodeToMark, @NotNull A a, @NotNull B b) {
+        return makeDiagnostic(new DiagnosticWithPsiElementImpl<T>(this, severity, makeMessage(a, b), elementToBlame, nodeToMark.getTextRange()));
+    }
+
+    public DiagnosticWithPsiElement<T> makeDiagnostic(DiagnosticWithPsiElement<T> diagnostic) {
+        return diagnostic;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement3.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement3.java
new file mode 100644
index 00000000000..a4801044fbf
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement3.java
@@ -0,0 +1,56 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author svtk
+ */
+public abstract class DiagnosticFactoryWithPsiElement3<T extends PsiElement, A, B, C> extends DiagnosticFactoryWithMessageFormat {
+    protected DiagnosticFactoryWithPsiElement3(Severity severity, String messageStub, Renderer renderer) {
+        super(severity, messageStub, renderer);
+    }
+
+    protected DiagnosticFactoryWithPsiElement3(Severity severity, String message) {
+        super(severity, message);
+    }
+
+    protected String makeMessage(@NotNull A a, @NotNull B b, @NotNull C c) {
+        return messageFormat.format(new Object[]{makeMessageForA(a), makeMessageForB(b), makeMessageForC(c)});
+    }
+
+    protected String makeMessageForA(@NotNull A a) {
+        return renderer.render(a);
+    }
+
+    protected String makeMessageForB(@NotNull B b) {
+        return renderer.render(b);
+    }
+
+    protected String makeMessageForC(@NotNull C c) {
+        return renderer.render(c);
+    }
+
+    @NotNull
+    public DiagnosticWithPsiElement<T> on(@NotNull T elementToMark, @NotNull A a, @NotNull B b, @NotNull C c) {
+        return on(elementToMark, elementToMark, a, b, c);
+    }
+    
+    @NotNull
+    public DiagnosticWithPsiElement<T> on(@NotNull T elementToBlame, @NotNull PsiElement elementToMark, @NotNull A a, @NotNull B b, @NotNull C c) {
+        return on(elementToBlame, elementToMark.getTextRange(), a, b, c);
+    }
+
+    @NotNull
+    public DiagnosticWithPsiElement<T> on(@NotNull T elementToBlame, @NotNull ASTNode nodeToMark, @NotNull A a, @NotNull B b, @NotNull C c) {
+        return on(elementToBlame, nodeToMark.getTextRange(), a, b, c);
+    }
+
+    @NotNull
+    protected DiagnosticWithPsiElement<T> on(@NotNull T elementToBlame, @NotNull TextRange textRangeToMark, @NotNull A a, @NotNull B b, @NotNull C c) {
+        return new DiagnosticWithPsiElementImpl<T>(this, severity, makeMessage(a, b, c), elementToBlame, textRangeToMark);
+    }
+    
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithSeverity.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithSeverity.java
new file mode 100644
index 00000000000..872e368fbab
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithSeverity.java
@@ -0,0 +1,13 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+/**
+ * @author abreslav
+ */
+public abstract class DiagnosticFactoryWithSeverity extends AbstractDiagnosticFactory {
+    protected final Severity severity;
+
+    public DiagnosticFactoryWithSeverity(Severity severity) {
+        this.severity = severity;
+    }
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticHolder.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticHolder.java
new file mode 100644
index 00000000000..fbbbc1ea72f
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticHolder.java
@@ -0,0 +1,28 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+* @author abreslav
+*/
+public interface DiagnosticHolder {
+    DiagnosticHolder DO_NOTHING = new DiagnosticHolder() {
+        @Override
+        public void report(@NotNull Diagnostic diagnostic) {
+        }
+    };
+    DiagnosticHolder THROW_EXCEPTION = new DiagnosticHolder() {
+        @Override
+        public void report(@NotNull Diagnostic diagnostic) {
+            if (diagnostic.getSeverity() == Severity.ERROR) {
+                PsiFile psiFile = diagnostic.getFactory().getPsiFile(diagnostic);
+                TextRange textRange = diagnostic.getFactory().getTextRange(diagnostic);
+                throw new IllegalStateException(diagnostic.getMessage() + DiagnosticUtils.atLocation(psiFile, textRange));
+            }
+        }
+    };
+
+    void report(@NotNull Diagnostic diagnostic);
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticParameter.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticParameter.java
new file mode 100644
index 00000000000..869b6e929a9
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticParameter.java
@@ -0,0 +1,7 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+/**
+ * @author svtk
+ */
+public interface DiagnosticParameter<P> {
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticParameterImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticParameterImpl.java
new file mode 100644
index 00000000000..d3cf7cf003e
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticParameterImpl.java
@@ -0,0 +1,17 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+/**
+ * @author svtk
+ */
+public class DiagnosticParameterImpl<P> implements DiagnosticParameter<P> {
+    private final String value;
+
+    public DiagnosticParameterImpl(String value) {
+        this.value = value;
+    }
+
+    @Override
+    public String toString() {
+        return this.value;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticParameters.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticParameters.java
new file mode 100644
index 00000000000..4712b76625b
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticParameters.java
@@ -0,0 +1,16 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import org.jetbrains.jet.lang.psi.JetClass;
+import org.jetbrains.jet.lang.psi.JetProperty;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lexer.JetKeywordToken;
+
+/**
+ * @author svtk
+ */
+public interface DiagnosticParameters {
+    DiagnosticParameter<JetKeywordToken> MODIFIER = new DiagnosticParameterImpl<JetKeywordToken>("MODIFIER");
+    DiagnosticParameter<JetClass> CLASS = new DiagnosticParameterImpl<JetClass>("CLASS");
+    DiagnosticParameter<JetType> TYPE = new DiagnosticParameterImpl<JetType>("TYPE");
+    DiagnosticParameter<JetProperty> PROPERTY = new DiagnosticParameterImpl<JetProperty>("TYPE");
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java
new file mode 100644
index 00000000000..ea3d2d57700
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java
@@ -0,0 +1,66 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author abreslav
+ */
+public class DiagnosticUtils {
+    public static String atLocation(@NotNull PsiElement element) {
+        return atLocation(element.getNode());
+    }
+
+    public static String atLocation(@NotNull ASTNode node) {
+        int startOffset = node.getStartOffset();
+        PsiElement element = getClosestPsiElement(node);
+        if (element != null) {
+            return atLocation(element.getContainingFile(), element.getTextRange());
+        }
+        return "' at offset " + startOffset + " (line and file unknown)";
+    }
+
+    @Nullable
+    public static PsiElement getClosestPsiElement(@NotNull ASTNode node) {
+        while (node != null && node.getPsi() == null) {
+            node = node.getTreeParent();
+        }
+        return node == null ? null : node.getPsi();
+    }
+    
+    @NotNull
+    public static PsiFile getContainingFile(@NotNull ASTNode node) {
+        PsiElement closestPsiElement = getClosestPsiElement(node);
+        assert closestPsiElement != null : "This node is not contained by a file";
+        return closestPsiElement.getContainingFile();
+    }
+
+    @NotNull
+    public static String atLocation(@NotNull PsiFile file, @NotNull TextRange textRange) {
+        Document document = file.getViewProvider().getDocument();//PsiDocumentManager.getInstance(file.getProject()).getDocument(file);
+        return atLocation(file, textRange, document);
+    }
+
+    @NotNull
+    public static String atLocation(PsiFile file, TextRange textRange, Document document) {
+        int offset = textRange.getStartOffset();
+        VirtualFile virtualFile = file.getVirtualFile();
+        String pathSuffix = virtualFile == null ? "" : " in " + virtualFile.getPath();
+        if (document != null) {
+            int lineNumber = document.getLineNumber(offset);
+            int lineStartOffset = document.getLineStartOffset(lineNumber);
+            int column = offset - lineStartOffset;
+
+            return "' at line " + (lineNumber + 1) + ":" + column + pathSuffix;
+        }
+        else {
+            return "' at offset " + offset + " (line unknown)" + pathSuffix;
+        }
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameterFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameterFactory.java
new file mode 100644
index 00000000000..341f26f8c8c
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameterFactory.java
@@ -0,0 +1,27 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author svtk
+ */
+public class DiagnosticWithParameterFactory<T extends PsiElement, A> extends PsiElementOnlyDiagnosticFactory1<T, A> {
+    public static <T extends PsiElement, A> DiagnosticWithParameterFactory<T, A> create(Severity severity, String messageStub, DiagnosticParameter<A> diagnosticParameter) {
+        return new DiagnosticWithParameterFactory<T, A>(severity, messageStub, diagnosticParameter);
+    }
+
+    private final DiagnosticParameter<A> diagnosticParameter;
+
+    protected DiagnosticWithParameterFactory(Severity severity, String message, DiagnosticParameter<A> diagnosticParameter) {
+        super(severity, message);
+        this.diagnosticParameter = diagnosticParameter;
+    }
+
+    @NotNull
+    @Override
+    protected DiagnosticWithPsiElement<T> on(@NotNull T elementToBlame, @NotNull TextRange textRangeToMark, @NotNull A argument) {
+        return super.on(elementToBlame, textRangeToMark, argument).add(diagnosticParameter, argument);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters.java
new file mode 100644
index 00000000000..d6b29d8c3be
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters.java
@@ -0,0 +1,37 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.google.common.collect.Maps;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.util.slicedmap.MutableSlicedMap;
+import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
+import org.jetbrains.jet.util.slicedmap.SlicedMapImpl;
+import org.jetbrains.jet.util.slicedmap.WritableSlice;
+
+import java.util.Map;
+
+/**
+ * @author svtk
+ */
+public class DiagnosticWithParameters<T extends PsiElement> extends DiagnosticWithPsiElementImpl<T> {
+
+    private final Map<DiagnosticParameter, Object> map = Maps.newHashMap();
+
+    public DiagnosticWithParameters(DiagnosticWithPsiElement<T> diagnostic) {
+        super(diagnostic.getFactory(), diagnostic.getSeverity(), diagnostic.getMessage(), diagnostic.getPsiElement(), diagnostic.getTextRange());
+    }
+
+    @Override
+    public <P> DiagnosticWithPsiElement<T> add(DiagnosticParameter<P> parameterType, P parameter) {
+        map.put(parameterType, parameter);
+        return this;
+    }
+
+    public <P> P getParameter(DiagnosticParameter<P> parameterType) {
+        return (P) map.get(parameterType);
+    }
+    
+    public <P> boolean hasParameter(DiagnosticParameter<P> parameterType) {
+        return getParameter(parameterType) != null;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElement.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElement.java
new file mode 100644
index 00000000000..c3b8b5b9f8c
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElement.java
@@ -0,0 +1,14 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public interface DiagnosticWithPsiElement<T extends PsiElement> extends DiagnosticWithTextRange {
+    @NotNull
+    T getPsiElement();
+
+    <P> DiagnosticWithPsiElement<T> add(DiagnosticParameter<P> parameterType, P parameter);
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElementImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElementImpl.java
new file mode 100644
index 00000000000..55371d51e1d
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElementImpl.java
@@ -0,0 +1,32 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author svtk
+ */
+public class DiagnosticWithPsiElementImpl<T extends PsiElement> extends GenericDiagnostic implements DiagnosticWithPsiElement<T> {
+    private final T psiElement;
+
+    public DiagnosticWithPsiElementImpl(DiagnosticFactory factory, Severity severity, String message, T psiElement) {
+        this(factory, severity, message, psiElement, psiElement.getTextRange());
+    }
+
+    public DiagnosticWithPsiElementImpl(DiagnosticFactory factory, Severity severity, String message, T psiElement, @NotNull TextRange textRange) {
+        super(factory, severity, message, psiElement.getContainingFile(), textRange);
+        this.psiElement = psiElement;
+    }
+
+    @Override
+    @NotNull
+    public T getPsiElement() {
+        return psiElement;
+    }
+
+    @Override
+    public <P> DiagnosticWithPsiElement<T> add(DiagnosticParameter<P> parameterType, P parameter) {
+        return (new DiagnosticWithParameters<T>(this)).add(parameterType, parameter);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithTextRange.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithTextRange.java
new file mode 100644
index 00000000000..dba4b6f85ea
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithTextRange.java
@@ -0,0 +1,17 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public interface DiagnosticWithTextRange extends Diagnostic {
+    @NotNull
+    TextRange getTextRange();
+
+    @NotNull
+    PsiFile getPsiFile();
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
new file mode 100644
index 00000000000..7cff43d00f5
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
@@ -0,0 +1,393 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.resolve.DescriptorRenderer;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Collection;
+import java.util.Iterator;
+
+import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR;
+import static org.jetbrains.jet.lang.diagnostics.Severity.WARNING;
+
+/**
+ * @author abreslav
+ */
+public interface Errors {
+
+    Renderer NAME = new Renderer() {
+        @NotNull
+        @Override
+        public String render(@Nullable Object object) {
+            if (object == null) return "null";
+            if (object instanceof Named) {
+                return ((Named) object).getName();
+            }
+            return object.toString();
+        }
+    };
+
+    ParameterizedDiagnosticFactory1<Throwable> EXCEPTION_WHILE_ANALYZING = new ParameterizedDiagnosticFactory1<Throwable>(ERROR, "{0}") {
+        @Override
+        protected String makeMessageFor(@NotNull Throwable e) {
+            return e.getClass().getSimpleName() + ": " + e.getMessage();
+        }
+    };
+    UnresolvedReferenceDiagnosticFactory UNRESOLVED_REFERENCE = new UnresolvedReferenceDiagnosticFactory("Unresolved reference");
+    RedeclarationDiagnosticFactory REDECLARATION = RedeclarationDiagnosticFactory.INSTANCE;
+    PsiElementOnlyDiagnosticFactory2<PsiElement, JetType, JetType> TYPE_MISMATCH = PsiElementOnlyDiagnosticFactory2.create(ERROR, "Type mismatch: inferred type is {1} but {0} was expected");
+    ParameterizedDiagnosticFactory1<Collection<JetKeywordToken>> INCOMPATIBLE_MODIFIERS = new ParameterizedDiagnosticFactory1<Collection<JetKeywordToken>>(ERROR, "Incompatible modifiers: ''{0}''") {
+        @Override
+        protected String makeMessageFor(Collection<JetKeywordToken> argument) {
+            StringBuilder sb = new StringBuilder();
+            for (Iterator<JetKeywordToken> iterator = argument.iterator(); iterator.hasNext(); ) {
+                JetKeywordToken modifier =  iterator.next();
+                sb.append(modifier.getValue());
+                if (iterator.hasNext()) {
+                    sb.append(" ");
+                }
+            }
+            return sb.toString();
+        }
+    };
+    ParameterizedDiagnosticFactory1<JetKeywordToken> ILLEGAL_MODIFIER = ParameterizedDiagnosticFactory1.create(ERROR, "Illegal modifier ''{0}''");
+
+    PsiElementOnlyDiagnosticFactory2<JetModifierList, JetKeywordToken, JetKeywordToken> REDUNDANT_MODIFIER = new PsiElementOnlyDiagnosticFactory2<JetModifierList, JetKeywordToken, JetKeywordToken>(Severity.WARNING, "Modifier {0} is redundant because {1} is present") {
+        @NotNull
+        @Override
+        public DiagnosticWithPsiElement<JetModifierList> on(@NotNull JetModifierList elementToBlame, @NotNull ASTNode nodeToMark, @NotNull JetKeywordToken redundantModifier, @NotNull JetKeywordToken presentModifier) {
+            return super.on(elementToBlame, nodeToMark, redundantModifier, presentModifier).add(DiagnosticParameters.MODIFIER, redundantModifier);
+        }
+    };
+    DiagnosticWithParameterFactory<JetModifierList, JetKeywordToken> REDUNDANT_MODIFIER_IN_TRAIT = DiagnosticWithParameterFactory.create(WARNING, "Modifier ''{0}'' is redundant in trait", DiagnosticParameters.MODIFIER);
+    SimplePsiElementOnlyDiagnosticFactory<JetClass> TRAIT_CAN_NOT_BE_FINAL = SimplePsiElementOnlyDiagnosticFactory.create(ERROR, "Trait can not be final");
+    SimpleDiagnosticFactory SAFE_CALLS_ARE_NOT_ALLOWED_ON_NAMESPACES = SimpleDiagnosticFactory.create(ERROR, "Safe calls are not allowed on namespaces");
+    SimpleDiagnosticFactory TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM = SimpleDiagnosticFactory.create(ERROR, "Type checking has run into a recursive problem"); // TODO: message
+    SimpleDiagnosticFactory RETURN_NOT_ALLOWED = SimpleDiagnosticFactory.create(ERROR, "'return' is not allowed here");
+    SimpleDiagnosticFactory PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE = SimpleDiagnosticFactory.create(ERROR, "Projections are not allowed for immediate arguments of a supertype");
+    SimpleDiagnosticFactory LABEL_NAME_CLASH = SimpleDiagnosticFactory.create(WARNING, "There is more than one label with such a name in this scope");
+    SimpleDiagnosticFactory EXPRESSION_EXPECTED_NAMESPACE_FOUND = SimpleDiagnosticFactory.create(ERROR, "Expression expected, but a namespace name found");
+
+    SimpleDiagnosticFactory CANNOT_INFER_PARAMETER_TYPE = SimpleDiagnosticFactory.create(ERROR, "Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) => ...} notation");
+
+    SimpleDiagnosticFactory NO_BACKING_FIELD = SimpleDiagnosticFactory.create(ERROR, "This property does not have a backing field");
+    SimpleDiagnosticFactory MIXING_NAMED_AND_POSITIONED_ARGUMENTS = SimpleDiagnosticFactory.create(ERROR, "Mixing named and positioned arguments in not allowed");
+    SimpleDiagnosticFactory ARGUMENT_PASSED_TWICE = SimpleDiagnosticFactory.create(ERROR, "An argument is already passed for this parameter");
+    UnresolvedReferenceDiagnosticFactory NAMED_PARAMETER_NOT_FOUND = new UnresolvedReferenceDiagnosticFactory("Cannot find a parameter with this name");//SimpleDiagnosticFactory.create(ERROR, "Cannot find a parameter with this name");
+    SimpleDiagnosticFactory VARARG_OUTSIDE_PARENTHESES = SimpleDiagnosticFactory.create(ERROR, "Passing value as a vararg is only allowed inside a parenthesized argument list");
+
+    SimpleDiagnosticFactory MANY_FUNCTION_LITERAL_ARGUMENTS = SimpleDiagnosticFactory.create(ERROR, "Only one function literal is allowed outside a parenthesized argument list");
+    SimpleDiagnosticFactory PROPERTY_WITH_NO_TYPE_NO_INITIALIZER = SimpleDiagnosticFactory.create(ERROR, "This property must either have a type annotation or be initialized");
+
+    SimpleDiagnosticFactory FUNCTION_WITH_NO_TYPE_NO_BODY = SimpleDiagnosticFactory.create(ERROR, "This function must either declare a return type or have a body element");
+    SimplePsiElementOnlyDiagnosticFactory<JetModifierListOwner> ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS = SimplePsiElementOnlyDiagnosticFactory.create(ERROR, "This property cannot be declared abstract");
+    SimplePsiElementOnlyDiagnosticFactory<JetModifierListOwner> ABSTRACT_PROPERTY_NOT_IN_CLASS = SimplePsiElementOnlyDiagnosticFactory.create(ERROR, "A property may be abstract only when defined in a class or trait");
+    DiagnosticWithParameterFactory<JetProperty, JetType> ABSTRACT_PROPERTY_WITH_INITIALIZER = DiagnosticWithParameterFactory.create(ERROR, "Property with initializer cannot be abstract", DiagnosticParameters.TYPE);
+    DiagnosticWithParameterFactory<JetProperty, JetType> ABSTRACT_PROPERTY_WITH_GETTER = DiagnosticWithParameterFactory.create(ERROR, "Property with getter implementation cannot be abstract", DiagnosticParameters.TYPE);
+    DiagnosticWithParameterFactory<JetProperty, JetType> ABSTRACT_PROPERTY_WITH_SETTER = DiagnosticWithParameterFactory.create(ERROR, "Property with setter implementation cannot be abstract", DiagnosticParameters.TYPE);
+    SimpleDiagnosticFactory BACKING_FIELD_IN_TRAIT = SimpleDiagnosticFactory.create(ERROR, "Property in a trait cannot have a backing field");
+    SimpleDiagnosticFactory MUST_BE_INITIALIZED = SimpleDiagnosticFactory.create(ERROR, "Property must be initialized");
+    SimplePsiElementOnlyDiagnosticFactory<JetModifierListOwner> MUST_BE_INITIALIZED_OR_BE_ABSTRACT = SimplePsiElementOnlyDiagnosticFactory.create(ERROR, "Property must be initialized or be abstract");
+    DiagnosticWithParameterFactory<JetProperty, JetType> PROPERTY_INITIALIZER_IN_TRAIT = DiagnosticWithParameterFactory.create(ERROR, "Property initializers are not allowed in traits", DiagnosticParameters.TYPE);
+    SimpleDiagnosticFactory PROPERTY_INITIALIZER_NO_BACKING_FIELD = SimpleDiagnosticFactory.create(ERROR, "Initializer is not allowed here because this property has no backing field");
+    DiagnosticWithParameterFactory<JetProperty, JetClass> PROPERTY_INITIALIZER_NO_PRIMARY_CONSTRUCTOR = DiagnosticWithParameterFactory.create(ERROR, "Property initializers are not allowed when no primary constructor is present", DiagnosticParameters.CLASS);
+    PsiElementOnlyDiagnosticFactory3<JetModifierListOwner, String, ClassDescriptor, JetClass> ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS = new PsiElementOnlyDiagnosticFactory3<JetModifierListOwner, String, ClassDescriptor, JetClass>(ERROR, "Abstract property {0} in non-abstract class {1}") {
+        @NotNull
+        protected DiagnosticWithPsiElement<JetModifierListOwner> on(@NotNull JetModifierListOwner elementToBlame, @NotNull TextRange textRangeToMark, @NotNull String s, @NotNull ClassDescriptor classDescriptor, @NotNull JetClass aClass) {
+            return super.on(elementToBlame, textRangeToMark, s, classDescriptor, aClass).add(DiagnosticParameters.CLASS, aClass);
+        }
+    };
+    PsiElementOnlyDiagnosticFactory3<JetFunctionOrPropertyAccessor, String, ClassDescriptor, JetClass> ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS = new PsiElementOnlyDiagnosticFactory3<JetFunctionOrPropertyAccessor, String, ClassDescriptor, JetClass>(ERROR, "Abstract function {0} in non-abstract class {1}") {
+        @NotNull
+        public DiagnosticWithPsiElement<JetFunctionOrPropertyAccessor> on(@NotNull JetFunctionOrPropertyAccessor elementToBlame, @NotNull ASTNode nodeToMark, @NotNull String s, @NotNull ClassDescriptor classDescriptor, @NotNull JetClass modifierListOwner) {
+            return super.on(elementToBlame, nodeToMark, s, classDescriptor, modifierListOwner).add(DiagnosticParameters.CLASS, modifierListOwner);
+        }
+    };
+    PsiElementOnlyDiagnosticFactory1<JetFunctionOrPropertyAccessor, FunctionDescriptor> ABSTRACT_FUNCTION_WITH_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "A function {0} with body cannot be abstract");
+    PsiElementOnlyDiagnosticFactory1<JetFunctionOrPropertyAccessor, FunctionDescriptor> NON_ABSTRACT_FUNCTION_WITH_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Method {0} without a body must be abstract");
+    PsiElementOnlyDiagnosticFactory1<JetModifierListOwner, FunctionDescriptor> NON_MEMBER_ABSTRACT_FUNCTION = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} is not a class or trait member and cannot be abstract");
+    SimplePsiElementOnlyDiagnosticFactory<JetModifierListOwner> NON_MEMBER_ABSTRACT_ACCESSOR = SimplePsiElementOnlyDiagnosticFactory.create(ERROR, "This property is not a class or trait member and thus cannot have abstract accessors"); // TODO : Better message
+
+    PsiElementOnlyDiagnosticFactory1<JetFunctionOrPropertyAccessor, FunctionDescriptor> NON_MEMBER_FUNCTION_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} must have a body");
+    
+    DiagnosticWithParameterFactory<JetNamedDeclaration, JetClass> NON_FINAL_MEMBER_IN_FINAL_CLASS = DiagnosticWithParameterFactory.create(ERROR, "Non final member in a final class", DiagnosticParameters.CLASS);
+    DiagnosticWithParameterFactory<JetPropertyAccessor, JetProperty> NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY = DiagnosticWithParameterFactory.create(ERROR, "Non final accessor of a final property", DiagnosticParameters.PROPERTY);
+    DiagnosticWithParameterFactory<JetPropertyAccessor, JetProperty> ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY = DiagnosticWithParameterFactory.create(ERROR, "Abstract accessor of a final property", DiagnosticParameters.PROPERTY);
+
+    SimpleDiagnosticFactory PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT = SimpleDiagnosticFactory.create(ERROR, "Projections are not allowed on type arguments of functions and properties"); // TODO : better positioning
+    SimpleDiagnosticFactory SUPERTYPE_NOT_INITIALIZED = SimpleDiagnosticFactory.create(ERROR, "This type has a constructor, and thus must be initialized here");
+    SimpleDiagnosticFactory SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY = SimpleDiagnosticFactory.create(ERROR, "A secondary constructor may appear only in a class that has a primary constructor");
+    SimpleDiagnosticFactory SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST = SimpleDiagnosticFactory.create(ERROR, "Secondary constructors must have an initializer list");
+    SimpleDiagnosticFactory BY_IN_SECONDARY_CONSTRUCTOR = SimpleDiagnosticFactory.create(ERROR, "'by'-clause is only supported for primary constructors");
+    SimpleDiagnosticFactory INITIALIZER_WITH_NO_ARGUMENTS = SimpleDiagnosticFactory.create(ERROR, "Constructor arguments required");
+    SimpleDiagnosticFactory MANY_CALLS_TO_THIS = SimpleDiagnosticFactory.create(ERROR, "Only one call to 'this(...)' is allowed");
+    PsiElementOnlyDiagnosticFactory1<JetModifierListOwner, CallableMemberDescriptor> NOTHING_TO_OVERRIDE = PsiElementOnlyDiagnosticFactory1.create(ERROR, "{0} overrides nothing", DescriptorRenderer.TEXT);
+    PsiElementOnlyDiagnosticFactory1<JetClass, PropertyDescriptor> PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "This class must have a primary constructor, because property {0} has a backing field");
+    ParameterizedDiagnosticFactory1<JetClassOrObject> PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL = new ParameterizedDiagnosticFactory1<JetClassOrObject>(ERROR, "Class {0} must have a constructor in order to be able to initialize supertypes") {
+        @Override
+        protected String makeMessageFor(@NotNull JetClassOrObject argument) {
+            return JetPsiUtil.safeName(argument.getName());
+        }
+    };
+    PsiElementOnlyDiagnosticFactory3<JetModifierListOwner, CallableMemberDescriptor, CallableMemberDescriptor, DeclarationDescriptor> VIRTUAL_MEMBER_HIDDEN = PsiElementOnlyDiagnosticFactory3.create(ERROR, "''{0}'' hides ''{1}'' in class {2} and needs 'override' modifier", DescriptorRenderer.TEXT);
+
+    SimpleDiagnosticFactory UNREACHABLE_CODE = SimpleDiagnosticFactory.create(ERROR, "Unreachable code");
+    ParameterizedDiagnosticFactory1<String> UNREACHABLE_BECAUSE_OF_NOTHING = ParameterizedDiagnosticFactory1.create(ERROR, "This code is unreachable, because ''{0}'' never terminates normally");
+
+    SimpleDiagnosticFactory MANY_CLASS_OBJECTS = SimpleDiagnosticFactory.create(ERROR, "Only one class object is allowed per class");
+    SimpleDiagnosticFactory CLASS_OBJECT_NOT_ALLOWED = SimpleDiagnosticFactory.create(ERROR, "A class object is not allowed here");
+    SimpleDiagnosticFactory DELEGATION_IN_TRAIT = SimpleDiagnosticFactory.create(ERROR, "Traits cannot use delegation");
+    SimpleDiagnosticFactory DELEGATION_NOT_TO_TRAIT = SimpleDiagnosticFactory.create(ERROR, "Only traits can be delegated to");
+    SimpleDiagnosticFactory NO_CONSTRUCTOR = SimpleDiagnosticFactory.create(ERROR, "This class does not have a constructor");
+    SimpleDiagnosticFactory NOT_A_CLASS = SimpleDiagnosticFactory.create(ERROR, "Not a class");
+    SimpleDiagnosticFactory ILLEGAL_ESCAPE_SEQUENCE = SimpleDiagnosticFactory.create(ERROR, "Illegal escape sequence");
+
+    SimpleDiagnosticFactory LOCAL_EXTENSION_PROPERTY = SimpleDiagnosticFactory.create(ERROR, "Local extension properties are not allowed");
+    SimpleDiagnosticFactory LOCAL_VARIABLE_WITH_GETTER = SimpleDiagnosticFactory.create(ERROR, "Local variables are not allowed to have getters");
+    SimpleDiagnosticFactory LOCAL_VARIABLE_WITH_SETTER = SimpleDiagnosticFactory.create(ERROR, "Local variables are not allowed to have setters");
+    SimplePsiElementOnlyDiagnosticFactory<JetProperty> VAL_WITH_SETTER = SimplePsiElementOnlyDiagnosticFactory.create(ERROR, "A 'val'-property cannot have a setter");
+
+    SimpleDiagnosticFactory EQUALS_MISSING = SimpleDiagnosticFactory.create(ERROR, "No method 'equals(Any?) : Boolean' available");
+    SimpleDiagnosticFactory ASSIGNMENT_IN_EXPRESSION_CONTEXT = SimpleDiagnosticFactory.create(ERROR, "Assignments are not expressions, and only expressions are allowed in this context");
+    SimpleDiagnosticFactory NAMESPACE_IS_NOT_AN_EXPRESSION = SimpleDiagnosticFactory.create(ERROR, "'namespace' is not an expression");
+    SimpleDiagnosticFactory DECLARATION_IN_ILLEGAL_CONTEXT = SimpleDiagnosticFactory.create(ERROR, "Declarations are not allowed in this position");
+    SimpleDiagnosticFactory REF_SETTER_PARAMETER = SimpleDiagnosticFactory.create(ERROR, "Setter parameters can not be 'ref'");
+    SimpleDiagnosticFactory SETTER_PARAMETER_WITH_DEFAULT_VALUE = SimpleDiagnosticFactory.create(ERROR, "Setter parameters can not have default values");
+    SimpleDiagnosticFactory NO_THIS = SimpleDiagnosticFactory.create(ERROR, "'this' is not defined in this context");
+    SimpleDiagnosticFactory NOT_A_SUPERTYPE = SimpleDiagnosticFactory.create(ERROR, "Not a supertype");
+    SimpleDiagnosticFactory NO_WHEN_ENTRIES = SimpleDiagnosticFactory.create(ERROR, "Entries are required for when-expression"); // TODO : Scope, and maybe this should not be an error
+    SimplePsiElementOnlyDiagnosticFactory<JetBinaryExpressionWithTypeRHS> USELESS_CAST_STATIC_ASSERT_IS_FINE = SimplePsiElementOnlyDiagnosticFactory.create(WARNING, "No cast needed, use ':' instead");
+    SimplePsiElementOnlyDiagnosticFactory<JetBinaryExpressionWithTypeRHS> USELESS_CAST = SimplePsiElementOnlyDiagnosticFactory.create(WARNING, "No cast needed");
+    SimpleDiagnosticFactory CAST_NEVER_SUCCEEDS = SimpleDiagnosticFactory.create(WARNING, "This cast can never succeed");
+    DiagnosticWithParameterFactory<JetPropertyAccessor, JetType> WRONG_SETTER_PARAMETER_TYPE = DiagnosticWithParameterFactory.create(ERROR, "Setter parameter type must be equal to the type of the property, i.e. {0}", DiagnosticParameters.TYPE);
+    DiagnosticWithParameterFactory<JetPropertyAccessor, JetType> WRONG_GETTER_RETURN_TYPE = DiagnosticWithParameterFactory.create(ERROR, "Getter return type must be equal to the type of the property, i.e. {0}", DiagnosticParameters.TYPE);
+    ParameterizedDiagnosticFactory1<ClassifierDescriptor> NO_CLASS_OBJECT = ParameterizedDiagnosticFactory1.create(ERROR, "Classifier {0} does not have a class object", NAME);
+    SimpleDiagnosticFactory NO_GENERICS_IN_SUPERTYPE_SPECIFIER = SimpleDiagnosticFactory.create(ERROR, "Generic arguments of the base type must be specified");
+
+    SimpleDiagnosticFactory HAS_NEXT_PROPERTY_AND_FUNCTION_AMBIGUITY = SimpleDiagnosticFactory.create(ERROR, "An ambiguity between 'iterator().hasNext()' function and 'iterator().hasNext' property");
+    SimpleDiagnosticFactory HAS_NEXT_MISSING = SimpleDiagnosticFactory.create(ERROR, "Loop range must have an 'iterator().hasNext()' function or an 'iterator().hasNext' property");
+    SimpleDiagnosticFactory HAS_NEXT_FUNCTION_AMBIGUITY = SimpleDiagnosticFactory.create(ERROR, "Function 'iterator().hasNext()' is ambiguous for this expression");
+    SimpleDiagnosticFactory HAS_NEXT_MUST_BE_READABLE = SimpleDiagnosticFactory.create(ERROR, "The 'iterator().hasNext' property of the loop range must be readable");
+    ParameterizedDiagnosticFactory1<JetType> HAS_NEXT_PROPERTY_TYPE_MISMATCH = ParameterizedDiagnosticFactory1.create(ERROR, "The 'iterator().hasNext' property of the loop range must return Boolean, but returns {0}");
+    ParameterizedDiagnosticFactory1<JetType> HAS_NEXT_FUNCTION_TYPE_MISMATCH = ParameterizedDiagnosticFactory1.create(ERROR, "The 'iterator().hasNext()' function of the loop range must return Boolean, but returns {0}");
+    SimpleDiagnosticFactory NEXT_AMBIGUITY = SimpleDiagnosticFactory.create(ERROR, "Function 'iterator().next()' is ambiguous for this expression");
+    SimpleDiagnosticFactory NEXT_MISSING = SimpleDiagnosticFactory.create(ERROR, "Loop range must have an 'iterator().next()' function");
+    SimpleDiagnosticFactory ITERATOR_MISSING = SimpleDiagnosticFactory.create(ERROR, "For-loop range must have an iterator() method");
+    AmbiguousDescriptorDiagnosticFactory ITERATOR_AMBIGUITY = AmbiguousDescriptorDiagnosticFactory.create("Method 'iterator()' is ambiguous for this expression: {0}");
+
+    ParameterizedDiagnosticFactory1<JetType> COMPARE_TO_TYPE_MISMATCH = ParameterizedDiagnosticFactory1.create(ERROR, "compareTo() must return Int, but returns {0}");
+
+    SimpleDiagnosticFactory RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY = SimpleDiagnosticFactory.create(ERROR, "Returns are not allowed for functions with expression body. Use block body in '{...}'");
+    SimpleDiagnosticFactory NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY = SimpleDiagnosticFactory.create(ERROR, "A 'return' expression required in a function with a block body ('{...}')");
+    ParameterizedDiagnosticFactory1<JetType> RETURN_TYPE_MISMATCH = ParameterizedDiagnosticFactory1.create(ERROR, "This function must return a value of type {0}");
+
+    ParameterizedDiagnosticFactory1<JetType> UPPER_BOUND_VIOLATED = ParameterizedDiagnosticFactory1.create(ERROR, "An upper bound {0} is violated"); // TODO : Message
+    ParameterizedDiagnosticFactory1<JetType> FINAL_CLASS_OBJECT_UPPER_BOUND = ParameterizedDiagnosticFactory1.create(ERROR, "{0} is a final type, and thus a class object cannot extend it");
+    ParameterizedDiagnosticFactory1<JetType> FINAL_UPPER_BOUND = ParameterizedDiagnosticFactory1.create(WARNING, "{0} is a final type, and thus a value of the type parameter is predetermined");
+    PsiElementOnlyDiagnosticFactory1<JetBinaryExpression, JetType> USELESS_ELVIS = PsiElementOnlyDiagnosticFactory1.create(WARNING, "Elvis operator (?:) always returns the left operand of non-nullable type {0}");
+    ParameterizedDiagnosticFactory1<TypeParameterDescriptor> CONFLICTING_UPPER_BOUNDS = new ParameterizedDiagnosticFactory1<TypeParameterDescriptor>(ERROR, "Upper bounds of {0} have empty intersection") {
+        @Override
+        protected String makeMessageFor(@NotNull TypeParameterDescriptor argument) {
+            return argument.getName();
+        }
+    };
+    ParameterizedDiagnosticFactory1<TypeParameterDescriptor> CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS = ParameterizedDiagnosticFactory1.create(ERROR, "Class object upper bounds of {0} have empty intersection", NAME);
+
+    ParameterizedDiagnosticFactory1<CallableDescriptor> TOO_MANY_ARGUMENTS = ParameterizedDiagnosticFactory1.create(ERROR, "Too many arguments for {0}");
+    ParameterizedDiagnosticFactory1<String> ERROR_COMPILE_TIME_VALUE = ParameterizedDiagnosticFactory1.create(ERROR, "{0}");
+
+    SimpleDiagnosticFactory ELSE_MISPLACED_IN_WHEN = SimpleDiagnosticFactory.create(ERROR, "'else' entry must be the last one in a when-expression");
+    SimpleDiagnosticFactory CYCLIC_INHERITANCE_HIERARCHY = SimpleDiagnosticFactory.create(ERROR, "There's a cycle in the inheritance hierarchy for this type");
+
+    SimpleDiagnosticFactory MANY_CLASSES_IN_SUPERTYPE_LIST = SimpleDiagnosticFactory.create(ERROR, "Only one class may appear in a supertype list");
+    SimpleDiagnosticFactory SUPERTYPE_NOT_A_CLASS_OR_TRAIT = SimpleDiagnosticFactory.create(ERROR, "Only classes and traits may serve as supertypes");
+    SimpleDiagnosticFactory SUPERTYPE_INITIALIZED_IN_TRAIT = SimpleDiagnosticFactory.create(ERROR, "Traits cannot initialize supertypes");
+    SimpleDiagnosticFactory CONSTRUCTOR_IN_TRAIT = SimpleDiagnosticFactory.create(ERROR, "A trait may not have a constructor");
+    SimpleDiagnosticFactory SUPERTYPE_APPEARS_TWICE = SimpleDiagnosticFactory.create(ERROR, "A supertype appears twice");
+    SimpleDiagnosticFactory FINAL_SUPERTYPE = SimpleDiagnosticFactory.create(ERROR, "This type is final, so it cannot be inherited from");
+
+    SimpleDiagnosticFactory REF_PARAMETER_WITH_VAL_OR_VAR = SimpleDiagnosticFactory.create(ERROR, "'val' and 'var' are not allowed on ref-parameters");
+    SimpleDiagnosticFactory VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION = SimpleDiagnosticFactory.create(ERROR, "A type annotation is required on a value parameter");
+    SimpleDiagnosticFactory BREAK_OR_CONTINUE_OUTSIDE_A_LOOP = SimpleDiagnosticFactory.create(ERROR, "'break' and 'continue' are only allowed inside a loop");
+    ParameterizedDiagnosticFactory1<String> NOT_A_LOOP_LABEL = ParameterizedDiagnosticFactory1.create(ERROR, "The label ''{0}'' does not denote a loop");
+
+    SimpleDiagnosticFactory ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR = SimpleDiagnosticFactory.create(ERROR, "Anonymous initializers are only allowed in the presence of a primary constructor");
+    SimpleDiagnosticFactory NULLABLE_SUPERTYPE = SimpleDiagnosticFactory.create(ERROR, "A supertype cannot be nullable");
+    ParameterizedDiagnosticFactory1<JetType> UNSAFE_CALL = ParameterizedDiagnosticFactory1.create(ERROR, "Only safe calls (?.) are allowed on a nullable receiver of type {0}");
+    SimpleDiagnosticFactory AMBIGUOUS_LABEL = SimpleDiagnosticFactory.create(ERROR, "Ambiguous label");
+    ParameterizedDiagnosticFactory1<String> UNSUPPORTED = ParameterizedDiagnosticFactory1.create(ERROR, "Unsupported [{0}]");
+    PsiElementOnlyDiagnosticFactory1<JetElement, JetType> UNNECESSARY_SAFE_CALL = PsiElementOnlyDiagnosticFactory1.create(WARNING, "Unnecessary safe call on a non-null receiver of type {0}");
+    ParameterizedDiagnosticFactory2<JetTypeConstraint, JetTypeParameterListOwner> NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER = new ParameterizedDiagnosticFactory2<JetTypeConstraint, JetTypeParameterListOwner>(ERROR, "{0} does not refer to a type parameter of {1}") {
+        @Override
+        protected String makeMessageForA(@NotNull JetTypeConstraint jetTypeConstraint) {
+            return jetTypeConstraint.getSubjectTypeParameterName().getReferencedName();
+        }
+
+        @Override
+        protected String makeMessageForB(@NotNull JetTypeParameterListOwner constraintOwner) {
+            return constraintOwner.getName();
+        }
+    };
+    ParameterizedDiagnosticFactory2<JetType, VariableDescriptor> AUTOCAST_IMPOSSIBLE = ParameterizedDiagnosticFactory2.create(ERROR, "Automatic cast to {0} is impossible, because variable {1} is mutable", NAME);
+
+    ParameterizedDiagnosticFactory2<JetType, JetType> TYPE_MISMATCH_IN_FOR_LOOP = ParameterizedDiagnosticFactory2.create(ERROR, "The loop iterates over values of type {0} but the parameter is declared to be {1}");
+    ParameterizedDiagnosticFactory1<JetType> TYPE_MISMATCH_IN_CONDITION = ParameterizedDiagnosticFactory1.create(ERROR, "Condition must be of type Boolean, but was of type {0}");
+    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}");
+    
+    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) {
+            return typeParameterDescriptor.getName();
+        }
+
+        @Override
+        protected String makeMessageForB(@NotNull ClassDescriptor classDescriptor) {
+            return DescriptorRenderer.TEXT.render(classDescriptor);
+        }
+
+        @Override
+        protected String makeMessageForC(@NotNull Collection<JetType> jetTypes) {
+            StringBuilder builder = new StringBuilder();
+            for (Iterator<JetType> iterator = jetTypes.iterator(); iterator.hasNext(); ) {
+                JetType jetType = iterator.next();
+                builder.append(jetType);
+                if (iterator.hasNext()) {
+                    builder.append(", ");
+                }
+            }
+            return builder.toString();
+        }
+    };
+    
+    ParameterizedDiagnosticFactory3<JetSimpleNameExpression, JetType, JetType> EQUALITY_NOT_APPLICABLE = new ParameterizedDiagnosticFactory3<JetSimpleNameExpression, JetType, JetType>(ERROR, "Operator {0} cannot be applied to {1} and {2}") {
+        @Override
+        protected String makeMessageForA(@NotNull JetSimpleNameExpression nameExpression) {
+            return nameExpression.getReferencedName();
+        }
+    };
+    ParameterizedDiagnosticFactory2<CallableMemberDescriptor, DeclarationDescriptor> OVERRIDING_FINAL_MEMBER = ParameterizedDiagnosticFactory2.create(ERROR, "{0} in {1} is final and cannot be overridden", NAME);
+
+    ParameterizedDiagnosticFactory2<CallableMemberDescriptor, CallableMemberDescriptor> RETURN_TYPE_MISMATCH_ON_OVERRIDE = new ParameterizedDiagnosticFactory2<CallableMemberDescriptor, CallableMemberDescriptor>(ERROR, "Return type of {0} is not a subtype of the return type overridden member {1}") {
+        @NotNull
+        @Override
+        public TextRange getTextRange(@NotNull Diagnostic diagnostic) {
+            PsiElement psiElement = ((DiagnosticWithPsiElement) diagnostic).getPsiElement();
+            JetTypeReference returnTypeRef = null;
+            ASTNode nameNode = null;
+            if (psiElement instanceof JetNamedFunction) {
+                JetFunction function = (JetNamedFunction) psiElement;
+                returnTypeRef = function.getReturnTypeRef();
+                nameNode = getNameNode(function);
+            }
+            else if (psiElement instanceof JetProperty) {
+                JetProperty property = (JetProperty) psiElement;
+                returnTypeRef = property.getPropertyTypeRef();
+                nameNode = getNameNode(property);
+            }
+            else if (psiElement instanceof JetPropertyAccessor) {
+                JetPropertyAccessor accessor = (JetPropertyAccessor) psiElement;
+                returnTypeRef = accessor.getReturnTypeReference();
+                nameNode = accessor.getNamePlaceholder().getNode();
+            }
+            if (returnTypeRef != null) return returnTypeRef.getTextRange();
+            if (nameNode != null) return nameNode.getTextRange();
+            return super.getTextRange(diagnostic);
+        }
+
+        private ASTNode getNameNode(JetNamedDeclaration function) {
+            PsiElement nameIdentifier = function.getNameIdentifier();
+            return nameIdentifier == null ? null : nameIdentifier.getNode();
+        }
+
+        @Override
+        protected String makeMessageForA(@NotNull CallableMemberDescriptor callableMemberDescriptor) {
+            return DescriptorRenderer.TEXT.render(callableMemberDescriptor);
+        }
+
+        @Override
+        protected String makeMessageForB(@NotNull CallableMemberDescriptor callableMemberDescriptor) {
+            return DescriptorRenderer.TEXT.render(callableMemberDescriptor);
+        }
+    };
+
+    ParameterizedDiagnosticFactory2<PropertyDescriptor, PropertyDescriptor> VAR_OVERRIDDEN_BY_VAL = new ParameterizedDiagnosticFactory2<PropertyDescriptor, PropertyDescriptor>(ERROR, "Var-property {0} cannot be overridden by val-property {1}", DescriptorRenderer.TEXT);
+
+    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();
+        }
+
+        @Override
+        protected String makeMessageForB(@NotNull CallableMemberDescriptor memberDescriptor) {
+            return DescriptorRenderer.TEXT.render(memberDescriptor);
+        }
+    };
+
+    ParameterizedDiagnosticFactory2<JetClassOrObject, CallableMemberDescriptor> MANY_IMPL_MEMBER_NOT_IMPLEMENTED = new ParameterizedDiagnosticFactory2<JetClassOrObject, CallableMemberDescriptor>(ERROR, "Class ''{0}'' must override {1} because it inherits many implementations of it") {
+        @Override
+        protected String makeMessageForA(@NotNull JetClassOrObject jetClassOrObject) {
+            return jetClassOrObject.getName();
+        }
+
+        @Override
+        protected String makeMessageForB(@NotNull CallableMemberDescriptor memberDescriptor) {
+            return DescriptorRenderer.TEXT.render(memberDescriptor);
+        }
+    };
+
+    ParameterizedDiagnosticFactory3<String, JetType, JetType> RESULT_TYPE_MISMATCH = ParameterizedDiagnosticFactory3.create(ERROR, "{0} must return {1} but returns {2}");
+    ParameterizedDiagnosticFactory3<String, String, String> UNSAFE_INFIX_CALL = ParameterizedDiagnosticFactory3.create(ERROR, "Infix call corresponds to a dot-qualified call ''{0}.{1}({2})' which is not allowed on a nullable receiver ''{0}''. Use '?.'-qualified call instead");
+
+    ParameterizedDiagnosticFactory1<Collection<? extends CallableDescriptor>> OVERLOAD_RESOLUTION_AMBIGUITY = new AmbiguousDescriptorDiagnosticFactory("Overload resolution ambiguity: {0}");
+    ParameterizedDiagnosticFactory1<Collection<? extends CallableDescriptor>> NONE_APPLICABLE = new AmbiguousDescriptorDiagnosticFactory("None of the following functions can be called with the arguments supplied: {0}");
+    ParameterizedDiagnosticFactory1<ValueParameterDescriptor> NO_VALUE_FOR_PARAMETER = ParameterizedDiagnosticFactory1.create(ERROR, "No value passed for parameter {0}", DescriptorRenderer.TEXT);
+    ParameterizedDiagnosticFactory1<JetType> MISSING_RECEIVER = ParameterizedDiagnosticFactory1.create(ERROR, "A receiver of type {0} is required");
+    SimpleDiagnosticFactory NO_RECEIVER_ADMITTED = SimpleDiagnosticFactory.create(ERROR, "No receiver can be passed to this function or property");
+
+    SimpleDiagnosticFactory CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS = SimpleDiagnosticFactory.create(ERROR, "Can not create an instance of an abstract class");
+    SimpleDiagnosticFactory TYPE_INFERENCE_FAILED = SimpleDiagnosticFactory.create(ERROR, "Type inference failed");
+    ParameterizedDiagnosticFactory1<Integer> WRONG_NUMBER_OF_TYPE_ARGUMENTS = new ParameterizedDiagnosticFactory1<Integer>(ERROR, "{0} type arguments expected") {
+        @Override
+        protected String makeMessageFor(@NotNull Integer argument) {
+            return argument == 0 ? "No" : argument.toString();
+        }
+    };
+
+
+    // This field is needed to make the Initializer class load (interfaces cannot have static initializers)
+    @SuppressWarnings("UnusedDeclaration")
+    Initializer __initializer = Initializer.INSTANCE;
+    class Initializer {
+        static {
+            for (Field field : Errors.class.getFields()) {
+                if ((field.getModifiers() & Modifier.STATIC) != 0) {
+                    try {
+                        Object value = field.get(null);
+                        if (value instanceof AbstractDiagnosticFactory) {
+                            AbstractDiagnosticFactory factory = (AbstractDiagnosticFactory) value;
+                            factory.setName(field.getName());
+                        }
+                    }
+                    catch (IllegalAccessException e) {
+                        throw new IllegalStateException(e);
+                    }
+                }
+            }
+        }
+        private static final Initializer INSTANCE = new Initializer();
+        private Initializer() {};
+    }
+    
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/GenericDiagnostic.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/GenericDiagnostic.java
new file mode 100644
index 00000000000..db13595aeb8
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/GenericDiagnostic.java
@@ -0,0 +1,54 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+* @author abreslav
+*/
+public class GenericDiagnostic implements DiagnosticWithTextRange {
+
+    private final TextRange textRange;
+    private final String message;
+    private final DiagnosticFactory factory;
+    private final Severity severity;
+    private final PsiFile psiFile;
+
+    public GenericDiagnostic(DiagnosticFactory factory, Severity severity, String message, @NotNull PsiFile psiFile, @NotNull TextRange textRange) {
+        this.factory = factory;
+        this.textRange = textRange;
+        this.severity = severity;
+        this.message = message;
+        this.psiFile = psiFile;
+    }
+
+    @NotNull
+    @Override
+    public DiagnosticFactory getFactory() {
+        return factory;
+    }
+
+    @NotNull
+    public TextRange getTextRange() {
+        return textRange;
+    }
+
+    @NotNull
+    @Override
+    public PsiFile getPsiFile() {
+        return psiFile;
+    }
+
+    @NotNull
+    @Override
+    public String getMessage() {
+        return message;
+    }
+
+    @NotNull
+    @Override
+    public Severity getSeverity() {
+        return severity;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory1.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory1.java
new file mode 100644
index 00000000000..e22b08002c0
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory1.java
@@ -0,0 +1,38 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+* @author abreslav
+*/
+public class ParameterizedDiagnosticFactory1<A> extends DiagnosticFactoryWithPsiElement1<PsiElement, A> {
+    public static <T> ParameterizedDiagnosticFactory1<T> create(Severity severity, String messageStub) {
+        return new ParameterizedDiagnosticFactory1<T>(severity, messageStub);
+    }
+
+    public static <T> ParameterizedDiagnosticFactory1<T> create(Severity severity, String messageStub, Renderer renderer) {
+        return new ParameterizedDiagnosticFactory1<T>(severity, messageStub, renderer);
+    }
+
+    public ParameterizedDiagnosticFactory1(Severity severity, String message, Renderer renderer) {
+        super(severity, message, renderer);
+    }
+
+    public ParameterizedDiagnosticFactory1(Severity severity, String message) {
+        super(severity, message);
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull PsiFile psiFile, @NotNull TextRange rangeToMark, @NotNull A argument) {
+        return new GenericDiagnostic(this, severity, makeMessage(argument), psiFile, rangeToMark);
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull ASTNode nodeToMark, @NotNull A argument) {
+        return on(DiagnosticUtils.getContainingFile(nodeToMark), nodeToMark.getTextRange(), argument);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory2.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory2.java
new file mode 100644
index 00000000000..c25fcc78f86
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory2.java
@@ -0,0 +1,39 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+* @author abreslav
+*/
+public class ParameterizedDiagnosticFactory2<A, B> extends DiagnosticFactoryWithPsiElement2<PsiElement, A,B> {
+    public static <A, B> ParameterizedDiagnosticFactory2<A, B> create(Severity severity, String messageStub) {
+        return new ParameterizedDiagnosticFactory2<A, B>(severity, messageStub);
+    }
+
+    public static <A, B> ParameterizedDiagnosticFactory2<A, B> create(Severity severity, String messageStub, Renderer renderer) {
+        return new ParameterizedDiagnosticFactory2<A, B>(severity, messageStub, renderer);
+    }
+
+    public ParameterizedDiagnosticFactory2(Severity severity, String message, Renderer renderer) {
+        super(severity, message, renderer);
+    }
+
+    public ParameterizedDiagnosticFactory2(Severity severity, String messageStub) {
+        super(severity, messageStub);
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull PsiFile psiFile, @NotNull TextRange rangeToMark, @NotNull A a, @NotNull B b) {
+        return new GenericDiagnostic(this, severity, makeMessage(a, b), psiFile, rangeToMark);
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull ASTNode nodeToMark, @NotNull A a, @NotNull B b) {
+        return on(DiagnosticUtils.getContainingFile(nodeToMark), nodeToMark.getTextRange(), a, b);
+    }
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory3.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory3.java
new file mode 100644
index 00000000000..aefdcb8c876
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory3.java
@@ -0,0 +1,38 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+* @author abreslav
+*/
+public class ParameterizedDiagnosticFactory3<A, B, C> extends DiagnosticFactoryWithPsiElement3<PsiElement, A, B, C> {
+    public static <A, B, C> ParameterizedDiagnosticFactory3<A, B, C> create(Severity severity, String messageStub) {
+        return new ParameterizedDiagnosticFactory3<A, B, C>(severity, messageStub);
+    }
+
+    public static <A, B, C> ParameterizedDiagnosticFactory3<A, B, C> create(Severity severity, String messageStub, Renderer renderer) {
+        return new ParameterizedDiagnosticFactory3<A, B, C>(severity, messageStub, renderer);
+    }
+
+    public ParameterizedDiagnosticFactory3(Severity severity, String messageStub, Renderer renderer) {
+        super(severity, messageStub, renderer);
+    }
+
+    protected ParameterizedDiagnosticFactory3(Severity severity, String messageStub) {
+        super(severity, messageStub);
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull PsiFile psiFile, @NotNull TextRange rangeToMark, @NotNull A a, @NotNull B b, @NotNull C c) {
+        return new GenericDiagnostic(this, severity, makeMessage(a, b, c), psiFile, rangeToMark);
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull ASTNode nodeToMark, @NotNull A a, @NotNull B b, @NotNull C c) {
+        return on(DiagnosticUtils.getContainingFile(nodeToMark), nodeToMark.getTextRange(), a, b, c);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory.java
new file mode 100644
index 00000000000..6cf335b2a35
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory.java
@@ -0,0 +1,9 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.psi.PsiElement;
+
+/**
+ * @author svtk
+ */
+public interface PsiElementOnlyDiagnosticFactory<T extends PsiElement> extends DiagnosticFactory {
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory1.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory1.java
new file mode 100644
index 00000000000..bd7a89b5af6
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory1.java
@@ -0,0 +1,23 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.psi.PsiElement;
+/**
+ * @author svtk
+ */
+public class PsiElementOnlyDiagnosticFactory1<T extends PsiElement, A> extends DiagnosticFactoryWithPsiElement1<T, A> implements PsiElementOnlyDiagnosticFactory<T> {
+    public static <T extends PsiElement, A> PsiElementOnlyDiagnosticFactory1<T, A> create(Severity severity, String messageStub) {
+        return new PsiElementOnlyDiagnosticFactory1<T, A>(severity, messageStub);
+    }
+
+    public static <T extends PsiElement, A> PsiElementOnlyDiagnosticFactory1<T, A> create(Severity severity, String messageStub, Renderer renderer) {
+        return new PsiElementOnlyDiagnosticFactory1<T, A>(severity, messageStub, renderer);
+    }
+
+    public PsiElementOnlyDiagnosticFactory1(Severity severity, String message, Renderer renderer) {
+        super(severity, message, renderer);
+    }
+
+    protected PsiElementOnlyDiagnosticFactory1(Severity severity, String message) {
+        super(severity, message);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory2.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory2.java
new file mode 100644
index 00000000000..5e34f33c0fc
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory2.java
@@ -0,0 +1,24 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.psi.PsiElement;
+
+/**
+ * @author svtk
+ */
+public class PsiElementOnlyDiagnosticFactory2<T extends PsiElement, A, B> extends DiagnosticFactoryWithPsiElement2<T, A, B> implements PsiElementOnlyDiagnosticFactory<T> {
+    public static <T extends PsiElement, A, B> PsiElementOnlyDiagnosticFactory2<T, A, B> create(Severity severity, String messageStub, Renderer renderer) {
+        return new PsiElementOnlyDiagnosticFactory2<T, A, B>(severity, messageStub, renderer);
+    }
+
+    public static <T extends PsiElement, A, B> PsiElementOnlyDiagnosticFactory2<T, A, B> create(Severity severity, String messageStub) {
+        return new PsiElementOnlyDiagnosticFactory2<T, A, B>(severity, messageStub);
+    }
+
+    public PsiElementOnlyDiagnosticFactory2(Severity severity, String message, Renderer renderer) {
+        super(severity, message, renderer);
+    }
+
+    protected PsiElementOnlyDiagnosticFactory2(Severity severity, String message) {
+        super(severity, message);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory3.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory3.java
new file mode 100644
index 00000000000..a793ea0f3ac
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PsiElementOnlyDiagnosticFactory3.java
@@ -0,0 +1,23 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.psi.PsiElement;
+/**
+ * @author svtk
+ */
+public class PsiElementOnlyDiagnosticFactory3<T extends PsiElement, A, B, C> extends DiagnosticFactoryWithPsiElement3<T, A, B, C> implements PsiElementOnlyDiagnosticFactory<T> {
+    public static <T extends PsiElement, A, B, C> PsiElementOnlyDiagnosticFactory3<T, A, B, C> create(Severity severity, String messageStub) {
+        return new PsiElementOnlyDiagnosticFactory3<T, A, B, C>(severity, messageStub);
+    }
+
+    public static <T extends PsiElement, A, B, C> PsiElementOnlyDiagnosticFactory3<T, A, B, C> create(Severity severity, String messageStub, Renderer renderer) {
+        return new PsiElementOnlyDiagnosticFactory3<T, A, B, C>(severity, messageStub, renderer);
+    }
+
+    protected PsiElementOnlyDiagnosticFactory3(Severity severity, String messageStub) {
+        super(severity, messageStub);
+    }
+
+    public PsiElementOnlyDiagnosticFactory3(Severity severity, String messageStub, Renderer renderer) {
+        super(severity, messageStub, renderer);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnostic.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnostic.java
new file mode 100644
index 00000000000..9092b9edf19
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnostic.java
@@ -0,0 +1,84 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+
+import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR;
+
+/**
+ * @author abreslav
+ */
+public interface RedeclarationDiagnostic extends DiagnosticWithPsiElement<PsiElement> {
+    public class SimpleRedeclarationDiagnostic extends DiagnosticWithPsiElementImpl<PsiElement> implements RedeclarationDiagnostic {
+
+        public SimpleRedeclarationDiagnostic(@NotNull PsiElement psiElement) {
+            super(RedeclarationDiagnosticFactory.INSTANCE, ERROR, "Redeclaration", psiElement);
+        }
+    }
+
+    public class RedeclarationDiagnosticWithDeferredResolution implements RedeclarationDiagnostic {
+        
+        private final DeclarationDescriptor duplicatingDescriptor;
+        private final BindingContext contextToResolveToDeclaration;
+        private PsiElement element;
+
+        public RedeclarationDiagnosticWithDeferredResolution(@NotNull DeclarationDescriptor duplicatingDescriptor, @NotNull BindingContext contextToResolveToDeclaration) {
+            this.duplicatingDescriptor = duplicatingDescriptor;
+            this.contextToResolveToDeclaration = contextToResolveToDeclaration;
+        }
+
+        private PsiElement resolve() {
+            if (element == null) {
+                element = contextToResolveToDeclaration.get(BindingContext.DESCRIPTOR_TO_DECLARATION, duplicatingDescriptor);
+                assert element != null : "No element for descriptor: " + duplicatingDescriptor;
+                }
+            return element;
+        }
+        
+        @NotNull
+        @Override
+        public PsiElement getPsiElement() {
+            return resolve();
+        }
+
+        @NotNull
+        @Override
+        public TextRange getTextRange() {
+            return resolve().getTextRange();
+        }
+
+        @NotNull
+        @Override
+        public PsiFile getPsiFile() {
+            return resolve().getContainingFile();
+        }
+
+        @NotNull
+        @Override
+        public DiagnosticFactory getFactory() {
+            return Errors.REDECLARATION;
+        }
+
+        @NotNull
+        @Override
+        public String getMessage() {
+            return "Redeclaration";
+        }
+
+        @NotNull
+        @Override
+        public Severity getSeverity() {
+            return ERROR;
+        }
+
+        @Override
+        public <P> DiagnosticWithPsiElement<PsiElement> add(DiagnosticParameter<P> parameterType, P parameter) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnosticFactory.java
new file mode 100644
index 00000000000..c9303288d18
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnosticFactory.java
@@ -0,0 +1,50 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.psi.JetNamedDeclaration;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+
+/**
+* @author abreslav
+*/
+public class RedeclarationDiagnosticFactory extends AbstractDiagnosticFactory {
+
+    public static final RedeclarationDiagnosticFactory INSTANCE = new RedeclarationDiagnosticFactory();
+
+    public RedeclarationDiagnosticFactory() {}
+
+    public RedeclarationDiagnostic on(@NotNull PsiElement duplicatingElement) {
+        return new RedeclarationDiagnostic.SimpleRedeclarationDiagnostic(duplicatingElement);
+    }
+
+    public Diagnostic on(DeclarationDescriptor duplicatingDescriptor, BindingContext contextToResolveToDeclaration) {
+        return new RedeclarationDiagnostic.RedeclarationDiagnosticWithDeferredResolution(duplicatingDescriptor, contextToResolveToDeclaration);
+    }
+
+    @NotNull
+    @Override
+    public TextRange getTextRange(@NotNull Diagnostic diagnostic) {
+        PsiElement redeclaration = ((RedeclarationDiagnostic) diagnostic).getPsiElement();
+        if (redeclaration instanceof JetNamedDeclaration) {
+            PsiElement nameIdentifier = ((JetNamedDeclaration) redeclaration).getNameIdentifier();
+            if (nameIdentifier != null) {
+                return nameIdentifier.getTextRange();
+            }
+        }
+        return redeclaration.getTextRange();
+    }
+
+    @NotNull
+    @Override
+    public String getName() {
+        return "REDECLARATION";
+    }
+
+    @Override
+    public String toString() {
+        return getName();
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Renderer.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Renderer.java
new file mode 100644
index 00000000000..9439e6a2dfa
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Renderer.java
@@ -0,0 +1,25 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author abreslav
+ */
+public interface Renderer {
+    Renderer TO_STRING = new Renderer() {
+        @NotNull
+        @Override
+        public String render(@Nullable Object object) {
+            return object == null ? "null" : object.toString();
+        }
+
+        @Override
+        public String toString() {
+            return "TO_STRING";
+        }
+    };
+
+    @NotNull
+    String render(@Nullable Object object);
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Severity.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Severity.java
new file mode 100644
index 00000000000..6c8ee194921
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Severity.java
@@ -0,0 +1,10 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+/**
+ * @author abreslav
+ */
+public enum Severity {
+    INFO,
+    ERROR,
+    WARNING
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactory.java
new file mode 100644
index 00000000000..cd67cb5b670
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactory.java
@@ -0,0 +1,30 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+* @author abreslav
+*/
+public class SimpleDiagnosticFactory extends SimpleDiagnosticFactoryWithPsiElement<PsiElement> {
+    public static SimpleDiagnosticFactory create(Severity severity, String message) {
+        return new SimpleDiagnosticFactory(severity, message);
+    }
+
+    protected SimpleDiagnosticFactory(Severity severity, String message) {
+        super(severity, message);
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull PsiFile psiFile, @NotNull TextRange range) {
+        return new GenericDiagnostic(this, severity, message, psiFile, range);
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull ASTNode node) {
+        return on(DiagnosticUtils.getContainingFile(node), node.getTextRange());
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactoryWithPsiElement.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactoryWithPsiElement.java
new file mode 100644
index 00000000000..a0da054399a
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactoryWithPsiElement.java
@@ -0,0 +1,33 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author svtk
+ */
+public abstract class SimpleDiagnosticFactoryWithPsiElement<T extends PsiElement> extends DiagnosticFactoryWithSeverity {
+
+    protected final String message;
+
+    protected SimpleDiagnosticFactoryWithPsiElement(Severity severity, String message) {
+        super(severity);
+        this.message = message;
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull T elementToBlame, @NotNull ASTNode nodeToMark) {
+        return new DiagnosticWithPsiElementImpl<T>(this, severity, message, elementToBlame, nodeToMark.getTextRange());
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull T elementToBlame, @NotNull PsiElement elementToMark) {
+        return new DiagnosticWithPsiElementImpl<T>(this, severity, message, elementToBlame, elementToMark.getTextRange());
+    }
+
+    @NotNull
+    public Diagnostic on(@NotNull T element) {
+        return on(element, element.getNode());
+    }
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimplePsiElementOnlyDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimplePsiElementOnlyDiagnosticFactory.java
new file mode 100644
index 00000000000..06b4fad83d7
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimplePsiElementOnlyDiagnosticFactory.java
@@ -0,0 +1,17 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import com.intellij.psi.PsiElement;
+
+/**
+ * @author svtk
+ */
+public class SimplePsiElementOnlyDiagnosticFactory<T extends PsiElement> extends SimpleDiagnosticFactoryWithPsiElement<T> implements PsiElementOnlyDiagnosticFactory<T> {
+
+    public static <T extends PsiElement> SimplePsiElementOnlyDiagnosticFactory<T> create(Severity severity, String message) {
+        return new SimplePsiElementOnlyDiagnosticFactory<T>(severity, message);
+    }
+
+    protected SimplePsiElementOnlyDiagnosticFactory(Severity severity, String message) {
+        super(severity, message);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java
new file mode 100644
index 00000000000..1d248f97638
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java
@@ -0,0 +1,22 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetReferenceExpression;
+
+import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR;
+
+/**
+* @author abreslav
+*/
+public class UnresolvedReferenceDiagnostic extends DiagnosticWithPsiElementImpl<JetReferenceExpression> {
+
+    public UnresolvedReferenceDiagnostic(JetReferenceExpression referenceExpression, String message) {
+        super(Errors.UNRESOLVED_REFERENCE, ERROR, message, referenceExpression);
+    }
+
+    @NotNull
+    @Override
+    public String getMessage() {
+        return super.getMessage() + ": " + getPsiElement().getText();
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java
new file mode 100644
index 00000000000..f5bbc087fd8
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java
@@ -0,0 +1,21 @@
+package org.jetbrains.jet.lang.diagnostics;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetReferenceExpression;
+
+/**
+* @author abreslav
+*/
+public class UnresolvedReferenceDiagnosticFactory extends AbstractDiagnosticFactory {
+//    public static final UnresolvedReferenceDiagnosticFactory INSTANCE = new UnresolvedReferenceDiagnosticFactory();
+
+    private final String message;
+    
+    public UnresolvedReferenceDiagnosticFactory(String message) {
+        this.message = message;
+    }
+
+    public UnresolvedReferenceDiagnostic on(@NotNull JetReferenceExpression reference) {
+        return new UnresolvedReferenceDiagnostic(reference, message);
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/AbstractJetParsing.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/AbstractJetParsing.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/AbstractJetParsing.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/AbstractJetParsing.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/AbstractTokenStreamPattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/AbstractTokenStreamPattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/AbstractTokenStreamPattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/AbstractTokenStreamPattern.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/AbstractTokenStreamPredicate.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/AbstractTokenStreamPredicate.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/AbstractTokenStreamPredicate.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/AbstractTokenStreamPredicate.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/Consumer.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/Consumer.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/Consumer.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/Consumer.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/FirstBefore.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/FirstBefore.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/FirstBefore.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/FirstBefore.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java
similarity index 96%
rename from idea/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java
index 484f354c181..2da63a0e2d6 100644
--- a/idea/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java
@@ -20,7 +20,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
     private static final TokenSet TYPE_ARGUMENT_LIST_STOPPERS = TokenSet.create(
             INTEGER_LITERAL, FLOAT_LITERAL, CHARACTER_LITERAL, OPEN_QUOTE, RAW_STRING_LITERAL,
-            NAMESPACE_KEYWORD, AS_KEYWORD, TYPE_KEYWORD, CLASS_KEYWORD, THIS_KEYWORD, VAL_KEYWORD, VAR_KEYWORD,
+            NAMESPACE_KEYWORD, AS_KEYWORD, TYPE_KEYWORD, TRAIT_KEYWORD, CLASS_KEYWORD, THIS_KEYWORD, VAL_KEYWORD, VAR_KEYWORD,
             FUN_KEYWORD, FOR_KEYWORD, NULL_KEYWORD,
             TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD, THROW_KEYWORD, RETURN_KEYWORD, BREAK_KEYWORD,
             CONTINUE_KEYWORD, OBJECT_KEYWORD, IF_KEYWORD, TRY_KEYWORD, ELSE_KEYWORD, WHILE_KEYWORD, DO_KEYWORD,
@@ -79,6 +79,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
             LBRACKET, // attribute
             FUN_KEYWORD,
             VAL_KEYWORD, VAR_KEYWORD,
+            TRAIT_KEYWORD,
             CLASS_KEYWORD,
             TYPE_KEYWORD
         ),
@@ -723,7 +724,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
                 if (atSet(WHEN_CONDITION_RECOVERY_SET)) {
                     error("Expecting an element");
                 } else {
-                    parseExpression();
+                    parseExpressionPreferringBlocks();
                 }
             } else if (!atSet(WHEN_CONDITION_RECOVERY_SET)) {
                  errorAndAdvance("Expecting '=>'");
@@ -750,7 +751,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
         if (atSet(WHEN_CONDITION_RECOVERY_SET)) {
             error("Expecting an element");
         } else {
-            parseExpression();
+            parseExpressionPreferringBlocks();
         }
         // SEMI is consumed in parseWhenEntry
     }
@@ -1032,6 +1033,10 @@ public class JetExpressionParsing extends AbstractJetParsing {
      *   ;
      */
     private void parseFunctionLiteral() {
+        parseFunctionLiteral(false);
+    }
+
+    private void parseFunctionLiteral(boolean preferBlock) {
         assert _at(LBRACE);
 
         PsiBuilder.Marker literalExpression = mark();
@@ -1048,7 +1053,8 @@ public class JetExpressionParsing extends AbstractJetParsing {
             }
         });
 
-        if (doubleArrowPos >= 0) {
+        boolean doubleArrowPresent = doubleArrowPos >= 0;
+        if (doubleArrowPresent) {
             boolean dontExpectParameters = false;
 
             int lastDot = matchTokenStreamPredicate(new LastBefore(new At(DOT), new AtOffset(doubleArrowPos)));
@@ -1116,7 +1122,17 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
             expectNoAdvance(DOUBLE_ARROW, "Expecting '=>'");
         }
+        else {
+            if (preferBlock) {
+                literal.drop();
+                parseStatements();
+                expect(RBRACE, "Expecting '}'");
+                literalExpression.done(BLOCK);
+                myBuilder.restoreNewlinesState();
 
+                return;
+            }
+        }
         PsiBuilder.Marker body = mark();
         parseStatements();
         body.done(BLOCK);
@@ -1221,7 +1237,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
     private JetNodeType parseLocalDeclarationRest(boolean isEnum) {
          IElementType keywordToken = tt();
          JetNodeType declType = null;
-         if (keywordToken == CLASS_KEYWORD) {
+         if (keywordToken == CLASS_KEYWORD || keywordToken == TRAIT_KEYWORD) {
              declType = myJetParsing.parseClass(isEnum);
          }
          else if (keywordToken == FUN_KEYWORD) {
@@ -1322,13 +1338,34 @@ public class JetExpressionParsing extends AbstractJetParsing {
         loop.done(FOR);
     }
 
+    /**
+     * If it has no =>, it's a block, otherwise a function literal
+     */
+    private void parseExpressionPreferringBlocks() {
+        if (at(LBRACE)) {
+            parseFunctionLiteral(true);
+        }
+        else if (atSet(LABELS) && lookahead(1) == LBRACE ) {
+            PsiBuilder.Marker mark = mark();
+
+            parseOperationReference();
+
+            parseFunctionLiteral(true);
+
+            mark.done(PREFIX_EXPRESSION);
+        }
+        else {
+            parseExpression();
+        }
+    }
+
     /*
      * element
      */
     private void parseControlStructureBody() {
         PsiBuilder.Marker body = mark();
         if (!at(SEMICOLON)) {
-            parseExpression();
+            parseExpressionPreferringBlocks();
         }
         body.done(BODY);
     }
@@ -1400,7 +1437,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
         PsiBuilder.Marker thenBranch = mark();
         if (!at(ELSE_KEYWORD) && !at(SEMICOLON)) {
-            parseExpression();
+            parseExpressionPreferringBlocks();
         }
         if (at(SEMICOLON) && lookahead(1) == ELSE_KEYWORD) {
             advance(); // SEMICOLON
@@ -1412,7 +1449,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
             PsiBuilder.Marker elseBranch = mark();
             if (!at(SEMICOLON)) {
-                parseExpression();
+                parseExpressionPreferringBlocks();
             }
             elseBranch.done(ELSE);
         }
@@ -1625,7 +1662,11 @@ public class JetExpressionParsing extends AbstractJetParsing {
     private void parseValueArgument() {
         PsiBuilder.Marker argument = mark();
         if (at(IDENTIFIER) && lookahead(1) == EQ) {
+            PsiBuilder.Marker argName = mark();
+            PsiBuilder.Marker reference = mark();
             advance(); // IDENTIFIER
+            reference.done(REFERENCE_EXPRESSION);
+            argName.done(VALUE_ARGUMENT_NAME);
             advance(); // EQ
         }
         if (at(OUT_KEYWORD) || at(REF_KEYWORD)) advance(); // REF or OUT
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/JetParser.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParser.java
similarity index 97%
rename from idea/src/org/jetbrains/jet/lang/parsing/JetParser.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParser.java
index d5a8689c13f..b3e62ad4b2a 100644
--- a/idea/src/org/jetbrains/jet/lang/parsing/JetParser.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParser.java
@@ -10,6 +10,7 @@ import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 
 public class JetParser implements PsiParser {
+    @Override
     @NotNull
     public ASTNode parse(IElementType iElementType, PsiBuilder psiBuilder) {
         JetParsing.createForTopLevel(new SemanticWhitespaceAwarePsiBuilderImpl(psiBuilder)).parseFile();
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/JetParserDefinition.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParserDefinition.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/JetParserDefinition.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParserDefinition.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/JetParsing.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java
similarity index 96%
rename from idea/src/org/jetbrains/jet/lang/parsing/JetParsing.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java
index 67b1913eea5..6637d0bedec 100644
--- a/idea/src/org/jetbrains/jet/lang/parsing/JetParsing.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java
@@ -28,13 +28,13 @@ public class JetParsing extends AbstractJetParsing {
         }
     }
 
-    private static final TokenSet TOPLEVEL_OBJECT_FIRST = TokenSet.create(TYPE_KEYWORD, CLASS_KEYWORD,
+    private static final TokenSet TOPLEVEL_OBJECT_FIRST = TokenSet.create(TYPE_KEYWORD, TRAIT_KEYWORD, CLASS_KEYWORD,
                 FUN_KEYWORD, VAL_KEYWORD, NAMESPACE_KEYWORD);
-    private static final TokenSet ENUM_MEMBER_FIRST = TokenSet.create(TYPE_KEYWORD, CLASS_KEYWORD,
+    private static final TokenSet ENUM_MEMBER_FIRST = TokenSet.create(TYPE_KEYWORD, TRAIT_KEYWORD, CLASS_KEYWORD,
                 FUN_KEYWORD, VAL_KEYWORD, IDENTIFIER);
 
-    private static final TokenSet CLASS_NAME_RECOVERY_SET = TokenSet.orSet(TokenSet.create(LT, WRAPS_KEYWORD, LPAR, COLON, LBRACE), TOPLEVEL_OBJECT_FIRST);
-    private static final TokenSet TYPE_PARAMETER_GT_RECOVERY_SET = TokenSet.create(WHERE_KEYWORD, WRAPS_KEYWORD, LPAR, COLON, LBRACE, GT);
+    private static final TokenSet CLASS_NAME_RECOVERY_SET = TokenSet.orSet(TokenSet.create(LT, LPAR, COLON, LBRACE), TOPLEVEL_OBJECT_FIRST);
+    private static final TokenSet TYPE_PARAMETER_GT_RECOVERY_SET = TokenSet.create(WHERE_KEYWORD, LPAR, COLON, LBRACE, GT);
     private static final TokenSet PARAMETER_NAME_RECOVERY_SET = TokenSet.create(COLON, EQ, COMMA, RPAR);
     private static final TokenSet NAMESPACE_NAME_RECOVERY_SET = TokenSet.create(DOT, EOL_OR_SEMICOLON);
     /*package*/ static final TokenSet TYPE_REF_FIRST = TokenSet.create(LBRACKET, IDENTIFIER, FUN_KEYWORD, LPAR, CAPITALIZED_THIS_KEYWORD);
@@ -227,7 +227,7 @@ public class JetParsing extends AbstractJetParsing {
         if (keywordToken == NAMESPACE_KEYWORD) {
             declType = parseNamespaceBlock();
         }
-        else if (keywordToken == CLASS_KEYWORD) {
+        else if (keywordToken == CLASS_KEYWORD || keywordToken == TRAIT_KEYWORD) {
             declType = parseClass(detector.isDetected());
         }
         else if (keywordToken == FUN_KEYWORD) {
@@ -404,36 +404,28 @@ public class JetParsing extends AbstractJetParsing {
 
     /*
      * class
-     *   : modifiers "class" SimpleName
+     *   : modifiers ("class" | "trait") SimpleName
      *       typeParameters?
-     *       (
-     *          ("wraps" "(" primaryConstructorParameter{","} ")") |
-     *          (modifiers "(" primaryConstructorParameter{","} ")"))?
+     *         modifiers ("(" primaryConstructorParameter{","} ")")?
      *       (":" attributes delegationSpecifier{","})?
      *       typeConstraints
      *       (classBody? | enumClassBody)
      *   ;
      */
     public JetNodeType parseClass(boolean enumClass) {
-        assert _at(CLASS_KEYWORD);
-        advance(); // CLASS_KEYWORD
+        assert _atSet(CLASS_KEYWORD, TRAIT_KEYWORD);
+        advance(); // CLASS_KEYWORD or TRAIT_KEYWORD
 
         expect(IDENTIFIER, "Class name expected", CLASS_NAME_RECOVERY_SET);
         boolean typeParametersDeclared = parseTypeParameterList(TYPE_PARAMETER_GT_RECOVERY_SET);
 
-        if (at(WRAPS_KEYWORD)) {
-            advance(); // WRAPS_KEYWORD
+        if (parseModifierList(PRIMARY_CONSTRUCTOR_MODIFIER_LIST, false)) {
             parseValueParameterList(false, TokenSet.create(COLON, LBRACE));
         }
         else {
-            if (parseModifierList(PRIMARY_CONSTRUCTOR_MODIFIER_LIST, false)) {
+            if (at(LPAR)) {
                 parseValueParameterList(false, TokenSet.create(COLON, LBRACE));
             }
-            else {
-                if (at(LPAR)) {
-                    parseValueParameterList(false, TokenSet.create(COLON, LBRACE));
-                }
-            }
         }
 
         if (at(COLON)) {
@@ -601,8 +593,11 @@ public class JetParsing extends AbstractJetParsing {
                 declType = parseClass(isEnum);
             }
         }
+        else if (keywordToken == TRAIT_KEYWORD) {
+            declType = parseClass(isEnum);
+        }
         else if (keywordToken == FUN_KEYWORD) {
-            declType = parseFunction();
+                declType = parseFunction();
         }
         else if (keywordToken == VAL_KEYWORD || keywordToken == VAR_KEYWORD) {
             declType = parseProperty();
@@ -806,6 +801,8 @@ public class JetParsing extends AbstractJetParsing {
 
         TokenSet propertyNameFollow = TokenSet.create(COLON, EQ, LBRACE, SEMICOLON);
 
+        myBuilder.disableJoiningComplexTokens();
+
         // TODO: extract constant
         int lastDot = matchTokenStreamPredicate(new FirstBefore(
                 new AtSet(DOT, SAFE_ACCESS),
@@ -815,7 +812,7 @@ public class JetParsing extends AbstractJetParsing {
                         if (topLevel && (at(EQ) || at(COLON))) return true;
                         if (topLevel && at(IDENTIFIER)) {
                             IElementType lookahead = lookahead(1);
-                            return lookahead != LT && lookahead != DOT && lookahead != SAFE_ACCESS;
+                            return lookahead != LT && lookahead != DOT && lookahead != SAFE_ACCESS && lookahead != QUEST;
                         }
                         return false;
                     }
@@ -823,6 +820,8 @@ public class JetParsing extends AbstractJetParsing {
 
         parseReceiverType("property", propertyNameFollow, lastDot);
 
+        myBuilder.enableJoiningComplexTokens();
+
         if (at(COLON)) {
             advance(); // COLON
             parseTypeRef();
@@ -956,8 +955,10 @@ public class JetParsing extends AbstractJetParsing {
             typeParameterListOccurred = true;
         }
 
+        myBuilder.disableJoiningComplexTokens();
         int lastDot = findLastBefore(RECEIVER_TYPE_TERMINATORS, TokenSet.create(LPAR), true);
         parseReceiverType("function", TokenSet.create(LT, LPAR, COLON, EQ), lastDot);
+        myBuilder.enableJoiningComplexTokens();
 
         TokenSet valueParametersFollow = TokenSet.create(COLON, EQ, LBRACE, SEMICOLON, RPAR);
 
@@ -998,21 +999,11 @@ public class JetParsing extends AbstractJetParsing {
      *   (type "." | attributes)?
      */
     private void parseReceiverType(String title, TokenSet nameFollow, int lastDot) {
-
         if (lastDot == -1) { // There's no explicit receiver type specified
             parseAnnotations(false);
             expect(IDENTIFIER, "Expecting " + title + " name or receiver type", nameFollow);
         } else {
-            PsiBuilder.Marker typeRefMarker = mark();
-            PsiBuilder.Marker nullableType = mark();
-            typeRefMarker = createTruncatedBuilder(lastDot).parseTypeRefContents(typeRefMarker);
-            if (at(SAFE_ACCESS)) {
-                nullableType.done(NULLABLE_TYPE);
-            }
-            else {
-                nullableType.drop();
-            }
-            typeRefMarker.done(TYPE_REFERENCE);
+            createTruncatedBuilder(lastDot).parseTypeRef();
 
             if (atSet(RECEIVER_TYPE_TERMINATORS)) {
                 advance(); // expectation
@@ -1263,10 +1254,7 @@ public class JetParsing extends AbstractJetParsing {
      *   : typeDescriptor "?"
      */
     public void parseTypeRef() {
-        parseTypeRefContents(mark()).done(TYPE_REFERENCE);
-    }
-
-    private PsiBuilder.Marker parseTypeRefContents(PsiBuilder.Marker typeRefMarker) {
+        PsiBuilder.Marker typeRefMarker = mark();
         parseAnnotations(false);
 
         if (at(IDENTIFIER) || at(NAMESPACE_KEYWORD)) {
@@ -1295,7 +1283,7 @@ public class JetParsing extends AbstractJetParsing {
 
             typeRefMarker = precede;
         }
-        return typeRefMarker;
+        typeRefMarker.done(TYPE_REFERENCE);
     }
 
     /*
@@ -1495,7 +1483,7 @@ public class JetParsing extends AbstractJetParsing {
         myBuilder.disableNewlines();
         expect(LPAR, "Expecting '(", recoverySet);
 
-        if (!at(RPAR)) {
+        if (!at(RPAR) && !atSet(recoverySet)) {
             while (true) {
                 if (at(COMMA)) {
                     errorAndAdvance("Expecting a parameter declaration");
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/LastBefore.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/LastBefore.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/LastBefore.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/LastBefore.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/MarkerAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/MarkerAdapter.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/MarkerAdapter.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/MarkerAdapter.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilder.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilder.java
similarity index 83%
rename from idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilder.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilder.java
index 127bc633677..9c836948b2a 100644
--- a/idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilder.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilder.java
@@ -12,4 +12,7 @@ public interface SemanticWhitespaceAwarePsiBuilder extends PsiBuilder {
     void disableNewlines();
     void enableNewlines();
     void restoreNewlinesState();
+
+    void enableJoiningComplexTokens();
+    void disableJoiningComplexTokens();
 }
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java
similarity index 74%
rename from idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java
index 9a72d5aa570..bdec327ec20 100644
--- a/idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java
@@ -1,6 +1,6 @@
 package org.jetbrains.jet.lang.parsing;
 
-import com.intellij.lang.java.parser.JavaParserUtil.PsiBuilderAdapter;
+import com.intellij.lang.impl.PsiBuilderAdapter;
 
 /**
  * @author abreslav
@@ -35,4 +35,13 @@ public class SemanticWhitespaceAwarePsiBuilderAdapter extends PsiBuilderAdapter
         myBuilder.restoreNewlinesState();
     }
 
+    @Override
+    public void enableJoiningComplexTokens() {
+        myBuilder.enableJoiningComplexTokens();
+    }
+
+    @Override
+    public void disableJoiningComplexTokens() {
+        myBuilder.disableJoiningComplexTokens();
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderForByClause.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderForByClause.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderForByClause.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderForByClause.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
new file mode 100644
index 00000000000..e211deb85f4
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
@@ -0,0 +1,134 @@
+package org.jetbrains.jet.lang.parsing;
+
+
+import com.intellij.lang.PsiBuilder;
+import com.intellij.lang.impl.PsiBuilderAdapter;
+import com.intellij.psi.TokenType;
+import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
+import org.jetbrains.jet.lexer.JetTokens;
+
+import java.util.Stack;
+
+import static org.jetbrains.jet.lexer.JetTokens.*;
+
+/**
+ * @author abreslav
+ */
+public class SemanticWhitespaceAwarePsiBuilderImpl extends PsiBuilderAdapter implements SemanticWhitespaceAwarePsiBuilder {
+    private final Stack<Boolean> newlinesEnabled = new Stack<Boolean>();
+
+    public SemanticWhitespaceAwarePsiBuilderImpl(final PsiBuilder delegate) {
+        super(delegate);
+        newlinesEnabled.push(true);
+    }
+
+    @Override
+    public boolean newlineBeforeCurrentToken() {
+        if (!newlinesEnabled.peek()) return false;
+        if (eof()) return true;
+        // TODO: maybe, memoize this somehow?
+        for (int i = 1; i <= getCurrentOffset(); i++) {
+            IElementType previousToken = rawLookup(-i);
+            if (previousToken == JetTokens.BLOCK_COMMENT
+                    || previousToken == JetTokens.DOC_COMMENT
+                    || previousToken == JetTokens.EOL_COMMENT) {
+                continue;
+            }
+            if (previousToken != TokenType.WHITE_SPACE) {
+                break;
+            }
+            int previousTokenStart = rawTokenTypeStart(-i);
+            int previousTokenEnd = rawTokenTypeStart(-i + 1);
+            assert previousTokenStart >= 0;
+            assert previousTokenEnd < getOriginalText().length();
+            for (int j = previousTokenStart; j < previousTokenEnd; j++) {
+                if (getOriginalText().charAt(j) == '\n') return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void disableNewlines() {
+        newlinesEnabled.push(false);
+    }
+
+    @Override
+    public void enableNewlines() {
+        newlinesEnabled.push(true);
+    }
+
+    @Override
+    public void restoreNewlinesState() {
+        assert newlinesEnabled.size() > 1;
+        newlinesEnabled.pop();
+    }
+
+    private final TokenSet complexTokens = TokenSet.create(SAFE_ACCESS, ELVIS);
+    private boolean joinComplexTokens = true;
+
+    @Override
+    public void enableJoiningComplexTokens() {
+        joinComplexTokens = true;
+    }
+
+    @Override
+    public void disableJoiningComplexTokens() {
+        joinComplexTokens = false;
+    }
+
+    @Override
+    public IElementType getTokenType() {
+        if (!joinComplexTokens) return super.getTokenType();
+        return getJoinedTokenType(super.getTokenType(), 1);
+    }
+
+    private IElementType getJoinedTokenType(IElementType rawTokenType, int rawLookupSteps) {
+        if (rawTokenType == QUEST) {
+            IElementType nextRawToken = rawLookup(rawLookupSteps);
+            if (nextRawToken == DOT) return SAFE_ACCESS;
+            if (nextRawToken == COLON) return ELVIS;
+        }
+        return rawTokenType;
+    }
+
+    @Override
+    public void advanceLexer() {
+        if (!joinComplexTokens) {
+            super.advanceLexer();
+            return;
+        }
+        IElementType tokenType = getTokenType();
+        if (complexTokens.contains(tokenType)) {
+            Marker mark = mark();
+            super.advanceLexer();
+            super.advanceLexer();
+            mark.collapse(tokenType);
+        }
+        else {
+            super.advanceLexer();
+        }
+    }
+
+    @Override
+    public String getTokenText() {
+        if (!joinComplexTokens) return super.getTokenText();
+        IElementType tokenType = getTokenType();
+        if (complexTokens.contains(tokenType)) {
+                if (tokenType == ELVIS) return "?:";
+                if (tokenType == SAFE_ACCESS) return "?.";
+            }
+        return super.getTokenText();
+    }
+
+    @Override
+    public IElementType lookAhead(int steps) {
+        if (!joinComplexTokens) return super.lookAhead(steps);
+
+        if (complexTokens.contains(getTokenType())) {
+            return super.lookAhead(steps + 1);
+        }
+        return getJoinedTokenType(super.lookAhead(steps), 2);
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/TokenStreamPattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/TokenStreamPattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/TokenStreamPattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/TokenStreamPattern.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/TokenStreamPredicate.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/TokenStreamPredicate.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/TokenStreamPredicate.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/TokenStreamPredicate.java
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/TruncatedSemanticWhitespaceAwarePsiBuilder.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/TruncatedSemanticWhitespaceAwarePsiBuilder.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/parsing/TruncatedSemanticWhitespaceAwarePsiBuilder.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/parsing/TruncatedSemanticWhitespaceAwarePsiBuilder.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/Call.java
similarity index 72%
rename from idea/src/org/jetbrains/jet/lang/psi/JetCall.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/Call.java
index 58a62ef1679..6813fdfdbaf 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetCall.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/Call.java
@@ -1,6 +1,5 @@
 package org.jetbrains.jet.lang.psi;
 
-import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -9,7 +8,7 @@ import java.util.List;
 /**
  * @author abreslav
  */
-public interface JetCall extends PsiElement {
+public interface Call {
     @Nullable
     JetExpression getCalleeExpression();
 
@@ -17,7 +16,7 @@ public interface JetCall extends PsiElement {
     JetValueArgumentList getValueArgumentList();
 
     @NotNull
-    List<JetValueArgument> getValueArguments();
+    List<? extends ValueArgument> getValueArguments();
 
     @NotNull
     List<JetExpression> getFunctionLiteralArguments();
@@ -25,6 +24,6 @@ public interface JetCall extends PsiElement {
     @NotNull
     List<JetTypeProjection> getTypeArguments();
 
-    @NotNull
-    JetElement asElement();
+    @Nullable
+    JetTypeArgumentList getTypeArgumentList();
 }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetAnnotatedExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotatedExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetAnnotatedExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotatedExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetAnnotation.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotation.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetAnnotation.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotation.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetAnnotationEntry.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotationEntry.java
similarity index 73%
rename from idea/src/org/jetbrains/jet/lang/psi/JetAnnotationEntry.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotationEntry.java
index b5d430b2b89..77a4634e791 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetAnnotationEntry.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotationEntry.java
@@ -11,7 +11,7 @@ import java.util.List;
 /**
  * @author max
  */
-public class JetAnnotationEntry extends JetElement implements JetCall {
+public class JetAnnotationEntry extends JetElement implements JetCallElement {
     public JetAnnotationEntry(@NotNull ASTNode node) {
         super(node);
     }
@@ -48,7 +48,7 @@ public class JetAnnotationEntry extends JetElement implements JetCall {
 
     @NotNull
     @Override
-    public List<JetValueArgument> getValueArguments() {
+    public List<? extends ValueArgument> getValueArguments() {
         JetValueArgumentList list = getValueArgumentList();
         return list != null ? list.getArguments() : Collections.<JetValueArgument>emptyList();
     }
@@ -62,20 +62,25 @@ public class JetAnnotationEntry extends JetElement implements JetCall {
     @NotNull
     @Override
     public List<JetTypeProjection> getTypeArguments() {
-        JetTypeReference typeReference = getTypeReference();
-        if (typeReference != null) {
-            JetTypeElement typeElement = typeReference.getTypeElement();
-            if (typeElement instanceof JetUserType) {
-                JetUserType userType = (JetUserType) typeElement;
-                return userType.getTypeArguments();
-            }
+        JetTypeArgumentList typeArgumentList = getTypeArgumentList();
+        if (typeArgumentList == null) {
+            return Collections.emptyList();
         }
-        return Collections.emptyList();
+        return typeArgumentList.getArguments();
     }
 
-    @NotNull
     @Override
-    public JetElement asElement() {
-        return this;
+    public JetTypeArgumentList getTypeArgumentList() {
+        JetTypeReference typeReference = getTypeReference();
+        if (typeReference == null) {
+            return null;
+        }
+        JetTypeElement typeElement = typeReference.getTypeElement();
+        if (typeElement instanceof JetUserType) {
+            JetUserType userType = (JetUserType) typeElement;
+            return userType.getTypeArgumentList();
+        }
+        return null;
     }
+
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetArrayAccessExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetArrayAccessExpression.java
new file mode 100644
index 00000000000..a690f1454fb
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetArrayAccessExpression.java
@@ -0,0 +1,56 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.PsiReferenceService;
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
+import com.intellij.psi.util.PsiTreeUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetNodeTypes;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author max
+ */
+public class JetArrayAccessExpression extends JetReferenceExpression {
+    public JetArrayAccessExpression(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @NotNull
+    @Override
+    public PsiReference[] getReferences() {
+        return ReferenceProvidersRegistry.getReferencesFromProviders(this, PsiReferenceService.Hints.NO_HINTS);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitorVoid visitor) {
+        visitor.visitArrayAccessExpression(this);
+    }
+
+    @Override
+    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+        return visitor.visitArrayAccessExpression(this, data);
+    }
+
+    @NotNull
+    public JetExpression getArrayExpression() {
+        JetExpression baseExpression = findChildByClass(JetExpression.class);
+        assert baseExpression != null;
+        return baseExpression;
+    }
+
+    @NotNull
+    public List<JetExpression> getIndexExpressions() {
+        PsiElement container = getIndicesNode();
+        if (container == null) return Collections.emptyList();
+        return PsiTreeUtil.getChildrenOfTypeAsList(container, JetExpression.class);
+    }
+
+    public JetContainerNode getIndicesNode() {
+        return (JetContainerNode) findChildByType(JetNodeTypes.INDICES);
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetBinaryExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBinaryExpression.java
similarity index 99%
rename from idea/src/org/jetbrains/jet/lang/psi/JetBinaryExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBinaryExpression.java
index 378dda09480..33cfe223c08 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetBinaryExpression.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBinaryExpression.java
@@ -54,5 +54,4 @@ public class JetBinaryExpression extends JetExpression {
     public IElementType getOperationToken() {
         return getOperationReference().getReferencedNameElementType();
     }
-
 }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetBinaryExpressionWithTypeRHS.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBinaryExpressionWithTypeRHS.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetBinaryExpressionWithTypeRHS.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBinaryExpressionWithTypeRHS.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetBindingPattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBindingPattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetBindingPattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBindingPattern.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetBlockExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetBlockExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetBlockStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockStringTemplateEntry.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetBlockStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBlockStringTemplateEntry.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetBreakExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBreakExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetBreakExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetBreakExpression.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCallElement.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCallElement.java
new file mode 100644
index 00000000000..a9a1a38d6e0
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCallElement.java
@@ -0,0 +1,14 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * @author abreslav
+ */
+public interface JetCallElement extends PsiElement, Call {
+
+}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetCallExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCallExpression.java
similarity index 91%
rename from idea/src/org/jetbrains/jet/lang/psi/JetCallExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCallExpression.java
index 33ae21cf505..84d08e200a4 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetCallExpression.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCallExpression.java
@@ -11,7 +11,7 @@ import java.util.List;
 /**
  * @author max
  */
-public class JetCallExpression extends JetExpression implements JetCall {
+public class JetCallExpression extends JetExpression implements JetCallElement {
     public JetCallExpression(@NotNull ASTNode node) {
         super(node);
     }
@@ -49,15 +49,9 @@ public class JetCallExpression extends JetExpression implements JetCall {
         return findChildrenByType(JetNodeTypes.FUNCTION_LITERAL_EXPRESSION);
     }
 
-    @NotNull
-    @Override
-    public JetElement asElement() {
-        return this;
-    }
-
     @Override
     @NotNull
-    public List<JetValueArgument> getValueArguments() {
+    public List<? extends ValueArgument> getValueArguments() {
         JetValueArgumentList list = getValueArgumentList();
         return list != null ? list.getArguments() : Collections.<JetValueArgument>emptyList();
     }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetCatchClause.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCatchClause.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetCatchClause.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCatchClause.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetClass.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClass.java
similarity index 95%
rename from idea/src/org/jetbrains/jet/lang/psi/JetClass.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClass.java
index 1b859f92c3d..176693cc17c 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetClass.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClass.java
@@ -5,6 +5,7 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
+import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collections;
 import java.util.List;
@@ -12,7 +13,7 @@ import java.util.List;
 /**
  * @author max
  */
-public class JetClass extends JetTypeParameterListOwner implements JetClassOrObject {
+public class JetClass extends JetTypeParameterListOwner implements JetClassOrObject, JetModifierListOwner {
     public JetClass(@NotNull ASTNode node) {
         super(node);
     }
@@ -114,4 +115,8 @@ public class JetClass extends JetTypeParameterListOwner implements JetClassOrObj
         }
         return getName();
     }
+
+    public boolean isTrait() {
+        return findChildByType(JetTokens.TRAIT_KEYWORD) != null;
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetClassBody.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassBody.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetClassBody.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassBody.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetClassInitializer.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassInitializer.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetClassInitializer.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassInitializer.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetClassObject.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassObject.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetClassObject.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassObject.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetClassOrObject.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassOrObject.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetClassOrObject.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassOrObject.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetConstantExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetConstantExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetConstantExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetConstantExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetConstructor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetConstructor.java
similarity index 96%
rename from idea/src/org/jetbrains/jet/lang/psi/JetConstructor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetConstructor.java
index bc53af61e4b..0971e9553a6 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetConstructor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetConstructor.java
@@ -32,8 +32,9 @@ public class JetConstructor extends JetDeclaration implements JetDeclarationWith
         return (JetParameterList) findChildByType(JetNodeTypes.VALUE_PARAMETER_LIST);
     }
 
+    @Override
     @NotNull
-    public List<JetParameter> getParameters() {
+    public List<JetParameter> getValueParameters() {
         JetParameterList list = getParameterList();
         return list != null ? list.getParameters() : Collections.<JetParameter>emptyList();
     }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetConstructorCalleeExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetConstructorCalleeExpression.java
similarity index 86%
rename from idea/src/org/jetbrains/jet/lang/psi/JetConstructorCalleeExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetConstructorCalleeExpression.java
index fcd388862ea..e765de01f83 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetConstructorCalleeExpression.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetConstructorCalleeExpression.java
@@ -24,7 +24,10 @@ public class JetConstructorCalleeExpression extends JetExpression {
             return null;
         }
         JetTypeElement typeElement = typeReference.getTypeElement();
-        assert typeElement instanceof JetUserType;
+        if (typeElement == null) {
+            return null;
+        }
+        assert typeElement instanceof JetUserType : typeElement;
         return ((JetUserType) typeElement).getReferenceExpression();
     }
 
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetContainerNode.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetContainerNode.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetContainerNode.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetContainerNode.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetContinueExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetContinueExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetContinueExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetContinueExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDeclaration.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclaration.java
similarity index 88%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDeclaration.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclaration.java
index bc4af407c63..433b26aa2af 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetDeclaration.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclaration.java
@@ -9,7 +9,7 @@ import org.jetbrains.jet.lexer.JetToken;
 /**
  * @author max
  */
-public abstract class JetDeclaration extends JetExpression {
+public abstract class JetDeclaration extends JetExpression implements JetModifierListOwner {
     public JetDeclaration(@NotNull ASTNode node) {
         super(node);
     }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDeclarationWithBody.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationWithBody.java
similarity index 73%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDeclarationWithBody.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationWithBody.java
index 3bce72ddf0f..115a953a9d0 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetDeclarationWithBody.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationWithBody.java
@@ -4,10 +4,12 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
+
 /**
  * @author abreslav
  */
-public interface JetDeclarationWithBody {
+public interface JetDeclarationWithBody extends PsiElement {
 
     @Nullable
     JetExpression getBodyExpression();
@@ -21,5 +23,8 @@ public interface JetDeclarationWithBody {
 
     @NotNull
     JetElement asElement();
+
+    @NotNull
+    List<JetParameter> getValueParameters();
 }
 
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDecomposerPattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDecomposerPattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDecomposerPattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDecomposerPattern.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifier.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifier.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifier.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifier.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifierList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifierList.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifierList.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifierList.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDelegatorByExpressionSpecifier.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorByExpressionSpecifier.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDelegatorByExpressionSpecifier.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorByExpressionSpecifier.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperCall.java
similarity index 71%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperCall.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperCall.java
index 602cfcb63ab..91e9487a881 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperCall.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperCall.java
@@ -11,7 +11,7 @@ import java.util.List;
 /**
  * @author max
  */
-public class JetDelegatorToSuperCall extends JetDelegationSpecifier implements JetCall {
+public class JetDelegatorToSuperCall extends JetDelegationSpecifier implements JetCallElement {
     public JetDelegatorToSuperCall(@NotNull ASTNode node) {
         super(node);
     }
@@ -38,7 +38,7 @@ public class JetDelegatorToSuperCall extends JetDelegationSpecifier implements J
     }
 
     @NotNull
-    public List<JetValueArgument> getValueArguments() {
+    public List<? extends ValueArgument> getValueArguments() {
         JetValueArgumentList list = getValueArgumentList();
         return list != null ? list.getArguments() : Collections.<JetValueArgument>emptyList();
     }
@@ -57,20 +57,25 @@ public class JetDelegatorToSuperCall extends JetDelegationSpecifier implements J
     @NotNull
     @Override
     public List<JetTypeProjection> getTypeArguments() {
-        JetTypeReference typeReference = getTypeReference();
-        if (typeReference != null) {
-            JetTypeElement typeElement = typeReference.getTypeElement();
-            if (typeElement instanceof JetUserType) {
-                JetUserType userType = (JetUserType) typeElement;
-                return userType.getTypeArguments();
-            }
+        JetTypeArgumentList typeArgumentList = getTypeArgumentList();
+        if (typeArgumentList == null) {
+            return Collections.emptyList();
         }
-        return Collections.emptyList();
+        return typeArgumentList.getArguments();
     }
 
-    @NotNull
     @Override
-    public JetElement asElement() {
-        return this;
+    public JetTypeArgumentList getTypeArgumentList() {
+        JetTypeReference typeReference = getTypeReference();
+        if (typeReference == null) {
+            return null;
+        }
+        JetTypeElement typeElement = typeReference.getTypeElement();
+        if (typeElement instanceof JetUserType) {
+            JetUserType userType = (JetUserType) typeElement;
+            return userType.getTypeArgumentList();
+        }
+        return null;
     }
+
 }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperClass.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperClass.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperClass.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperClass.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDelegatorToThisCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToThisCall.java
similarity index 90%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDelegatorToThisCall.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToThisCall.java
index c06b8e216b1..9b5501880ce 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetDelegatorToThisCall.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToThisCall.java
@@ -11,7 +11,7 @@ import java.util.List;
 /**
  * @author max
  */
-public class JetDelegatorToThisCall extends JetDelegationSpecifier implements JetCall {
+public class JetDelegatorToThisCall extends JetDelegationSpecifier implements JetCallElement {
 
     public JetDelegatorToThisCall(@NotNull ASTNode node) {
         super(node);
@@ -38,7 +38,7 @@ public class JetDelegatorToThisCall extends JetDelegationSpecifier implements Je
     }
 
     @NotNull
-    public List<JetValueArgument> getValueArguments() {
+    public List<? extends ValueArgument> getValueArguments() {
         JetValueArgumentList list = getValueArgumentList();
         return list != null ? list.getArguments() : Collections.<JetValueArgument>emptyList();
     }
@@ -49,18 +49,17 @@ public class JetDelegatorToThisCall extends JetDelegationSpecifier implements Je
         return Collections.emptyList();
     }
 
-    @NotNull
-    @Override
-    public JetElement asElement() {
-        return this;
-    }
-
     @NotNull
     @Override
     public List<JetTypeProjection> getTypeArguments() {
         return Collections.emptyList();
     }
 
+    @Override
+    public JetTypeArgumentList getTypeArgumentList() {
+        return null;
+    }
+
     public JetReferenceExpression getThisReference() {
         return findChildByClass(JetThisReferenceExpression.class);
     }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDoWhileExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDoWhileExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDoWhileExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDoWhileExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetDotQualifiedExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDotQualifiedExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetDotQualifiedExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDotQualifiedExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetElement.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetElement.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetElement.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetElement.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetEnumEntry.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetEnumEntry.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetEnumEntry.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetEnumEntry.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetEscapeStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetEscapeStringTemplateEntry.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetEscapeStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetEscapeStringTemplateEntry.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetExpressionPattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionPattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetExpressionPattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionPattern.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetFile.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFile.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetFile.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFile.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetFinallySection.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFinallySection.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetFinallySection.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFinallySection.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetForExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetForExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetForExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetForExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetFunction.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunction.java
similarity index 97%
rename from idea/src/org/jetbrains/jet/lang/psi/JetFunction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunction.java
index 10f03300dca..09fee5a8b43 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetFunction.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunction.java
@@ -14,7 +14,7 @@ import java.util.List;
 /**
  * @author abreslav
  */
-abstract public class JetFunction extends JetTypeParameterListOwner implements JetDeclarationWithBody {
+abstract public class JetFunction extends JetTypeParameterListOwner implements JetFunctionOrPropertyAccessor {
     public JetFunction(@NotNull ASTNode node) {
         super(node);
     }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetFunctionLiteral.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionLiteral.java
similarity index 66%
rename from idea/src/org/jetbrains/jet/lang/psi/JetFunctionLiteral.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionLiteral.java
index 976b8d04d62..6f20e9a1478 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetFunctionLiteral.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionLiteral.java
@@ -3,6 +3,7 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lexer.JetTokens;
 
 /**
@@ -36,4 +37,20 @@ public class JetFunctionLiteral extends JetFunction {
     public JetBlockExpression getBodyExpression() {
         return (JetBlockExpression) super.getBodyExpression();
     }
+
+    @NotNull
+    public ASTNode getOpenBraceNode() {
+        return getNode().findChildByType(JetTokens.LBRACE);
+    }
+
+    @Nullable
+    @IfNotParsed
+    public ASTNode getClosingBraceNode() {
+        return getNode().findChildByType(JetTokens.RBRACE);
+    }
+
+    @Nullable
+    public ASTNode getArrowNode() {
+        return getNode().findChildByType(JetTokens.DOUBLE_ARROW);
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionLiteralExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionLiteralExpression.java
new file mode 100644
index 00000000000..efed8a90e56
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionLiteralExpression.java
@@ -0,0 +1,59 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetNodeTypes;
+
+import java.util.List;
+
+/**
+ * @author max
+ */
+public class JetFunctionLiteralExpression extends JetExpression implements JetDeclarationWithBody {
+    public JetFunctionLiteralExpression(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitorVoid visitor) {
+        visitor.visitFunctionLiteralExpression(this);
+    }
+
+    @Override
+    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+        return visitor.visitFunctionLiteralExpression(this, data);
+    }
+
+    @NotNull
+    public JetFunctionLiteral getFunctionLiteral() {
+        return (JetFunctionLiteral) findChildByType(JetNodeTypes.FUNCTION_LITERAL);
+    }
+
+    @NotNull
+    @Override
+    public List<JetParameter> getValueParameters() {
+        return getFunctionLiteral().getValueParameters();
+    }
+
+    @Override
+    public JetBlockExpression getBodyExpression() {
+        return getFunctionLiteral().getBodyExpression();
+    }
+
+    @Override
+    public boolean hasBlockBody() {
+        return getFunctionLiteral().hasBlockBody();
+    }
+
+    @Override
+    public boolean hasDeclaredReturnType() {
+        return getFunctionLiteral().getReturnTypeRef() != null;
+    }
+
+    @NotNull
+    @Override
+    public JetElement asElement() {
+        return this;
+    }
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionOrPropertyAccessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionOrPropertyAccessor.java
new file mode 100644
index 00000000000..9ce62477999
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionOrPropertyAccessor.java
@@ -0,0 +1,7 @@
+package org.jetbrains.jet.lang.psi;
+
+/**
+ * @author svtk
+ */
+public interface JetFunctionOrPropertyAccessor extends JetDeclarationWithBody, JetModifierListOwner {
+}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetFunctionType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionType.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetFunctionType.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionType.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetHashQualifiedExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetHashQualifiedExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetHashQualifiedExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetHashQualifiedExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetIfExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetIfExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetIfExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetIfExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetImportDirective.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportDirective.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetImportDirective.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportDirective.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetInitializerList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetInitializerList.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetInitializerList.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetInitializerList.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetIsExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetIsExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetIsExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetIsExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetLabelQualifiedExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetLabelQualifiedExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetLabelQualifiedExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetLabelQualifiedExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetLiteralStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetLiteralStringTemplateEntry.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetLiteralStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetLiteralStringTemplateEntry.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetLoopExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetLoopExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetLoopExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetLoopExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetModifierList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierList.java
similarity index 87%
rename from idea/src/org/jetbrains/jet/lang/psi/JetModifierList.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierList.java
index 8cfbe02064b..2c5e47472c5 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetModifierList.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierList.java
@@ -1,5 +1,6 @@
 package org.jetbrains.jet.lang.psi;
 
+import com.google.common.collect.Lists;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -34,7 +35,8 @@ public class JetModifierList extends JetElement {
     }
 
     public List<JetAnnotationEntry> getAnnotationEntries() {
-        List<JetAnnotationEntry> answer = null;
+        List<JetAnnotationEntry> entries = findChildrenByType(JetNodeTypes.ANNOTATION_ENTRY);
+        List<JetAnnotationEntry> answer = entries.isEmpty() ? null : Lists.newArrayList(entries);
         for (JetAnnotation annotation : getAnnotations()) {
             if (answer == null) answer = new ArrayList<JetAnnotationEntry>();
             answer.addAll(annotation.getEntries());
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierListOwner.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierListOwner.java
new file mode 100644
index 00000000000..b56e9bea2ac
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierListOwner.java
@@ -0,0 +1,15 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lexer.JetToken;
+
+/**
+ * @author svtk
+ */
+public interface JetModifierListOwner extends PsiElement {
+    @Nullable
+    JetModifierList getModifierList();
+
+    boolean hasModifier(JetToken modifier);
+}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetNamedArgumentImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedArgumentImpl.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetNamedArgumentImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedArgumentImpl.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetNamedDeclaration.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclaration.java
similarity index 94%
rename from idea/src/org/jetbrains/jet/lang/psi/JetNamedDeclaration.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclaration.java
index d6a5caa149c..f80a390fc75 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetNamedDeclaration.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclaration.java
@@ -29,7 +29,7 @@ public abstract class JetNamedDeclaration extends JetDeclaration implements PsiN
 
     @Override
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        return getNameIdentifier().replace(JetChangeUtil.createNameIdentifier(getProject(), name));
+        return getNameIdentifier().replace(JetPsiFactory.createNameIdentifier(getProject(), name));
     }
 
     @Override
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetNamedFunction.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedFunction.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetNamedFunction.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedFunction.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetNamespace.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespace.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetNamespace.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespace.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetNamespaceBody.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespaceBody.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetNamespaceBody.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespaceBody.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetNewExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNewExpression.java
similarity index 98%
rename from idea/src/org/jetbrains/jet/lang/psi/JetNewExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNewExpression.java
index 62301009b10..b7edbc97ee2 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetNewExpression.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNewExpression.java
@@ -3,7 +3,7 @@ package org.jetbrains.jet.lang.psi;
 /**
  * @author max
  */
-//public class JetNewExpression extends JetExpression implements JetCall {
+//public class JetNewExpression extends JetExpression implements JetCallElement {
 //    public JetNewExpression(@NotNull ASTNode node) {
 //        super(node);
 //    }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetNullableType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNullableType.java
similarity index 83%
rename from idea/src/org/jetbrains/jet/lang/psi/JetNullableType.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNullableType.java
index f674154a740..0e1e049da29 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetNullableType.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNullableType.java
@@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.List;
 
@@ -12,6 +13,11 @@ public class JetNullableType extends JetTypeElement {
     public JetNullableType(@NotNull ASTNode node) {
         super(node);
     }
+    
+    @NotNull
+    public ASTNode getQuestionMarkNode() {
+        return getNode().findChildByType(JetTokens.QUEST);
+    }
 
     @NotNull
     @Override
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java
similarity index 97%
rename from idea/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java
index dc3c76bc5f9..e3b91196931 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java
@@ -22,7 +22,7 @@ public class JetObjectDeclaration extends JetNamedDeclaration implements JetClas
     @Override
     public String getName() {
         JetObjectDeclarationName nameAsDeclaration = getNameAsDeclaration();
-        return nameAsDeclaration == null ? "<Anonymous>" : nameAsDeclaration.getName();
+        return nameAsDeclaration == null ? null : nameAsDeclaration.getName();
     }
 
     @Override
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetObjectDeclarationName.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclarationName.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetObjectDeclarationName.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclarationName.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetObjectLiteralExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectLiteralExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetObjectLiteralExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectLiteralExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetParameter.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameter.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetParameter.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameter.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetParameterList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameterList.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetParameterList.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameterList.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetParenthesizedExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParenthesizedExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetParenthesizedExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParenthesizedExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetPattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetPattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPattern.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetPostfixExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPostfixExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetPostfixExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPostfixExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetPredicateExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPredicateExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetPredicateExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPredicateExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetPrefixExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPrefixExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetPrefixExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPrefixExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetProjectionKind.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetProjectionKind.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetProjectionKind.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetProjectionKind.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetProperty.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetProperty.java
similarity index 80%
rename from idea/src/org/jetbrains/jet/lang/psi/JetProperty.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetProperty.java
index a7d1af61ef4..6e5b0f476ec 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetProperty.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetProperty.java
@@ -3,6 +3,7 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -11,10 +12,15 @@ import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.List;
 
+import static org.jetbrains.jet.JetNodeTypes.PROPERTY_ACCESSOR;
+import static org.jetbrains.jet.lexer.JetTokens.EQ;
+import static org.jetbrains.jet.lexer.JetTokens.VAL_KEYWORD;
+import static org.jetbrains.jet.lexer.JetTokens.VAR_KEYWORD;
+
 /**
  * @author max
  */
-public class JetProperty extends JetTypeParameterListOwner {
+public class JetProperty extends JetTypeParameterListOwner implements JetModifierListOwner {
     public JetProperty(@NotNull ASTNode node) {
         super(node);
     }
@@ -69,7 +75,7 @@ public class JetProperty extends JetTypeParameterListOwner {
 
     @NotNull
     public List<JetPropertyAccessor> getAccessors() {
-        return findChildrenByType(JetNodeTypes.PROPERTY_ACCESSOR);
+        return findChildrenByType(PROPERTY_ACCESSOR);
     }
 
     @Nullable
@@ -92,7 +98,12 @@ public class JetProperty extends JetTypeParameterListOwner {
 
     @Nullable
     public JetExpression getInitializer() {
-        PsiElement eq = findChildByType(JetTokens.EQ);
+        PsiElement eq = findChildByType(EQ);
         return PsiTreeUtil.getNextSiblingOfType(eq, JetExpression.class);
     }
+
+    @NotNull
+    public ASTNode getValOrVarNode() {
+        return getNode().findChildByType(TokenSet.create(VAL_KEYWORD, VAR_KEYWORD));
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetPropertyAccessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPropertyAccessor.java
similarity index 73%
rename from idea/src/org/jetbrains/jet/lang/psi/JetPropertyAccessor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPropertyAccessor.java
index df7e061e3a8..a1aa5e418c9 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetPropertyAccessor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPropertyAccessor.java
@@ -1,17 +1,19 @@
 package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
+import java.util.Collections;
 import java.util.List;
 
 /**
  * @author max
  */
-public class JetPropertyAccessor extends JetDeclaration implements JetDeclarationWithBody {
+public class JetPropertyAccessor extends JetDeclaration implements JetFunctionOrPropertyAccessor {
     public JetPropertyAccessor(@NotNull ASTNode node) {
         super(node);
     }
@@ -43,6 +45,16 @@ public class JetPropertyAccessor extends JetDeclaration implements JetDeclaratio
         return parameters.get(0);
     }
 
+    @NotNull
+    @Override
+    public List<JetParameter> getValueParameters() {
+        JetParameter parameter = getParameter();
+        if (parameter == null) {
+            return Collections.emptyList();
+        }
+        return Collections.singletonList(parameter);
+    }
+
     @Nullable
     @Override
     public JetExpression getBodyExpression() {
@@ -56,7 +68,7 @@ public class JetPropertyAccessor extends JetDeclaration implements JetDeclaratio
 
     @Override
     public boolean hasDeclaredReturnType() {
-        return false;
+        return true;
     }
 
     @NotNull
@@ -70,4 +82,12 @@ public class JetPropertyAccessor extends JetDeclaration implements JetDeclaratio
         return findChildByClass(JetTypeReference.class);
     }
 
+    @NotNull
+    public PsiElement getNamePlaceholder() {
+        PsiElement get = findChildByType(JetTokens.GET_KEYWORD);
+        if (get != null) {
+            return get;
+        }
+        return findChildByType(JetTokens.SET_KEYWORD);
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetChangeUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java
similarity index 50%
rename from idea/src/org/jetbrains/jet/lang/psi/JetChangeUtil.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java
index 6cbe9f35289..ab9ad23aa7c 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetChangeUtil.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java
@@ -1,10 +1,12 @@
 package org.jetbrains.jet.lang.psi;
 
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Pair;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFileFactory;
 import com.intellij.util.LocalTimeCounter;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lexer.JetKeywordToken;
 import org.jetbrains.jet.plugin.JetFileType;
 
 import java.util.List;
@@ -12,7 +14,7 @@ import java.util.List;
 /**
  * @author max
  */
-public class JetChangeUtil {
+public class JetPsiFactory {
     public static JetExpression createExpression(Project project, String text) {
         JetProperty property = createProperty(project, "val x = " + text);
         return property.getInitializer();
@@ -23,6 +25,21 @@ public class JetChangeUtil {
         return property.getPropertyTypeRef();
     }
 
+    //the pair contains the first and the last elements of a range
+    public static Pair<PsiElement, PsiElement> createColon(Project project) {
+        JetProperty property = createProperty(project, "val x : Int");
+        return Pair.create(property.findElementAt(5), property.findElementAt(7));
+    }
+
+    public static PsiElement createWhiteSpace(Project project) {
+        return createWhiteSpace(project, " ");
+    }
+
+    public static PsiElement createWhiteSpace(Project project, String text) {
+        JetProperty property = createProperty(project, "val" + text + "x");
+        return property.findElementAt(3);
+    }
+
     public static JetClass createClass(Project project, String text) {
         return createDeclaration(project, text, JetClass.class);
     }
@@ -32,8 +49,8 @@ public class JetChangeUtil {
         return (JetFile) PsiFileFactory.getInstance(project).createFileFromText("dummy.jet", JetFileType.INSTANCE, text, LocalTimeCounter.currentTime(), true);
     }
 
-    public static JetProperty createProperty(Project project, String name, String type) {
-        String text = "val " + name + (type != null ? ":" + type : "");
+    public static JetProperty createProperty(Project project, String name, String type, boolean isVar) {
+        String text = (isVar ? "var " : "val ") + name + (type != null ? ":" + type : "");
         return createProperty(project, text);
     }
 
@@ -52,10 +69,36 @@ public class JetChangeUtil {
     }
 
     public static PsiElement createNameIdentifier(Project project, String name) {
-        return createProperty(project, name, null).getNameIdentifier();
+        return createProperty(project, name, null, false).getNameIdentifier();
     }
 
     public static JetNamedFunction createFunction(Project project, String funDecl) {
         return createDeclaration(project, funDecl, JetNamedFunction.class);
     }
+
+    public static JetModifierList createModifier(Project project, JetKeywordToken modifier) {
+        String text = modifier.getValue() + " val x";
+        JetProperty property = createProperty(project, text);
+        return property.getModifierList();
+    }
+
+    public static JetExpression createEmptyBody(Project project) {
+        JetNamedFunction function = createFunction(project, "fun foo() {}");
+        return function.getBodyExpression();
+    }
+
+    public static JetNamespace createNamespace(Project project, String text) {
+        JetFile file = createFile(project, text);
+        return file.getRootNamespace();
+    }
+
+    public static JetImportDirective createImportDirective(Project project, String classPath) {
+        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/idea/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetQualifiedExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetQualifiedExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetQualifiedExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetQualifiedExpression.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java
new file mode 100644
index 00000000000..cbb25c75a4d
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java
@@ -0,0 +1,13 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public abstract class JetReferenceExpression extends JetExpression {
+    public JetReferenceExpression(@NotNull ASTNode node) {
+        super(node);
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetReturnExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetReturnExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetReturnExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetReturnExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetRootNamespaceExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetRootNamespaceExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetRootNamespaceExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetRootNamespaceExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetSafeQualifiedExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSafeQualifiedExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetSafeQualifiedExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSafeQualifiedExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetSelfType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSelfType.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetSelfType.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSelfType.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java
new file mode 100644
index 00000000000..1f1720abbf5
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java
@@ -0,0 +1,68 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.PsiReferenceService;
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
+import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.parsing.JetExpressionParsing;
+import org.jetbrains.jet.lexer.JetTokens;
+
+/**
+ * @author max
+ */
+public class JetSimpleNameExpression extends JetReferenceExpression {
+    public static final TokenSet REFERENCE_TOKENS = TokenSet.orSet(JetTokens.LABELS, TokenSet.create(JetTokens.IDENTIFIER, JetTokens.FIELD_IDENTIFIER, JetTokens.THIS_KEYWORD));
+
+    public JetSimpleNameExpression(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Nullable @IfNotParsed
+    public String getReferencedName() {
+        PsiElement referencedNameElement = getReferencedNameElement();
+        if (referencedNameElement == null) {
+            return null;
+        }
+        String text = referencedNameElement.getNode().getText();
+        if (text.startsWith("`") && text.endsWith("`") && text.length() >= 2) {
+            return text.substring(1, text.length()-1);
+        }
+        return text;
+    }
+
+    @Nullable @IfNotParsed
+    public PsiElement getReferencedNameElement() {
+        PsiElement element = findChildByType(REFERENCE_TOKENS);
+        if (element == null) {
+            element = findChildByType(JetExpressionParsing.ALL_OPERATIONS);
+        }
+        return element;
+    }
+
+    @Nullable @IfNotParsed
+    public IElementType getReferencedNameElementType() {
+        PsiElement element = getReferencedNameElement();
+        return element == null ? null : element.getNode().getElementType();
+    }
+
+    @NotNull
+    @Override
+    public PsiReference[] getReferences() {
+        return ReferenceProvidersRegistry.getReferencesFromProviders(this, PsiReferenceService.Hints.NO_HINTS);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitorVoid visitor) {
+        visitor.visitSimpleNameExpression(this);
+    }
+
+    @Override
+    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+        return visitor.visitSimpleNameExpression(this, data);
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSimpleNameStringTemplateEntry.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetSimpleNameStringTemplateEntry.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntry.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntry.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntryWithExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntryWithExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntryWithExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetStringTemplateEntryWithExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetStringTemplateExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetStringTemplateExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetStringTemplateExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetStringTemplateExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetThisExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThisExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetThisExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThisExpression.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThisReferenceExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThisReferenceExpression.java
new file mode 100644
index 00000000000..793e91ed146
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThisReferenceExpression.java
@@ -0,0 +1,23 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.PsiReferenceService;
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class JetThisReferenceExpression extends JetReferenceExpression {
+    public JetThisReferenceExpression(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @NotNull
+    @Override
+    public PsiReference[] getReferences() {
+        return ReferenceProvidersRegistry.getReferencesFromProviders(this, PsiReferenceService.Hints.NO_HINTS);
+    }
+
+}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetThrowExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThrowExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetThrowExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetThrowExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTryExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTryExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTryExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTryExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTupleExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTupleExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTupleExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTupleExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTuplePattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTuplePattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTuplePattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTuplePattern.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTuplePatternEntry.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTuplePatternEntry.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTuplePatternEntry.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTuplePatternEntry.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTupleType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTupleType.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTupleType.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTupleType.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypeArgumentList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeArgumentList.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypeArgumentList.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeArgumentList.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypeConstraint.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeConstraint.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypeConstraint.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeConstraint.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypeConstraintList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeConstraintList.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypeConstraintList.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeConstraintList.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypeElement.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeElement.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypeElement.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeElement.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypeParameter.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeParameter.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypeParameter.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeParameter.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypeParameterList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeParameterList.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypeParameterList.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeParameterList.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypeParameterListOwner.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeParameterListOwner.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypeParameterListOwner.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeParameterListOwner.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypePattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypePattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypePattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypePattern.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypeProjection.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeProjection.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypeProjection.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeProjection.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypeReference.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeReference.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypeReference.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeReference.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypedef.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypedef.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetTypedef.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypedef.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetUnaryExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetUnaryExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetUnaryExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetUnaryExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetUserType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetUserType.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetUserType.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetUserType.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetValueArgument.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgument.java
similarity index 79%
rename from idea/src/org/jetbrains/jet/lang/psi/JetValueArgument.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgument.java
index 3d4628cb026..6a60a1088af 100644
--- a/idea/src/org/jetbrains/jet/lang/psi/JetValueArgument.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgument.java
@@ -4,12 +4,13 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
 /**
  * @author max
  */
-public class JetValueArgument extends JetElement implements ValueArgumentPsi {
+public class JetValueArgument extends JetElement implements ValueArgument {
     public JetValueArgument(@NotNull ASTNode node) {
         super(node);
     }
@@ -23,34 +24,36 @@ public class JetValueArgument extends JetElement implements ValueArgumentPsi {
         return visitor.visitArgument(this, data);
     }
 
+    @Override
     @Nullable @IfNotParsed
     public JetExpression getArgumentExpression() {
         return findChildByClass(JetExpression.class);
     }
 
     @Override
-    public PsiElement asElement() {
-        return this;
-    }
-
     @Nullable
-    public String getArgumentName() {
-        ASTNode firstChildNode = getNode().getFirstChildNode();
-        if (firstChildNode == null) {
-            return null;
-        }
-        return firstChildNode.getElementType() == JetTokens.IDENTIFIER ? firstChildNode.getText() : null;
+    public JetValueArgumentName getArgumentName() {
+        return (JetValueArgumentName) findChildByType(JetNodeTypes.VALUE_ARGUMENT_NAME);
     }
 
+    @Override
     public boolean isNamed() {
         return getArgumentName() != null;
     }
 
+    @Override
     public boolean isOut() {
         return findChildByType(JetTokens.OUT_KEYWORD) != null;
     }
 
+    @Override
     public boolean isRef() {
         return findChildByType(JetTokens.REF_KEYWORD) != null;
     }
+
+    @NotNull
+    @Override
+    public PsiElement asElement() {
+        return this;
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetValueArgumentList.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgumentList.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetValueArgumentList.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgumentList.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgumentName.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgumentName.java
new file mode 100644
index 00000000000..87c4e8504d6
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetValueArgumentName.java
@@ -0,0 +1,22 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.JetNodeTypes;
+
+/**
+ * @author abreslav
+ */
+public class JetValueArgumentName extends JetElement {
+    public JetValueArgumentName(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Nullable @IfNotParsed
+    public JetSimpleNameExpression getReferenceExpression() {
+        return (JetSimpleNameExpression) findChildByType(JetNodeTypes.REFERENCE_EXPRESSION);
+    }
+
+
+}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetWhenCondition.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenCondition.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetWhenCondition.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenCondition.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetWhenConditionCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenConditionCall.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetWhenConditionCall.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenConditionCall.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetWhenConditionInRange.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenConditionInRange.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetWhenConditionInRange.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenConditionInRange.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetWhenConditionIsPattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenConditionIsPattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetWhenConditionIsPattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenConditionIsPattern.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetWhenEntry.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenEntry.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetWhenEntry.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenEntry.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetWhenExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetWhenExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhenExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetWhileExpression.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhileExpression.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetWhileExpression.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWhileExpression.java
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetWildcardPattern.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWildcardPattern.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/psi/JetWildcardPattern.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetWildcardPattern.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/ValueArgument.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/ValueArgument.java
new file mode 100644
index 00000000000..967a27d3d6a
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/ValueArgument.java
@@ -0,0 +1,27 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author abreslav
+ */
+public interface ValueArgument {
+    @Nullable
+    @JetElement.IfNotParsed
+    JetExpression getArgumentExpression();
+
+    @Nullable
+    JetValueArgumentName getArgumentName();
+
+    boolean isNamed();
+
+    boolean isOut();
+
+    boolean isRef();
+
+    @NotNull
+    PsiElement asElement();
+
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java
similarity index 73%
rename from idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java
index a75b1ed3be4..2d5218a40a3 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java
@@ -2,9 +2,12 @@ package org.jetbrains.jet.lang.resolve;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.Collection;
+import java.util.List;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -15,14 +18,19 @@ public abstract class AbstractScopeAdapter implements JetScope {
 
     @NotNull
     @Override
-    public JetType getThisType() {
-        return getWorkerScope().getThisType();
+    public ReceiverDescriptor getImplicitReceiver() {
+        return getWorkerScope().getImplicitReceiver();
+    }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+        getWorkerScope().getImplicitReceiversHierarchy(result);
     }
 
     @NotNull
     @Override
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        return getWorkerScope().getFunctionGroup(name);
+    public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        return getWorkerScope().getFunctions(name);
     }
 
     @Override
@@ -62,6 +70,7 @@ public abstract class AbstractScopeAdapter implements JetScope {
         return getWorkerScope().getDeclarationDescriptorForUnqualifiedThis();
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         return getWorkerScope().getAllDescriptors();
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java
similarity index 68%
rename from idea/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java
index 1c466051715..7b39810143c 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java
@@ -11,19 +11,22 @@ import com.intellij.psi.util.CachedValueProvider;
 import com.intellij.psi.util.CachedValuesManager;
 import com.intellij.psi.util.PsiModificationTracker;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ErrorHandler;
-import org.jetbrains.jet.lang.JetDiagnostic;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.diagnostics.*;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamespace;
-import org.jetbrains.jet.lang.resolve.java.JavaPackageScope;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 
-import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
+
+//import org.jetbrains.jet.lang.resolve.java.JavaPackageScope;
+//import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 
 /**
  * @author abreslav
@@ -32,55 +35,52 @@ public class AnalyzingUtils {
     private final static Key<CachedValue<BindingContext>> BINDING_CONTEXT = Key.create("BINDING_CONTEXT");
     private static final Object lock = new Object();
 
-    public static BindingContext analyzeFileWithCache(@NotNull final JetFile file) {
-        // TODO : Synchronization?
-        CachedValue<BindingContext> bindingContextCachedValue = file.getUserData(BINDING_CONTEXT);
-        if (bindingContextCachedValue == null) {
-            bindingContextCachedValue = CachedValuesManager.getManager(file.getProject()).createCachedValue(new CachedValueProvider<BindingContext>() {
-                @Override
-                public Result<BindingContext> compute() {
-                    synchronized (lock) {
-                        try {
-                            JetNamespace rootNamespace = file.getRootNamespace();
-                            BindingContext bindingContext = analyzeNamespace(rootNamespace, JetControlFlowDataTraceFactory.EMPTY);
-                            return new Result<BindingContext>(bindingContext, PsiModificationTracker.MODIFICATION_COUNT);
-                        }
-                        catch (ProcessCanceledException e) {
-                            throw e;
-                        }
-                        catch (Throwable e) {
-                            e.printStackTrace();
-                            BindingTraceContext bindingTraceContext = new BindingTraceContext();
-                            bindingTraceContext.getErrorHandler().genericError(file.getNode(), e.getClass().getSimpleName() + ": " + e.getMessage());
-                            return new Result<BindingContext>(bindingTraceContext.getBindingContext(), PsiModificationTracker.MODIFICATION_COUNT);
-                        }
-                    }
-                }
-            }, false);
-            file.putUserData(BINDING_CONTEXT, bindingContextCachedValue);
-        }
-        return bindingContextCachedValue.getValue();
+    public static AnalyzingUtils getInstance(@NotNull ImportingStrategy importingStrategy) {
+        return new AnalyzingUtils(importingStrategy);
     }
 
-    public static BindingContext analyzeNamespace(@NotNull JetNamespace namespace, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) {
-        Project project = namespace.getProject();
+    public static void checkForSyntacticErrors(@NotNull PsiElement root) {
+        root.acceptChildren(new PsiElementVisitor() {
+            @Override
+            public void visitElement(PsiElement element) {
+                element.acceptChildren(this);
+            }
 
+            @Override
+            public void visitErrorElement(PsiErrorElement element) {
+                throw new IllegalArgumentException(element.getErrorDescription() + "; looking at " + element.getNode().getElementType() + " '" + element.getText() + DiagnosticUtils.atLocation(element));
+            }
+        });
+    }
+
+    public static void throwExceptionOnErrors(BindingContext bindingContext) {
+        for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
+            DiagnosticHolder.THROW_EXCEPTION.report(diagnostic);
+        }
+    }
+
+    private final ImportingStrategy importingStrategy;
+
+    private AnalyzingUtils(ImportingStrategy importingStrategy) {
+        this.importingStrategy = importingStrategy;
+    }
+
+    public BindingContext analyzeNamespace(@NotNull JetNamespace namespace, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) {
+        Project project = namespace.getProject();
+        List<JetDeclaration> declarations = Collections.<JetDeclaration>singletonList(namespace);
+
+        return analyzeNamespaces(project, declarations, flowDataTraceFactory);
+    }
+
+    public BindingContext analyzeNamespaces(@NotNull Project project, @NotNull List<? extends JetDeclaration> declarations, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) {
         BindingTraceContext bindingTraceContext = new BindingTraceContext();
         JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project, flowDataTraceFactory);
-        JavaSemanticServices javaSemanticServices = new JavaSemanticServices(project, semanticServices, bindingTraceContext);
 
         JetScope libraryScope = semanticServices.getStandardLibrary().getLibraryScope();
         ModuleDescriptor owner = new ModuleDescriptor("<module>");
-        final WritableScope scope = new WritableScopeImpl(libraryScope, owner, bindingTraceContext.getErrorHandler()).setDebugName("Root scope in analyzeNamespace");
-//        scope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace("").getMemberScope());
-//        scope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace("java.lang").getMemberScope());
-        scope.importScope(new JavaPackageScope("", null, javaSemanticServices));
-        scope.importScope(new JavaPackageScope("java.lang", null, javaSemanticServices));
-
-        TopDownAnalyzer topDownAnalyzer = new TopDownAnalyzer(semanticServices, bindingTraceContext);
-//        topDownAnalyzer.process(scope, Collections.<JetDeclaration>singletonList(namespace));
-//        if (false)
-        topDownAnalyzer.process(scope, new NamespaceLike.Adapter(owner) {
+        final WritableScope scope = new WritableScopeImpl(libraryScope, owner, new TraceBasedRedeclarationHandler(bindingTraceContext)).setDebugName("Root scope in analyzeNamespace");
+        importingStrategy.addImports(project, semanticServices, bindingTraceContext, scope);
+        TopDownAnalyzer.process(semanticServices, bindingTraceContext, scope, new NamespaceLike.Adapter(owner) {
 
             @Override
             public NamespaceDescriptorImpl getNamespace(String name) {
@@ -111,32 +111,38 @@ public class AnalyzingUtils {
             public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
                 throw new IllegalStateException("Must be guaranteed not to happen by the parser");
             }
-        }, Collections.<JetDeclaration>singletonList(namespace));
+        }, declarations);
         return bindingTraceContext.getBindingContext();
     }
 
-    public static void applyHandler(@NotNull ErrorHandler errorHandler, @NotNull BindingContext bindingContext) {
-        Collection<JetDiagnostic> diagnostics = bindingContext.getDiagnostics();
-        applyHandler(errorHandler, diagnostics);
-    }
-
-    public static void applyHandler(@NotNull ErrorHandler errorHandler, @NotNull Collection<JetDiagnostic> diagnostics) {
-        for (JetDiagnostic jetDiagnostic : diagnostics) {
-            jetDiagnostic.acceptHandler(errorHandler);
+    public BindingContext analyzeFileWithCache(@NotNull final JetFile file) {
+        // TODO : Synchronization?
+        CachedValue<BindingContext> bindingContextCachedValue = file.getUserData(BINDING_CONTEXT);
+        if (bindingContextCachedValue == null) {
+            bindingContextCachedValue = CachedValuesManager.getManager(file.getProject()).createCachedValue(new CachedValueProvider<BindingContext>() {
+                @Override
+                public Result<BindingContext> compute() {
+                    synchronized (lock) {
+                        try {
+                            JetNamespace rootNamespace = file.getRootNamespace();
+                            BindingContext bindingContext = analyzeNamespace(rootNamespace, JetControlFlowDataTraceFactory.EMPTY);
+                            return new Result<BindingContext>(bindingContext, PsiModificationTracker.MODIFICATION_COUNT);
+                        }
+                        catch (ProcessCanceledException e) {
+                            throw e;
+                        }
+                        catch (Throwable e) {
+                            e.printStackTrace();
+                            BindingTraceContext bindingTraceContext = new BindingTraceContext();
+//                            bindingTraceContext.getErrorHandler().genericError(file.getNode(), e.getClass().getSimpleName() + ": " + e.getMessage());
+                            bindingTraceContext.report(Errors.EXCEPTION_WHILE_ANALYZING.on(file, e));
+                            return new Result<BindingContext>(bindingTraceContext.getBindingContext(), PsiModificationTracker.MODIFICATION_COUNT);
+                        }
+                    }
+                }
+            }, false);
+            file.putUserData(BINDING_CONTEXT, bindingContextCachedValue);
         }
+        return bindingContextCachedValue.getValue();
     }
-
-    public static void checkForSyntacticErrors(@NotNull PsiElement root) {
-        root.acceptChildren(new PsiElementVisitor() {
-            @Override
-            public void visitElement(PsiElement element) {
-                element.acceptChildren(this);
-            }
-
-            @Override
-            public void visitErrorElement(PsiErrorElement element) {
-                throw new IllegalArgumentException(element.getErrorDescription() + " at offset " + element.getTextRange().getStartOffset());
-            }
-        });
-    }
-}
\ No newline at end of file
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
similarity index 75%
rename from idea/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
index 51f97050489..813118617a6 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
@@ -4,24 +4,33 @@ import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetAnnotationEntry;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetModifierList;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.JetTypeInferrer;
 
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.jet.lang.types.JetTypeInferrer.NO_EXPECTED_TYPE;
+
 /**
  * @author abreslav
  */
 public class AnnotationResolver {
 
     private final BindingTrace trace;
+    private final JetTypeInferrer typeInferrer;
 
     public AnnotationResolver(JetSemanticServices semanticServices, BindingTrace trace) {
+        this.typeInferrer = new JetTypeInferrer(JetFlowInformationProvider.THROW_EXCEPTION, semanticServices);
         this.trace = trace;
     }
 
@@ -29,15 +38,19 @@ public class AnnotationResolver {
     public List<AnnotationDescriptor> resolveAnnotations(@NotNull JetScope scope, @NotNull List<JetAnnotationEntry> annotationEntryElements) {
         if (annotationEntryElements.isEmpty()) return Collections.emptyList();
         List<AnnotationDescriptor> result = Lists.newArrayList();
-//        for (JetAnnotationEntry entryElement : annotationEntryElements) {
-//            JetType jetType = typeInferrer.checkTypeInitializerCall(scope, entryElement.getTypeReference(), entryElement);
-//            AnnotationDescriptor descriptor = new AnnotationDescriptor();
-//            descriptor.setAnnotationType(jetType);
-//            result.add(descriptor);
-//        }
+        for (JetAnnotationEntry entryElement : annotationEntryElements) {
+            AnnotationDescriptor descriptor = new AnnotationDescriptor();
+            resolveAnnotationStub(scope, entryElement, descriptor);
+            result.add(descriptor);
+        }
         return result;
     }
 
+    public void resolveAnnotationStub(@NotNull JetScope scope, @NotNull JetAnnotationEntry entryElement, @NotNull AnnotationDescriptor descriptor) {
+        JetType jetType = typeInferrer.getCallResolver().resolveCall(trace, scope, ReceiverDescriptor.NO_RECEIVER, entryElement, NO_EXPECTED_TYPE);
+        descriptor.setAnnotationType(jetType == null ? ErrorUtils.createErrorType("Unresolved annotation type") : jetType);
+    }
+
     @NotNull
     public List<AnnotationDescriptor> resolveAnnotations(@NotNull JetScope scope, @Nullable JetModifierList modifierList) {
         if (modifierList == null) {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
new file mode 100644
index 00000000000..c4b719d139a
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
@@ -0,0 +1,130 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.DeferredType;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.util.CommonSuppliers;
+import org.jetbrains.jet.util.slicedmap.*;
+
+import java.util.Collection;
+
+/**
+ * @author abreslav
+ */
+public interface BindingContext {
+    WritableSlice<JetElement, ReceiverDescriptor> RECEIVER = Slices.createSimpleSlice("RECEIVER");
+
+    WritableSlice<JetAnnotationEntry, AnnotationDescriptor> ANNOTATION = Slices.createSimpleSlice("ANNOTATION");
+    WritableSlice<JetExpression, CompileTimeConstant<?>> COMPILE_TIME_VALUE = Slices.createSimpleSlice("COMPILE_TIME_VALUE");
+    WritableSlice<JetTypeReference, JetType> TYPE = Slices.createSimpleSlice("TYPE");
+    WritableSlice<JetExpression, JetType> EXPRESSION_TYPE = new BasicWritableSlice<JetExpression, JetType>("EXPRESSION_TYPE", RewritePolicy.DO_NOTHING);
+
+    WritableSlice<JetReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET = new BasicWritableSlice<JetReferenceExpression, DeclarationDescriptor>("REFERENCE_TARGET", RewritePolicy.DO_NOTHING);
+    WritableSlice<JetReferenceExpression, Collection<? extends DeclarationDescriptor>> AMBIGUOUS_REFERENCE_TARGET = new BasicWritableSlice<JetReferenceExpression, Collection<? extends DeclarationDescriptor>>("AMBIGUOUS_REFERENCE_TARGET", RewritePolicy.DO_NOTHING);
+
+    WritableSlice<JetExpression, FunctionDescriptor> LOOP_RANGE_ITERATOR = Slices.createSimpleSlice("LOOP_RANGE_ITERATOR");
+    WritableSlice<JetExpression, CallableDescriptor> LOOP_RANGE_HAS_NEXT = Slices.createSimpleSlice("LOOP_RANGE_HAS_NEXT");
+    WritableSlice<JetExpression, FunctionDescriptor> LOOP_RANGE_NEXT = Slices.createSimpleSlice("LOOP_RANGE_NEXT");
+
+    WritableSlice<JetExpression, JetType> AUTOCAST = Slices.createSimpleSlice("AUTOCAST");
+    WritableSlice<JetExpression, JetScope> RESOLUTION_SCOPE = Slices.createSimpleSlice("RESOLUTION_SCOPE");
+
+    WritableSlice<JetExpression, Boolean> VARIABLE_REASSIGNMENT = Slices.createSimpleSetSlice("VARIABLE_REASSIGNMENT");
+    WritableSlice<ValueParameterDescriptor, Boolean> AUTO_CREATED_IT = Slices.createSimpleSetSlice("AUTO_CREATED_IT");
+    WritableSlice<JetExpression, DeclarationDescriptor> VARIABLE_ASSIGNMENT = Slices.createSimpleSlice("VARIABLE_ASSIGNMENT");
+    WritableSlice<JetExpression, Boolean> PROCESSED = Slices.createSimpleSetSlice("PROCESSED");
+    WritableSlice<JetElement, Boolean> STATEMENT = Slices.createRemovableSetSlice("STATEMENT");
+    WritableSlice<CallableMemberDescriptor, Boolean> DELEGATED = Slices.createRemovableSetSlice("DELEGATED");
+    
+    enum DeferredTypeKey {DEFERRED_TYPE_KEY}
+    WritableSlice<DeferredTypeKey, Collection<DeferredType>> DEFERRED_TYPES = Slices.createSimpleSlice("DEFERRED_TYPES");
+    WritableSlice<DeferredTypeKey, DeferredType> DEFERRED_TYPE = new CollectionSliceWrapper<DeferredTypeKey, DeferredType>(DEFERRED_TYPES, CommonSuppliers.<DeferredType>getArrayListSupplier());
+
+    WritableSlice<PropertyDescriptor, Boolean> BACKING_FIELD_REQUIRED = new Slices.SetSlice<PropertyDescriptor>("BACKING_FIELD_REQUIRED", RewritePolicy.DO_NOTHING) {
+        @Override
+        public Boolean computeValue(SlicedMap map, PropertyDescriptor propertyDescriptor, Boolean backingFieldRequired, boolean valueNotFound) {
+            backingFieldRequired = valueNotFound ? false : backingFieldRequired;
+            assert backingFieldRequired != null;
+            PsiElement declarationPsiElement = map.get(DESCRIPTOR_TO_DECLARATION, propertyDescriptor);
+            if (declarationPsiElement instanceof JetParameter) {
+                JetParameter jetParameter = (JetParameter) declarationPsiElement;
+                return jetParameter.getValOrVarNode() != null ||
+                       backingFieldRequired;
+            }
+            if (propertyDescriptor.getModality() == Modality.ABSTRACT) return false;
+            PropertyGetterDescriptor getter = propertyDescriptor.getGetter();
+            PropertySetterDescriptor setter = propertyDescriptor.getSetter();
+            if (getter == null) {
+                return true;
+            }
+            else if (propertyDescriptor.isVar() && setter == null) {
+                return true;
+            }
+            else if (setter != null && !setter.hasBody() && setter.getModality() != Modality.ABSTRACT) {
+                return true;
+            }
+            else if (!getter.hasBody() && getter.getModality() != Modality.ABSTRACT) {
+                return true;
+            }
+            return backingFieldRequired;
+        }
+    };
+    WritableSlice<PropertyDescriptor, Boolean> IS_INITIALIZED = Slices.createSimpleSetSlice("IS_INITIALIZED");
+
+    WritableSlice<JetFunctionLiteralExpression, Boolean> BLOCK = new Slices.SetSlice<JetFunctionLiteralExpression>("BLOCK", RewritePolicy.DO_NOTHING) {
+        @Override
+        public Boolean computeValue(SlicedMap map, JetFunctionLiteralExpression expression, Boolean isBlock, boolean valueNotFound) {
+            isBlock = valueNotFound ? false : isBlock;
+            assert isBlock != null;
+            return isBlock && !expression.getFunctionLiteral().hasParameterSpecification();
+        }
+    };
+
+    Slices.KeyNormalizer<DeclarationDescriptor> DECLARATION_DESCRIPTOR_NORMALIZER = new Slices.KeyNormalizer<DeclarationDescriptor>() {
+        @Override
+        public DeclarationDescriptor normalize(DeclarationDescriptor declarationDescriptor) {
+            if (declarationDescriptor instanceof VariableAsFunctionDescriptor) {
+                VariableAsFunctionDescriptor descriptor = (VariableAsFunctionDescriptor) declarationDescriptor;
+                return descriptor.getVariableDescriptor().getOriginal();
+            }
+            return declarationDescriptor.getOriginal();
+        }
+    };
+    ReadOnlySlice<DeclarationDescriptor, PsiElement> DESCRIPTOR_TO_DECLARATION = Slices.<DeclarationDescriptor, PsiElement>sliceBuilder("DECLARATION_TO_DESCRIPTOR").setKeyNormalizer(DECLARATION_DESCRIPTOR_NORMALIZER).build();
+
+    WritableSlice<PsiElement, NamespaceDescriptor> NAMESPACE = Slices.<PsiElement, NamespaceDescriptor>sliceBuilder("DECLARATION").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.<PsiElement, ClassDescriptor>sliceBuilder("CLASS").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<JetTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.<JetTypeParameter, TypeParameterDescriptor>sliceBuilder("TYPE_PARAMETER").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<PsiElement, FunctionDescriptor> FUNCTION = Slices.<PsiElement, FunctionDescriptor>sliceBuilder("FUNCTION").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<PsiElement, ConstructorDescriptor> CONSTRUCTOR = Slices.<PsiElement, ConstructorDescriptor>sliceBuilder("CONSTRUCTOR").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<PsiElement, VariableDescriptor> VARIABLE = Slices.<PsiElement, VariableDescriptor>sliceBuilder("VARIABLE").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<JetParameter, VariableDescriptor> VALUE_PARAMETER = Slices.<JetParameter, VariableDescriptor>sliceBuilder("VALUE_PARAMETER").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<JetPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR = Slices.<JetPropertyAccessor, PropertyAccessorDescriptor>sliceBuilder("PROPERTY_ACCESSOR").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+
+    // normalize value to getOriginal(value)
+    WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER = Slices.<PsiElement, PropertyDescriptor>sliceBuilder("PRIMARY_CONSTRUCTOR_PARAMETER").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<JetObjectDeclarationName, PropertyDescriptor> OBJECT_DECLARATION = Slices.<JetObjectDeclarationName, PropertyDescriptor>sliceBuilder("OBJECT_DECLARATION").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+
+    WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] {
+        NAMESPACE, CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PRIMARY_CONSTRUCTOR_PARAMETER, OBJECT_DECLARATION
+    };
+
+    ReadOnlySlice<PsiElement, DeclarationDescriptor> DECLARATION_TO_DESCRIPTOR = Slices.<PsiElement, DeclarationDescriptor>sliceBuilder("DECLARATION_TO_DESCRIPTOR")
+            .setFurtherLookupSlices(DECLARATIONS_TO_DESCRIPTORS).build();
+
+    WritableSlice<JetReferenceExpression, PsiElement> LABEL_TARGET = Slices.<JetReferenceExpression, PsiElement>sliceBuilder("LABEL_TARGET").build();
+    WritableSlice<JetParameter, PropertyDescriptor> VALUE_PARAMETER_AS_PROPERTY = Slices.<JetParameter, PropertyDescriptor>sliceBuilder("VALUE_PARAMETER_AS_PROPERTY").build();
+
+    Collection<Diagnostic> getDiagnostics();
+
+    @Nullable
+    <K, V> V get(ReadOnlySlice<K, V> slice, K key);
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/BindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTrace.java
similarity index 54%
rename from idea/src/org/jetbrains/jet/lang/resolve/BindingTrace.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTrace.java
index e8669968c8e..b346cf32938 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/BindingTrace.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTrace.java
@@ -1,17 +1,14 @@
 package org.jetbrains.jet.lang.resolve;
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ErrorHandler;
-import org.jetbrains.jet.util.ReadOnlySlice;
-import org.jetbrains.jet.util.WritableSlice;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
+import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
+import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 /**
  * @author abreslav
  */
-public interface BindingTrace {
-
-    @NotNull
-    ErrorHandler getErrorHandler();
+public interface BindingTrace extends DiagnosticHolder {
 
     BindingContext getBindingContext();
     
@@ -20,5 +17,6 @@ public interface BindingTrace {
     // Writes TRUE for a boolean value
     <K> void record(WritableSlice<K, Boolean> slice, K key);
 
+    @Nullable
     <K, V> V get(ReadOnlySlice<K, V> slice, K key);
 }
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java
similarity index 60%
rename from idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java
index d919e31704f..1ada727f830 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java
@@ -2,13 +2,11 @@ package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.CollectingErrorHandler;
-import org.jetbrains.jet.lang.ErrorHandler;
-import org.jetbrains.jet.lang.JetDiagnostic;
-import org.jetbrains.jet.util.ManyMapImpl;
-import org.jetbrains.jet.util.MutableManyMap;
-import org.jetbrains.jet.util.ReadOnlySlice;
-import org.jetbrains.jet.util.WritableSlice;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.util.slicedmap.MutableSlicedMap;
+import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
+import org.jetbrains.jet.util.slicedmap.SlicedMapImpl;
+import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 import java.util.Collection;
 import java.util.List;
@@ -17,13 +15,14 @@ import java.util.List;
  * @author abreslav
  */
 public class BindingTraceContext implements BindingTrace {
-    private final List<JetDiagnostic> diagnostics = Lists.newArrayList();
-    private final ErrorHandler errorHandler = new CollectingErrorHandler(diagnostics);
-    private final MutableManyMap map = ManyMapImpl.create();
+    private final List<Diagnostic> diagnostics = Lists.newArrayList();
+
+    private final MutableSlicedMap map = SlicedMapImpl.create();
 
     private final BindingContext bindingContext = new BindingContext() {
+
         @Override
-        public Collection<JetDiagnostic> getDiagnostics() {
+        public Collection<Diagnostic> getDiagnostics() {
             return diagnostics;
         }
 
@@ -33,10 +32,9 @@ public class BindingTraceContext implements BindingTrace {
         }
     };
 
-    @NotNull
     @Override
-    public ErrorHandler getErrorHandler() {
-        return errorHandler;
+    public void report(@NotNull Diagnostic diagnostic) {
+        diagnostics.add(diagnostic);
     }
 
     @Override
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
new file mode 100644
index 00000000000..c8255af2f9d
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
@@ -0,0 +1,576 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.util.containers.Queue;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lexer.JetTokens;
+import org.jetbrains.jet.util.slicedmap.WritableSlice;
+
+import java.util.*;
+
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE;
+import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPES;
+import static org.jetbrains.jet.lang.resolve.BindingContext.DeferredTypeKey.DEFERRED_TYPE_KEY;
+import static org.jetbrains.jet.lang.types.JetTypeInferrer.NO_EXPECTED_TYPE;
+
+/**
+* @author abreslav
+*/
+public class BodyResolver {
+    private final TopDownAnalysisContext context;
+
+    private final ObservableBindingTrace traceForConstructors;
+    private final ObservableBindingTrace traceForMembers;
+
+    public BodyResolver(TopDownAnalysisContext context) {
+        this.context = context;
+
+        // This allows access to backing fields
+        this.traceForConstructors = new ObservableBindingTrace(context.getTrace()).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler<JetReferenceExpression, DeclarationDescriptor>() {
+            @Override
+            public void handleRecord(WritableSlice<JetReferenceExpression, DeclarationDescriptor> slice, JetReferenceExpression expression, DeclarationDescriptor descriptor) {
+                if (expression instanceof JetSimpleNameExpression) {
+                    JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression;
+                    if (simpleNameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
+                        if (!BodyResolver.this.context.getTrace().getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, (PropertyDescriptor) descriptor)) {
+                            BodyResolver.this.context.getTrace().report(NO_BACKING_FIELD.on(expression));
+                        }
+                    }
+                }
+            }
+        });
+
+        // This tracks access to properties in order to register primary constructor parameters that yield real fields (JET-9)
+        this.traceForMembers = new ObservableBindingTrace(context.getTrace()).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler<JetReferenceExpression, DeclarationDescriptor>() {
+            @Override
+            public void handleRecord(WritableSlice<JetReferenceExpression, DeclarationDescriptor> slice, JetReferenceExpression expression, DeclarationDescriptor descriptor) {
+                if (descriptor instanceof PropertyDescriptor) {
+                    PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
+                    if (BodyResolver.this.context.getPrimaryConstructorParameterProperties().contains(propertyDescriptor)) {
+                        traceForMembers.record(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor);
+                    }
+                }
+            }
+        });
+
+    }
+
+
+    public void resolveBehaviorDeclarationBodies() {
+
+        resolveDelegationSpecifierLists();
+        resolveClassAnnotations();
+
+        resolveAnonymousInitializers();
+        resolvePropertyDeclarationBodies();
+
+        resolveSecondaryConstructorBodies();
+        resolveFunctionBodies();
+
+        computeDeferredTypes();        
+    }
+    
+    private void computeDeferredTypes() {
+        Collection<DeferredType> deferredTypes = context.getTrace().get(DEFERRED_TYPES, DEFERRED_TYPE_KEY);
+        if (deferredTypes != null) {
+            final Queue<DeferredType> queue = new Queue<DeferredType>(deferredTypes.size());
+            context.getTrace().addHandler(DEFERRED_TYPE, new ObservableBindingTrace.RecordHandler<BindingContext.DeferredTypeKey, DeferredType>() {
+                @Override
+                public void handleRecord(WritableSlice<BindingContext.DeferredTypeKey, DeferredType> deferredTypeKeyDeferredTypeWritableSlice, BindingContext.DeferredTypeKey key, DeferredType value) {
+                    queue.addLast(value);
+                }
+            });
+            for (DeferredType deferredType : deferredTypes) {
+                queue.addLast(deferredType);
+            }
+            while (!queue.isEmpty()) {
+                DeferredType deferredType = queue.pullFirst();
+                if (!deferredType.isComputed()) {
+                    try {
+                        deferredType.getActualType(); // to compute
+                    }
+                    catch (ReenteringLazyValueComputationException e) {
+                        // A problem should be reported while computing the type
+                    }
+                }
+            }
+        }
+    }
+
+
+    private void resolveDelegationSpecifierLists() {
+        // TODO : Make sure the same thing is not initialized twice
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            resolveDelegationSpecifierList(entry.getKey(), entry.getValue());
+        }
+        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+            resolveDelegationSpecifierList(entry.getKey(), entry.getValue());
+        }
+    }
+
+    private void resolveDelegationSpecifierList(final JetClassOrObject jetClass, final MutableClassDescriptor descriptor) {
+        final ConstructorDescriptor primaryConstructor = descriptor.getUnsubstitutedPrimaryConstructor();
+        final JetScope scopeForConstructor = primaryConstructor == null
+                ? null
+                : getInnerScopeForConstructor(primaryConstructor, descriptor.getScopeForMemberResolution(), true);
+        final JetTypeInferrer.Services typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors, JetFlowInformationProvider.NONE); // TODO : flow
+
+        final Map<JetTypeReference, JetType> supertypes = Maps.newLinkedHashMap();
+        JetVisitorVoid visitor = new JetVisitorVoid() {
+            private void recordSupertype(JetTypeReference typeReference, JetType supertype) {
+                if (supertype == null) return;
+                supertypes.put(typeReference, supertype);
+            }
+
+            @Override
+            public void visitDelegationByExpressionSpecifier(JetDelegatorByExpressionSpecifier specifier) {
+                if (descriptor.getKind() == ClassKind.TRAIT) {
+                    context.getTrace().report(DELEGATION_IN_TRAIT.on(specifier));
+                }
+                JetType supertype = context.getTrace().getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
+                recordSupertype(specifier.getTypeReference(), supertype);
+                if (supertype != null) {
+                    DeclarationDescriptor declarationDescriptor = supertype.getConstructor().getDeclarationDescriptor();
+                    if (declarationDescriptor instanceof ClassDescriptor) {
+                        ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor;
+                        if (classDescriptor.getKind() != ClassKind.TRAIT) {
+                            context.getTrace().report(DELEGATION_NOT_TO_TRAIT.on(specifier.getTypeReference()));
+                        }
+                    }
+                }
+                JetExpression delegateExpression = specifier.getDelegateExpression();
+                if (delegateExpression != null) {
+                    JetScope scope = scopeForConstructor == null
+                                     ? descriptor.getScopeForMemberResolution()
+                                     : scopeForConstructor;
+                    JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE);
+                    if (type != null && supertype != null && !context.getSemanticServices().getTypeChecker().isSubtypeOf(type, supertype)) {
+                        context.getTrace().report(TYPE_MISMATCH.on(delegateExpression, supertype, type));
+                    }
+                }
+            }
+
+            @Override
+            public void visitDelegationToSuperCallSpecifier(JetDelegatorToSuperCall call) {
+                JetValueArgumentList valueArgumentList = call.getValueArgumentList();
+                ASTNode node = valueArgumentList == null ? call.getNode() : valueArgumentList.getNode();
+                if (descriptor.getKind() == ClassKind.TRAIT) {
+                    context.getTrace().report(SUPERTYPE_INITIALIZED_IN_TRAIT.on(node));
+                }
+                JetTypeReference typeReference = call.getTypeReference();
+                if (typeReference != null) {
+                    if (descriptor.getUnsubstitutedPrimaryConstructor() != null) {
+                        JetType supertype = typeInferrer.getCallResolver().resolveCall(context.getTrace(), scopeForConstructor, ReceiverDescriptor.NO_RECEIVER, call, NO_EXPECTED_TYPE);
+                        if (supertype != null) {
+                            recordSupertype(typeReference, supertype);
+                            ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);
+                            if (classDescriptor != null) {
+                                if (classDescriptor.getKind() == ClassKind.TRAIT) {
+                                    context.getTrace().report(CONSTRUCTOR_IN_TRAIT.on(node));
+                                }
+                            }
+                        }
+                        else {
+                            recordSupertype(typeReference, context.getTrace().getBindingContext().get(BindingContext.TYPE, typeReference));
+                        }
+                    }
+                    else if (descriptor.getKind() != ClassKind.TRAIT) {
+                        JetType supertype = context.getTrace().getBindingContext().get(BindingContext.TYPE, typeReference);
+                        recordSupertype(typeReference, supertype);
+
+                        assert valueArgumentList != null;
+                        context.getTrace().report(PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL.on(valueArgumentList, jetClass));
+                    }
+                }
+            }
+
+            @Override
+            public void visitDelegationToSuperClassSpecifier(JetDelegatorToSuperClass specifier) {
+                JetTypeReference typeReference = specifier.getTypeReference();
+                JetType supertype = context.getTrace().getBindingContext().get(BindingContext.TYPE, typeReference);
+                recordSupertype(typeReference, supertype);
+                if (supertype != null) {
+                    ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);
+                    if (classDescriptor != null) {
+                        if (descriptor.getKind() != ClassKind.TRAIT) {
+                            if (classDescriptor.hasConstructors() && !ErrorUtils.isError(classDescriptor.getTypeConstructor()) && classDescriptor.getKind() != ClassKind.TRAIT) {
+                                context.getTrace().report(SUPERTYPE_NOT_INITIALIZED.on(specifier));
+                            }
+                        }
+                    }
+                }
+            }
+
+            @Override
+            public void visitDelegationToThisCall(JetDelegatorToThisCall thisCall) {
+                throw new IllegalStateException("This-calls should be prohibited by the parser");
+            }
+
+            @Override
+            public void visitJetElement(JetElement element) {
+                throw new UnsupportedOperationException(element.getText() + " : " + element);
+            }
+        };
+
+        for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) {
+            delegationSpecifier.accept(visitor);
+        }
+
+
+        Set<TypeConstructor> parentEnum = Collections.emptySet();
+        if (jetClass instanceof JetEnumEntry) {
+            parentEnum = Collections.singleton(((ClassDescriptor) descriptor.getContainingDeclaration().getContainingDeclaration()).getTypeConstructor());
+        }
+
+        checkSupertypeList(descriptor, supertypes, parentEnum);
+    }
+
+    // allowedFinalSupertypes typically contains a enum type of which supertypeOwner is an entry
+    private void checkSupertypeList(@NotNull MutableClassDescriptor supertypeOwner, @NotNull Map<JetTypeReference, JetType> supertypes, Set<TypeConstructor> allowedFinalSupertypes) {
+        Set<TypeConstructor> typeConstructors = Sets.newHashSet();
+        boolean classAppeared = false;
+        for (Map.Entry<JetTypeReference, JetType> entry : supertypes.entrySet()) {
+            JetTypeReference typeReference = entry.getKey();
+            JetType supertype = entry.getValue();
+
+            ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);
+            if (classDescriptor != null) {
+                if (classDescriptor.getKind() != ClassKind.TRAIT) {
+                    if (classAppeared) {
+                        context.getTrace().report(MANY_CLASSES_IN_SUPERTYPE_LIST.on(typeReference));
+                    }
+                    else {
+                        classAppeared = true;
+                    }
+                }
+            }
+            else {
+                context.getTrace().report(SUPERTYPE_NOT_A_CLASS_OR_TRAIT.on(typeReference));
+            }
+
+            TypeConstructor constructor = supertype.getConstructor();
+            if (!typeConstructors.add(constructor)) {
+                context.getTrace().report(SUPERTYPE_APPEARS_TWICE.on(typeReference));
+            }
+
+            if (constructor.isSealed() && !allowedFinalSupertypes.contains(constructor)) {
+                context.getTrace().report(FINAL_SUPERTYPE.on(typeReference));
+            }
+        }
+    }
+
+    private void resolveClassAnnotations() {
+
+    }
+
+    private void resolveAnonymousInitializers() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            resolveAnonymousInitializers(entry.getKey(), entry.getValue());
+        }
+        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+            resolveAnonymousInitializers(entry.getKey(), entry.getValue());
+        }
+    }
+
+    private void resolveAnonymousInitializers(JetClassOrObject jetClassOrObject, MutableClassDescriptor classDescriptor) {
+        List<JetClassInitializer> anonymousInitializers = jetClassOrObject.getAnonymousInitializers();
+        if (jetClassOrObject.hasPrimaryConstructor()) {
+            ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
+            assert primaryConstructor != null;
+            final JetScope scopeForConstructor = getInnerScopeForConstructor(primaryConstructor, classDescriptor.getScopeForMemberResolution(), true);
+            JetTypeInferrer.Services typeInferrer = context.getSemanticServices().getTypeInferrerServices(createFieldAssignTrackingTrace(), JetFlowInformationProvider.NONE); // TODO : flow
+            for (JetClassInitializer anonymousInitializer : anonymousInitializers) {
+                typeInferrer.getType(scopeForConstructor, anonymousInitializer.getBody(), NO_EXPECTED_TYPE);
+            }
+        }
+        else {
+            for (JetClassInitializer anonymousInitializer : anonymousInitializers) {
+                context.getTrace().report(ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR.on(anonymousInitializer));
+            }
+        }
+    }
+
+    private void resolveSecondaryConstructorBodies() {
+        for (Map.Entry<JetDeclaration, ConstructorDescriptor> entry : this.context.getConstructors().entrySet()) {
+            JetDeclaration declaration = entry.getKey();
+            ConstructorDescriptor descriptor = entry.getValue();
+
+            resolveSecondaryConstructorBody((JetConstructor) declaration, descriptor, ((MutableClassDescriptor) descriptor.getContainingDeclaration()).getScopeForMemberResolution());
+
+            assert descriptor.getReturnType() != null;
+        }
+    }
+
+    private void resolveSecondaryConstructorBody(JetConstructor declaration, final ConstructorDescriptor descriptor, final JetScope declaringScope) {
+        final JetScope functionInnerScope = getInnerScopeForConstructor(descriptor, declaringScope, false);
+
+        final JetTypeInferrer.Services typeInferrerForInitializers = context.getSemanticServices().getTypeInferrerServices(traceForConstructors, JetFlowInformationProvider.NONE);
+
+        JetClass containingClass = PsiTreeUtil.getParentOfType(declaration, JetClass.class);
+        assert containingClass != null : "This must be guaranteed by the parser";
+        if (!containingClass.hasPrimaryConstructor()) {
+            context.getTrace().report(SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY.on(declaration.getNameNode()));
+        }
+        else {
+            List<JetDelegationSpecifier> initializers = declaration.getInitializers();
+            if (initializers.isEmpty()) {
+                context.getTrace().report(SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST.on(declaration.getNameNode()));
+            }
+            else {
+                initializers.get(0).accept(new JetVisitorVoid() {
+                    @Override
+                    public void visitDelegationToSuperCallSpecifier(JetDelegatorToSuperCall call) {
+                        JetTypeReference typeReference = call.getTypeReference();
+                        if (typeReference != null) {
+                            typeInferrerForInitializers.getCallResolver().resolveCall(context.getTrace(), functionInnerScope, null, call, NO_EXPECTED_TYPE);
+                        }
+                    }
+
+                    @Override
+                    public void visitDelegationToThisCall(JetDelegatorToThisCall call) {
+                        // TODO : check that there's no recursion in this() calls
+                        // TODO : check: if a this() call is present, no other initializers are allowed
+                        ClassDescriptor classDescriptor = descriptor.getContainingDeclaration();
+
+                        typeInferrerForInitializers.getCallResolver().resolveCall(context.getTrace(),
+                                functionInnerScope,
+                                ReceiverDescriptor.NO_RECEIVER, call, NO_EXPECTED_TYPE);
+//                                call.getThisReference(),
+//                                classDescriptor,
+//                                classDescriptor.getDefaultType(),
+//                                call);
+//                        context.getTrace().getErrorHandler().genericError(call.getNode(), "this-calls are not supported");
+                    }
+
+                    @Override
+                    public void visitDelegationByExpressionSpecifier(JetDelegatorByExpressionSpecifier specifier) {
+                        context.getTrace().report(BY_IN_SECONDARY_CONSTRUCTOR.on(specifier));
+                    }
+
+                    @Override
+                    public void visitDelegationToSuperClassSpecifier(JetDelegatorToSuperClass specifier) {
+                        context.getTrace().report(INITIALIZER_WITH_NO_ARGUMENTS.on(specifier));
+                    }
+
+                    @Override
+                    public void visitDelegationSpecifier(JetDelegationSpecifier specifier) {
+                        throw new IllegalStateException();
+                    }
+                });
+                for (int i = 1, initializersSize = initializers.size(); i < initializersSize; i++) {
+                    JetDelegationSpecifier initializer = initializers.get(i);
+                    context.getTrace().report(MANY_CALLS_TO_THIS.on(initializer));
+                }
+            }
+        }
+        JetExpression bodyExpression = declaration.getBodyExpression();
+        if (bodyExpression != null) {
+            context.getClassDescriptorResolver().computeFlowData(declaration, bodyExpression);
+            JetFlowInformationProvider flowInformationProvider = context.getClassDescriptorResolver().computeFlowData(declaration, bodyExpression);
+            JetTypeInferrer.Services typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors, flowInformationProvider);
+
+            typeInferrer.checkFunctionReturnType(functionInnerScope, declaration, JetStandardClasses.getUnitType());
+        }
+    }
+
+    @NotNull
+    private JetScope getInnerScopeForConstructor(@NotNull ConstructorDescriptor descriptor, @NotNull JetScope declaringScope, boolean primary) {
+        WritableScope constructorScope = new WritableScopeImpl(declaringScope, declaringScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Inner scope for constructor");
+        for (PropertyDescriptor propertyDescriptor : ((MutableClassDescriptor) descriptor.getContainingDeclaration()).getProperties()) {
+            constructorScope.addPropertyDescriptorByFieldName("$" + propertyDescriptor.getName(), propertyDescriptor);
+        }
+
+//        constructorScope.setImplicitReceiver(new ClassReceiver(descriptor.getContainingDeclaration()));
+
+        for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getValueParameters()) {
+            JetParameter parameter = (JetParameter) context.getTrace().getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, valueParameterDescriptor);
+            if (parameter.getValOrVarNode() == null || !primary) {
+                constructorScope.addVariableDescriptor(valueParameterDescriptor);
+            }
+        }
+
+        constructorScope.addLabeledDeclaration(descriptor); // TODO : Labels for constructors?!
+
+        return constructorScope;
+    }
+
+    private void resolvePropertyDeclarationBodies() {
+
+        // Member properties
+        Set<JetProperty> processed = Sets.newHashSet();
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            JetClass jetClass = entry.getKey();
+            MutableClassDescriptor classDescriptor = entry.getValue();
+
+            for (JetProperty property : jetClass.getProperties()) {
+                final PropertyDescriptor propertyDescriptor = this.context.getProperties().get(property);
+                assert propertyDescriptor != null;
+
+                JetScope declaringScope = this.context.getDeclaringScopes().get(property);
+
+                JetExpression initializer = property.getInitializer();
+                if (initializer != null) {
+                    ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
+                    if (primaryConstructor != null) {
+                        JetScope scope = getInnerScopeForConstructor(primaryConstructor, classDescriptor.getScopeForMemberResolution(), true);
+                        resolvePropertyInitializer(property, propertyDescriptor, initializer, scope);
+                    }
+                }
+
+                resolvePropertyAccessors(property, propertyDescriptor, declaringScope);
+                processed.add(property);
+            }
+        }
+
+        // Top-level properties & properties of objects
+        for (Map.Entry<JetProperty, PropertyDescriptor> entry : this.context.getProperties().entrySet()) {
+            JetProperty property = entry.getKey();
+            if (processed.contains(property)) continue;
+
+            final PropertyDescriptor propertyDescriptor = entry.getValue();
+            JetScope declaringScope = this.context.getDeclaringScopes().get(property);
+
+            JetExpression initializer = property.getInitializer();
+            if (initializer != null) {
+                resolvePropertyInitializer(property, propertyDescriptor, initializer, declaringScope);
+            }
+
+            resolvePropertyAccessors(property, propertyDescriptor, declaringScope);
+        }
+    }
+
+    private JetScope getPropertyDeclarationInnerScope(@NotNull JetScope outerScope, @NotNull PropertyDescriptor propertyDescriptor) {
+        WritableScopeImpl result = new WritableScopeImpl(outerScope, propertyDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Property declaration inner scope");
+        for (TypeParameterDescriptor typeParameterDescriptor : propertyDescriptor.getTypeParameters()) {
+            result.addTypeParameterDescriptor(typeParameterDescriptor);
+        }
+        ReceiverDescriptor receiver = propertyDescriptor.getReceiver();
+        if (receiver.exists()) {
+            result.setImplicitReceiver(receiver);
+        }
+        return result;
+    }
+
+    private void resolvePropertyAccessors(JetProperty property, PropertyDescriptor propertyDescriptor, JetScope declaringScope) {
+        ObservableBindingTrace fieldAccessTrackingTrace = createFieldTrackingTrace(propertyDescriptor);
+
+        WritableScope accessorScope = new WritableScopeImpl(getPropertyDeclarationInnerScope(declaringScope, propertyDescriptor), declaringScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Accessor scope");
+        accessorScope.addPropertyDescriptorByFieldName("$" + propertyDescriptor.getName(), propertyDescriptor);
+
+        JetPropertyAccessor getter = property.getGetter();
+        PropertyGetterDescriptor getterDescriptor = propertyDescriptor.getGetter();
+        if (getter != null && getterDescriptor != null) {
+            resolveFunctionBody(fieldAccessTrackingTrace, getter, getterDescriptor, accessorScope);
+        }
+
+        JetPropertyAccessor setter = property.getSetter();
+        PropertySetterDescriptor setterDescriptor = propertyDescriptor.getSetter();
+        if (setter != null && setterDescriptor != null) {
+            resolveFunctionBody(fieldAccessTrackingTrace, setter, setterDescriptor, accessorScope);
+        }
+    }
+
+    private ObservableBindingTrace createFieldTrackingTrace(final PropertyDescriptor propertyDescriptor) {
+        return new ObservableBindingTrace(traceForMembers).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler<JetReferenceExpression, DeclarationDescriptor>() {
+            @Override
+            public void handleRecord(WritableSlice<JetReferenceExpression, DeclarationDescriptor> slice, JetReferenceExpression expression, DeclarationDescriptor descriptor) {
+                if (expression instanceof JetSimpleNameExpression) {
+                    JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression;
+                    if (simpleNameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
+                        // This check may be considered redundant as long as $x is only accessible from accessors to $x
+                        if (descriptor == propertyDescriptor) { // TODO : original?
+                            traceForMembers.record(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor); // TODO: this context.getTrace()?
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    private ObservableBindingTrace createFieldAssignTrackingTrace() {
+        return new ObservableBindingTrace(traceForConstructors).addHandler(BindingContext.VARIABLE_ASSIGNMENT, new ObservableBindingTrace.RecordHandler<JetExpression, DeclarationDescriptor>() {
+            @Override
+            public void handleRecord(WritableSlice<JetExpression, DeclarationDescriptor> jetExpressionBooleanWritableSlice, JetExpression expression, DeclarationDescriptor descriptor) {
+                if (expression instanceof JetSimpleNameExpression) {
+                    JetSimpleNameExpression variable = (JetSimpleNameExpression) expression;
+                    if (variable.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
+                        if (descriptor instanceof PropertyDescriptor) {
+                            traceForMembers.record(BindingContext.IS_INITIALIZED, (PropertyDescriptor) descriptor);
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    private void resolvePropertyInitializer(JetProperty property, PropertyDescriptor propertyDescriptor, JetExpression initializer, JetScope scope) {
+        JetFlowInformationProvider flowInformationProvider = context.getClassDescriptorResolver().computeFlowData(property, initializer); // TODO : flow JET-15
+        JetTypeInferrer.Services typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors, flowInformationProvider);
+        JetType type = typeInferrer.getType(getPropertyDeclarationInnerScope(scope, propertyDescriptor), initializer, NO_EXPECTED_TYPE);
+
+        JetType expectedType = propertyDescriptor.getInType();
+        if (expectedType == null) {
+            expectedType = propertyDescriptor.getOutType();
+        }
+        if (type != null && expectedType != null
+            && !context.getSemanticServices().getTypeChecker().isSubtypeOf(type, expectedType)) {
+            context.getTrace().report(TYPE_MISMATCH.on(initializer, expectedType, type));
+        }
+    }
+
+    private void resolveFunctionBodies() {
+        for (Map.Entry<JetNamedFunction, FunctionDescriptorImpl> entry : this.context.getFunctions().entrySet()) {
+            JetNamedFunction declaration = entry.getKey();
+            FunctionDescriptor descriptor = entry.getValue();
+
+            JetScope declaringScope = this.context.getDeclaringScopes().get(declaration);
+            assert declaringScope != null;
+
+            resolveFunctionBody(traceForMembers, declaration, descriptor, declaringScope);
+
+            assert descriptor.getReturnType() != null;
+        }
+    }
+
+    private void resolveFunctionBody(
+            @NotNull BindingTrace trace,
+            @NotNull JetDeclarationWithBody function,
+            @NotNull FunctionDescriptor functionDescriptor,
+            @NotNull JetScope declaringScope) {
+
+        JetExpression bodyExpression = function.getBodyExpression();
+        if (bodyExpression != null) {
+            JetFlowInformationProvider flowInformationProvider = context.getClassDescriptorResolver().computeFlowData(function.asElement(), bodyExpression);
+            JetTypeInferrer.Services typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace, flowInformationProvider);
+
+            typeInferrer.checkFunctionReturnType(declaringScope, function, functionDescriptor);
+        }
+
+        JetTypeInferrer.Services typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace, JetFlowInformationProvider.THROW_EXCEPTION);
+        List<JetParameter> valueParameters = function.getValueParameters();
+        for (int i = 0; i < valueParameters.size(); i++) {
+            ValueParameterDescriptor valueParameterDescriptor = functionDescriptor.getValueParameters().get(i);
+            if (valueParameterDescriptor.hasDefaultValue()) {
+                JetParameter jetParameter = valueParameters.get(i);
+                JetExpression defaultValue = jetParameter.getDefaultValue();
+                if (defaultValue != null) {
+                    typeInferrer.getType(declaringScope, defaultValue, valueParameterDescriptor.getOutType());
+                }
+            }
+        }
+
+        assert functionDescriptor.getReturnType() != null;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java
similarity index 73%
rename from idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java
index 7a94482da7f..1672a1329c8 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java
@@ -15,19 +15,22 @@ import org.jetbrains.jet.lang.cfg.LoopInfo;
 import org.jetbrains.jet.lang.cfg.pseudocode.*;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.*;
 
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+
 /**
  * @author abreslav
  */
 public class ClassDescriptorResolver {
-
-    private static final MemberModifiers DEFAULT_MODIFIERS = new MemberModifiers(false, false, false);
-
     private final JetSemanticServices semanticServices;
     private final TypeResolver typeResolver;
     private final TypeResolver typeResolverNotCheckingBounds;
@@ -44,84 +47,6 @@ public class ClassDescriptorResolver {
         this.annotationResolver = new AnnotationResolver(semanticServices, trace);
     }
 
-    @Nullable
-    public ClassDescriptor resolveClassDescriptor(@NotNull JetScope scope, @NotNull JetClass classElement) {
-        final ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
-                scope.getContainingDeclaration(),
-                annotationResolver.resolveAnnotations(scope, classElement.getModifierList()),
-                JetPsiUtil.safeName(classElement.getName()));
-
-        trace.record(BindingContext.CLASS, classElement, classDescriptor);
-
-        final WritableScope parameterScope = new WritableScopeImpl(scope, classDescriptor, trace.getErrorHandler());
-
-        // This call has side-effects on the parameterScope (fills it in)
-        List<TypeParameterDescriptor> typeParameters
-                = resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters());
-        resolveGenericBounds(classElement, parameterScope, typeParameters);
-
-        List<JetDelegationSpecifier> delegationSpecifiers = classElement.getDelegationSpecifiers();
-        // TODO : assuming that the hierarchy is acyclic
-        Collection<JetType> supertypes = delegationSpecifiers.isEmpty()
-                ? Collections.singleton(JetStandardClasses.getAnyType())
-                : resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver);
-        boolean open = classElement.hasModifier(JetTokens.OPEN_KEYWORD);
-
-        final WritableScope memberDeclarations = new WritableScopeImpl(parameterScope, classDescriptor, trace.getErrorHandler());
-
-        List<JetDeclaration> declarations = classElement.getDeclarations();
-        for (JetDeclaration declaration : declarations) {
-            declaration.accept(new JetVisitorVoid() {
-                @Override
-                public void visitProperty(JetProperty property) {
-                    if (property.getPropertyTypeRef() != null) {
-                        memberDeclarations.addVariableDescriptor(resolvePropertyDescriptor(classDescriptor, parameterScope, property));
-                    } else {
-                        // TODO : Caution: a cyclic dependency possible
-                        throw new UnsupportedOperationException();
-                    }
-                }
-
-                @Override
-                public void visitNamedFunction(JetNamedFunction function) {
-                    if (function.getReturnTypeRef() != null) {
-                        memberDeclarations.addFunctionDescriptor(resolveFunctionDescriptor(classDescriptor, parameterScope, function));
-                    } else {
-                        // TODO : Caution: a cyclic dependency possible
-                        throw new UnsupportedOperationException();
-                    }
-                }
-
-                @Override
-                public void visitJetElement(JetElement element) {
-                    throw new UnsupportedOperationException(element.toString());
-                }
-            });
-        }
-
-        WritableFunctionGroup constructors = new WritableFunctionGroup("<init>");
-        classDescriptor.initialize(
-                !open,
-                typeParameters,
-                supertypes,
-                memberDeclarations,
-                constructors,
-                null
-        );
-        for (JetConstructor constructor : classElement.getSecondaryConstructors()) {
-            ConstructorDescriptorImpl functionDescriptor = resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor);
-            functionDescriptor.setReturnType(classDescriptor.getDefaultType());
-            constructors.addFunction(functionDescriptor);
-        }
-        ConstructorDescriptorImpl primaryConstructorDescriptor = resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement);
-        if (primaryConstructorDescriptor != null) {
-            primaryConstructorDescriptor.setReturnType(classDescriptor.getDefaultType());
-            constructors.addFunction(primaryConstructorDescriptor);
-            classDescriptor.setPrimaryConstructor(primaryConstructorDescriptor);
-        }
-        return classDescriptor;
-    }
-
     public void resolveMutableClassDescriptor(@NotNull JetClass classElement, @NotNull MutableClassDescriptor descriptor) {
         // TODO : Where-clause
         List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
@@ -139,36 +64,79 @@ public class ClassDescriptorResolver {
             index++;
         }
         descriptor.setTypeParameterDescriptors(typeParameters);
-
-        descriptor.setOpen(classElement.hasModifier(JetTokens.OPEN_KEYWORD) || classElement.hasModifier(JetTokens.ABSTRACT_KEYWORD));
+        Modality defaultModality = descriptor.getKind() == ClassKind.TRAIT ? Modality.ABSTRACT : Modality.FINAL;
+        descriptor.setModality(resolveModalityFromModifiers(classElement.getModifierList(), defaultModality));
+        descriptor.setVisibility(resolveVisibilityFromModifiers(classElement.getModifierList()));
 
         trace.record(BindingContext.CLASS, classElement, descriptor);
     }
 
     public void resolveSupertypes(@NotNull JetClassOrObject jetClass, @NotNull MutableClassDescriptor descriptor) {
         List<JetDelegationSpecifier> delegationSpecifiers = jetClass.getDelegationSpecifiers();
-        JetType defaultSupertype = JetStandardClasses.getAnyType();
+        if (delegationSpecifiers.isEmpty()) {
+            descriptor.addSupertype(getDefaultSupertype(jetClass));
+        }
+        else {
+            Collection<JetType> supertypes = resolveDelegationSpecifiers(
+                    descriptor.getScopeForSupertypeResolution(),
+                    delegationSpecifiers,
+                    typeResolverNotCheckingBounds);
+            for (JetType supertype : supertypes) {
+                descriptor.addSupertype(supertype);
+            }
+        }
+
+    }
+
+    private JetType getDefaultSupertype(JetClassOrObject jetClass) {
         // TODO : beautify
         if (jetClass instanceof JetEnumEntry) {
             JetClassOrObject parent = PsiTreeUtil.getParentOfType(jetClass, JetClassOrObject.class);
             ClassDescriptor parentDescriptor = trace.getBindingContext().get(BindingContext.CLASS, parent);
             if (parentDescriptor.getTypeConstructor().getParameters().isEmpty()) {
-                defaultSupertype = parentDescriptor.getDefaultType();
+                return parentDescriptor.getDefaultType();
             }
-            else if (delegationSpecifiers.isEmpty()) {
-                trace.getErrorHandler().genericError(((JetEnumEntry) jetClass).getNameIdentifier().getNode(), "generic arguments of the base type must be specified");
+            else {
+//                trace.getErrorHandler().genericError(((JetEnumEntry) jetClass).getNameIdentifier().getNode(), "Generic arguments of the base type must be specified");
+                trace.report(NO_GENERICS_IN_SUPERTYPE_SPECIFIER.on(((JetEnumEntry) jetClass).getNameIdentifier()));
+                return ErrorUtils.createErrorType("Supertype not specified");
             }
         }
-        Collection<? extends JetType> superclasses = delegationSpecifiers.isEmpty()
-                ? Collections.singleton(defaultSupertype)
-                : resolveDelegationSpecifiers(
-                    descriptor.getScopeForSupertypeResolution(),
-                    delegationSpecifiers,
-                    typeResolverNotCheckingBounds);
+        return JetStandardClasses.getAnyType();
+    }
 
-        for (JetType superclass : superclasses) {
-            descriptor.addSupertype(superclass);
+    public Collection<JetType> resolveDelegationSpecifiers(JetScope extensibleScope, List<JetDelegationSpecifier> delegationSpecifiers, @NotNull TypeResolver resolver) {
+        if (delegationSpecifiers.isEmpty()) {
+            return Collections.emptyList();
         }
+        Collection<JetType> result = Lists.newArrayList();
+        for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) {
+            JetTypeReference typeReference = delegationSpecifier.getTypeReference();
+            if (typeReference != null) {
+                result.add(resolver.resolveType(extensibleScope, typeReference));
+                JetTypeElement typeElement = typeReference.getTypeElement();
+                while (typeElement instanceof JetNullableType) {
+                    JetNullableType nullableType = (JetNullableType) typeElement;
+//                    trace.getErrorHandler().genericError(nullableType.getQuestionMarkNode(), "A supertype cannot be nullable");
+                    trace.report(NULLABLE_SUPERTYPE.on(nullableType.getQuestionMarkNode()));
+                    typeElement = nullableType.getInnerType();
+                }
+                if (typeElement instanceof JetUserType) {
+                    JetUserType userType = (JetUserType) typeElement;
+                    List<JetTypeProjection> typeArguments = userType.getTypeArguments();
+                    for (JetTypeProjection typeArgument : typeArguments) {
+                        if (typeArgument.getProjectionKind() != JetProjectionKind.NONE) {
+//                            trace.getErrorHandler().genericError(typeArgument.getProjectionNode(), "Projections are not allowed for immediate arguments of a supertype");
+                            trace.report(PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE.on(typeArgument.getProjectionNode()));
+                        }
+                    }
+                }
+            }
+            else {
+                result.add(ErrorUtils.createErrorType("No type reference"));
+            }
+        }
+        return result;
     }
 
     @NotNull
@@ -178,7 +146,7 @@ public class ClassDescriptorResolver {
                 annotationResolver.resolveAnnotations(scope, function.getModifierList()),
                 JetPsiUtil.safeName(function.getName())
         );
-        WritableScope innerScope = new WritableScopeImpl(scope, functionDescriptor, trace.getErrorHandler()).setDebugName("Function descriptor header scope");
+        WritableScope innerScope = new WritableScopeImpl(scope, functionDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Function descriptor header scope");
         innerScope.addLabeledDeclaration(functionDescriptor);
 
         List<TypeParameterDescriptor> typeParameterDescriptors = resolveTypeParameters(functionDescriptor, innerScope, function.getTypeParameters());
@@ -207,7 +175,7 @@ public class ClassDescriptorResolver {
         else {
             final JetExpression bodyExpression = function.getBodyExpression();
             if (bodyExpression != null) {
-                returnType = new DeferredType(new LazyValue<JetType>() {
+                returnType = DeferredType.create(trace, new LazyValueWithDefault<JetType>(ErrorUtils.createErrorType("Recursive dependency")) {
                     @Override
                     protected JetType compute() {
                         JetFlowInformationProvider flowInformationProvider = computeFlowData(function, bodyExpression);
@@ -216,21 +184,41 @@ public class ClassDescriptorResolver {
                 });
             }
             else {
-                trace.getErrorHandler().genericError(function.asElement().getNode(), "This function must either declare a return type or have a body element");
+//                trace.getErrorHandler().genericError(function.asElement().getNode(), "This function must either declare a return type or have a body element");
+                trace.report(FUNCTION_WITH_NO_TYPE_NO_BODY.on(function.asElement()));
                 returnType = ErrorUtils.createErrorType("No type, no body");
             }
         }
-
+        boolean hasBody = function.getBodyExpression() != null;
+        Modality defaultModality = getDefaultModality(containingDescriptor, hasBody);
+        Modality modality = resolveModalityFromModifiers(function.getModifierList(), defaultModality);
+        Visibility visibility = resolveVisibilityFromModifiers(function.getModifierList());
         functionDescriptor.initialize(
                 receiverType,
                 typeParameterDescriptors,
                 valueParameterDescriptors,
-                returnType);
+                returnType,
+                modality,
+                visibility);
 
         trace.record(BindingContext.FUNCTION, function, functionDescriptor);
         return functionDescriptor;
     }
 
+    private Modality getDefaultModality(DeclarationDescriptor containingDescriptor, boolean isBodyPresent) {
+        Modality defaultModality;
+        if (containingDescriptor instanceof ClassDescriptor) {
+            boolean isTrait = ((ClassDescriptor) containingDescriptor).getKind() == ClassKind.TRAIT;
+            boolean isDefinitelyAbstract = isTrait && !isBodyPresent;
+            Modality basicModality = isTrait ? Modality.OPEN : Modality.FINAL;
+            defaultModality = isDefinitelyAbstract ? Modality.ABSTRACT : basicModality;
+        }
+        else {
+            defaultModality = Modality.FINAL;
+        }
+        return defaultModality;
+    }
+
     @NotNull
     private List<ValueParameterDescriptor> resolveValueParameters(FunctionDescriptor functionDescriptor, WritableScope parameterScope, List<JetParameter> valueParameters) {
         List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>();
@@ -240,12 +228,14 @@ public class ClassDescriptorResolver {
 
             ASTNode valOrVarNode = valueParameter.getValOrVarNode();
             if (valueParameter.isRef() && valOrVarNode != null) {
-                trace.getErrorHandler().genericError(valOrVarNode, "'val' and 'var' are not allowed on ref-parameters");
+//                trace.getErrorHandler().genericError(valOrVarNode, "'val' and 'var' are not allowed on ref-parameters");
+                trace.report(REF_PARAMETER_WITH_VAL_OR_VAR.on(valOrVarNode));
             }
 
             JetType type;
             if (typeReference == null) {
-                trace.getErrorHandler().genericError(valueParameter.getNode(), "A type annotation is required on a value parameter");
+//                trace.getErrorHandler().genericError(valueParameter.getNode(), "A type annotation is required on a value parameter");
+                trace.report(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION.on(valueParameter));
                 type = ErrorUtils.createErrorType("Type annotation was missing");
             } else {
                 type = typeResolver.resolveType(parameterScope, typeReference);
@@ -268,9 +258,8 @@ public class ClassDescriptorResolver {
             valueParameter.isMutable() ? type : null,
             type,
             valueParameter.getDefaultValue() != null,
-            false // TODO : varargs
-    );
-        // TODO : Default values???
+            valueParameter.hasModifier(JetTokens.VARARG_KEYWORD)
+        );
 
         trace.record(BindingContext.VALUE_PARAMETER, valueParameter, valueParameterDescriptor);
         return valueParameterDescriptor;
@@ -325,22 +314,23 @@ public class ClassDescriptorResolver {
                 continue;
             }
             TypeParameterDescriptor typeParameterDescriptor = parameterByName.get(referencedName);
+            JetTypeReference boundTypeReference = constraint.getBoundTypeReference();
+            JetType bound = boundTypeReference != null ? resolveAndCheckUpperBoundType(boundTypeReference, scope, constraint.isClassObjectContraint()) : null;
             if (typeParameterDescriptor == null) {
                 // To tell the user that we look only for locally defined type parameters
                 ClassifierDescriptor classifier = scope.getClassifier(referencedName);
                 if (classifier != null) {
-                    trace.getErrorHandler().genericError(subjectTypeParameterName.getNode(), referencedName + " does not refer to a type parameter of " + declaration.getName());
+//                    trace.getErrorHandler().genericError(subjectTypeParameterName.getNode(), referencedName + " does not refer to a type parameter of " + declaration.getName());
+                    trace.report(NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER.on(subjectTypeParameterName, constraint, declaration));
                     trace.record(BindingContext.REFERENCE_TARGET, subjectTypeParameterName, classifier);
                 }
                 else {
-                    trace.getErrorHandler().unresolvedReference(subjectTypeParameterName);
+                    trace.report(UNRESOLVED_REFERENCE.on(subjectTypeParameterName));
                 }
             }
             else {
                 trace.record(BindingContext.REFERENCE_TARGET, subjectTypeParameterName, typeParameterDescriptor);
-                JetTypeReference boundTypeReference = constraint.getBoundTypeReference();
-                if (boundTypeReference != null) {
-                    JetType bound = resolveAndCheckUpperBoundType(boundTypeReference, scope, constraint.isClassObjectContraint());
+                if (bound != null) {
                     if (constraint.isClassObjectContraint()) {
                         typeParameterDescriptor.addClassObjectBound(bound);
                     }
@@ -359,7 +349,8 @@ public class ClassDescriptorResolver {
             if (JetStandardClasses.isNothing(parameter.getBoundsAsType())) {
                 PsiElement nameIdentifier = typeParameters.get(parameter.getIndex()).getNameIdentifier();
                 if (nameIdentifier != null) {
-                    trace.getErrorHandler().genericError(nameIdentifier.getNode(), "Upper bounds of " + parameter.getName() + " have empty intersection");
+//                    trace.getErrorHandler().genericError(nameIdentifier.getNode(), "Upper bounds of " + parameter.getName() + " have empty intersection");
+                    trace.report(CONFLICTING_UPPER_BOUNDS.on(nameIdentifier, parameter));
                 }
             }
 
@@ -367,7 +358,8 @@ public class ClassDescriptorResolver {
             if (classObjectType != null && JetStandardClasses.isNothing(classObjectType)) {
                 PsiElement nameIdentifier = typeParameters.get(parameter.getIndex()).getNameIdentifier();
                 if (nameIdentifier != null) {
-                    trace.getErrorHandler().genericError(nameIdentifier.getNode(), "Class object upper bounds of " + parameter.getName() + " have empty intersection");
+//                    trace.getErrorHandler().genericError(nameIdentifier.getNode(), "Class object upper bounds of " + parameter.getName() + " have empty intersection");
+                    trace.report(CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS.on(nameIdentifier, parameter));
                 }
             }
         }
@@ -376,34 +368,18 @@ public class ClassDescriptorResolver {
     private JetType resolveAndCheckUpperBoundType(@NotNull JetTypeReference upperBound, @NotNull JetScope scope, boolean classObjectConstaint) {
         JetType jetType = typeResolverNotCheckingBounds.resolveType(scope, upperBound);
         if (!TypeUtils.canHaveSubtypes(semanticServices.getTypeChecker(), jetType)) {
-            String message = jetType + " is a final type, and thus a class object cannot extend it";
             if (classObjectConstaint) {
-                trace.getErrorHandler().genericError(upperBound.getNode(), message);
+//                trace.getErrorHandler().genericError(upperBound.getNode(), jetType + " is a final type, and thus a class object cannot extend it");
+                trace.report(FINAL_CLASS_OBJECT_UPPER_BOUND.on(upperBound, jetType));
             }
             else {
-                trace.getErrorHandler().genericWarning(upperBound.getNode(), message);
+//                trace.getErrorHandler().genericWarning(upperBound.getNode(), jetType + " is a final type, and thus a value of the type parameter is predetermined");
+                trace.report(FINAL_UPPER_BOUND.on(upperBound, jetType));
             }
         }
         return jetType;
     }
 
-    private Collection<JetType> resolveDelegationSpecifiers(JetScope extensibleScope, List<JetDelegationSpecifier> delegationSpecifiers, @NotNull TypeResolver resolver) {
-        if (delegationSpecifiers.isEmpty()) {
-            return Collections.emptyList();
-        }
-        Collection<JetType> result = new ArrayList<JetType>();
-        for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) {
-            JetTypeReference typeReference = delegationSpecifier.getTypeReference();
-            if (typeReference != null) {
-                result.add(resolver.resolveType(extensibleScope, typeReference));
-            }
-            else {
-                result.add(ErrorUtils.createErrorType("No type reference"));
-            }
-        }
-        return result;
-    }
-
     @NotNull
     public VariableDescriptor resolveLocalVariableDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, @NotNull JetParameter parameter) {
         JetType type = resolveParameterType(scope, parameter);
@@ -458,7 +434,8 @@ public class ClassDescriptorResolver {
         PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
                 containingDeclaration,
                 annotationResolver.createAnnotationStubs(modifierList),
-                resolveModifiers(modifierList, DEFAULT_MODIFIERS), // TODO : default modifiers differ in different contexts
+                Modality.FINAL,
+                resolveVisibilityFromModifiers(objectDeclaration.getModifierList()),
                 false,
                 null,
                 JetPsiUtil.safeName(objectDeclaration.getName()),
@@ -479,7 +456,6 @@ public class ClassDescriptorResolver {
 
     @NotNull
     public PropertyDescriptor resolvePropertyDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, JetProperty property) {
-
         JetScope scopeWithTypeParameters;
         List<TypeParameterDescriptor> typeParameterDescriptors;
         List<JetTypeParameter> typeParameters = property.getTypeParameters();
@@ -488,7 +464,7 @@ public class ClassDescriptorResolver {
             typeParameterDescriptors = Collections.emptyList();
         }
         else {
-            WritableScope writableScope = new WritableScopeImpl(scope, containingDeclaration, trace.getErrorHandler()).setDebugName("Scope with type parameters of a property");
+            WritableScope writableScope = new WritableScopeImpl(scope, containingDeclaration, new TraceBasedRedeclarationHandler(trace)).setDebugName("Scope with type parameters of a property");
             typeParameterDescriptors = resolveTypeParameters(containingDeclaration, writableScope, typeParameters);
             resolveGenericBounds(property, writableScope, typeParameterDescriptors);
             scopeWithTypeParameters = writableScope;
@@ -505,10 +481,23 @@ public class ClassDescriptorResolver {
 
         JetType type = getVariableType(scopeWithTypeParameters, property, true);
 
+        boolean hasBody = property.getInitializer() != null;
+        if (!hasBody) {
+            JetPropertyAccessor getter = property.getGetter();
+            if (getter != null && getter.getBodyExpression() != null) {
+                hasBody = true;
+            }
+            JetPropertyAccessor setter = property.getSetter();
+            if (!hasBody && setter != null && setter.getBodyExpression() != null) {
+                hasBody = true;
+            }
+        }
+        Modality defaultModality = getDefaultModality(containingDeclaration, hasBody);
         PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
                 containingDeclaration,
                 annotationResolver.resolveAnnotations(scope, modifierList),
-                resolveModifiers(modifierList, DEFAULT_MODIFIERS), // TODO : default modifiers differ in different contexts
+                resolveModalityFromModifiers(property.getModifierList(), defaultModality),
+                resolveVisibilityFromModifiers(property.getModifierList()),
                 isVar,
                 receiverType,
                 JetPsiUtil.safeName(property.getName()),
@@ -532,19 +521,23 @@ public class ClassDescriptorResolver {
         if (propertyTypeRef == null) {
             final JetExpression initializer = property.getInitializer();
             if (initializer == null) {
-                trace.getErrorHandler().genericError(property.getNode(), "This property must either have a type annotation or be initialized");
+//                trace.getErrorHandler().genericError(property.getNode(), "This property must either have a type annotation or be initialized");
+                PsiElement nameIdentifier = property.getNameIdentifier();
+                if (nameIdentifier != null) {
+                    trace.report(PROPERTY_WITH_NO_TYPE_NO_INITIALIZER.on(nameIdentifier.getNode()));
+                }
                 return ErrorUtils.createErrorType("No type, no body");
             } else {
                 // TODO : a risk of a memory leak
-                LazyValue<JetType> lazyValue = new LazyValue<JetType>() {
+                LazyValue<JetType> lazyValue = new LazyValueWithDefault<JetType>(ErrorUtils.createErrorType("Recursive dependency")) {
                     @Override
                     protected JetType compute() {
                         JetFlowInformationProvider flowInformationProvider = computeFlowData(property, initializer);
-                        return semanticServices.getTypeInferrerServices(trace, flowInformationProvider).safeGetType(scope, initializer, false, JetTypeInferrer.NO_EXPECTED_TYPE);
+                        return semanticServices.getTypeInferrerServices(trace, flowInformationProvider).safeGetType(scope, initializer, JetTypeInferrer.NO_EXPECTED_TYPE);
                     }
                 };
                 if (allowDeferred) {
-                    return new DeferredType(lazyValue);
+                    return DeferredType.create(trace, lazyValue);
                 }
                 else {
                     return lazyValue.get();
@@ -556,39 +549,72 @@ public class ClassDescriptorResolver {
     }
 
     @NotNull
-    private MemberModifiers resolveModifiers(@Nullable JetModifierList modifierList, @NotNull MemberModifiers defaultModifiers) {
-        if (modifierList == null) return defaultModifiers;
-        return new MemberModifiers(
-                modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD),
-                modifierList.hasModifier(JetTokens.VIRTUAL_KEYWORD),
-                modifierList.hasModifier(JetTokens.OVERRIDE_KEYWORD)
-        );
+    /*package*/ static Modality resolveModalityFromModifiers(@Nullable JetModifierList modifierList, @NotNull Modality defaultModality) {
+        if (modifierList == null) return defaultModality;
+        boolean hasAbstractModifier = modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD);
+        boolean hasOverrideModifier = modifierList.hasModifier(JetTokens.OVERRIDE_KEYWORD);
+
+        if (modifierList.hasModifier(JetTokens.OPEN_KEYWORD)) {
+            if (hasAbstractModifier || defaultModality == Modality.ABSTRACT) {
+                return Modality.ABSTRACT;
+            }
+            return Modality.OPEN;
+        }
+        if (hasAbstractModifier) {
+            return Modality.ABSTRACT;
+        }
+        boolean hasFinalModifier = modifierList.hasModifier(JetTokens.FINAL_KEYWORD);
+        if (hasOverrideModifier && !hasFinalModifier && !(defaultModality == Modality.ABSTRACT)) {
+            return Modality.OPEN;
+        }
+        if (hasFinalModifier) {
+            return Modality.FINAL;
+        }
+        return defaultModality;
+    }
+    
+    @NotNull
+    /*package*/ static Visibility resolveVisibilityFromModifiers(@Nullable JetModifierList modifierList) {
+        return resolveVisibilityFromModifiers(modifierList, Visibility.INTERNAL);
+    }
+
+    @NotNull
+    /*package*/ static Visibility resolveVisibilityFromModifiers(@Nullable JetModifierList modifierList, @NotNull Visibility defaultVisibility) {
+        if (modifierList == null) return defaultVisibility;
+        if (modifierList.hasModifier(JetTokens.PRIVATE_KEYWORD)) return Visibility.PRIVATE;
+        if (modifierList.hasModifier(JetTokens.PUBLIC_KEYWORD)) return Visibility.PUBLIC;
+        if (modifierList.hasModifier(JetTokens.PROTECTED_KEYWORD)) {
+            if (modifierList.hasModifier(JetTokens.INTERNAL_KEYWORD)) {
+                return Visibility.INTERNAL_PROTECTED;
+            }
+            return Visibility.PROTECTED;
+        }
+        return defaultVisibility;
     }
 
     @Nullable
     private PropertySetterDescriptor resolvePropertySetterDescriptor(@NotNull JetScope scope, @NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
         JetPropertyAccessor setter = property.getSetter();
-        if (setter != null && !property.isVar()) {
-            trace.getErrorHandler().genericError(setter.asElement().getNode(), "A 'val'-property cannot have a setter");
-            return null;
-        }
         PropertySetterDescriptor setterDescriptor = null;
         if (setter != null) {
             List<AnnotationDescriptor> annotations = annotationResolver.resolveAnnotations(scope, setter.getModifierList());
             JetParameter parameter = setter.getParameter();
 
             setterDescriptor = new PropertySetterDescriptor(
-                    resolveModifiers(setter.getModifierList(), DEFAULT_MODIFIERS), // TODO : default modifiers differ in different contexts
-                    propertyDescriptor, annotations, setter.getBodyExpression() != null);
+                    resolveModalityFromModifiers(setter.getModifierList(), propertyDescriptor.getModality()),
+                    resolveVisibilityFromModifiers(setter.getModifierList(), propertyDescriptor.getVisibility()),
+                    propertyDescriptor, annotations, setter.getBodyExpression() != null, false);
             if (parameter != null) {
                 if (parameter.isRef()) {
-                    trace.getErrorHandler().genericError(parameter.getRefNode(), "Setter parameters can not be 'ref'");
+//                    trace.getErrorHandler().genericError(parameter.getRefNode(), "Setter parameters can not be 'ref'");
+                    trace.report(Errors.REF_SETTER_PARAMETER.on(parameter.getRefNode()));
                 }
 
                 // This check is redundant: the parser does not allow a default value, but we'll keep it just in case
                 JetExpression defaultValue = parameter.getDefaultValue();
                 if (defaultValue != null) {
-                    trace.getErrorHandler().genericError(defaultValue.getNode(), "Setter parameters can not have default values");
+//                    trace.getErrorHandler().genericError(defaultValue.getNode(), "Setter parameters can not have default values");
+                    trace.report(SETTER_PARAMETER_WITH_DEFAULT_VALUE.on(defaultValue));
                 }
 
                 JetType type;
@@ -600,8 +626,9 @@ public class ClassDescriptorResolver {
                     type = typeResolver.resolveType(scope, typeReference);
                     JetType inType = propertyDescriptor.getInType();
                     if (inType != null) {
-                        if (!semanticServices.getTypeChecker().isSubtypeOf(type, inType)) {
-                            trace.getErrorHandler().genericError(typeReference.getNode(), "Setter parameter type must be a subtype of the type of the property, i.e. " + inType);
+                        if (!semanticServices.getTypeChecker().equalTypes(type, inType)) {
+//                            trace.getErrorHandler().genericError(typeReference.getNode(), "Setter parameter type must be equal to the type of the property, i.e. " + inType);
+                            trace.report(WRONG_SETTER_PARAMETER_TYPE.on(setter, typeReference, inType));
                         }
                     }
                     else {
@@ -614,33 +641,58 @@ public class ClassDescriptorResolver {
             }
             trace.record(BindingContext.PROPERTY_ACCESSOR, setter, setterDescriptor);
         }
+        else if (property.isVar()) {
+            setterDescriptor = new PropertySetterDescriptor(
+                    propertyDescriptor.getModality(),
+                    propertyDescriptor.getVisibility(),
+                    propertyDescriptor, Collections.<AnnotationDescriptor>emptyList(), false, true);
+        }
+
+        if (! property.isVar()) {
+            if (setter != null) {
+//                trace.getErrorHandler().genericError(setter.asElement().getNode(), "A 'val'-property cannot have a setter");
+                trace.report(VAL_WITH_SETTER.on(property, setter));
+            }
+        }
         return setterDescriptor;
     }
 
     @Nullable
     private PropertyGetterDescriptor resolvePropertyGetterDescriptor(@NotNull JetScope scope, @NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
-        PropertyGetterDescriptor getterDescriptor = null;
+        PropertyGetterDescriptor getterDescriptor;
         JetPropertyAccessor getter = property.getGetter();
         if (getter != null) {
             List<AnnotationDescriptor> annotations = annotationResolver.resolveAnnotations(scope, getter.getModifierList());
 
-            JetType returnType = null;
+            JetType outType = propertyDescriptor.getOutType();
+            JetType returnType = outType;
             JetTypeReference returnTypeReference = getter.getReturnTypeReference();
             if (returnTypeReference != null) {
                 returnType = typeResolver.resolveType(scope, returnTypeReference);
+                if (outType != null && !semanticServices.getTypeChecker().equalTypes(returnType, outType)) {
+//                    trace.getErrorHandler().genericError(returnTypeReference.getNode(), "Getter return type must be equal to the type of the property, i.e. " + propertyDescriptor.getReturnType());
+                    trace.report(WRONG_GETTER_RETURN_TYPE.on(getter, returnTypeReference, propertyDescriptor.getReturnType()));
+                }
             }
 
             getterDescriptor = new PropertyGetterDescriptor(
-                    resolveModifiers(getter.getModifierList(), DEFAULT_MODIFIERS), // TODO : default modifiers differ in different contexts
-                    propertyDescriptor, annotations, returnType, getter.getBodyExpression() != null);
+                    propertyDescriptor, annotations, resolveModalityFromModifiers(getter.getModifierList(), propertyDescriptor.getModality()),
+                    resolveVisibilityFromModifiers(getter.getModifierList(), propertyDescriptor.getVisibility()),
+                    returnType, getter.getBodyExpression() != null, false);
             trace.record(BindingContext.PROPERTY_ACCESSOR, getter, getterDescriptor);
         }
+        else {
+            getterDescriptor = new PropertyGetterDescriptor(
+                    propertyDescriptor, Collections.<AnnotationDescriptor>emptyList(), propertyDescriptor.getModality(),
+                    propertyDescriptor.getVisibility(),
+                    propertyDescriptor.getOutType(), false, true);
+        }
         return getterDescriptor;
     }
 
     @NotNull
     public ConstructorDescriptorImpl resolveSecondaryConstructorDescriptor(@NotNull JetScope scope, @NotNull ClassDescriptor classDescriptor, @NotNull JetConstructor constructor) {
-        return createConstructorDescriptor(scope, classDescriptor, false, constructor.getModifierList(), constructor, classDescriptor.getTypeConstructor().getParameters(), constructor.getParameters());
+        return createConstructorDescriptor(scope, classDescriptor, false, constructor.getModifierList(), constructor, classDescriptor.getTypeConstructor().getParameters(), constructor.getValueParameters());
     }
 
     @NotNull
@@ -661,8 +713,10 @@ public class ClassDescriptorResolver {
                 typeParameters,
                 resolveValueParameters(
                         constructorDescriptor,
-                        new WritableScopeImpl(scope, classDescriptor, trace.getErrorHandler()).setDebugName("Scope with value parameters of a constructor"),
-                        valueParameters));
+                        new WritableScopeImpl(scope, classDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Scope with value parameters of a constructor"),
+                        valueParameters),
+                        Modality.FINAL,
+                        resolveVisibilityFromModifiers(modifierList));
     }
 
     @Nullable
@@ -690,14 +744,16 @@ public class ClassDescriptorResolver {
         if (modifierList != null) {
             ASTNode abstractNode = modifierList.getModifierNode(JetTokens.ABSTRACT_KEYWORD);
             if (abstractNode != null) {
-                trace.getErrorHandler().genericError(abstractNode, "This property cannot be declared abstract");
+//                trace.getErrorHandler().genericError(abstractNode, "This property cannot be declared abstract");
+                trace.report(ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS.on(parameter, abstractNode));
             }
         }
 
         PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
                 classDescriptor,
                 annotationResolver.resolveAnnotations(scope, modifierList),
-                resolveModifiers(modifierList, DEFAULT_MODIFIERS),
+                resolveModalityFromModifiers(parameter.getModifierList(), Modality.FINAL),
+                resolveVisibilityFromModifiers(parameter.getModifierList()),
                 isMutable,
                 null,
                 name == null ? "<no name>" : name,
@@ -743,7 +799,8 @@ public class ClassDescriptorResolver {
         for (JetType bound : typeParameterDescriptor.getUpperBounds()) {
             JetType substitutedBound = substitutor.safeSubstitute(bound, Variance.INVARIANT);
             if (!semanticServices.getTypeChecker().isSubtypeOf(typeArgument, substitutedBound)) {
-                trace.getErrorHandler().genericError(argumentTypeReference.getNode(), "An upper bound " + substitutedBound + " is violated"); // TODO : Message
+//                trace.getErrorHandler().genericError(argumentTypeReference.getNode(), "An upper bound " + substitutedBound + " is violated");
+                trace.report(UPPER_BOUND_VIOLATED.on(argumentTypeReference, substitutedBound));
             }
         }
     }
@@ -782,7 +839,7 @@ public class ClassDescriptorResolver {
             }
         };
         JetControlFlowInstructionsGenerator instructionsGenerator = new JetControlFlowInstructionsGenerator(wrappedTrace);
-        new JetControlFlowProcessor(semanticServices, trace, instructionsGenerator).generate(declaration, bodyExpression);
+        new JetControlFlowProcessor(trace, instructionsGenerator).generate(declaration, bodyExpression);
         wrappedTrace.close();
         return new JetFlowInformationProvider() {
             @Override
@@ -938,7 +995,8 @@ public class ClassDescriptorResolver {
 
             @Override
             public void visitUnsupportedElementInstruction(UnsupportedElementInstruction instruction) {
-                trace.getErrorHandler().genericError(instruction.getElement().getNode(), "Unsupported by control-flow builder " + instruction.getElement());
+//                trace.getErrorHandler().genericError(instruction.getElement().getNode(), "Unsupported by control-flow builder " + instruction.getElement());
+                trace.report(UNSUPPORTED.on(instruction.getElement(), "Control-flow builder"));
             }
 
             @Override
@@ -960,7 +1018,8 @@ public class ClassDescriptorResolver {
             public void visitInstruction(Instruction instruction) {
                 if (instruction instanceof JetElementInstructionImpl) {
                     JetElementInstructionImpl elementInstruction = (JetElementInstructionImpl) instruction;
-                    trace.getErrorHandler().genericError(elementInstruction.getElement().getNode(), "Unsupported by control-flow builder " + elementInstruction.getElement());
+//                    trace.getErrorHandler().genericError(elementInstruction.getElement().getNode(), "Unsupported by control-flow builder " + elementInstruction.getElement());
+                    trace.report(UNSUPPORTED.on(elementInstruction.getElement(), "Control-flow builder"));
                 }
                 else {
                     throw new UnsupportedOperationException(instruction.toString());
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java
new file mode 100644
index 00000000000..7a840513fdb
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java
@@ -0,0 +1,171 @@
+package org.jetbrains.jet.lang.resolve;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.jetbrains.jet.lang.diagnostics.Errors.CONSTRUCTOR_IN_TRAIT;
+import static org.jetbrains.jet.lang.resolve.BindingContext.ANNOTATION;
+
+/**
+* @author abreslav
+*/
+public class DeclarationResolver {
+    private final AnnotationResolver annotationResolver;
+    private final TopDownAnalysisContext context;
+
+    public DeclarationResolver(TopDownAnalysisContext context) {
+        this.context = context;
+        this.annotationResolver = new AnnotationResolver(context.getSemanticServices(), context.getTrace());
+    }
+
+    public void process() {
+        resolveConstructorHeaders();
+        resolveAnnotationStubsOnClassesAndConstructors();
+        resolveFunctionAndPropertyHeaders();
+    }
+
+    private void resolveConstructorHeaders() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            JetClass jetClass = entry.getKey();
+            MutableClassDescriptor classDescriptor = entry.getValue();
+
+            processPrimaryConstructor(classDescriptor, jetClass);
+            for (JetConstructor jetConstructor : jetClass.getSecondaryConstructors()) {
+                processSecondaryConstructor(classDescriptor, jetConstructor);
+            }
+        }
+    }
+
+    private void resolveAnnotationStubsOnClassesAndConstructors() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            JetClass jetClass = entry.getKey();
+            MutableClassDescriptor mutableClassDescriptor = entry.getValue();
+
+            JetModifierList modifierList = jetClass.getModifierList();
+            if (modifierList != null) {
+                List<JetAnnotationEntry> annotationEntries = modifierList.getAnnotationEntries();
+                for (JetAnnotationEntry annotationEntry : annotationEntries) {
+                    AnnotationDescriptor annotationDescriptor = context.getTrace().get(ANNOTATION, annotationEntry);
+                    if (annotationDescriptor != null) {
+                        annotationResolver.resolveAnnotationStub(mutableClassDescriptor.getScopeForSupertypeResolution(), annotationEntry, annotationDescriptor);
+                    }
+                }
+            }
+        }
+    }
+
+    private void resolveFunctionAndPropertyHeaders() {
+        for (Map.Entry<JetNamespace, WritableScope> entry : context.getNamespaceScopes().entrySet()) {
+            JetNamespace namespace = entry.getKey();
+            WritableScope namespaceScope = entry.getValue();
+            NamespaceLike namespaceDescriptor = context.getNamespaceDescriptors().get(namespace);
+
+            resolveFunctionAndPropertyHeaders(namespace.getDeclarations(), namespaceScope, namespaceDescriptor);
+        }
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            JetClass jetClass = entry.getKey();
+            MutableClassDescriptor classDescriptor = entry.getValue();
+
+            resolveFunctionAndPropertyHeaders(jetClass.getDeclarations(), classDescriptor.getScopeForMemberResolution(), classDescriptor);
+//            processPrimaryConstructor(classDescriptor, jetClass);
+//            for (JetConstructor jetConstructor : jetClass.getSecondaryConstructors()) {
+//                processSecondaryConstructor(classDescriptor, jetConstructor);
+//            }
+        }
+        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+            JetObjectDeclaration object = entry.getKey();
+            MutableClassDescriptor classDescriptor = entry.getValue();
+
+            resolveFunctionAndPropertyHeaders(object.getDeclarations(), classDescriptor.getScopeForMemberResolution(), classDescriptor);
+        }
+
+        // TODO : Extensions
+    }
+
+    private void resolveFunctionAndPropertyHeaders(@NotNull List<JetDeclaration> declarations, final @NotNull JetScope scope, final @NotNull NamespaceLike namespaceLike) {
+        for (JetDeclaration declaration : declarations) {
+            declaration.accept(new JetVisitorVoid() {
+                @Override
+                public void visitNamedFunction(JetNamedFunction function) {
+                    FunctionDescriptorImpl functionDescriptor = context.getClassDescriptorResolver().resolveFunctionDescriptor(namespaceLike, scope, function);
+                    namespaceLike.addFunctionDescriptor(functionDescriptor);
+                    context.getFunctions().put(function, functionDescriptor);
+                    context.getDeclaringScopes().put(function, scope);
+                }
+
+                @Override
+                public void visitProperty(JetProperty property) {
+                    PropertyDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolvePropertyDescriptor(namespaceLike, scope, property);
+                    namespaceLike.addPropertyDescriptor(propertyDescriptor);
+                    context.getProperties().put(property, propertyDescriptor);
+                    context.getDeclaringScopes().put(property, scope);
+                }
+
+                @Override
+                public void visitObjectDeclaration(JetObjectDeclaration declaration) {
+                    PropertyDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(namespaceLike, declaration, context.getObjects().get(declaration));
+                    namespaceLike.addPropertyDescriptor(propertyDescriptor);
+                }
+
+                @Override
+                public void visitEnumEntry(JetEnumEntry enumEntry) {
+                    if (enumEntry.getPrimaryConstructorParameterList() == null) {
+                        PropertyDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(namespaceLike, enumEntry, context.getClasses().get(enumEntry));
+                        MutableClassDescriptor classObjectDescriptor = ((MutableClassDescriptor) namespaceLike).getClassObjectDescriptor();
+                        assert classObjectDescriptor != null;
+                        classObjectDescriptor.addPropertyDescriptor(propertyDescriptor);
+                    }
+                }
+            });
+        }
+    }
+
+    private void processPrimaryConstructor(MutableClassDescriptor classDescriptor, JetClass klass) {
+        if (!klass.hasPrimaryConstructor()) return;
+
+        if (classDescriptor.getKind() == ClassKind.TRAIT) {
+//           context.getTrace().getErrorHandler().genericError(klass.getPrimaryConstructorParameterList().getNode(), "A trait may not have a constructor");
+            context.getTrace().report(CONSTRUCTOR_IN_TRAIT.on(klass.getPrimaryConstructorParameterList()));
+        }
+
+        // TODO : not all the parameters are real properties
+        JetScope memberScope = classDescriptor.getScopeForSupertypeResolution();
+        ConstructorDescriptor constructorDescriptor = context.getClassDescriptorResolver().resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass);
+        for (JetParameter parameter : klass.getPrimaryConstructorParameters()) {
+            if (parameter.getValOrVarNode() != null) {
+                PropertyDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolvePrimaryConstructorParameterToAProperty(
+                        classDescriptor,
+                        memberScope,
+                        parameter
+                );
+                classDescriptor.addPropertyDescriptor(propertyDescriptor);
+                context.getPrimaryConstructorParameterProperties().add(propertyDescriptor);
+            }
+        }
+        if (constructorDescriptor != null) {
+            classDescriptor.setPrimaryConstructor(constructorDescriptor);
+        }
+    }
+
+    private void processSecondaryConstructor(MutableClassDescriptor classDescriptor, JetConstructor constructor) {
+        if (classDescriptor.getKind() == ClassKind.TRAIT) {
+//            context.getTrace().getErrorHandler().genericError(constructor.getNameNode(), "A trait may not have a constructor");
+            context.getTrace().report(CONSTRUCTOR_IN_TRAIT.on(constructor.getNameNode()));
+        }
+        ConstructorDescriptor constructorDescriptor = context.getClassDescriptorResolver().resolveSecondaryConstructorDescriptor(
+                classDescriptor.getScopeForMemberResolution(),
+                classDescriptor,
+                constructor);
+        classDescriptor.addConstructor(constructorDescriptor);
+        context.getConstructors().put(constructor, constructorDescriptor);
+        context.getDeclaringScopes().put(constructor, classDescriptor.getScopeForMemberLookup());
+    }
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java
new file mode 100644
index 00000000000..97efea7d0d9
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java
@@ -0,0 +1,357 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.Pair;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+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.scopes.JetScope;
+import org.jetbrains.jet.lang.types.DeferredType;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetTokens;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+
+/**
+ * @author svtk
+ */
+public class DeclarationsChecker {
+    private TopDownAnalysisContext context;
+
+    public DeclarationsChecker(TopDownAnalysisContext context) {
+        this.context = context;
+    }
+
+    public void process() {
+        checkIfPrimaryConstructorIsNecessary();
+
+        Map<JetClass, MutableClassDescriptor> classes = context.getClasses();
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
+            JetClass aClass = entry.getKey();
+            MutableClassDescriptor classDescriptor = entry.getValue();
+            
+            checkClass(aClass, classDescriptor);
+            checkModifiers(aClass.getModifierList());
+        }
+
+        Map<JetObjectDeclaration, MutableClassDescriptor> objects = context.getObjects();
+        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : objects.entrySet()) {
+            JetObjectDeclaration objectDeclaration = entry.getKey();
+            MutableClassDescriptor objectDescriptor = entry.getValue();
+
+            checkObject(objectDeclaration, objectDescriptor);
+        }
+
+        Map<JetNamedFunction, FunctionDescriptorImpl> functions = context.getFunctions();
+        for (Map.Entry<JetNamedFunction, FunctionDescriptorImpl> entry : functions.entrySet()) {
+            JetNamedFunction function = entry.getKey();
+            FunctionDescriptorImpl functionDescriptor = entry.getValue();
+            
+            checkFunction(function, functionDescriptor);
+            checkModifiers(function.getModifierList());
+        }
+
+        Map<JetProperty, PropertyDescriptor> properties = context.getProperties();
+        for (Map.Entry<JetProperty, PropertyDescriptor> entry : properties.entrySet()) {
+            JetProperty property = entry.getKey();
+            PropertyDescriptor propertyDescriptor = entry.getValue();
+            
+            checkProperty(property, propertyDescriptor);
+            checkModifiers(property.getModifierList());
+        }
+
+    }
+
+    private void checkIfPrimaryConstructorIsNecessary() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            MutableClassDescriptor classDescriptor = entry.getValue();
+            JetClass jetClass = entry.getKey();
+            if (classDescriptor.getUnsubstitutedPrimaryConstructor() == null && !(classDescriptor.getKind() == ClassKind.TRAIT)) {
+                for (PropertyDescriptor propertyDescriptor : classDescriptor.getProperties()) {
+                    if (context.getTrace().getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
+                        PsiElement nameIdentifier = jetClass.getNameIdentifier();
+                        if (nameIdentifier != null) {
+                            context.getTrace().report(PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY.on(jetClass, nameIdentifier, propertyDescriptor));
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    private void checkClass(JetClass aClass, MutableClassDescriptor classDescriptor) {
+        checkOpenMembers(aClass, classDescriptor);
+        checkTraitModifiers(aClass);
+    }
+
+    private void checkTraitModifiers(JetClass aClass) {
+        if (!aClass.isTrait()) return;
+        JetModifierList modifierList = aClass.getModifierList();
+        if (modifierList == null) return;
+        if (modifierList.hasModifier(JetTokens.FINAL_KEYWORD)) {
+            context.getTrace().report(Errors.TRAIT_CAN_NOT_BE_FINAL.on(aClass, modifierList.getModifierNode(JetTokens.FINAL_KEYWORD)));
+        }
+        ArrayList<JetKeywordToken> redundantModifiers = Lists.newArrayList(JetTokens.OPEN_KEYWORD, JetTokens.ABSTRACT_KEYWORD);
+        for (JetKeywordToken modifier : redundantModifiers) {
+            if (modifierList.hasModifier(modifier)) {
+                context.getTrace().report(Errors.REDUNDANT_MODIFIER_IN_TRAIT.on(modifierList, modifierList.getModifierNode(modifier), modifier));
+            }
+        }
+    }
+
+    
+    private void checkObject(JetObjectDeclaration objectDeclaration, MutableClassDescriptor classDescriptor) {
+        checkIllegalInThisContextModifiers(objectDeclaration.getModifierList(), JetTokens.ABSTRACT_KEYWORD, JetTokens.OPEN_KEYWORD, JetTokens.OVERRIDE_KEYWORD);        
+    }
+
+    private void checkOpenMembers(JetClass aClass, MutableClassDescriptor classDescriptor) {
+            for (CallableMemberDescriptor memberDescriptor : classDescriptor.getCallableMembers()) {
+    
+                JetNamedDeclaration member = (JetNamedDeclaration) context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, memberDescriptor);
+                if (member != null && classDescriptor.getModality() == Modality.FINAL && member.hasModifier(JetTokens.OPEN_KEYWORD)) {
+                    ASTNode openModifierNode = member.getModifierList().getModifierNode(JetTokens.OPEN_KEYWORD);
+                    context.getTrace().report(NON_FINAL_MEMBER_IN_FINAL_CLASS.on(member, openModifierNode, aClass));
+                }
+            }
+        }    
+
+    private void checkProperty(JetProperty property, PropertyDescriptor propertyDescriptor) {
+        DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
+        ClassDescriptor classDescriptor = (containingDeclaration instanceof ClassDescriptor)
+                                          ? (ClassDescriptor) containingDeclaration
+                                          : null;
+        checkPropertyAbstractness(property, propertyDescriptor, classDescriptor);
+        checkPropertyInitializer(property, propertyDescriptor, classDescriptor);
+        checkAccessors(property, propertyDescriptor);
+    }
+
+    private void checkPropertyAbstractness(JetProperty property, PropertyDescriptor propertyDescriptor, ClassDescriptor classDescriptor) {
+        JetPropertyAccessor getter = property.getGetter();
+        JetPropertyAccessor setter = property.getSetter();
+        JetModifierList modifierList = property.getModifierList();
+        ASTNode abstractNode = modifierList != null ? modifierList.getModifierNode(JetTokens.ABSTRACT_KEYWORD) : null;
+
+        if (abstractNode != null) { //has abstract modifier
+            if (classDescriptor == null) {
+                context.getTrace().report(ABSTRACT_PROPERTY_NOT_IN_CLASS.on(property, abstractNode));
+                return;
+            }
+            if (!(classDescriptor.getModality() == Modality.ABSTRACT) && classDescriptor.getKind() != ClassKind.ENUM_CLASS) {
+                PsiElement classElement = context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, classDescriptor);
+                assert classElement instanceof JetClass;
+                context.getTrace().report(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(property, abstractNode, property.getName(), classDescriptor, (JetClass) classElement));
+                return;
+            }
+            if (classDescriptor.getKind() == ClassKind.TRAIT) {
+                context.getTrace().report(REDUNDANT_MODIFIER_IN_TRAIT.on(modifierList, abstractNode, JetTokens.ABSTRACT_KEYWORD));
+            }
+        }
+
+        if (propertyDescriptor.getModality() == Modality.ABSTRACT) {
+            JetType returnType = propertyDescriptor.getReturnType();
+            if (returnType instanceof DeferredType) {
+                returnType = ((DeferredType) returnType).getActualType();
+            }
+
+            JetExpression initializer = property.getInitializer();
+            if (initializer != null) {
+                context.getTrace().report(ABSTRACT_PROPERTY_WITH_INITIALIZER.on(property, initializer, returnType));
+            }
+            if (getter != null && getter.getBodyExpression() != null) {
+                context.getTrace().report(ABSTRACT_PROPERTY_WITH_GETTER.on(property, getter, returnType));
+            }
+            if (setter != null && setter.getBodyExpression() != null) {
+                context.getTrace().report(ABSTRACT_PROPERTY_WITH_SETTER.on(property, setter, returnType));
+            }
+        }
+    }
+
+    private void checkPropertyInitializer(JetProperty property, PropertyDescriptor propertyDescriptor, ClassDescriptor classDescriptor) {
+        JetPropertyAccessor getter = property.getGetter();
+        JetPropertyAccessor setter = property.getSetter();
+        boolean hasAccessorImplementation = (getter != null && getter.getBodyExpression() != null) ||
+                                            (setter != null && setter.getBodyExpression() != null);
+        if (propertyDescriptor.getModality() == Modality.ABSTRACT) return;
+
+        boolean inTrait = classDescriptor != null && classDescriptor.getKind() == ClassKind.TRAIT;
+        JetExpression initializer = property.getInitializer();
+        boolean backingFieldRequired = context.getTrace().getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor);
+
+        PsiElement nameIdentifier = property.getNameIdentifier();
+        ASTNode nameNode = nameIdentifier == null ? property.getNode() : nameIdentifier.getNode();
+
+        if (inTrait && backingFieldRequired && hasAccessorImplementation) {
+            context.getTrace().report(BACKING_FIELD_IN_TRAIT.on(nameNode));
+        }
+        if (initializer == null) {
+            if (backingFieldRequired && !inTrait && !context.getTrace().getBindingContext().get(BindingContext.IS_INITIALIZED, propertyDescriptor)) {
+                if (classDescriptor == null || hasAccessorImplementation) {
+                    context.getTrace().report(MUST_BE_INITIALIZED.on(nameNode));
+                }
+                else {
+                    context.getTrace().report(MUST_BE_INITIALIZED_OR_BE_ABSTRACT.on(property, nameNode));
+                }
+            }
+            return;
+        }
+        if (inTrait) {
+            JetType returnType = propertyDescriptor.getReturnType();
+            if (returnType instanceof DeferredType) {
+                returnType = ((DeferredType) returnType).getActualType();
+            }
+            context.getTrace().report(PROPERTY_INITIALIZER_IN_TRAIT.on(property, initializer, returnType));
+        }
+        else if (!backingFieldRequired) {
+            context.getTrace().report(PROPERTY_INITIALIZER_NO_BACKING_FIELD.on(initializer));
+        }
+        else if (classDescriptor != null && classDescriptor.getUnsubstitutedPrimaryConstructor() == null) {
+            PsiElement classElement = context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, classDescriptor);
+            assert classElement instanceof JetClass;
+
+            context.getTrace().report(PROPERTY_INITIALIZER_NO_PRIMARY_CONSTRUCTOR.on(property, initializer, (JetClass) classElement));
+        }
+    }
+
+    protected void checkFunction(JetDeclarationWithBody function, FunctionDescriptor functionDescriptor) {
+        DeclarationDescriptor containingDescriptor = functionDescriptor.getContainingDeclaration();
+        PsiElement nameIdentifier;
+        boolean isPropertyAccessor = false;
+        if (function instanceof JetNamedFunction) {
+            nameIdentifier = ((JetNamedFunction) function).getNameIdentifier();
+        }
+        else if (function instanceof JetPropertyAccessor) {
+            isPropertyAccessor = true;
+            nameIdentifier = ((JetPropertyAccessor) function).getNamePlaceholder();
+        }
+        else {
+            throw new UnsupportedOperationException();
+        }
+        JetFunctionOrPropertyAccessor functionOrPropertyAccessor = (JetFunctionOrPropertyAccessor) function;
+        JetModifierList modifierList = functionOrPropertyAccessor.getModifierList();
+        ASTNode abstractNode = modifierList != null ? modifierList.getModifierNode(JetTokens.ABSTRACT_KEYWORD) : null;
+        boolean hasAbstractModifier = abstractNode != null;
+        if (containingDescriptor instanceof ClassDescriptor) {
+            ClassDescriptor classDescriptor = (ClassDescriptor) containingDescriptor;
+            boolean inTrait = classDescriptor.getKind() == ClassKind.TRAIT;
+            boolean inEnum = classDescriptor.getKind() == ClassKind.ENUM_CLASS;
+            boolean inAbstractClass = classDescriptor.getModality() == Modality.ABSTRACT;
+            if (hasAbstractModifier && !inAbstractClass && !inTrait && !inEnum) {
+                PsiElement classElement = context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, classDescriptor);
+                assert classElement instanceof JetClass;
+                context.getTrace().report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(functionOrPropertyAccessor, abstractNode, functionDescriptor.getName(), classDescriptor, (JetClass) classElement));
+            }
+            if (hasAbstractModifier && inTrait && !isPropertyAccessor) {
+                context.getTrace().report(REDUNDANT_MODIFIER_IN_TRAIT.on(modifierList, abstractNode, JetTokens.ABSTRACT_KEYWORD));
+            }
+            if (function.getBodyExpression() != null && hasAbstractModifier) {
+                context.getTrace().report(ABSTRACT_FUNCTION_WITH_BODY.on(functionOrPropertyAccessor, abstractNode, functionDescriptor));
+            }
+            if (function.getBodyExpression() == null && !hasAbstractModifier && !inTrait && nameIdentifier != null && !isPropertyAccessor) {
+                context.getTrace().report(NON_ABSTRACT_FUNCTION_WITH_NO_BODY.on(functionOrPropertyAccessor, nameIdentifier, functionDescriptor));
+            }
+            return;
+        }
+        if (hasAbstractModifier) {
+            if (!isPropertyAccessor) {
+                context.getTrace().report(NON_MEMBER_ABSTRACT_FUNCTION.on(functionOrPropertyAccessor, abstractNode, functionDescriptor));
+            }
+            else {
+                context.getTrace().report(NON_MEMBER_ABSTRACT_ACCESSOR.on(functionOrPropertyAccessor, abstractNode));
+            }
+        }
+        if (function.getBodyExpression() == null && !hasAbstractModifier && nameIdentifier != null && !isPropertyAccessor) {
+            context.getTrace().report(NON_MEMBER_FUNCTION_NO_BODY.on(functionOrPropertyAccessor, nameIdentifier, functionDescriptor));
+        }
+    }
+
+    private void checkAccessors(JetProperty property, PropertyDescriptor propertyDescriptor) {
+        for (JetPropertyAccessor accessor : property.getAccessors()) {
+            PropertyAccessorDescriptor accessorDescriptor = accessor.isGetter()
+                                                            ? propertyDescriptor.getGetter()
+                                                            : propertyDescriptor.getSetter();
+            checkFunction(accessor, accessorDescriptor);
+            checkModifiers(accessor.getModifierList());
+            if (propertyDescriptor.getModality() == Modality.FINAL && accessor.hasModifier(JetTokens.OPEN_KEYWORD)) {
+                ASTNode openModifierNode = accessor.getModifierList().getModifierNode(JetTokens.OPEN_KEYWORD);
+                context.getTrace().report(NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY.on(accessor, openModifierNode, property));
+            }
+            if (propertyDescriptor.getModality() != Modality.ABSTRACT && accessor.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+                ASTNode abstractModifierNode = accessor.getModifierList().getModifierNode(JetTokens.ABSTRACT_KEYWORD);
+                context.getTrace().report(ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY.on(accessor, abstractModifierNode, property));
+            }
+        }
+    }
+
+    private void checkModifiers(@Nullable JetModifierList modifierList) {
+        checkModalityModifiers(modifierList);
+        checkVisibilityModifiers(modifierList);
+    }
+
+    private void checkModalityModifiers(@Nullable JetModifierList modifierList) {
+        if (modifierList == null) return;
+        checkRedundantModifier(modifierList, Pair.create(JetTokens.OPEN_KEYWORD, JetTokens.ABSTRACT_KEYWORD), Pair.create(JetTokens.OPEN_KEYWORD, JetTokens.OVERRIDE_KEYWORD));
+
+        checkCompatibility(modifierList, Lists.newArrayList(JetTokens.ABSTRACT_KEYWORD, JetTokens.OPEN_KEYWORD, JetTokens.FINAL_KEYWORD),
+                           Lists.<JetToken>newArrayList(JetTokens.ABSTRACT_KEYWORD, JetTokens.OPEN_KEYWORD));
+    }
+
+    private void checkVisibilityModifiers(@Nullable JetModifierList modifierList) {
+        if (modifierList == null) return;
+
+        checkCompatibility(modifierList, Lists.newArrayList(JetTokens.PRIVATE_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.PUBLIC_KEYWORD, JetTokens.INTERNAL_KEYWORD),
+                           Lists.<JetToken>newArrayList(JetTokens.PROTECTED_KEYWORD, JetTokens.INTERNAL_KEYWORD));
+    }
+
+    private void checkCompatibility(@Nullable JetModifierList modifierList, Collection<JetKeywordToken> availableModifiers, Collection<JetToken>... availableCombinations) {
+        if (modifierList == null) return;
+        Collection<JetKeywordToken> presentModifiers = Sets.newLinkedHashSet();
+        for (JetKeywordToken modifier : availableModifiers) {
+            if (modifierList.hasModifier(modifier)) {
+                presentModifiers.add(modifier);
+            }
+        }
+        if (presentModifiers.size() == 1) {
+            return;
+        }
+        for (Collection<JetToken> combination : availableCombinations) {
+            if (presentModifiers.containsAll(combination) && combination.containsAll(presentModifiers)) {
+                return;
+            }
+        }
+        for (JetKeywordToken token : presentModifiers) {
+            context.getTrace().report(Errors.INCOMPATIBLE_MODIFIERS.on(modifierList.getModifierNode(token), presentModifiers));
+        }
+    }
+
+    private void checkRedundantModifier(@NotNull JetModifierList modifierList, Pair<JetKeywordToken, JetKeywordToken>... redundantBundles) {
+        for (Pair<JetKeywordToken, JetKeywordToken> tokenPair : redundantBundles) {
+            JetKeywordToken redundantModifier = tokenPair.getFirst();
+            JetKeywordToken sufficientModifier = tokenPair.getSecond();
+            if (modifierList.hasModifier(redundantModifier) && modifierList.hasModifier(sufficientModifier)) {
+                context.getTrace().report(Errors.REDUNDANT_MODIFIER.on(modifierList, modifierList.getModifierNode(redundantModifier), redundantModifier, sufficientModifier));
+            }
+        }
+    }
+
+    private void checkIllegalInThisContextModifiers(@Nullable JetModifierList modifierList, JetKeywordToken... illegalModifiers) {
+        if (modifierList == null) return;
+        for (JetKeywordToken modifier : illegalModifiers) {
+            if (modifierList.hasModifier(modifier)) {
+                context.getTrace().report(Errors.ILLEGAL_MODIFIER.on(modifierList.getModifierNode(modifier), modifier));
+            }
+        }
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java
similarity index 57%
rename from idea/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java
index 505a253ed44..9b00c34e64a 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java
@@ -2,10 +2,8 @@ package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.CollectingErrorHandler;
-import org.jetbrains.jet.lang.ErrorHandler;
-import org.jetbrains.jet.lang.JetDiagnostic;
-import org.jetbrains.jet.util.*;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.util.slicedmap.*;
 
 import java.util.Collection;
 import java.util.List;
@@ -14,34 +12,27 @@ import java.util.Map;
 /**
  * @author abreslav
  */
-public class TemporaryBindingTrace implements BindingTrace {
+public class DelegatingBindingTrace implements BindingTrace {
     private final BindingContext parentContext;
-    private final MutableManyMap map = ManyMapImpl.create();
-    private final List<JetDiagnostic> diagnostics = Lists.newArrayList();
-    private final ErrorHandler errorHandler = new CollectingErrorHandler(diagnostics);
+    private final MutableSlicedMap map = SlicedMapImpl.create();
+    private final List<Diagnostic> diagnostics = Lists.newArrayList();
 
     private final BindingContext bindingContext = new BindingContext() {
         @Override
-        public Collection<JetDiagnostic> getDiagnostics() {
+        public Collection<Diagnostic> getDiagnostics() {
             throw new UnsupportedOperationException(); // TODO
         }
 
         @Override
         public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
-            return TemporaryBindingTrace.this.get(slice, key);
+            return DelegatingBindingTrace.this.get(slice, key);
         }
     };
 
-    public TemporaryBindingTrace(BindingContext parentContext) {
+    public DelegatingBindingTrace(BindingContext parentContext) {
         this.parentContext = parentContext;
     }
 
-    @Override
-    @NotNull
-    public ErrorHandler getErrorHandler() {
-        return errorHandler;
-    }
-
     @Override
     public BindingContext getBindingContext() {
         return bindingContext;
@@ -66,14 +57,21 @@ public class TemporaryBindingTrace implements BindingTrace {
     }
 
     public void addAllMyDataTo(BindingTrace trace) {
-        for (Map.Entry<ManyMapKey<?, ?>, ?> entry : map) {
-            ManyMapKey manyMapKey = entry.getKey();
+        for (Map.Entry<SlicedMapKey<?, ?>, ?> entry : map) {
+            SlicedMapKey slicedMapKey = entry.getKey();
             Object value = entry.getValue();
 
             //noinspection unchecked
-            trace.record(manyMapKey.getSlice(), manyMapKey.getKey(), value);
+            trace.record(slicedMapKey.getSlice(), slicedMapKey.getKey(), value);
         }
         
-        AnalyzingUtils.applyHandler(trace.getErrorHandler(), diagnostics);
+        for (Diagnostic diagnostic : diagnostics) {
+            trace.report(diagnostic);
+        }
+    }
+
+    @Override
+    public void report(@NotNull Diagnostic diagnostic) {
+        diagnostics.add(diagnostic);
     }
 }
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java
new file mode 100644
index 00000000000..9fb7350d280
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java
@@ -0,0 +1,66 @@
+package org.jetbrains.jet.lang.resolve;
+
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.MutableClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.types.JetType;
+
+import java.util.Map;
+
+import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED;
+
+/**
+ * @author abreslav
+ */
+public class DelegationResolver {
+    private final TopDownAnalysisContext context;
+
+    public DelegationResolver(TopDownAnalysisContext context) {
+        this.context = context;
+    }
+
+    public void process() {
+        addDelegatedMembers();
+    }
+
+    private void addDelegatedMembers() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            addDelegatedMembers(entry.getKey(), entry.getValue());
+        }
+        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+            addDelegatedMembers(entry.getKey(), entry.getValue());
+        }
+    }
+
+    private void addDelegatedMembers(JetClassOrObject jetClass, MutableClassDescriptor classDescriptor) {
+        for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) {
+            if (delegationSpecifier instanceof JetDelegatorByExpressionSpecifier) {
+                JetDelegatorByExpressionSpecifier specifier = (JetDelegatorByExpressionSpecifier) delegationSpecifier;
+                JetType type = context.getTrace().get(BindingContext.TYPE, specifier.getTypeReference());
+                if (type != null) {
+                    for (DeclarationDescriptor declarationDescriptor : type.getMemberScope().getAllDescriptors()) {
+                        if (declarationDescriptor instanceof PropertyDescriptor) {
+                            PropertyDescriptor propertyDescriptor = (PropertyDescriptor) declarationDescriptor;
+                            if (propertyDescriptor.getModality().isOverridable()) {
+                                PropertyDescriptor copy = propertyDescriptor.copy(classDescriptor, true);
+                                classDescriptor.addPropertyDescriptor(copy);
+                                context.getTrace().record(DELEGATED, copy);
+                            }
+                        }
+                        else if (declarationDescriptor instanceof FunctionDescriptor) {
+                            FunctionDescriptor functionDescriptor = (FunctionDescriptor) declarationDescriptor;
+                            if (functionDescriptor.getModality().isOverridable()) {
+                                FunctionDescriptor copy = functionDescriptor.copy(classDescriptor, true);
+                                classDescriptor.addFunctionDescriptor(copy);
+                                context.getTrace().record(DELEGATED, copy);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java
new file mode 100644
index 00000000000..42fb64620ed
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java
@@ -0,0 +1,114 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.types.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author abreslav
+ */
+public class DescriptorUtils {
+    public static boolean definesItsOwnThis(@NotNull DeclarationDescriptor descriptor) {
+        return descriptor.accept(new DeclarationDescriptorVisitor<Boolean, Void>() {
+            @Override
+            public Boolean visitDeclarationDescriptor(DeclarationDescriptor descriptor, Void data) {
+                return false;
+            }
+
+            @Override
+            public Boolean visitFunctionDescriptor(FunctionDescriptor descriptor, Void data) {
+                return descriptor.getReceiver().exists();
+            }
+
+            @Override
+            public Boolean visitClassDescriptor(ClassDescriptor descriptor, Void data) {
+                return true;
+            }
+
+            @Override
+            public Boolean visitPropertyDescriptor(PropertyDescriptor descriptor, Void data) {
+                return descriptor.getReceiver().exists();
+            }
+        }, null);
+    }
+
+    @NotNull
+    public static <Descriptor extends CallableDescriptor> Descriptor substituteBounds(@NotNull Descriptor functionDescriptor) {
+        final List<TypeParameterDescriptor> typeParameters = functionDescriptor.getTypeParameters();
+        if (typeParameters.isEmpty()) return functionDescriptor;
+        final Map<TypeConstructor, TypeParameterDescriptor> typeConstructors = Maps.newHashMap();
+        for (TypeParameterDescriptor typeParameter : typeParameters) {
+            typeConstructors.put(typeParameter.getTypeConstructor(), typeParameter);
+        }
+        //noinspection unchecked
+        return (Descriptor) functionDescriptor.substitute(new TypeSubstitutor(TypeSubstitutor.TypeSubstitution.EMPTY) {
+            @Override
+            public boolean inRange(@NotNull TypeConstructor typeConstructor) {
+                return typeConstructors.containsKey(typeConstructor);
+            }
+
+            @Override
+            public boolean isEmpty() {
+                return typeParameters.isEmpty();
+            }
+
+            @NotNull
+            @Override
+            public TypeSubstitution getSubstitution() {
+                throw new UnsupportedOperationException();
+            }
+
+            @NotNull
+            @Override
+            public JetType safeSubstitute(@NotNull JetType type, @NotNull Variance howThisTypeIsUsed) {
+                JetType substituted = substitute(type, howThisTypeIsUsed);
+                if (substituted == null) {
+                    return ErrorUtils.createErrorType("Substitution failed");
+                }
+                return substituted;
+            }
+
+            @Override
+            public JetType substitute(@NotNull JetType type, @NotNull Variance howThisTypeIsUsed) {
+                TypeParameterDescriptor typeParameterDescriptor = typeConstructors.get(type.getConstructor());
+                if (typeParameterDescriptor != null) {
+                    switch (howThisTypeIsUsed) {
+                        case INVARIANT:
+                            return type;
+                        case IN_VARIANCE:
+                            throw new UnsupportedOperationException(); // TODO : lower bounds
+                        case OUT_VARIANCE:
+                            return typeParameterDescriptor.getDefaultType();
+                    }
+                }
+                return super.substitute(type, howThisTypeIsUsed);
+            }
+        });
+    }
+    
+    public static List<ValueParameterDescriptor> copyValueParameters(DeclarationDescriptor newOwner, List<ValueParameterDescriptor> parameters) {
+        List<ValueParameterDescriptor> result = Lists.newArrayList();
+        for (ValueParameterDescriptor parameter : parameters) {
+            result.add(parameter.copy(newOwner));
+        }
+        return result;
+    }
+
+    public static List<TypeParameterDescriptor> copyTypeParameters(DeclarationDescriptor newOwner, List<TypeParameterDescriptor> parameters) {
+        List<TypeParameterDescriptor> result = Lists.newArrayList();
+        for (TypeParameterDescriptor parameter : parameters) {
+            result.add(parameter.copy(newOwner));
+        }
+        return result;
+    }
+    
+    public static Modality convertModality(Modality modality, boolean makeNonAbstract) {
+        if (makeNonAbstract && modality == Modality.ABSTRACT) return Modality.OPEN;
+        return modality;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportingStrategy.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportingStrategy.java
new file mode 100644
index 00000000000..1671b51fa74
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportingStrategy.java
@@ -0,0 +1,19 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.intellij.openapi.project.Project;
+import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+
+/**
+* @author abreslav
+*/
+public interface ImportingStrategy {
+    ImportingStrategy NONE = new ImportingStrategy() {
+        @Override
+        public void addImports(Project project, JetSemanticServices semanticServices, BindingTrace trace, WritableScope rootScope) {
+
+        }
+    };
+
+    void addImports(Project project, JetSemanticServices semanticServices, BindingTrace trace, WritableScope rootScope);
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java
similarity index 88%
rename from idea/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java
index 83b7b08e240..a23a151f168 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java
@@ -1,6 +1,7 @@
 package org.jetbrains.jet.lang.resolve;
 
 import org.jetbrains.jet.lang.psi.JetElement;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.NamespaceType;
 
 /**
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ObservableBindingTrace.java
similarity index 70%
rename from idea/src/org/jetbrains/jet/lang/resolve/BindingTraceAdapter.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/ObservableBindingTrace.java
index a0c691ec476..928c463217b 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceAdapter.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ObservableBindingTrace.java
@@ -2,31 +2,30 @@ package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.collect.Maps;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ErrorHandler;
-import org.jetbrains.jet.util.ReadOnlySlice;
-import org.jetbrains.jet.util.WritableSlice;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
+import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 import java.util.Map;
 
 /**
  * @author abreslav
  */
-public class BindingTraceAdapter implements BindingTrace {
+public class ObservableBindingTrace implements BindingTrace {
     public interface RecordHandler<K, V> {
+
         void handleRecord(WritableSlice<K, V> slice, K key, V value);
     }
-
     private final BindingTrace originalTrace;
-    private Map<WritableSlice, RecordHandler> handlers = Maps.newHashMap();
 
-    public BindingTraceAdapter(BindingTrace originalTrace) {
+    private Map<WritableSlice, RecordHandler> handlers = Maps.newHashMap();
+    public ObservableBindingTrace(BindingTrace originalTrace) {
         this.originalTrace = originalTrace;
     }
 
     @Override
-    @NotNull
-    public ErrorHandler getErrorHandler() {
-        return originalTrace.getErrorHandler();
+    public void report(@NotNull Diagnostic diagnostic) {
+        originalTrace.report(diagnostic);
     }
 
     @Override
@@ -53,7 +52,7 @@ public class BindingTraceAdapter implements BindingTrace {
         return originalTrace.get(slice, key);
     }
     
-    public <K, V> BindingTraceAdapter addHandler(@NotNull WritableSlice<K, V> slice, @NotNull RecordHandler<K, V> handler) {
+    public <K, V> ObservableBindingTrace addHandler(@NotNull WritableSlice<K, V> slice, @NotNull RecordHandler<K, V> handler) {
         handlers.put(slice, handler);
         return this;
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
new file mode 100644
index 00000000000..67e12a470e7
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
@@ -0,0 +1,275 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.google.common.collect.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.JetTypeChecker;
+import org.jetbrains.jet.lexer.JetTokens;
+import org.jetbrains.jet.util.CommonSuppliers;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED;
+
+/**
+ * @author abreslav
+ */
+public class OverrideResolver {
+
+    private final TopDownAnalysisContext context;
+
+    public OverrideResolver(@NotNull TopDownAnalysisContext context) {
+        this.context = context;
+    }
+
+    public void process() {
+        bindOverrides();
+        checkOverrides();
+    }
+
+    private void bindOverrides() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            bindOverridesInAClass(entry.getValue());
+        }
+        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+            bindOverridesInAClass(entry.getValue());
+        }
+    }
+
+    private void bindOverridesInAClass(MutableClassDescriptor classDescriptor) {
+        for (FunctionDescriptor declaredFunction : classDescriptor.getFunctions()) {
+            for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
+                FunctionDescriptor overridden = findFunctionOverridableBy(declaredFunction, supertype);
+                if (overridden != null) {
+                    ((FunctionDescriptorImpl) declaredFunction).addOverriddenFunction(overridden);
+                }
+            }
+        }
+
+        for (PropertyDescriptor propertyDescriptor : classDescriptor.getProperties()) {
+            for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
+                PropertyDescriptor overridden = findPropertyOverridableBy(propertyDescriptor, supertype);
+                if (overridden != null) {
+                    propertyDescriptor.addOverriddenDescriptor(overridden);
+                }
+            }
+        }
+    }
+
+    @Nullable
+    private FunctionDescriptor findFunctionOverridableBy(@NotNull FunctionDescriptor declaredFunction, @NotNull JetType supertype) {
+        Set<FunctionDescriptor> functionGroup = supertype.getMemberScope().getFunctions(declaredFunction.getName());
+        for (FunctionDescriptor functionDescriptor : functionGroup) {
+            if (OverridingUtil.isOverridableBy(functionDescriptor, declaredFunction).isSuccess()) {
+                return functionDescriptor;
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    private PropertyDescriptor findPropertyOverridableBy(@NotNull PropertyDescriptor declaredProperty, @NotNull JetType supertype) {
+        PropertyDescriptor property = (PropertyDescriptor) supertype.getMemberScope().getVariable(declaredProperty.getName());
+        if (property == null) {
+            return null;
+        }
+        if (OverridingUtil.isOverridableBy(property, declaredProperty).isSuccess()) {
+            return property;
+        }
+        return null;
+    }
+
+    private void checkOverrides() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            checkOverridesInAClass(entry.getValue(), entry.getKey());
+        }
+        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+            checkOverridesInAClass(entry.getValue(), entry.getKey());
+        }
+    }
+
+    protected void checkOverridesInAClass(MutableClassDescriptor classDescriptor, JetClassOrObject klass) {
+        // Check overrides for internal consistency
+        for (CallableMemberDescriptor member : classDescriptor.getCallableMembers()) {
+            checkOverride(member);
+        }
+
+        // Check if everything that must be overridden, actually is
+
+        // Everything from supertypes
+        Map<CallableMemberDescriptor, CallableMemberDescriptor> implementedWithDelegationBy = Maps.newHashMap();
+        Set<CallableMemberDescriptor> inheritedFunctions = Sets.newLinkedHashSet();
+        for (JetType supertype : classDescriptor.getSupertypes()) {
+            for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors()) {
+                if (descriptor instanceof CallableMemberDescriptor) {
+                    CallableMemberDescriptor memberDescriptor = (CallableMemberDescriptor) descriptor;
+                    inheritedFunctions.add(memberDescriptor);
+                }
+            }
+        }
+
+        // Only those actually inherited
+        Set<CallableMemberDescriptor> filteredMembers = OverridingUtil.filterOverrides(inheritedFunctions);
+
+        // Group members with "the same" signature
+        Multimap<CallableMemberDescriptor, CallableMemberDescriptor> factoredMembers = CommonSuppliers.newLinkedHashSetHashSetMultimap();
+        for (CallableMemberDescriptor one : filteredMembers) {
+            if (factoredMembers.values().contains(one)) continue;
+            for (CallableMemberDescriptor another : filteredMembers) {
+//                if (one == another) continue;
+                factoredMembers.put(one, one);
+                if (OverridingUtil.isOverridableBy(one, another).isSuccess()
+                        || OverridingUtil.isOverridableBy(another, one).isSuccess()) {
+                    factoredMembers.put(one, another);
+                }
+            }
+        }
+
+        // More than one implementation or no implementations at all
+        Set<CallableMemberDescriptor> abstractNoImpl = Sets.newLinkedHashSet();
+        Set<CallableMemberDescriptor> manyImpl = Sets.newLinkedHashSet();
+        for (CallableMemberDescriptor key : factoredMembers.keySet()) {
+            Collection<CallableMemberDescriptor> mutuallyOverridable = factoredMembers.get(key);
+
+            int implementationCount = 0;
+            for (CallableMemberDescriptor member : mutuallyOverridable) {
+                if (member.getModality() != Modality.ABSTRACT) {
+                    implementationCount++;
+                }
+            }
+            
+            if (implementationCount == 0) {
+                abstractNoImpl.addAll(mutuallyOverridable);
+            }
+            else if (implementationCount > 1) {
+                manyImpl.addAll(mutuallyOverridable);
+            }
+        }
+
+        // Members actually present (declared) in the class
+        Set<CallableMemberDescriptor> actuallyOverridden = Sets.newHashSet(implementedWithDelegationBy.keySet());
+        for (CallableMemberDescriptor member : classDescriptor.getCallableMembers()) {
+            actuallyOverridden.addAll(member.getOverriddenDescriptors());
+        }
+
+        // Those to be overridden that are actually not
+        abstractNoImpl.removeAll(actuallyOverridden);
+        manyImpl.removeAll(actuallyOverridden);
+
+        PsiElement nameIdentifier = klass;
+        if (klass instanceof JetClass) {
+            nameIdentifier = ((JetClass) klass).getNameIdentifier();
+        }
+        else if (klass instanceof JetObjectDeclaration) {
+            nameIdentifier = ((JetObjectDeclaration) klass).getNameIdentifier();
+        }
+
+        for (CallableMemberDescriptor memberDescriptor : manyImpl) {
+            context.getTrace().report(MANY_IMPL_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, memberDescriptor));
+            break;
+        }
+
+
+        if (classDescriptor.getModality() == Modality.ABSTRACT) {
+            return;
+        }
+
+        for (CallableMemberDescriptor memberDescriptor : abstractNoImpl) {
+            context.getTrace().report(ABSTRACT_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, memberDescriptor));
+            break;
+        }
+
+//        Set<FunctionDescriptor> allOverriddenFunctions = Sets.newHashSet();
+//        Collection<DeclarationDescriptor> allDescriptors = classDescriptor.getDefaultType().getMemberScope().getAllDescriptors();
+//        for (DeclarationDescriptor descriptor : allDescriptors) {
+//            if (descriptor instanceof FunctionDescriptor) {
+//                FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
+//                if (functionDescriptor.getModality() != Modality.ABSTRACT) {
+//                    for (FunctionDescriptor overriddenDescriptor : functionDescriptor.getOverriddenDescriptors()) {
+//                        allOverriddenFunctions.add(overriddenDescriptor.getOriginal());
+//                    }
+//                }
+//            }
+//        }
+//        boolean foundError = false;
+//        for (DeclarationDescriptor descriptor : allDescriptors) {
+//            if (descriptor instanceof FunctionDescriptor) {
+//                FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
+//                if (functionDescriptor.getModality() == Modality.ABSTRACT && !allOverriddenFunctions.contains(functionDescriptor.getOriginal()) && !foundError && nameIdentifier != null) {
+//                    DeclarationDescriptor declarationDescriptor = functionDescriptor.getContainingDeclaration();
+//                    if (declarationDescriptor != classDescriptor) {
+////                        context.getTrace().getErrorHandler().genericError(nameIdentifier.getNode(), "Class '" + klass.getName() + "' must be declared abstract or implement abstract method '" +
+////                                                                                                    functionDescriptor.getName() + "' declared in " + declarationDescriptor.getName());
+//                        context.getTrace().report(ABSTRACT_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, functionDescriptor));
+//                        foundError = true;
+//                    }
+//                }
+//            }
+//        }
+    }
+
+    private void checkOverride(CallableMemberDescriptor declared) {
+        JetNamedDeclaration member = (JetNamedDeclaration) context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, declared);
+        if (member == null) {
+            assert context.getTrace().get(DELEGATED, declared);
+            return;
+        }
+
+        JetModifierList modifierList = member.getModifierList();
+        ASTNode overrideNode = modifierList != null ? modifierList.getModifierNode(JetTokens.OVERRIDE_KEYWORD) : null;
+        boolean hasOverrideModifier = overrideNode != null;
+
+        boolean finalOverriddenError = false;
+        boolean typeMismatchError = false;
+        boolean kindMismatchError = false;
+        for (CallableMemberDescriptor overridden : declared.getOverriddenDescriptors()) {
+            if (overridden != null) {
+                if (hasOverrideModifier) {
+                    if (!overridden.getModality().isOverridable() && !finalOverriddenError) {
+    //                    context.getTrace().getErrorHandler().genericError(overrideNode, "Method " + overridden.getName() + " in " + overridden.getContainingDeclaration().getName() + " is final and cannot be overridden");
+                        context.getTrace().report(OVERRIDING_FINAL_MEMBER.on(overrideNode, overridden, overridden.getContainingDeclaration()));
+                        finalOverriddenError = true;
+                    }
+
+                    if (!OverridingUtil.isReturnTypeOkForOverride(JetTypeChecker.INSTANCE, overridden, declared) && !typeMismatchError) {
+                        context.getTrace().report(RETURN_TYPE_MISMATCH_ON_OVERRIDE.on(member, declared, overridden));
+                        typeMismatchError = true;
+                    }
+
+                    if (checkPropertyKind(overridden, true) && checkPropertyKind(declared, false) && !kindMismatchError) {
+                        context.getTrace().report(VAR_OVERRIDDEN_BY_VAL.on(member, ((JetProperty) member).getValOrVarNode(), (PropertyDescriptor) declared, (PropertyDescriptor) overridden));
+                        kindMismatchError = true;
+                    }
+                }
+            }
+        }
+        if (hasOverrideModifier && declared.getOverriddenDescriptors().size() == 0) {
+//            context.getTrace().getErrorHandler().genericError(overrideNode, "Method " + declared.getName() + " overrides nothing");
+            context.getTrace().report(NOTHING_TO_OVERRIDE.on(member, overrideNode, declared));
+        }
+        PsiElement nameIdentifier = member.getNameIdentifier();
+        if (!hasOverrideModifier && declared.getOverriddenDescriptors().size() > 0 && nameIdentifier != null) {
+            CallableMemberDescriptor overridden = declared.getOverriddenDescriptors().iterator().next();
+//            context.getTrace().getErrorHandler().genericError(nameIdentifier.getNode(),
+//                                                 "Method '" + declared.getName() + "' overrides method '" + overridden.getName() + "' in class " +
+//                                                 overridden.getContainingDeclaration().getName() + " and needs 'override' modifier");
+            context.getTrace().report(VIRTUAL_MEMBER_HIDDEN.on(member, nameIdentifier, declared, overridden, overridden.getContainingDeclaration()));
+        }
+    }
+
+    private boolean checkPropertyKind(CallableMemberDescriptor descriptor, boolean isVar) {
+        if (descriptor instanceof PropertyDescriptor) {
+            PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
+            return propertyDescriptor.isVar() == isVar;
+        }
+        return false;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
new file mode 100644
index 00000000000..314f847b5ef
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
@@ -0,0 +1,234 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.types.*;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author abreslav
+ */
+public class OverridingUtil {
+
+    private OverridingUtil() {
+    }
+
+    public static Set<CallableDescriptor> getEffectiveMembers(@NotNull ClassDescriptor classDescriptor) {
+        Collection<DeclarationDescriptor> allDescriptors = classDescriptor.getDefaultType().getMemberScope().getAllDescriptors();
+        Set<CallableDescriptor> allMembers = Sets.newLinkedHashSet();
+        for (DeclarationDescriptor descriptor : allDescriptors) {
+            assert !(descriptor instanceof ConstructorDescriptor);
+            if (descriptor instanceof CallableDescriptor && descriptor instanceof MemberDescriptor) {
+                CallableDescriptor callableDescriptor = (CallableDescriptor) descriptor;
+                if (((MemberDescriptor) descriptor).getModality() != Modality.ABSTRACT) {
+                    allMembers.add(callableDescriptor);
+                }
+            }
+        }
+        return filterOverrides(allMembers);
+    }
+
+    public static <D extends CallableDescriptor> Set<D> filterOverrides(Set<D> candidateSet) {
+        Set<D> candidates = Sets.newLinkedHashSet();
+        outerLoop:
+        for (D me : candidateSet) {
+            for (D other : candidateSet) {
+                if (me == other) continue;
+                if (overrides(other, me)) {
+                    continue outerLoop;
+                }
+            }
+            for (D other : candidates) {
+                if (me.getOriginal() == other.getOriginal()
+                        && isOverridableBy(other, me).isSuccess()
+                        && isOverridableBy(me, other).isSuccess()) {
+                    continue outerLoop;
+                }
+            }
+//            System.out.println(me);
+            candidates.add(me);
+        }
+//        Set<D> candidates = Sets.newLinkedHashSet(candidateSet);
+//        for (D descriptor : candidateSet) {
+//            Set<CallableDescriptor> overriddenDescriptors = Sets.newHashSet();
+//            getAllOverriddenDescriptors(descriptor.getOriginal(), overriddenDescriptors);
+//            candidates.removeAll(overriddenDescriptors);
+//        }
+        return candidates;
+    }
+
+    public static <Descriptor extends CallableDescriptor> boolean overrides(@NotNull Descriptor f, @NotNull Descriptor g) {
+        Set<CallableDescriptor> overriddenDescriptors = Sets.newHashSet();
+        getAllOverriddenDescriptors(f.getOriginal(), overriddenDescriptors);
+        CallableDescriptor originalG = g.getOriginal();
+        for (CallableDescriptor overriddenFunction : overriddenDescriptors) {
+            if (originalG.equals(overriddenFunction.getOriginal())) return true;
+        }
+        return false;
+    }
+
+    private static void getAllOverriddenDescriptors(@NotNull CallableDescriptor current, @NotNull Set<CallableDescriptor> overriddenDescriptors) {
+        if (overriddenDescriptors.contains(current)) return;
+        for (CallableDescriptor descriptor : current.getOriginal().getOverriddenDescriptors()) {
+            getAllOverriddenDescriptors(descriptor, overriddenDescriptors);
+            overriddenDescriptors.add(descriptor);
+        }
+    }
+
+    @NotNull
+    public static OverrideCompatibilityInfo isOverridableBy(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
+        if (superDescriptor instanceof FunctionDescriptor) {
+            if (subDescriptor instanceof PropertyDescriptor) return OverrideCompatibilityInfo.memberKindMismatch();
+        }
+        if (superDescriptor instanceof PropertyDescriptor) {
+            if (subDescriptor instanceof FunctionDescriptor) return OverrideCompatibilityInfo.memberKindMismatch();
+        }
+        if (!superDescriptor.getName().equals(subDescriptor.getName())) {
+            return OverrideCompatibilityInfo.nameMismatch();
+        }
+
+        // TODO : Visibility
+
+        if (superDescriptor.getTypeParameters().size() != subDescriptor.getTypeParameters().size()) {
+            return OverrideCompatibilityInfo.typeParameterNumberMismatch();
+        }
+
+        if (superDescriptor.getValueParameters().size() != subDescriptor.getValueParameters().size()) {
+            return OverrideCompatibilityInfo.valueParameterNumberMismatch();
+        }
+
+        List<TypeParameterDescriptor> superTypeParameters = superDescriptor.getTypeParameters();
+        List<TypeParameterDescriptor> subTypeParameters = subDescriptor.getTypeParameters();
+
+        BiMap<TypeConstructor, TypeConstructor> axioms = HashBiMap.create();
+        for (int i = 0, typeParametersSize = superTypeParameters.size(); i < typeParametersSize; i++) {
+            TypeParameterDescriptor superTypeParameter = superTypeParameters.get(i);
+            TypeParameterDescriptor subTypeParameter = subTypeParameters.get(i);
+            axioms.put(superTypeParameter.getTypeConstructor(), subTypeParameter.getTypeConstructor());
+        }
+
+        for (int i = 0, typeParametersSize = superTypeParameters.size(); i < typeParametersSize; i++) {
+            TypeParameterDescriptor superTypeParameter = superTypeParameters.get(i);
+            TypeParameterDescriptor subTypeParameter = subTypeParameters.get(i);
+
+            if (!JetTypeImpl.equalTypes(superTypeParameter.getBoundsAsType(), subTypeParameter.getBoundsAsType(), axioms)) {
+                return OverrideCompatibilityInfo.boundsMismatch(superTypeParameter, subTypeParameter);
+            }
+        }
+
+        List<ValueParameterDescriptor> superValueParameters = superDescriptor.getValueParameters();
+        List<ValueParameterDescriptor> subValueParameters = subDescriptor.getValueParameters();
+        for (int i = 0, unsubstitutedValueParametersSize = superValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
+            ValueParameterDescriptor superValueParameter = superValueParameters.get(i);
+            ValueParameterDescriptor subValueParameter = subValueParameters.get(i);
+
+            if (!JetTypeImpl.equalTypes(superValueParameter.getOutType(), subValueParameter.getOutType(), axioms)) {
+                return OverrideCompatibilityInfo.valueParameterTypeMismatch(superValueParameter, subValueParameter);
+            }
+        }
+
+        // TODO : Default values, varargs etc
+
+        return OverrideCompatibilityInfo.success();
+    }
+
+    @NotNull
+    public static boolean isReturnTypeOkForOverride(@NotNull JetTypeChecker typeChecker, @NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
+        List<TypeParameterDescriptor> superTypeParameters = superDescriptor.getTypeParameters();
+        List<TypeParameterDescriptor> subTypeParameters = subDescriptor.getTypeParameters();
+        Map<TypeConstructor, TypeProjection> substitutionContext = Maps.newHashMap();
+        for (int i = 0, typeParametersSize = superTypeParameters.size(); i < typeParametersSize; i++) {
+            TypeParameterDescriptor superTypeParameter = superTypeParameters.get(i);
+            TypeParameterDescriptor subTypeParameter = subTypeParameters.get(i);
+            substitutionContext.put(
+                    superTypeParameter.getTypeConstructor(),
+                    new TypeProjection(subTypeParameter.getDefaultType()));
+        }
+
+        // This code compares return types, but they are not a part of the signature, so this code does not belong here
+        TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitutionContext);
+        JetType substitutedSuperReturnType = typeSubstitutor.substitute(superDescriptor.getReturnType(), Variance.OUT_VARIANCE);
+        assert substitutedSuperReturnType != null;
+        if (!typeChecker.isSubtypeOf(subDescriptor.getReturnType(), substitutedSuperReturnType)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public static class OverrideCompatibilityInfo {
+
+        private static final OverrideCompatibilityInfo SUCCESS = new OverrideCompatibilityInfo(true, "SUCCESS");
+
+        @NotNull
+        public static OverrideCompatibilityInfo success() {
+            return SUCCESS;
+        }
+
+        @NotNull
+        public static OverrideCompatibilityInfo nameMismatch() {
+            return new OverrideCompatibilityInfo(false, "nameMismatch"); // TODO
+        }
+
+        @NotNull
+        public static OverrideCompatibilityInfo typeParameterNumberMismatch() {
+            return new OverrideCompatibilityInfo(false, "typeParameterNumberMismatch"); // TODO
+        }
+
+        @NotNull
+        public static OverrideCompatibilityInfo valueParameterNumberMismatch() {
+            return new OverrideCompatibilityInfo(false, "valueParameterNumberMismatch"); // TODO
+        }
+
+        @NotNull
+        public static OverrideCompatibilityInfo boundsMismatch(TypeParameterDescriptor superTypeParameter, TypeParameterDescriptor subTypeParameter) {
+            return new OverrideCompatibilityInfo(false, "boundsMismatch"); // TODO
+        }
+
+        @NotNull
+        public static OverrideCompatibilityInfo valueParameterTypeMismatch(ValueParameterDescriptor superValueParameter, ValueParameterDescriptor subValueParameter) {
+            return new OverrideCompatibilityInfo(false, "valueParameterTypeMismatch"); // TODO
+        }
+
+        @NotNull
+        public static OverrideCompatibilityInfo memberKindMismatch() {
+            return new OverrideCompatibilityInfo(false, "memberKindMismatch"); // TODO
+        }
+
+        @NotNull
+        public static OverrideCompatibilityInfo returnTypeMismatch(JetType substitutedSuperReturnType, JetType unsubstitutedSubReturnType) {
+            return new OverrideCompatibilityInfo(true, "returnTypeMismatch: " + unsubstitutedSubReturnType + " >< " + substitutedSuperReturnType); // TODO
+        }
+
+        @NotNull
+        public static OverrideCompatibilityInfo varOverriddenByVal() {
+            return new OverrideCompatibilityInfo(false, "varOverriddenByVal"); // TODO
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+        private final boolean isSuccess;
+        private final String message;
+
+        public OverrideCompatibilityInfo(boolean success, String message) {
+            isSuccess = success;
+            this.message = message;
+        }
+
+        public boolean isSuccess() {
+            return isSuccess;
+        }
+
+        public String getMessage() {
+            return message;
+        }
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java
new file mode 100644
index 00000000000..9d7f3fd1a18
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java
@@ -0,0 +1,22 @@
+package org.jetbrains.jet.lang.resolve;
+
+/**
+ * @author abreslav
+ */
+public class TemporaryBindingTrace extends DelegatingBindingTrace {
+
+    public static TemporaryBindingTrace create(BindingTrace trace) {
+        return new TemporaryBindingTrace(trace);
+    }
+
+    private final BindingTrace trace;
+
+    private TemporaryBindingTrace(BindingTrace trace) {
+        super(trace.getBindingContext());
+        this.trace = trace;
+    }
+
+    public void commit() {
+        addAllMyDataTo(trace);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
new file mode 100644
index 00000000000..5847cf61cfd
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
@@ -0,0 +1,88 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author abreslav
+ */
+/*package*/ class TopDownAnalysisContext {
+
+    private final ObservableBindingTrace trace;
+    private final JetSemanticServices semanticServices;
+    private final ClassDescriptorResolver classDescriptorResolver;
+
+    private final Map<JetClass, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
+    private final Map<JetObjectDeclaration, MutableClassDescriptor> objects = Maps.newLinkedHashMap();
+    protected final Map<JetNamespace, WritableScope> namespaceScopes = Maps.newHashMap();
+    protected final Map<JetNamespace, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
+
+    private final Map<JetNamedFunction, FunctionDescriptorImpl> functions = Maps.newLinkedHashMap();
+    private final Map<JetDeclaration, ConstructorDescriptor> constructors = Maps.newLinkedHashMap();
+    private final Map<JetProperty, PropertyDescriptor> properties = Maps.newLinkedHashMap();
+    private final Set<PropertyDescriptor> primaryConstructorParameterProperties = Sets.newHashSet();
+    private final Map<JetDeclaration, JetScope> declaringScopes = Maps.newHashMap();
+
+    public TopDownAnalysisContext(JetSemanticServices semanticServices, BindingTrace trace) {
+        this.trace = new ObservableBindingTrace(trace);
+        this.semanticServices = semanticServices;
+        this.classDescriptorResolver = semanticServices.getClassDescriptorResolver(trace);
+    }
+
+    public ObservableBindingTrace getTrace() {
+        return trace;
+    }
+
+    public JetSemanticServices getSemanticServices() {
+        return semanticServices;
+    }
+
+    public ClassDescriptorResolver getClassDescriptorResolver() {
+        return classDescriptorResolver;
+    }
+
+    public Map<JetClass, MutableClassDescriptor> getClasses() {
+        return classes;
+    }
+
+    public Map<JetObjectDeclaration, MutableClassDescriptor> getObjects() {
+        return objects;
+    }
+
+    public Map<JetNamespace, WritableScope> getNamespaceScopes() {
+        return namespaceScopes;
+    }
+
+    public Map<JetNamespace, NamespaceDescriptorImpl> getNamespaceDescriptors() {
+        return namespaceDescriptors;
+    }
+
+    public Set<PropertyDescriptor> getPrimaryConstructorParameterProperties() {
+        return primaryConstructorParameterProperties;
+    }
+
+    public Map<JetDeclaration, ConstructorDescriptor> getConstructors() {
+        return constructors;
+    }
+
+    public Map<JetProperty, PropertyDescriptor> getProperties() {
+        return properties;
+    }
+
+    public Map<JetDeclaration, JetScope> getDeclaringScopes() {
+        return declaringScopes;
+    }
+
+    public Map<JetNamedFunction, FunctionDescriptorImpl> getFunctions() {
+        return functions;
+    }
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
new file mode 100644
index 00000000000..42762dd3c5b
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
@@ -0,0 +1,95 @@
+package org.jetbrains.jet.lang.resolve;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author abreslav
+ */
+public class TopDownAnalyzer {
+
+    private TopDownAnalyzer() {}
+
+    public static void processObject(
+            @NotNull JetSemanticServices semanticServices,
+            @NotNull BindingTrace trace,
+            @NotNull JetScope outerScope,
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull JetObjectDeclaration object) {
+        process(semanticServices, trace, outerScope, new NamespaceLike.Adapter(containingDeclaration) {
+
+                    @Override
+                    public NamespaceDescriptorImpl getNamespace(String name) {
+                        throw new UnsupportedOperationException();
+                    }
+
+                    @Override
+                    public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) {
+                        throw new UnsupportedOperationException();
+                    }
+
+                    @Override
+                    public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
+
+                    }
+
+                    @Override
+                    public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
+                        throw new UnsupportedOperationException();
+                    }
+
+                    @Override
+                    public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
+
+                    }
+
+                    @Override
+                    public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
+                        return ClassObjectStatus.NOT_ALLOWED;
+                    }
+                }, Collections.<JetDeclaration>singletonList(object));
+    }
+
+    public static void process(
+            @NotNull JetSemanticServices semanticServices,
+            @NotNull BindingTrace trace,
+            @NotNull JetScope outerScope, NamespaceLike owner, @NotNull List<? extends JetDeclaration> declarations) {
+        TopDownAnalysisContext context = new TopDownAnalysisContext(semanticServices, trace);
+        new TypeHierarchyResolver(context).process(outerScope, owner, declarations);
+        new DeclarationResolver(context).process();
+        new DelegationResolver(context).process();
+        new OverrideResolver(context).process();
+        new BodyResolver(context).resolveBehaviorDeclarationBodies();
+        new DeclarationsChecker(context).process();
+    }
+
+    public static void processStandardLibraryNamespace(
+            @NotNull JetSemanticServices semanticServices,
+            @NotNull BindingTrace trace,
+            @NotNull WritableScope outerScope, @NotNull NamespaceDescriptorImpl standardLibraryNamespace, @NotNull JetNamespace namespace) {
+        TopDownAnalysisContext context = new TopDownAnalysisContext(semanticServices, trace);
+        context.getNamespaceScopes().put(namespace, standardLibraryNamespace.getMemberScope());
+        context.getNamespaceDescriptors().put(namespace, standardLibraryNamespace);
+        new TypeHierarchyResolver(context).process(outerScope, standardLibraryNamespace, namespace.getDeclarations());
+        new DeclarationResolver(context).process();
+        new DelegationResolver(context).process();
+        OverrideResolver overrideResolver = new OverrideResolver(context) {
+            @Override
+            protected void checkOverridesInAClass(MutableClassDescriptor classDescriptor, JetClassOrObject klass) {
+            }
+        };
+        overrideResolver.process();
+        new BodyResolver(context).resolveBehaviorDeclarationBodies();
+    }
+
+}
+
+
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TraceBasedRedeclarationHandler.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TraceBasedRedeclarationHandler.java
new file mode 100644
index 00000000000..299b6f63455
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TraceBasedRedeclarationHandler.java
@@ -0,0 +1,35 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
+
+import static org.jetbrains.jet.lang.diagnostics.Errors.REDECLARATION;
+
+/**
+ * @author abreslav
+ */
+public class TraceBasedRedeclarationHandler implements RedeclarationHandler {
+    private final BindingTrace trace;
+
+    public TraceBasedRedeclarationHandler(@NotNull BindingTrace trace) {
+        this.trace = trace;
+    }
+    
+    @Override
+    public void handleRedeclaration(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) {
+        report(first);
+        report(second);
+    }
+
+    private void report(DeclarationDescriptor first) {
+        PsiElement firstElement = trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, first);
+        if (firstElement != null) {
+            trace.report(REDECLARATION.on(firstElement));
+        }
+        else {
+            trace.report(REDECLARATION.on(first, trace.getBindingContext()));
+        }
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
new file mode 100644
index 00000000000..1a5d519e22c
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
@@ -0,0 +1,523 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiNameIdentifierOwner;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
+import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope;
+import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lexer.JetTokens;
+
+import java.util.*;
+
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+import static org.jetbrains.jet.lang.resolve.BindingContext.CONSTRUCTOR;
+import static org.jetbrains.jet.lang.resolve.BindingContext.DESCRIPTOR_TO_DECLARATION;
+import static org.jetbrains.jet.lang.resolve.BindingContext.TYPE;
+
+/**
+ * @author abreslav
+ */
+public class TypeHierarchyResolver {
+    private final TopDownAnalysisContext context;
+    private LinkedList<MutableClassDescriptor> topologicalOrder;
+
+
+    public TypeHierarchyResolver(TopDownAnalysisContext context) {
+        this.context = context;
+    }
+
+    public void process(@NotNull JetScope outerScope, NamespaceLike owner, @NotNull List<? extends JetDeclaration> declarations) {
+        collectNamespacesAndClassifiers(outerScope, owner, declarations); // namespaceScopes, classes
+
+        createTypeConstructors(); // create type constructors for classes and generic parameters, supertypes are not filled in
+        resolveTypesInClassHeaders(); // Generic bounds and types in supertype lists (no expressions or constructor resolution)
+
+        topologicalOrder = topologicallySortClassesAndObjects();
+
+        // Detect and disconnect all loops in the hierarchy
+        detectAndDisconnectLoops();
+
+        // At this point, there are no loops in the type hierarchy
+
+        checkSupertypesForConsistency();
+//        computeSuperclasses();
+
+        // Add supertypes to resolution scopes of classes
+        addSupertypesToScopes();
+
+        checkTypesInClassHeaders(); // Check bounds in the types used in generic bounds and supertype lists
+    }
+
+    private void collectNamespacesAndClassifiers(
+            @NotNull final JetScope outerScope,
+            @NotNull final NamespaceLike owner,
+            @NotNull Collection<? extends JetDeclaration> declarations) {
+        for (JetDeclaration declaration : declarations) {
+            declaration.accept(new JetVisitorVoid() {
+                @Override
+                public void visitNamespace(JetNamespace namespace) {
+                    String name = JetPsiUtil.safeName(namespace.getName());
+
+                    NamespaceDescriptorImpl namespaceDescriptor = owner.getNamespace(name);
+                    if (namespaceDescriptor == null) {
+                        namespaceDescriptor = new NamespaceDescriptorImpl(
+                                owner.getOriginal(),
+                                Collections.<AnnotationDescriptor>emptyList(), // TODO: annotations
+                                name
+                        );
+                        namespaceDescriptor.initialize(new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope"));
+                        owner.addNamespace(namespaceDescriptor);
+                        context.getTrace().record(BindingContext.NAMESPACE, namespace, namespaceDescriptor);
+                    }
+                    context.getNamespaceDescriptors().put(namespace, namespaceDescriptor);
+
+                    WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(context.getTrace()));
+                    context.getNamespaceScopes().put(namespace, namespaceScope);
+
+                    processImports(namespace, namespaceScope, outerScope);
+
+                    collectNamespacesAndClassifiers(namespaceScope, namespaceDescriptor, namespace.getDeclarations());
+                }
+
+                @Override
+                public void visitClass(JetClass klass) {
+                    MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(context.getTrace(), owner, outerScope, getClassKind(klass));
+
+                    if (klass.hasModifier(JetTokens.ENUM_KEYWORD)) {
+                        MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor(context.getTrace(), mutableClassDescriptor, outerScope, ClassKind.OBJECT);
+                        classObjectDescriptor.setName("class-object-for-" + klass.getName());
+                        classObjectDescriptor.setModality(Modality.FINAL);
+                        classObjectDescriptor.setVisibility(ClassDescriptorResolver.resolveVisibilityFromModifiers(klass.getModifierList()));
+                        classObjectDescriptor.createTypeConstructor();
+                        createPrimaryConstructorForObject(null, classObjectDescriptor);
+                        mutableClassDescriptor.setClassObjectDescriptor(classObjectDescriptor);
+                    }
+                    visitClassOrObject(
+                            klass,
+                            (Map) context.getClasses(),
+                            owner,
+                            outerScope,
+                            mutableClassDescriptor);
+                    owner.addClassifierDescriptor(mutableClassDescriptor);
+                }
+
+                @Override
+                public void visitObjectDeclaration(JetObjectDeclaration declaration) {
+                    createClassDescriptorForObject(declaration, owner);
+                }
+
+                @Override
+                public void visitEnumEntry(JetEnumEntry enumEntry) {
+                    MutableClassDescriptor classObjectDescriptor = ((MutableClassDescriptor) owner).getClassObjectDescriptor();
+                    assert classObjectDescriptor != null : enumEntry.getParent().getText();
+                    if (enumEntry.getPrimaryConstructorParameterList() == null) {
+                        MutableClassDescriptor classDescriptor = createClassDescriptorForObject(enumEntry, classObjectDescriptor);
+                        context.getObjects().remove(enumEntry);
+                        context.getClasses().put(enumEntry, classDescriptor);
+                    }
+                    else {
+                        MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(context.getTrace(), classObjectDescriptor, outerScope, ClassKind.CLASS); // TODO : Special kind for enum entry classes?
+                        visitClassOrObject(
+                                enumEntry,
+                                (Map) context.getClasses(),
+                                classObjectDescriptor,
+                                outerScope,
+                                mutableClassDescriptor);
+                        classObjectDescriptor.addClassifierDescriptor(mutableClassDescriptor);
+                    }
+                }
+
+                private MutableClassDescriptor createClassDescriptorForObject(@NotNull JetClassOrObject declaration, @NotNull NamespaceLike owner) {
+                    MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(context.getTrace(), owner, outerScope, ClassKind.OBJECT) {
+                        @Override
+                        public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
+                            return ClassObjectStatus.NOT_ALLOWED;
+                        }
+                    };
+                    visitClassOrObject(declaration, (Map) context.getObjects(), owner, outerScope, mutableClassDescriptor);
+                    createPrimaryConstructorForObject((JetDeclaration) declaration, mutableClassDescriptor);
+                    context.getTrace().record(BindingContext.CLASS, declaration, mutableClassDescriptor);
+                    return mutableClassDescriptor;
+                }
+
+                private void createPrimaryConstructorForObject(@Nullable JetDeclaration object, MutableClassDescriptor mutableClassDescriptor) {
+                    ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(mutableClassDescriptor, Collections.<AnnotationDescriptor>emptyList(), true);
+                    constructorDescriptor.initialize(Collections.<TypeParameterDescriptor>emptyList(), Collections.<ValueParameterDescriptor>emptyList(),
+                                                     Modality.FINAL, Visibility.INTERNAL);//TODO check set mutableClassDescriptor.getVisibility()
+                    // TODO : make the constructor private?
+                    mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor);
+                    if (object != null) {
+                        context.getTrace().record(CONSTRUCTOR, object, constructorDescriptor);
+                    }
+                }
+
+                private void visitClassOrObject(@NotNull JetClassOrObject declaration, Map<JetClassOrObject, MutableClassDescriptor> map, NamespaceLike owner, JetScope outerScope, MutableClassDescriptor mutableClassDescriptor) {
+                    mutableClassDescriptor.setName(JetPsiUtil.safeName(declaration.getName()));
+
+                    map.put(declaration, mutableClassDescriptor);
+//                    declaringScopes.put((JetDeclaration) declaration, outerScope);
+
+                    JetScope classScope = mutableClassDescriptor.getScopeForMemberResolution();
+                    collectNamespacesAndClassifiers(classScope, mutableClassDescriptor, declaration.getDeclarations());
+                }
+
+                @Override
+                public void visitTypedef(JetTypedef typedef) {
+//                    context.getTrace().getErrorHandler().genericError(typedef.getNode(), "Unsupported [TopDownAnalyzer]");
+                    context.getTrace().report(UNSUPPORTED.on(typedef, "TypeHierarchyResolver"));
+                }
+
+                @Override
+                public void visitClassObject(JetClassObject classObject) {
+                    JetObjectDeclaration objectDeclaration = classObject.getObjectDeclaration();
+                    if (objectDeclaration != null) {
+                        NamespaceLike.ClassObjectStatus status = owner.setClassObjectDescriptor(createClassDescriptorForObject(objectDeclaration, owner));
+                        switch (status) {
+                            case DUPLICATE:
+//                                context.getTrace().getErrorHandler().genericError(classObject.getNode(), "Only one class object is allowed per class");
+                                context.getTrace().report(MANY_CLASS_OBJECTS.on(classObject));
+                                break;
+                            case NOT_ALLOWED:
+//                                context.getTrace().getErrorHandler().genericError(classObject.getNode(), "A class object is not allowed here");
+                                context.getTrace().report(CLASS_OBJECT_NOT_ALLOWED.on(classObject));
+                                break;
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    @NotNull
+    private ClassKind getClassKind(@NotNull JetClass jetClass) {
+        if (jetClass.isTrait()) return ClassKind.TRAIT;
+        if (jetClass.hasModifier(JetTokens.ANNOTATION_KEYWORD)) return ClassKind.ANNOTATION_CLASS;
+        if (jetClass.hasModifier(JetTokens.ENUM_KEYWORD)) return ClassKind.ENUM_CLASS;
+        return ClassKind.CLASS;
+    }
+
+    private void processImports(@NotNull JetNamespace namespace, @NotNull WriteThroughScope namespaceScope, @NotNull JetScope outerScope) {
+        List<JetImportDirective> importDirectives = namespace.getImportDirectives();
+        for (JetImportDirective importDirective : importDirectives) {
+            if (importDirective.isAbsoluteInRootNamespace()) {
+//                context.getTrace().getErrorHandler().genericError(namespace.getNode(), "Unsupported by TDA"); // TODO
+                context.getTrace().report(UNSUPPORTED.on(namespace, "TypeHierarchyResolver")); // TODO
+                continue;
+            }
+            if (importDirective.isAllUnder()) {
+                JetExpression importedReference = importDirective.getImportedReference();
+                if (importedReference != null) {
+                    JetTypeInferrer.Services typeInferrerServices = context.getSemanticServices().getTypeInferrerServices(context.getTrace(), JetFlowInformationProvider.THROW_EXCEPTION);
+                    JetType type = typeInferrerServices.getTypeWithNamespaces(namespaceScope, importedReference);
+                    if (type != null) {
+                        namespaceScope.importScope(type.getMemberScope());
+                    }
+                }
+            }
+            else {
+                ClassifierDescriptor classifierDescriptor = null;
+                JetSimpleNameExpression referenceExpression = null;
+
+                JetExpression importedReference = importDirective.getImportedReference();
+                if (importedReference instanceof JetDotQualifiedExpression) {
+                    JetDotQualifiedExpression reference = (JetDotQualifiedExpression) importedReference;
+                    JetType type = context.getSemanticServices().getTypeInferrerServices(context.getTrace(), JetFlowInformationProvider.THROW_EXCEPTION).getTypeWithNamespaces(namespaceScope, reference.getReceiverExpression());
+                    JetExpression selectorExpression = reference.getSelectorExpression();
+                    if (selectorExpression != null) {
+                        referenceExpression = (JetSimpleNameExpression) selectorExpression;
+                        String referencedName = referenceExpression.getReferencedName();
+                        if (type != null && referencedName != null) {
+                            classifierDescriptor = type.getMemberScope().getClassifier(referencedName);
+                        }
+                    }
+                }
+                else {
+                    assert importedReference instanceof JetSimpleNameExpression;
+                    referenceExpression = (JetSimpleNameExpression) importedReference;
+
+                    String referencedName = referenceExpression.getReferencedName();
+                    if (referencedName != null) {
+                        classifierDescriptor = outerScope.getClassifier(referencedName);
+                    }
+                }
+
+                if (classifierDescriptor != null) {
+                    context.getTrace().record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor);
+
+                    String aliasName = importDirective.getAliasName();
+                    String importedClassifierName = aliasName != null ? aliasName : classifierDescriptor.getName();
+                    namespaceScope.importClassifierAlias(importedClassifierName, classifierDescriptor);
+                }
+            }
+        }
+    }
+
+    private void createTypeConstructors() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            JetClass jetClass = entry.getKey();
+            MutableClassDescriptor descriptor = entry.getValue();
+            context.getClassDescriptorResolver().resolveMutableClassDescriptor(jetClass, descriptor);
+            descriptor.createTypeConstructor();
+        }
+        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+            JetObjectDeclaration objectDeclaration = entry.getKey();
+            MutableClassDescriptor descriptor = entry.getValue();
+            descriptor.setModality(Modality.FINAL);
+            descriptor.setVisibility(ClassDescriptorResolver.resolveVisibilityFromModifiers(objectDeclaration.getModifierList()));
+            descriptor.createTypeConstructor();
+        }
+    }
+
+    private void resolveTypesInClassHeaders() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            JetClass jetClass = entry.getKey();
+            MutableClassDescriptor descriptor = entry.getValue();
+            context.getClassDescriptorResolver().resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters());
+            context.getClassDescriptorResolver().resolveSupertypes(jetClass, descriptor);
+        }
+        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+            JetClassOrObject jetClass = entry.getKey();
+            MutableClassDescriptor descriptor = entry.getValue();
+            context.getClassDescriptorResolver().resolveSupertypes(jetClass, descriptor);
+        }
+    }
+
+    private LinkedList<MutableClassDescriptor> topologicallySortClassesAndObjects() {
+        // A topsort is needed only for better diagnostics:
+        //    edges that get removed to disconnect loops are more reasonable in this case
+        LinkedList<MutableClassDescriptor> topologicalOrder = Lists.newLinkedList();
+        Set<ClassDescriptor> visited = Sets.newHashSet();
+        for (MutableClassDescriptor mutableClassDescriptor : context.getClasses().values()) {
+            topologicallySort(mutableClassDescriptor, visited, topologicalOrder);
+        }
+        for (MutableClassDescriptor mutableClassDescriptor : context.getObjects().values()) {
+            topologicallySort(mutableClassDescriptor, visited, topologicalOrder);
+        }
+        return topologicalOrder;
+    }
+
+    private void detectAndDisconnectLoops() {
+        // Loop detection and disconnection
+        Set<ClassDescriptor> visited = Sets.newHashSet();
+        Set<ClassDescriptor> beingProcessed = Sets.newHashSet();
+        List<ClassDescriptor> currentPath = Lists.newArrayList();
+        for (MutableClassDescriptor mutableClassDescriptor : topologicalOrder) {
+            traverseTypeHierarchy(mutableClassDescriptor, visited, beingProcessed, currentPath);
+        }
+    }
+
+    private static void topologicallySort(MutableClassDescriptor mutableClassDescriptor, Set<ClassDescriptor> visited, LinkedList<MutableClassDescriptor> topologicalOrder) {
+        if (!visited.add(mutableClassDescriptor)) {
+            return;
+        }
+        for (JetType supertype : mutableClassDescriptor.getSupertypes()) {
+            DeclarationDescriptor declarationDescriptor = supertype.getConstructor().getDeclarationDescriptor();
+            if (declarationDescriptor instanceof MutableClassDescriptor) {
+                MutableClassDescriptor classDescriptor = (MutableClassDescriptor) declarationDescriptor;
+                topologicallySort(classDescriptor, visited, topologicalOrder);
+            }
+        }
+        topologicalOrder.addFirst(mutableClassDescriptor);
+    }
+
+    private void traverseTypeHierarchy(MutableClassDescriptor currentClass, Set<ClassDescriptor> visited, Set<ClassDescriptor> beingProcessed, List<ClassDescriptor> currentPath) {
+        if (!visited.add(currentClass)) {
+            if (beingProcessed.contains(currentClass)) {
+                markCycleErrors(currentPath, currentClass);
+                assert !currentPath.isEmpty() : "Cycle cannot be found on an empty currentPath";
+                ClassDescriptor subclassOfCurrent = currentPath.get(currentPath.size() - 1);
+                assert subclassOfCurrent instanceof MutableClassDescriptor;
+                // Disconnect the loop
+                for (Iterator<JetType> iterator = ((MutableClassDescriptor) subclassOfCurrent).getSupertypes().iterator(); iterator.hasNext(); ) {
+                    JetType type = iterator.next();
+                    if (type.getConstructor() == currentClass.getTypeConstructor()) {
+                        iterator.remove();
+                        break;
+                    }
+                }
+            }
+            return;
+        }
+
+        beingProcessed.add(currentClass);
+        currentPath.add(currentClass);
+        for (JetType supertype : Lists.newArrayList(currentClass.getSupertypes())) {
+            DeclarationDescriptor declarationDescriptor = supertype.getConstructor().getDeclarationDescriptor();
+            if (declarationDescriptor instanceof MutableClassDescriptor) {
+                MutableClassDescriptor mutableClassDescriptor = (MutableClassDescriptor) declarationDescriptor;
+                traverseTypeHierarchy(mutableClassDescriptor, visited, beingProcessed, currentPath);
+            }
+        }
+        beingProcessed.remove(currentClass);
+        currentPath.remove(currentPath.size() - 1);
+    }
+
+    private void markCycleErrors(List<ClassDescriptor> currentPath, @NotNull ClassDescriptor current) {
+        int size = currentPath.size();
+        boolean found = false;
+        for (int i = 0; i < size; i++) {
+            ClassDescriptor classDescriptor = currentPath.get(i);
+            if (classDescriptor == current) found = true;
+            if (!found) continue;
+
+            ClassDescriptor superclass = (i < size - 1) ? currentPath.get(i + 1) : current;
+            PsiElement psiElement = context.getTrace().get(DESCRIPTOR_TO_DECLARATION, classDescriptor);
+
+            ASTNode node = null;
+            if (psiElement instanceof JetClassOrObject) {
+                JetClassOrObject classOrObject = (JetClassOrObject) psiElement;
+                for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
+                    JetTypeReference typeReference = delegationSpecifier.getTypeReference();
+                    if (typeReference == null) continue;
+                    JetType supertype = context.getTrace().get(TYPE, typeReference);
+                    if (supertype != null && supertype.getConstructor() == superclass.getTypeConstructor()) {
+                        node = typeReference.getNode();
+                    }
+                }
+            }
+            if (node == null && psiElement instanceof PsiNameIdentifierOwner) {
+                PsiNameIdentifierOwner namedElement = (PsiNameIdentifierOwner) psiElement;
+                PsiElement nameIdentifier = namedElement.getNameIdentifier();
+                if (nameIdentifier != null) {
+                    node = nameIdentifier.getNode();
+                }
+            }
+            if (node != null) {
+//                context.getTrace().getErrorHandler().genericError(node, "There's a cycle in the inheritance hierarchy for this type");
+                context.getTrace().report(CYCLIC_INHERITANCE_HIERARCHY.on(node));
+            }
+        }
+    }
+
+    private void checkSupertypesForConsistency() {
+        for (MutableClassDescriptor mutableClassDescriptor : topologicalOrder) {
+            Multimap<TypeConstructor, TypeProjection> multimap = TypeUtils.buildDeepSubstitutionMultimap(mutableClassDescriptor.getDefaultType());
+            for (Map.Entry<TypeConstructor, Collection<TypeProjection>> entry : multimap.asMap().entrySet()) {
+                Collection<TypeProjection> projections = entry.getValue();
+                if (projections.size() > 1) {
+                    TypeConstructor typeConstructor = entry.getKey();
+                    DeclarationDescriptor declarationDescriptor = typeConstructor.getDeclarationDescriptor();
+                    assert declarationDescriptor instanceof TypeParameterDescriptor : declarationDescriptor;
+                    TypeParameterDescriptor typeParameterDescriptor = (TypeParameterDescriptor) declarationDescriptor;
+
+                    // Immediate arguments of supertypes cannot be projected
+                    Set<JetType> conflictingTypes = Sets.newLinkedHashSet();
+                    for (TypeProjection projection : projections) {
+                        conflictingTypes.add(projection.getType());
+                    }
+                    switch (typeParameterDescriptor.getVariance()) {
+                        case INVARIANT:
+                            // Leave conflicting types as is
+                            break;
+                        case IN_VARIANCE:
+                            // Filter out those who have supertypes in this set (common supertype)
+                            Filter.REMOVE_IF_SUPERTYPE_IN_THE_SET.proceed(conflictingTypes);
+                            break;
+                        case OUT_VARIANCE:
+                            // Filter out those who have subtypes in this set (common subtype)
+                            Filter.REMOVE_IF_SUBTYPE_IN_THE_SET.proceed(conflictingTypes);
+                            break;
+                    }
+                    
+                    if (conflictingTypes.size() > 1) {
+                        DeclarationDescriptor containingDeclaration = typeParameterDescriptor.getContainingDeclaration();
+                        assert containingDeclaration instanceof ClassDescriptor : containingDeclaration;
+                        PsiElement psiElement = context.getTrace().get(DESCRIPTOR_TO_DECLARATION, mutableClassDescriptor);
+                        assert psiElement instanceof JetClassOrObject : psiElement;
+                        JetClassOrObject declaration = (JetClassOrObject) psiElement;
+                        JetDelegationSpecifierList delegationSpecifierList = declaration.getDelegationSpecifierList();
+                        assert delegationSpecifierList != null;
+//                        context.getTrace().getErrorHandler().genericError(delegationSpecifierList.getNode(), "Type parameter " + typeParameterDescriptor.getName() + " of " + containingDeclaration.getName() + " has inconsistent values: " + conflictingTypes);
+                        context.getTrace().report(INCONSISTENT_TYPE_PARAMETER_VALUES.on(delegationSpecifierList, typeParameterDescriptor, (ClassDescriptor) containingDeclaration, conflictingTypes));
+                    }
+                }
+            }
+        }
+    }
+
+    private enum Filter {
+        REMOVE_IF_SUBTYPE_IN_THE_SET {
+            @Override
+            public boolean removeNeeded(JetType subject, JetType other) {
+                return JetTypeChecker.INSTANCE.isSubtypeOf(other, subject);
+            }
+        },
+        REMOVE_IF_SUPERTYPE_IN_THE_SET {
+            @Override
+            public boolean removeNeeded(JetType subject, JetType other) {
+                return JetTypeChecker.INSTANCE.isSubtypeOf(subject, other);
+            }
+        };
+        
+        private void proceed(Set<JetType> conflictingTypes) {
+            for (Iterator<JetType> iterator = conflictingTypes.iterator(); iterator.hasNext(); ) {
+                JetType type = iterator.next();
+                for (JetType otherType : conflictingTypes) {
+                    boolean subtypeOf = removeNeeded(type, otherType);
+                    if (type != otherType && subtypeOf) {
+                        iterator.remove();
+                        break;
+                    }
+                }
+            }
+        }
+
+        public abstract boolean removeNeeded(JetType subject, JetType other);
+    }
+    
+    private void addSupertypesToScopes() {
+        for (MutableClassDescriptor mutableClassDescriptor : context.getClasses().values()) {
+            mutableClassDescriptor.addSupertypesToScopeForMemberLookup();
+        }
+        for (MutableClassDescriptor mutableClassDescriptor : context.getObjects().values()) {
+            mutableClassDescriptor.addSupertypesToScopeForMemberLookup();
+        }
+    }
+
+    private void checkTypesInClassHeaders() {
+        for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+            JetClass jetClass = entry.getKey();
+
+            for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) {
+                JetTypeReference typeReference = delegationSpecifier.getTypeReference();
+                if (typeReference != null) {
+                    JetType type = context.getTrace().getBindingContext().get(TYPE, typeReference);
+                    if (type != null) {
+                        context.getClassDescriptorResolver().checkBounds(typeReference, type);
+                    }
+                }
+            }
+
+            for (JetTypeParameter jetTypeParameter : jetClass.getTypeParameters()) {
+                JetTypeReference extendsBound = jetTypeParameter.getExtendsBound();
+                if (extendsBound != null) {
+                    JetType type = context.getTrace().getBindingContext().get(TYPE, extendsBound);
+                    if (type != null) {
+                        context.getClassDescriptorResolver().checkBounds(extendsBound, type);
+                    }
+                }
+            }
+
+            for (JetTypeConstraint constraint : jetClass.getTypeConstaints()) {
+                JetTypeReference extendsBound = constraint.getBoundTypeReference();
+                if (extendsBound != null) {
+                    JetType type = context.getTrace().getBindingContext().get(TYPE, extendsBound);
+                    if (type != null) {
+                        context.getClassDescriptorResolver().checkBounds(extendsBound, type);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java
similarity index 67%
rename from idea/src/org/jetbrains/jet/lang/resolve/TypeResolver.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java
index 74afa4e7c20..0b023d82c01 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/TypeResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java
@@ -3,15 +3,23 @@ package org.jetbrains.jet.lang.resolve;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.JetSemanticServices;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.jet.lang.diagnostics.Errors.UNRESOLVED_REFERENCE;
+import static org.jetbrains.jet.lang.diagnostics.Errors.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
+
 /**
  * @author abreslav
  */
@@ -56,64 +64,70 @@ public class TypeResolver {
                     }
 
                     ClassifierDescriptor classifierDescriptor = resolveClass(scope, type);
-                    if (classifierDescriptor != null) {
-                        if (classifierDescriptor instanceof TypeParameterDescriptor) {
-                            TypeParameterDescriptor typeParameterDescriptor = (TypeParameterDescriptor) classifierDescriptor;
+                    if (classifierDescriptor == null) {
+                        resolveTypeProjections(scope, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments());
+                        return;
+                    }
+                    if (classifierDescriptor instanceof TypeParameterDescriptor) {
+                        TypeParameterDescriptor typeParameterDescriptor = (TypeParameterDescriptor) classifierDescriptor;
 
-                            trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, typeParameterDescriptor);
+                        trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, typeParameterDescriptor);
 
+                        result[0] = new JetTypeImpl(
+                                annotations,
+                                typeParameterDescriptor.getTypeConstructor(),
+                                nullable || TypeUtils.hasNullableBound(typeParameterDescriptor),
+                                Collections.<TypeProjection>emptyList(),
+                                getScopeForTypeParameter(typeParameterDescriptor)
+                        );
+
+                        resolveTypeProjections(scope, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments());
+                    }
+                    else if (classifierDescriptor instanceof ClassDescriptor) {
+                        ClassDescriptor classDescriptor = (ClassDescriptor) classifierDescriptor;
+
+                        trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor);
+                        TypeConstructor typeConstructor = classifierDescriptor.getTypeConstructor();
+                        List<TypeProjection> arguments = resolveTypeProjections(scope, typeConstructor, type.getTypeArguments());
+                        List<TypeParameterDescriptor> parameters = typeConstructor.getParameters();
+                        int expectedArgumentCount = parameters.size();
+                        int actualArgumentCount = arguments.size();
+                        if (ErrorUtils.isError(typeConstructor)) {
                             result[0] = new JetTypeImpl(
                                     annotations,
-                                    typeParameterDescriptor.getTypeConstructor(),
-                                    nullable || TypeUtils.hasNullableBound(typeParameterDescriptor),
-                                    Collections.<TypeProjection>emptyList(),
-                                    getScopeForTypeParameter(typeParameterDescriptor)
+                                    typeConstructor,
+                                    nullable,
+                                    arguments, // TODO : review
+                                    classDescriptor.getMemberScope(Collections.<TypeProjection>emptyList())
                             );
                         }
-                        else if (classifierDescriptor instanceof ClassDescriptor) {
-                            ClassDescriptor classDescriptor = (ClassDescriptor) classifierDescriptor;
-
-                            trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor);
-                            TypeConstructor typeConstructor = classifierDescriptor.getTypeConstructor();
-                            List<TypeProjection> arguments = resolveTypeProjections(scope, typeConstructor, type.getTypeArguments());
-                            List<TypeParameterDescriptor> parameters = typeConstructor.getParameters();
-                            int expectedArgumentCount = parameters.size();
-                            int actualArgumentCount = arguments.size();
-                            if (ErrorUtils.isError(typeConstructor)) {
+                        else {
+                            if (actualArgumentCount != expectedArgumentCount) {
+//                                String errorMessage = (expectedArgumentCount == 0 ? "No" : expectedArgumentCount) + " type arguments expected";
+                                if (actualArgumentCount == 0) {
+//                                    trace.getErrorHandler().genericError(type.getNode(), errorMessage);
+                                    trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type, expectedArgumentCount));
+                                } else {
+//                                    trace.getErrorHandler().genericError(type.getTypeArgumentList().getNode(), errorMessage);
+                                    trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type.getTypeArgumentList(), expectedArgumentCount));
+                                }
+                            } else {
                                 result[0] = new JetTypeImpl(
                                         annotations,
                                         typeConstructor,
                                         nullable,
-                                        arguments, // TODO : review
-                                        classDescriptor.getMemberScope(Collections.<TypeProjection>emptyList())
+                                        arguments,
+                                        classDescriptor.getMemberScope(arguments)
                                 );
-                            }
-                            else {
-                                if (actualArgumentCount != expectedArgumentCount) {
-                                    String errorMessage = (expectedArgumentCount == 0 ? "No" : expectedArgumentCount) + " type arguments expected";
-                                    if (actualArgumentCount == 0) {
-                                        trace.getErrorHandler().genericError(type.getNode(), errorMessage);
-                                    } else {
-                                        trace.getErrorHandler().genericError(type.getTypeArgumentList().getNode(), errorMessage);
-                                    }
-                                } else {
-                                    result[0] = new JetTypeImpl(
-                                            annotations,
-                                            typeConstructor,
-                                            nullable,
-                                            arguments,
-                                            classDescriptor.getMemberScope(arguments)
-                                    );
-                                    if (checkBounds) {
-                                        TypeSubstitutor substitutor = TypeSubstitutor.create(result[0]);
-                                        for (int i = 0, parametersSize = parameters.size(); i < parametersSize; i++) {
-                                            TypeParameterDescriptor parameter = parameters.get(i);
-                                            JetType argument = arguments.get(i).getType();
-                                            JetTypeReference typeReference = type.getTypeArguments().get(i).getTypeReference();
+                                if (checkBounds) {
+                                    TypeSubstitutor substitutor = TypeSubstitutor.create(result[0]);
+                                    for (int i = 0, parametersSize = parameters.size(); i < parametersSize; i++) {
+                                        TypeParameterDescriptor parameter = parameters.get(i);
+                                        JetType argument = arguments.get(i).getType();
+                                        JetTypeReference typeReference = type.getTypeArguments().get(i).getTypeReference();
 
-                                            if (typeReference != null) {
-                                                semanticServices.getClassDescriptorResolver(trace).checkBounds(typeReference, argument, parameter, substitutor);
-                                            }
+                                        if (typeReference != null) {
+                                            semanticServices.getClassDescriptorResolver(trace).checkBounds(typeReference, argument, parameter, substitutor);
                                         }
                                     }
                                 }
@@ -223,7 +237,7 @@ public class TypeResolver {
         ClassifierDescriptor classifierDescriptor = resolveClassWithoutErrorReporting(scope, userType);
 
         if (classifierDescriptor == null) {
-            trace.getErrorHandler().unresolvedReference(userType.getReferenceExpression());
+            trace.report(UNRESOLVED_REFERENCE.on(userType.getReferenceExpression()));
         }
 
         return classifierDescriptor;
@@ -266,7 +280,7 @@ public class TypeResolver {
 
         NamespaceDescriptor namespaceDescriptor = resolveNamespace(scope, userType);
         if (namespaceDescriptor == null) {
-            trace.getErrorHandler().unresolvedReference(userType.getReferenceExpression());
+            trace.report(UNRESOLVED_REFERENCE.on(userType.getReferenceExpression()));
             return null;
         }
         return namespaceDescriptor.getMemberScope();
@@ -279,15 +293,17 @@ public class TypeResolver {
         }
 
         JetUserType qualifier = userType.getQualifier();
+        NamespaceDescriptor namespace;
         if (qualifier != null) {
             NamespaceDescriptor domain = resolveNamespace(scope, qualifier);
             if (domain == null) {
                 return null;
             }
-            return domain.getMemberScope().getNamespace(userType.getReferencedName());
+            namespace = domain.getMemberScope().getNamespace(userType.getReferencedName());
+        }
+        else {
+            namespace = scope.getNamespace(userType.getReferencedName());
         }
-
-        NamespaceDescriptor namespace = scope.getNamespace(userType.getReferencedName());
         if (namespace != null) {
             trace.record(BindingContext.REFERENCE_TARGET, userType.getReferenceExpression(), namespace);
         }
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
new file mode 100644
index 00000000000..d37dfa72ee0
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
@@ -0,0 +1,823 @@
+package org.jetbrains.jet.lang.resolve.calls;
+
+import com.google.common.base.Function;
+import com.google.common.base.Functions;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.types.inference.ConstraintSystem;
+
+import java.util.*;
+
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+import static org.jetbrains.jet.lang.resolve.BindingContext.AMBIGUOUS_REFERENCE_TARGET;
+import static org.jetbrains.jet.lang.resolve.BindingContext.RECEIVER;
+import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
+import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER;
+import static org.jetbrains.jet.lang.types.JetTypeInferrer.NO_EXPECTED_TYPE;
+
+/**
+ * @author abreslav
+ */
+public class CallResolver {
+
+    private final JetTypeInferrer typeInferrer;
+    private final JetSemanticServices semanticServices;
+    private final OverloadingConflictResolver overloadingConflictResolver;
+
+    public CallResolver(JetSemanticServices semanticServices, JetTypeInferrer typeInferrer) {
+        this.typeInferrer = typeInferrer;
+        this.semanticServices = semanticServices;
+        this.overloadingConflictResolver = new OverloadingConflictResolver(semanticServices);
+    }
+
+    @Nullable
+    public VariableDescriptor resolveSimpleProperty(
+            @NotNull BindingTrace trace,
+            @NotNull JetScope scope,
+            @NotNull ReceiverDescriptor receiver,
+            @NotNull final JetSimpleNameExpression nameExpression,
+            @NotNull JetType expectedType) {
+        String referencedName = nameExpression.getReferencedName();
+        if (referencedName == null) {
+            return null;
+        }
+        Call call = CallMaker.makePropertyCall(nameExpression);
+        List<ResolutionTask<VariableDescriptor>> prioritizedTasks = PROPERTY_TASK_PRIORITIZER.computePrioritizedTasks(scope, receiver, call, referencedName);
+        return resolveCallToDescriptor(trace, scope, call, nameExpression.getNode(), expectedType, prioritizedTasks, nameExpression);
+    }
+
+
+    @Nullable
+    public JetType resolveCall(
+            @NotNull BindingTrace trace,
+            @NotNull JetScope scope,
+            @NotNull ReceiverDescriptor receiver,
+            @NotNull JetCallElement call,
+            @NotNull JetType expectedType
+    ) {
+        FunctionDescriptor functionDescriptor = resolveSimpleCallToFunctionDescriptor(trace, scope, receiver, call, expectedType);
+        return functionDescriptor == null ? null : functionDescriptor.getReturnType();
+    }
+    
+    @Nullable
+    public FunctionDescriptor resolveCallWithGivenName(
+            @NotNull BindingTrace trace,
+            @NotNull JetScope scope,
+            @NotNull final Call call,
+            @NotNull final JetReferenceExpression functionReference,
+            @NotNull String name,
+            @NotNull ReceiverDescriptor receiver,
+            @NotNull JetType expectedType) {
+        // TODO : autocasts
+        // TODO : nullability
+        List<ResolutionTask<FunctionDescriptor>> tasks = FUNCTION_TASK_PRIORITIZER.computePrioritizedTasks(scope, receiver, call, name);
+        return resolveCallToDescriptor(trace, scope, call, functionReference.getNode(), expectedType, tasks, functionReference);
+    }
+
+    @Nullable
+    public FunctionDescriptor resolveSimpleCallToFunctionDescriptor(
+            @NotNull BindingTrace trace,
+            @NotNull JetScope scope,
+            @NotNull ReceiverDescriptor receiver,
+            @NotNull final JetCallElement call,
+            @NotNull JetType expectedType
+    ) {
+        List<ResolutionTask<FunctionDescriptor>> prioritizedTasks;
+        
+        JetExpression calleeExpression = call.getCalleeExpression();
+        final JetReferenceExpression functionReference;
+        if (calleeExpression instanceof JetSimpleNameExpression) {
+            JetSimpleNameExpression expression = (JetSimpleNameExpression) calleeExpression;
+            functionReference = expression;
+
+            String name = expression.getReferencedName();
+            if (name == null) return checkArgumentTypesAndFail(trace, scope, call);
+
+            prioritizedTasks = FUNCTION_TASK_PRIORITIZER.computePrioritizedTasks(scope, receiver, call, name);
+            ResolutionTask.DescriptorCheckStrategy abstractConstructorCheck = new ResolutionTask.DescriptorCheckStrategy() {
+                @Override
+                public <D extends CallableDescriptor> boolean performAdvancedChecks(D descriptor, BindingTrace trace, TracingStrategy tracing) {
+                    if (descriptor instanceof ConstructorDescriptor) {
+                        Modality modality = ((ConstructorDescriptor) descriptor).getContainingDeclaration().getModality();
+                        if (modality == Modality.ABSTRACT) {
+//                            tracing.reportOverallResolutionError(trace, "Can not create an instance of an abstract class");
+                            tracing.instantiationOfAbstractClass(trace);
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+            };
+            for (ResolutionTask task : prioritizedTasks) {
+                task.setCheckingStrategy(abstractConstructorCheck);
+            }
+        }
+        else {
+            JetValueArgumentList valueArgumentList = call.getValueArgumentList();
+            ASTNode reportAbsenceOn = valueArgumentList == null ? call.getNode() : valueArgumentList.getNode();
+            if (calleeExpression instanceof JetConstructorCalleeExpression) {
+                assert receiver == NO_RECEIVER;
+
+                prioritizedTasks = Lists.newArrayList();
+
+                JetConstructorCalleeExpression expression = (JetConstructorCalleeExpression) calleeExpression;
+                functionReference = expression.getConstructorReferenceExpression();
+                if (functionReference == null) {
+                    return checkArgumentTypesAndFail(trace, scope, call); // No type there
+                }
+                JetTypeReference typeReference = expression.getTypeReference();
+                assert typeReference != null;
+                JetType constructedType = new TypeResolver(semanticServices, trace, true).resolveType(scope, typeReference);
+                DeclarationDescriptor declarationDescriptor = constructedType.getConstructor().getDeclarationDescriptor();
+                if (declarationDescriptor instanceof ClassDescriptor) {
+                    ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor;
+                    Set<FunctionDescriptor> constructors = classDescriptor.getConstructors();
+                    if (constructors.isEmpty()) {
+//                        trace.getErrorHandler().genericError(reportAbsenceOn, "This class does not have a constructor");
+                        trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn));
+                        return checkArgumentTypesAndFail(trace, scope, call);
+                    }
+                    prioritizedTasks.add(new ResolutionTask<FunctionDescriptor>(constructors, NO_RECEIVER, call));
+                }
+                else {
+//                    trace.getErrorHandler().genericError(calleeExpression.getNode(), "Not a class");
+                    trace.report(NOT_A_CLASS.on(calleeExpression));
+                    return checkArgumentTypesAndFail(trace, scope, call);
+                }
+            }
+            else if (calleeExpression instanceof JetThisReferenceExpression) {
+                functionReference = (JetThisReferenceExpression) calleeExpression;
+                DeclarationDescriptor containingDeclaration = scope.getContainingDeclaration();
+                assert containingDeclaration instanceof ClassDescriptor;
+                ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
+
+
+                Set<FunctionDescriptor> constructors = classDescriptor.getConstructors();
+                if (constructors.isEmpty()) {
+//                    trace.getErrorHandler().genericError(reportAbsenceOn, "This class does not have a constructor");
+                    trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn));
+                    return checkArgumentTypesAndFail(trace, scope, call);
+                }
+                prioritizedTasks = Collections.singletonList(new ResolutionTask<FunctionDescriptor>(constructors, NO_RECEIVER, call));
+            }
+            else {
+                throw new UnsupportedOperationException("Type argument inference not implemented for " + call.getText());
+            }
+        }
+
+        return resolveCallToDescriptor(trace, scope, call, call.getNode(), expectedType, prioritizedTasks, functionReference);
+    }
+
+    private FunctionDescriptor checkArgumentTypesAndFail(BindingTrace trace, JetScope scope, JetCallElement call) {
+        checkTypesWithNoCallee(trace, scope, call.getTypeArguments(), call.getValueArguments(), call.getFunctionLiteralArguments());
+        return null;
+    }
+
+
+    private <D extends CallableDescriptor> D resolveCallToDescriptor(
+            @NotNull BindingTrace trace,
+            @NotNull JetScope scope,
+            @NotNull final Call call,
+            @NotNull final ASTNode callNode,
+            @NotNull JetType expectedType,
+            @NotNull final List<ResolutionTask<D>> prioritizedTasks, // high to low priority
+            @NotNull final JetReferenceExpression reference) {
+        TemporaryBindingTrace traceForFirstNonemptyCandidateSet = null;
+        OverloadResolutionResult<D> resultForFirstNonemptyCandidateSet = null;
+        TracingStrategy tracing = new TracingStrategy() {
+            @Override
+            public void bindReference(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor receiver, @NotNull CallableDescriptor descriptor) {
+                trace.record(REFERENCE_TARGET, reference, descriptor);
+                trace.record(RECEIVER, reference, receiver);
+            }
+
+            @Override
+            public <D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<D> candidates) {
+                trace.record(AMBIGUOUS_REFERENCE_TARGET, reference, candidates);
+            }
+
+            @Override
+            public void unresolvedReference(@NotNull BindingTrace trace) {
+                trace.report(UNRESOLVED_REFERENCE.on(reference));
+            }
+
+            @Override
+            public void noValueForParameter(@NotNull BindingTrace trace, @NotNull ValueParameterDescriptor valueParameter) {
+//                ASTNode node;
+//
+//                JetValueArgumentList valueArgumentList = call.getValueArgumentList();
+//                if (valueArgumentList != null) {
+//                    node = valueArgumentList.getNode();
+//                }
+//                else if (!call.getFunctionLiteralArguments().isEmpty()) {
+//                    node = call.getFunctionLiteralArguments().get(0).getNode();
+//                }
+//                else {
+//                    node = callNode;
+//                }
+//                trace.report(NO_VALUE_FOR_PARAMETER.on(node, valueParameter));
+                trace.report(NO_VALUE_FOR_PARAMETER.on(reference, valueParameter));
+            }
+
+            @Override
+            public void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver) {
+                trace.report(MISSING_RECEIVER.on(reference, expectedReceiver.getType()));
+            }
+
+            @Override
+            public void noReceiverAllowed(@NotNull BindingTrace trace) {
+                trace.report(NO_RECEIVER_ADMITTED.on(reference));
+            }
+
+            @Override
+            public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) {
+                JetTypeArgumentList typeArgumentList = call.getTypeArgumentList();
+                if (typeArgumentList != null) {
+//                    trace.getErrorHandler().genericError(typeArgumentList.getNode(), message);
+                    trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(typeArgumentList, expectedTypeArgumentCount));
+                }
+                else {
+//                    reportOverallResolutionError(trace, message);
+                    trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(reference, expectedTypeArgumentCount));
+                }
+            }
+
+            @Override
+            public void ambiguity(@NotNull BindingTrace trace, @NotNull Set<? extends CallableDescriptor> descriptors) {
+                trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(callNode, descriptors));
+            }
+
+            @Override
+            public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set<? extends CallableDescriptor> descriptors) {
+                trace.report(NONE_APPLICABLE.on(callNode, descriptors));
+            }
+
+            @Override
+            public void instantiationOfAbstractClass(@NotNull BindingTrace trace) {
+                trace.report(CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS.on(callNode));
+            }
+
+            @Override
+            public void typeInferenceFailed(@NotNull BindingTrace trace) {
+                trace.report(TYPE_INFERENCE_FAILED.on(callNode));
+            }
+
+        };
+        for (ResolutionTask<D> task : prioritizedTasks) {
+            TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace);
+            OverloadResolutionResult<D> result = performResolution(temporaryTrace, scope, expectedType, task, tracing);
+            if (result.isSuccess()) {
+                temporaryTrace.commit();
+                return result.getDescriptor();
+            }
+            if (traceForFirstNonemptyCandidateSet == null && !task.getCandidates().isEmpty()) {
+                traceForFirstNonemptyCandidateSet = temporaryTrace;
+                resultForFirstNonemptyCandidateSet = result;
+            }
+        }
+        if (traceForFirstNonemptyCandidateSet != null) {
+            traceForFirstNonemptyCandidateSet.commit();
+            if (resultForFirstNonemptyCandidateSet.singleDescriptor()) {
+                return resultForFirstNonemptyCandidateSet.getDescriptor();
+            }
+        }
+        else {
+            trace.report(UNRESOLVED_REFERENCE.on(reference));
+            checkTypesWithNoCallee(trace, scope, call.getTypeArguments(), call.getValueArguments(), call.getFunctionLiteralArguments());
+        }
+        return null;
+    }
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    @NotNull
+    private <D extends CallableDescriptor> OverloadResolutionResult<D> performResolution(@NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull JetType expectedType, @NotNull ResolutionTask<D> task, @NotNull TracingStrategy tracing) {
+        Map<D, D> successfulCandidates = Maps.newLinkedHashMap();
+        Set<D> failedCandidates = Sets.newLinkedHashSet();
+        Set<D> dirtyCandidates = Sets.newLinkedHashSet();
+        Map<D, ConstraintSystem.Solution> solutions = Maps.newHashMap();
+        Map<D, TemporaryBindingTrace> traces = Maps.newHashMap();
+
+        for (D candidate : task.getCandidates()) {
+            TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace);
+            traces.put(candidate, temporaryTrace);
+            JetTypeInferrer.Services temporaryServices = typeInferrer.getServices(temporaryTrace);
+
+            tracing.bindReference(temporaryTrace, task.getReceiver(), candidate);
+            
+            if (ErrorUtils.isError(candidate)) {
+                successfulCandidates.put(candidate, candidate);
+                checkTypesWithNoCallee(temporaryTrace, scope, task.getTypeArguments(), task.getValueArguments(), task.getFunctionLiteralArguments());
+                continue;
+            }
+
+            Flag dirty = new Flag(false);
+
+            Map<ValueArgument, ValueParameterDescriptor> argumentsToParameters = Maps.newHashMap();
+            boolean error = ValueArgumentsToParametersMapper.mapValueArgumentsToParameters(task, tracing, candidate, temporaryTrace, argumentsToParameters);
+
+            if (error) {
+                failedCandidates.add(candidate);
+                checkTypesWithNoCallee(temporaryTrace, scope, task.getTypeArguments(), task.getValueArguments(), task.getFunctionLiteralArguments());
+                continue;
+            }
+
+            if (task.getTypeArguments().isEmpty()) {
+                if (candidate.getTypeParameters().isEmpty()) {
+                    if (checkValueArgumentTypes(scope, temporaryServices, argumentsToParameters, dirty, Functions.<ValueParameterDescriptor>identity())
+                            && checkReceiver(task, tracing, candidate, temporaryTrace)) {
+                        successfulCandidates.put(candidate, candidate);
+                    }
+                    else {
+                        failedCandidates.add(candidate);
+                    }
+                }
+                else {
+                    // Type argument inference
+
+                    ConstraintSystem constraintSystem = new ConstraintSystem();
+                    for (TypeParameterDescriptor typeParameterDescriptor : candidate.getTypeParameters()) {
+                        constraintSystem.registerTypeVariable(typeParameterDescriptor, Variance.INVARIANT); // TODO
+                    }
+
+                    for (Map.Entry<ValueArgument, ValueParameterDescriptor> entry : argumentsToParameters.entrySet()) {
+                        ValueArgument valueArgument = entry.getKey();
+                        ValueParameterDescriptor valueParameterDescriptor = entry.getValue();
+
+                        JetExpression expression = valueArgument.getArgumentExpression();
+                        // TODO : more attempts, with different expected types
+                        JetType type = temporaryServices.getType(scope, expression, NO_EXPECTED_TYPE);
+                        if (type != null) {
+                            constraintSystem.addSubtypingConstraint(type, valueParameterDescriptor.getOutType());
+                        }
+                        else {
+                            dirty.setValue(true);
+                        }
+                    }
+
+                    checkReceiverAbsence(task, tracing, candidate, temporaryTrace);
+                    // Error is already reported if something is missing
+                    ReceiverDescriptor receiver = task.getReceiver();
+                    ReceiverDescriptor candidateReceiver = candidate.getReceiver();
+                    if (receiver != NO_RECEIVER && candidateReceiver != NO_RECEIVER) {
+                        constraintSystem.addSubtypingConstraint(receiver.getType(), candidateReceiver.getType());
+                    }
+
+                    if (expectedType != NO_EXPECTED_TYPE) {
+                        constraintSystem.addSubtypingConstraint(candidate.getReturnType(), expectedType);
+                    }
+
+                    ConstraintSystem.Solution solution = constraintSystem.solve();
+                    solutions.put(candidate, solution);
+                    if (solution.isSuccessful()) {
+                        D substitute = (D) candidate.substitute(solution.getSubstitutor());
+                        assert substitute != null;
+                        successfulCandidates.put(candidate, substitute);
+                    }
+                    else {
+                        tracing.typeInferenceFailed(temporaryTrace);
+                        failedCandidates.add(candidate);
+                    }
+                }
+            }
+            else {
+                // Explicit type arguments passed
+
+                final List<JetTypeProjection> jetTypeArguments = task.getTypeArguments();
+
+                for (JetTypeProjection typeArgument : jetTypeArguments) {
+                    if (typeArgument.getProjectionKind() != JetProjectionKind.NONE) {
+//                        temporaryTrace.getErrorHandler().genericError(typeArgument.getNode(), "Projections are not allowed on type parameters for methods"); // TODO : better positioning
+                        temporaryTrace.report(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.on(typeArgument));
+                    }
+                }
+
+                int expectedTypeArgumentCount = candidate.getTypeParameters().size();
+                if (expectedTypeArgumentCount == jetTypeArguments.size()) {
+                    List<JetType> typeArguments = new ArrayList<JetType>();
+                    for (JetTypeProjection projection : jetTypeArguments) {
+                        // TODO : check that there's no projection
+                        JetTypeReference typeReference = projection.getTypeReference();
+                        if (typeReference != null) {
+                            typeArguments.add(new TypeResolver(semanticServices, temporaryTrace, true).resolveType(scope, typeReference));
+                        }
+                    }
+
+                    checkGenericBoundsInAFunctionCall(jetTypeArguments, typeArguments, candidate, temporaryTrace);
+
+                    Map<TypeConstructor, TypeProjection> substitutionContext = FunctionDescriptorUtil.createSubstitutionContext((FunctionDescriptor) candidate, typeArguments);
+                    D substitutedFunctionDescriptor = (D) candidate.substitute(TypeSubstitutor.create(substitutionContext));
+
+                    Function<ValueParameterDescriptor, ValueParameterDescriptor> mapFunction = createMapFunction(substitutedFunctionDescriptor);
+                    if (checkValueArgumentTypes(scope, temporaryServices, argumentsToParameters, dirty, mapFunction)
+                            && checkReceiver(task, tracing, substitutedFunctionDescriptor, temporaryTrace)) {
+                        successfulCandidates.put(candidate, substitutedFunctionDescriptor);
+                    }
+                    else {
+                        failedCandidates.add(candidate);
+                    }
+                }
+                else {
+                    failedCandidates.add(candidate);
+//                    tracing.reportWrongTypeArguments(temporaryTrace, "Number of type arguments does not match " + DescriptorRenderer.TEXT.render(candidate));
+                    tracing.wrongNumberOfTypeArguments(temporaryTrace, expectedTypeArgumentCount);
+                }
+            }
+            
+            if (dirty.getValue()) {
+                dirtyCandidates.add(candidate);
+            }
+            task.performAdvancedChecks(candidate, temporaryTrace, tracing);
+        }
+
+        OverloadResolutionResult<D> result = computeResultAndReportErrors(trace, tracing, successfulCandidates, failedCandidates, dirtyCandidates, traces);
+        if (!result.singleDescriptor()) {
+            checkTypesWithNoCallee(trace, scope, task.getTypeArguments(), task.getValueArguments(), task.getFunctionLiteralArguments());
+        }
+        return result;
+    }
+
+    private void checkTypesWithNoCallee(BindingTrace trace, JetScope scope, List<JetTypeProjection> typeArguments, List<? extends ValueArgument> valueArguments, List<JetExpression> functionLiteralArguments) {
+        for (ValueArgument valueArgument : valueArguments) {
+            JetExpression argumentExpression = valueArgument.getArgumentExpression();
+            if (argumentExpression != null) {
+                typeInferrer.getServices(trace).getType(scope, argumentExpression, NO_EXPECTED_TYPE);
+            }
+        }
+
+        for (JetExpression expression : functionLiteralArguments) {
+            typeInferrer.getServices(trace).getType(scope, expression, NO_EXPECTED_TYPE);
+        }
+
+        for (JetTypeProjection typeProjection : typeArguments) {
+            new TypeResolver(semanticServices, trace, true).resolveType(scope, typeProjection.getTypeReference());
+        }
+    }
+
+    private <D extends CallableDescriptor> Function<ValueParameterDescriptor, ValueParameterDescriptor> createMapFunction(D substitutedFunctionDescriptor) {
+        assert substitutedFunctionDescriptor != null;
+        final Map<ValueParameterDescriptor, ValueParameterDescriptor> parameterMap = Maps.newHashMap();
+        for (ValueParameterDescriptor valueParameterDescriptor : substitutedFunctionDescriptor.getValueParameters()) {
+            parameterMap.put(valueParameterDescriptor.getOriginal(), valueParameterDescriptor);
+        }
+
+        return new Function<ValueParameterDescriptor, ValueParameterDescriptor>() {
+            @Override
+            public ValueParameterDescriptor apply(ValueParameterDescriptor input) {
+                return parameterMap.get(input.getOriginal());
+            }
+        };
+    }
+
+    private <D extends CallableDescriptor> boolean checkReceiver(ResolutionTask<D> task, TracingStrategy tracing, D candidate, TemporaryBindingTrace temporaryTrace) {
+        if (!checkReceiverAbsence(task, tracing, candidate, temporaryTrace)) return false;
+        ReceiverDescriptor receiver = task.getReceiver();
+        ReceiverDescriptor candidateReceiver = candidate.getReceiver();
+        if (receiver != NO_RECEIVER
+                && candidateReceiver != NO_RECEIVER
+                && !semanticServices.getTypeChecker().isSubtypeOf(receiver.getType(), candidateReceiver.getType())) {
+            tracing.missingReceiver(temporaryTrace, candidateReceiver);
+            return false;
+        }
+        return true;
+    }
+
+    private <D extends CallableDescriptor> boolean checkReceiverAbsence(ResolutionTask<D> task, TracingStrategy tracing, D candidate, TemporaryBindingTrace temporaryTrace) {
+        ReceiverDescriptor receiver = task.getReceiver();
+        ReceiverDescriptor candidateReceiver = candidate.getReceiver();
+        if (receiver != NO_RECEIVER) {
+            if (candidateReceiver == NO_RECEIVER) {
+                tracing.noReceiverAllowed(temporaryTrace);
+                return false;
+            }
+        }
+        else if (candidateReceiver != NO_RECEIVER) {
+            tracing.missingReceiver(temporaryTrace, candidateReceiver);
+            return false;
+        }
+        return true;
+    }
+
+    @NotNull
+    private <D extends CallableDescriptor> OverloadResolutionResult<D> computeResultAndReportErrors(BindingTrace trace, TracingStrategy tracing, Map<D, D> successfulCandidates, Set<D> failedCandidates, Set<D> dirtyCandidates, Map<D, TemporaryBindingTrace> traces) {
+        // TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific
+        if (successfulCandidates.size() > 0) {
+            if (successfulCandidates.size() != 1) {
+                Map<D, D> cleanCandidates = Maps.newLinkedHashMap(successfulCandidates);
+                cleanCandidates.keySet().removeAll(dirtyCandidates);
+                if (cleanCandidates.isEmpty()) {
+                    cleanCandidates = successfulCandidates;
+                }
+                D maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, false);
+                if (maximallySpecific != null) {
+                    return OverloadResolutionResult.success(maximallySpecific);
+                }
+
+                D maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, true);
+                if (maximallySpecificGenericsDiscriminated != null) {
+                    return OverloadResolutionResult.success(maximallySpecificGenericsDiscriminated);
+                }
+
+                Set<D> noOverrides = OverridingUtil.filterOverrides(successfulCandidates.keySet());
+                if (dirtyCandidates.isEmpty()) {
+//                    tracing.reportOverallResolutionError(trace, "Overload resolution ambiguity: "
+//                                                                + makeErrorMessageForMultipleDescriptors(noOverrides));
+                    tracing.ambiguity(trace, noOverrides);
+                }
+
+                tracing.recordAmbiguity(trace, noOverrides);
+
+                return OverloadResolutionResult.ambiguity(noOverrides);
+            }
+            else {
+                Map.Entry<D, D> entry = successfulCandidates.entrySet().iterator().next();
+                D functionDescriptor = entry.getKey();
+                D result = entry.getValue();
+
+                TemporaryBindingTrace temporaryTrace = traces.get(functionDescriptor);
+                temporaryTrace.commit();
+                return OverloadResolutionResult.success(result);
+            }
+        }
+        else if (!failedCandidates.isEmpty()) {
+            if (failedCandidates.size() != 1) {
+                Set<D> noOverrides = OverridingUtil.filterOverrides(failedCandidates);
+                if (noOverrides.size() != 1) {
+//                    tracing.reportOverallResolutionError(trace, "None of the following functions can be called with the arguments supplied: "
+//                                                                + makeErrorMessageForMultipleDescriptors(noOverrides));
+                    tracing.noneApplicable(trace, noOverrides);
+                    tracing.recordAmbiguity(trace, noOverrides);
+                    return OverloadResolutionResult.manyFailedCandidates(noOverrides);
+                }
+                failedCandidates = noOverrides;
+            }
+            D functionDescriptor = failedCandidates.iterator().next();
+            TemporaryBindingTrace temporaryTrace = traces.get(functionDescriptor);
+            temporaryTrace.commit();
+            return OverloadResolutionResult.singleFailedCandidate(failedCandidates.iterator().next());
+        }
+        else {
+            tracing.unresolvedReference(trace);
+            return OverloadResolutionResult.nameNotFound();
+        }
+    }
+
+    private boolean checkValueArgumentTypes(JetScope scope, JetTypeInferrer.Services temporaryServices, Map<ValueArgument, ValueParameterDescriptor> argumentsToParameters, Flag dirty, Function<ValueParameterDescriptor, ValueParameterDescriptor> parameterMap) {
+        boolean result = true;
+        for (Map.Entry<ValueArgument, ValueParameterDescriptor> entry : argumentsToParameters.entrySet()) {
+            ValueArgument valueArgument = entry.getKey();
+            ValueParameterDescriptor valueParameterDescriptor = entry.getValue();
+
+            ValueParameterDescriptor substitutedParameter = parameterMap.apply(valueParameterDescriptor);
+
+            assert substitutedParameter != null;
+
+            JetType parameterType = substitutedParameter.getOutType();
+            JetExpression argumentExpression = valueArgument.getArgumentExpression();
+            if (argumentExpression != null) {
+                JetType type = temporaryServices.getType(scope, argumentExpression, parameterType);
+                if (type == null) {
+                    dirty.setValue(true);
+                }
+                else if (!semanticServices.getTypeChecker().isSubtypeOf(type, parameterType)) {
+                    result = false;
+                }
+            }
+        }
+        return result;
+    }
+
+    public void checkGenericBoundsInAFunctionCall(List<JetTypeProjection> jetTypeArguments, List<JetType> typeArguments, CallableDescriptor functionDescriptor, BindingTrace trace) {
+        Map<TypeConstructor, TypeProjection> context = Maps.newHashMap();
+
+        List<TypeParameterDescriptor> typeParameters = functionDescriptor.getOriginal().getTypeParameters();
+        for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
+            TypeParameterDescriptor typeParameter = typeParameters.get(i);
+            JetType typeArgument = typeArguments.get(i);
+            context.put(typeParameter.getTypeConstructor(), new TypeProjection(typeArgument));
+        }
+        TypeSubstitutor substitutor = TypeSubstitutor.create(context);
+        for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
+            TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i);
+            JetType typeArgument = typeArguments.get(i);
+            JetTypeReference typeReference = jetTypeArguments.get(i).getTypeReference();
+            assert typeReference != null;
+            semanticServices.getClassDescriptorResolver(trace).checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor);
+        }
+    }
+
+    @NotNull
+    public OverloadResolutionResult<FunctionDescriptor> resolveExactSignature(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List<JetType> parameterTypes) {
+        List<FunctionDescriptor> result = findCandidatesByExactSignature(scope, receiver, name, parameterTypes);
+
+        BindingTraceContext trace = new BindingTraceContext();
+        TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create(trace);
+        Map<FunctionDescriptor, TemporaryBindingTrace> traces = Maps.newHashMap();
+        Map<FunctionDescriptor, FunctionDescriptor> candidates = Maps.newLinkedHashMap();
+        for (FunctionDescriptor functionDescriptor : result) {
+            candidates.put(functionDescriptor, functionDescriptor);
+            traces.put(functionDescriptor, temporaryBindingTrace);
+        }
+        return computeResultAndReportErrors(trace, TracingStrategy.EMPTY, candidates, Collections.<FunctionDescriptor>emptySet(), Collections.<FunctionDescriptor>emptySet(), traces);
+    }
+
+    private List<FunctionDescriptor> findCandidatesByExactSignature(JetScope scope, ReceiverDescriptor receiver, String name, List<JetType> parameterTypes) {
+        List<FunctionDescriptor> result = Lists.newArrayList();
+        if (receiver != NO_RECEIVER) {
+            Set<FunctionDescriptor> extensionFunctionDescriptors = scope.getFunctions(name);
+            List<FunctionDescriptor> nonlocal = Lists.newArrayList();
+            List<FunctionDescriptor> local = Lists.newArrayList();
+            TaskPrioritizer.splitLexicallyLocalDescriptors(extensionFunctionDescriptors, scope.getContainingDeclaration(), local, nonlocal);
+
+
+            if (findExtensionFunctions(local, receiver, parameterTypes, result)) {
+                return result;
+            }
+
+            Set<FunctionDescriptor> functionDescriptors = receiver.getType().getMemberScope().getFunctions(name);
+            if (lookupExactSignature(functionDescriptors, parameterTypes, result)) {
+                return result;
+
+            }
+            findExtensionFunctions(nonlocal, receiver, parameterTypes, result);
+            return result;
+        }
+        else {
+            lookupExactSignature(scope.getFunctions(name), parameterTypes, result);
+            return result;
+        }
+    }
+
+    private boolean lookupExactSignature(Set<FunctionDescriptor> candidates, List<JetType> parameterTypes, List<FunctionDescriptor> result) {
+        boolean found = false;
+        for (FunctionDescriptor functionDescriptor : candidates) {
+            if (functionDescriptor.getReceiver() != NO_RECEIVER) continue;
+            if (!functionDescriptor.getTypeParameters().isEmpty()) continue;
+            if (!checkValueParameters(functionDescriptor, parameterTypes)) continue;
+            result.add(functionDescriptor);
+            found = true;
+        }
+        return found;
+    }
+
+    private boolean findExtensionFunctions(Collection<FunctionDescriptor> candidates, ReceiverDescriptor receiver, List<JetType> parameterTypes, List<FunctionDescriptor> result) {
+        boolean found = false;
+        for (FunctionDescriptor functionDescriptor : candidates) {
+            ReceiverDescriptor functionReceiver = functionDescriptor.getReceiver();
+            if (functionReceiver == NO_RECEIVER) continue;
+            if (!functionDescriptor.getTypeParameters().isEmpty()) continue;
+            if (!semanticServices.getTypeChecker().isSubtypeOf(receiver.getType(), functionReceiver.getType())) continue;
+            if (!checkValueParameters(functionDescriptor, parameterTypes))continue;
+            result.add(functionDescriptor);
+            found = true;
+        }
+        return found;
+    }
+
+    private boolean checkValueParameters(@NotNull FunctionDescriptor functionDescriptor, @NotNull List<JetType> parameterTypes) {
+        List<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters();
+        if (valueParameters.size() != parameterTypes.size()) return false;
+        for (int i = 0; i < valueParameters.size(); i++) {
+            ValueParameterDescriptor valueParameter = valueParameters.get(i);
+            JetType expectedType = parameterTypes.get(i);
+            if (!semanticServices.getTypeChecker().equalTypes(expectedType, valueParameter.getOutType())) return false;
+        }
+        return true;
+    }
+
+    private static TaskPrioritizer<FunctionDescriptor> FUNCTION_TASK_PRIORITIZER = new TaskPrioritizer<FunctionDescriptor>() {
+
+        @NotNull
+        @Override
+        protected Collection<FunctionDescriptor> getNonExtensionsByName(JetScope scope, String name) {
+            Set<FunctionDescriptor> functions = Sets.newLinkedHashSet(scope.getFunctions(name));
+            for (Iterator<FunctionDescriptor> iterator = functions.iterator(); iterator.hasNext(); ) {
+                FunctionDescriptor functionDescriptor = iterator.next();
+                if (functionDescriptor.getReceiver() != NO_RECEIVER) {
+                    iterator.remove();
+                }
+            }
+            addConstructors(scope, name, functions);
+
+            addVariableAsFunction(scope, name, functions, false);
+            return functions;
+        }
+
+        @NotNull
+        @Override
+        protected Collection<FunctionDescriptor> getMembersByName(@NotNull ReceiverDescriptor receiver, String name) {
+            JetScope receiverScope = receiver.getType().getMemberScope();
+            Set<FunctionDescriptor> members = Sets.newHashSet(receiverScope.getFunctions(name));
+            addConstructors(receiverScope, name, members);
+            addVariableAsFunction(receiverScope, name, members, false);
+            return members;
+        }
+
+        @NotNull
+        @Override
+        protected Collection<FunctionDescriptor> getExtensionsByName(JetScope scope, String name) {
+            Set<FunctionDescriptor> extensionFunctions = Sets.newHashSet(scope.getFunctions(name));
+            for (Iterator<FunctionDescriptor> iterator = extensionFunctions.iterator(); iterator.hasNext(); ) {
+                FunctionDescriptor descriptor = iterator.next();
+                if (descriptor.getReceiver() == NO_RECEIVER) {
+                    iterator.remove();
+                }
+            }
+            addVariableAsFunction(scope, name, extensionFunctions, true);
+            return extensionFunctions;
+        }
+
+        @NotNull
+        @Override
+        protected ResolutionTask<FunctionDescriptor> createTask(@NotNull ReceiverDescriptor receiver, Call call, Collection<FunctionDescriptor> candidates) {
+            return new ResolutionTask<FunctionDescriptor>(candidates, receiver, call);
+        }
+
+        private void addConstructors(JetScope scope, String name, Collection<FunctionDescriptor> functions) {
+            ClassifierDescriptor classifier = scope.getClassifier(name);
+            if (classifier instanceof ClassDescriptor && !ErrorUtils.isError(classifier.getTypeConstructor())) {
+                ClassDescriptor classDescriptor = (ClassDescriptor) classifier;
+                functions.addAll(classDescriptor.getConstructors());
+            }
+        }
+
+        private void addVariableAsFunction(JetScope scope, String name, Set<FunctionDescriptor> functions, boolean receiverNeeded) {
+            VariableDescriptor variable = scope.getVariable(name);
+            if (variable != null && variable.getReceiver() == NO_RECEIVER) {
+                JetType outType = variable.getOutType();
+                if (outType != null && JetStandardClasses.isFunctionType(outType)) {
+                    VariableAsFunctionDescriptor functionDescriptor = VariableAsFunctionDescriptor.create(variable);
+                    if ((functionDescriptor.getReceiver() != NO_RECEIVER) == receiverNeeded) {
+                        functions.add(functionDescriptor);
+                    }
+                }
+            }
+        }
+    };
+
+    private static TaskPrioritizer<VariableDescriptor> PROPERTY_TASK_PRIORITIZER = new TaskPrioritizer<VariableDescriptor>() {
+
+        @NotNull
+        @Override
+        protected Collection<VariableDescriptor> getNonExtensionsByName(JetScope scope, String name) {
+            VariableDescriptor variable = scope.getVariable(name);
+            if (variable != null && variable.getReceiver() == NO_RECEIVER) {
+                return Collections.singleton(variable);
+            }
+            return Collections.emptyList();
+        }
+
+        @NotNull
+        @Override
+        protected Collection<VariableDescriptor> getMembersByName(@NotNull ReceiverDescriptor receiver, String name) {
+            VariableDescriptor variable = receiver.getType().getMemberScope().getVariable(name);
+            if (variable != null) {
+                return Collections.singleton(variable);
+            }
+            return Collections.emptyList();
+        }
+
+        @NotNull
+        @Override
+        protected Collection<VariableDescriptor> getExtensionsByName(JetScope scope, String name) {
+            VariableDescriptor variable = scope.getVariable(name);
+            if (variable != null && variable.getReceiver() != NO_RECEIVER) {
+                return Collections.singleton(variable);
+            }
+            return Collections.emptyList();
+        }
+
+        @NotNull
+        @Override
+        protected ResolutionTask<VariableDescriptor> createTask(@NotNull ReceiverDescriptor receiver, Call call, Collection<VariableDescriptor> candidates) {
+            return new ResolutionTask<VariableDescriptor>(candidates, receiver, call);
+        }
+    };
+
+    private static class Flag {
+        private boolean flag;
+
+        public Flag(boolean  flag) {
+            this.flag = flag;
+        }
+
+        public boolean getValue() {
+            return flag;
+        }
+
+        public void setValue(boolean flag) {
+            this.flag = flag;
+        }
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResult.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResult.java
new file mode 100644
index 00000000000..799d001616b
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResult.java
@@ -0,0 +1,96 @@
+package org.jetbrains.jet.lang.resolve.calls;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+/**
+* @author abreslav
+*/
+public class OverloadResolutionResult<D> {
+    public enum Code {
+        SUCCESS(true),
+        NAME_NOT_FOUND(false),
+        SINGLE_CANDIDATE_ARGUMENT_MISMATCH(false),
+        AMBIGUITY(false),
+        MANY_FAILED_CANDIDATES(false);
+
+        private final boolean success;
+
+        Code(boolean success) {
+            this.success = success;
+        }
+
+        boolean isSuccess() {
+            return success;
+        }
+
+    }
+
+    public static <D> OverloadResolutionResult<D> success(@NotNull D descriptor) {
+        return new OverloadResolutionResult<D>(Code.SUCCESS, Collections.singleton(descriptor));
+    }
+
+    public static <D> OverloadResolutionResult<D> nameNotFound() {
+        return new OverloadResolutionResult<D>(Code.NAME_NOT_FOUND, Collections.<D>emptyList());
+    }
+
+    public static <D> OverloadResolutionResult<D> singleFailedCandidate(D candidate) {
+        return new OverloadResolutionResult<D>(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate));
+    }
+    public static <D> OverloadResolutionResult<D> manyFailedCandidates(Set<D> failedCandidates) {
+        return new OverloadResolutionResult<D>(Code.MANY_FAILED_CANDIDATES, failedCandidates);
+    }
+
+    public static <D> OverloadResolutionResult<D> ambiguity(Collection<D> descriptors) {
+        return new OverloadResolutionResult<D>(Code.AMBIGUITY, descriptors);
+    }
+
+    private final Collection<D> descriptors;
+
+    private final Code resultCode;
+
+    public OverloadResolutionResult(@NotNull Code resultCode, @NotNull Collection<D> descriptors) {
+        this.descriptors = descriptors;
+        this.resultCode = resultCode;
+
+    }
+
+    @NotNull
+    public Collection<D> getDescriptors() {
+        return descriptors;
+    }
+
+    @NotNull
+    public D getDescriptor() {
+        assert singleDescriptor();
+        return descriptors.iterator().next();
+    }
+
+    @NotNull
+    public Code getResultCode() {
+        return resultCode;
+    }
+
+    public boolean isSuccess() {
+        return resultCode.isSuccess();
+    }
+
+    public boolean singleDescriptor() {
+        return isSuccess() || resultCode == Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH;
+    }
+
+    public boolean isNothing() {
+        return resultCode == Code.NAME_NOT_FOUND;
+    }
+
+    public boolean isAmbiguity() {
+        return resultCode == Code.AMBIGUITY;
+    }
+
+    public OverloadResolutionResult<D> newContents(@NotNull Collection<D> functionDescriptors) {
+        return new OverloadResolutionResult<D>(resultCode, functionDescriptors);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java
new file mode 100644
index 00000000000..127cf37efec
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java
@@ -0,0 +1,123 @@
+package org.jetbrains.jet.lang.resolve.calls;
+
+import com.google.common.collect.Maps;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.OverridingUtil;
+import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.JetStandardLibrary;
+import org.jetbrains.jet.lang.types.JetType;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author abreslav
+ */
+public class OverloadingConflictResolver {
+
+    private final JetSemanticServices semanticServices;
+
+    public OverloadingConflictResolver(@NotNull JetSemanticServices semanticServices) {
+        this.semanticServices = semanticServices;
+    }
+
+    @Nullable
+    public <Descriptor extends CallableDescriptor> Descriptor findMaximallySpecific(Map<Descriptor, Descriptor> candidates, Map<Descriptor, TemporaryBindingTrace> traces, boolean discriminateGenericDescriptors) {
+        Map<Descriptor, TemporaryBindingTrace> maximallySpecific = Maps.newHashMap();
+        meLoop:
+        for (Map.Entry<Descriptor, Descriptor> myEntry : candidates.entrySet()) {
+            Descriptor me = myEntry.getValue();
+            TemporaryBindingTrace myTrace = traces.get(myEntry.getKey());
+            for (Descriptor other : candidates.values()) {
+                if (other == me) continue;
+                if (!moreSpecific(me, other, discriminateGenericDescriptors) || moreSpecific(other, me, discriminateGenericDescriptors)) continue meLoop;
+            }
+            maximallySpecific.put(me, myTrace);
+        }
+        if (maximallySpecific.size() == 1) {
+            Map.Entry<Descriptor, TemporaryBindingTrace> result = maximallySpecific.entrySet().iterator().next();
+            result.getValue().commit();
+            return result.getKey();
+        }
+        return null;
+    }
+
+    /**
+     * Let < mean "more specific"
+     * Subtype < supertype
+     * Double < Float
+     * Int < Long
+     * Int < Short < Byte
+     */
+    private <Descriptor extends CallableDescriptor> boolean moreSpecific(Descriptor f, Descriptor g, boolean discriminateGenericDescriptors) {
+        if (OverridingUtil.overrides(f, g)) return true;
+        if (OverridingUtil.overrides(g, f)) return false;
+
+        ReceiverDescriptor receiverOfF = f.getReceiver();
+        ReceiverDescriptor receiverOfG = g.getReceiver();
+        if (f.getReceiver().exists() && g.getReceiver().exists()) {
+            if (!typeMoreSpecific(receiverOfF.getType(), receiverOfG.getType())) return false;
+        }
+
+        List<ValueParameterDescriptor> fParams = f.getValueParameters();
+        List<ValueParameterDescriptor> gParams = g.getValueParameters();
+
+        int fSize = fParams.size();
+        if (fSize != gParams.size()) return false;
+        for (int i = 0; i < fSize; i++) {
+            JetType fParamType = fParams.get(i).getOutType();
+            JetType gParamType = gParams.get(i).getOutType();
+
+            if (!typeMoreSpecific(fParamType, gParamType)) {
+                return false;
+            }
+        }
+
+        if (discriminateGenericDescriptors && isGeneric(f)) {
+            if (!isGeneric(g)) {
+                return false;
+            }
+
+            // g is generic, too
+
+            return moreSpecific(DescriptorUtils.substituteBounds(f), DescriptorUtils.substituteBounds(g), false);
+        }
+
+        return true;
+    }
+
+    private boolean isGeneric(CallableDescriptor f) {
+        return !f.getOriginal().getTypeParameters().isEmpty();
+    }
+
+    private boolean typeMoreSpecific(@NotNull JetType specific, @NotNull JetType general) {
+        return semanticServices.getTypeChecker().isSubtypeOf(specific, general) ||
+                            numericTypeMoreSpecific(specific, general);
+    }
+
+    private boolean numericTypeMoreSpecific(@NotNull JetType specific, @NotNull JetType general) {
+        JetStandardLibrary standardLibrary = semanticServices.getStandardLibrary();
+        JetType _double = standardLibrary.getDoubleType();
+        JetType _float = standardLibrary.getFloatType();
+        JetType _long = standardLibrary.getLongType();
+        JetType _int = standardLibrary.getIntType();
+        JetType _byte = standardLibrary.getByteType();
+        JetType _short = standardLibrary.getShortType();
+
+        if (semanticServices.getTypeChecker().equalTypes(specific, _double) && semanticServices.getTypeChecker().equalTypes(general, _float)) return true;
+        if (semanticServices.getTypeChecker().equalTypes(specific, _int)) {
+            if (semanticServices.getTypeChecker().equalTypes(general, _long)) return true;
+            if (semanticServices.getTypeChecker().equalTypes(general, _byte)) return true;
+            if (semanticServices.getTypeChecker().equalTypes(general, _short)) return true;
+        }
+        if (semanticServices.getTypeChecker().equalTypes(specific, _short) && semanticServices.getTypeChecker().equalTypes(general, _byte)) return true;
+        return false;
+    }
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java
new file mode 100644
index 00000000000..c369d8aa730
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java
@@ -0,0 +1,88 @@
+package org.jetbrains.jet.lang.resolve.calls;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.psi.Call;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.psi.JetTypeProjection;
+import org.jetbrains.jet.lang.psi.ValueArgument;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.JetType;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * @author abreslav
+ */
+/*package*/ class ResolutionTask<Descriptor extends CallableDescriptor> {
+    private final Collection<Descriptor> candidates;
+    private final ReceiverDescriptor receiver;
+    private final List<JetTypeProjection> typeArguments;
+    private final List<? extends ValueArgument> valueArguments;
+    private final List<JetExpression> functionLiteralArguments;
+    private DescriptorCheckStrategy checkingStrategy;
+
+    public ResolutionTask(
+            @NotNull Collection<Descriptor> candidates,
+            @NotNull ReceiverDescriptor receiver,
+            @NotNull List<JetTypeProjection> typeArguments,
+            @NotNull List<? extends ValueArgument> valueArguments,
+            @NotNull List<JetExpression> functionLiteralArguments) {
+        this.candidates = candidates;
+        this.receiver = receiver;
+        this.typeArguments = typeArguments;
+        this.valueArguments = valueArguments;
+        this.functionLiteralArguments = functionLiteralArguments;
+    }
+
+    public ResolutionTask(
+            @NotNull Collection<Descriptor> candidates,
+            @NotNull ReceiverDescriptor receiver,
+            @NotNull Call call
+    ) {
+        this(candidates, receiver, call.getTypeArguments(), call.getValueArguments(), call.getFunctionLiteralArguments());
+    }
+
+    @NotNull
+    public Collection<Descriptor> getCandidates() {
+        return candidates;
+    }
+
+    @NotNull
+    public ReceiverDescriptor getReceiver() {
+        return receiver;
+    }
+
+    @NotNull
+    public List<JetTypeProjection> getTypeArguments() {
+        return typeArguments;
+    }
+
+    @NotNull
+    public List<? extends ValueArgument> getValueArguments() {
+        return valueArguments;
+    }
+
+    @NotNull
+    public List<JetExpression> getFunctionLiteralArguments() {
+        return functionLiteralArguments;
+    }
+    
+    public void setCheckingStrategy(DescriptorCheckStrategy strategy) {
+        checkingStrategy = strategy;
+    }
+
+    public boolean performAdvancedChecks(Descriptor descriptor, BindingTrace trace, TracingStrategy tracing) {
+        if (checkingStrategy != null && !checkingStrategy.performAdvancedChecks(descriptor, trace, tracing)) {
+            return false;
+        }
+        return true;
+    }
+
+    public interface DescriptorCheckStrategy {
+        <D extends CallableDescriptor> boolean performAdvancedChecks(D descriptor, BindingTrace trace, TracingStrategy tracing);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java
new file mode 100644
index 00000000000..c14a3c00e9e
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java
@@ -0,0 +1,128 @@
+package org.jetbrains.jet.lang.resolve.calls;
+
+import com.google.common.collect.Lists;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
+import org.jetbrains.jet.lang.psi.Call;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+* @author abreslav
+*/
+/*package*/ abstract class TaskPrioritizer<D extends CallableDescriptor> {
+
+    public static <T extends DeclarationDescriptor> void splitLexicallyLocalDescriptors(
+            Collection<? extends T> allDescriptors, DeclarationDescriptor containerOfTheCurrentLocality, List<? super T> local, List<? super T> nonlocal) {
+
+        for (T descriptor : allDescriptors) {
+            if (isLocal(containerOfTheCurrentLocality, descriptor)) {
+                local.add(descriptor);
+            }
+            else {
+                nonlocal.add(descriptor);
+            }
+        }
+    }
+
+    /**
+     * The primary case for local extensions is the following:
+     *
+     * I had a locally declared extension function or a local variable of function type called foo
+     * And I called it on my x
+     * Now, someone added function foo() to the class of x
+     * My code should not change
+     *
+     * thus
+     *
+     * local extension prevail over members (and members prevail over all non-local extensions)
+     */
+    public static boolean isLocal(DeclarationDescriptor containerOfTheCurrentLocality, DeclarationDescriptor candidate) {
+        if (candidate instanceof ValueParameterDescriptor) {
+            return true;
+        }
+        DeclarationDescriptor parent = candidate.getContainingDeclaration();
+        if (!(parent instanceof FunctionDescriptor)) {
+            return false;
+        }
+        FunctionDescriptor functionDescriptor = (FunctionDescriptor) parent;
+        DeclarationDescriptor current = containerOfTheCurrentLocality;
+        while (current != null) {
+            if (current == functionDescriptor) {
+                return true;
+            }
+            current = current.getContainingDeclaration();
+        }
+        return false;
+    }
+
+    public List<ResolutionTask<D>> computePrioritizedTasks(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, @NotNull Call call, @NotNull String name) {
+        List<ResolutionTask<D>> result = Lists.newArrayList();
+        doComputeTasks(scope, receiver, call, name, result);
+        return result;
+    }
+
+    private void doComputeTasks(JetScope scope, ReceiverDescriptor receiver, Call call, String name, List<ResolutionTask<D>> result) {
+        List<ReceiverDescriptor> implicitReceivers = Lists.newArrayList();
+        scope.getImplicitReceiversHierarchy(implicitReceivers);
+        if (receiver != ReceiverDescriptor.NO_RECEIVER) {
+            Collection<D> extensionFunctions = getExtensionsByName(scope, name);
+            List<D> nonlocals = Lists.newArrayList();
+            List<D> locals = Lists.newArrayList();
+            //noinspection unchecked,RedundantTypeArguments
+            TaskPrioritizer.<D>splitLexicallyLocalDescriptors(extensionFunctions, scope.getContainingDeclaration(), locals, nonlocals);
+
+            Collection<D> members = getMembersByName(receiver, name);
+
+            addTask(result, receiver, call, locals);
+            addTask(result, ReceiverDescriptor.NO_RECEIVER, call, members);
+
+            for (ReceiverDescriptor implicitReceiver : implicitReceivers) {
+                Collection<D> memberExtensions = getExtensionsByName(implicitReceiver.getType().getMemberScope(), name);
+                addTask(result, receiver, call, memberExtensions);
+            }
+
+            addTask(result, receiver, call, nonlocals);
+        }
+        else {
+            Collection<D> functions = getNonExtensionsByName(scope, name);
+
+            List<D> nonlocals = Lists.newArrayList();
+            List<D> locals = Lists.newArrayList();
+            //noinspection unchecked,RedundantTypeArguments
+            TaskPrioritizer.<D>splitLexicallyLocalDescriptors(functions, scope.getContainingDeclaration(), locals, nonlocals);
+
+            addTask(result, receiver, call, locals);
+
+            for (ReceiverDescriptor implicitReceiver : implicitReceivers) {
+                doComputeTasks(scope, implicitReceiver, call, name, result);
+            }
+
+            addTask(result, receiver, call, nonlocals);
+        }
+    }
+
+    @NotNull
+    protected abstract Collection<D> getNonExtensionsByName(JetScope scope, String name);
+
+    @NotNull
+    protected abstract Collection<D> getMembersByName(@NotNull ReceiverDescriptor receiver, String name);
+
+    @NotNull
+    protected abstract Collection<D> getExtensionsByName(JetScope scope, String name);
+
+    private void addTask(@NotNull List<ResolutionTask<D>> result, @NotNull ReceiverDescriptor receiver, @NotNull Call call, @NotNull Collection<D> candidates) {
+        if (candidates.isEmpty()) return;
+        result.add(createTask(receiver, call, candidates));
+    }
+
+    @NotNull
+    protected abstract ResolutionTask<D> createTask(ReceiverDescriptor receiver, Call call, Collection<D> candidates);
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java
new file mode 100644
index 00000000000..2429496de86
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java
@@ -0,0 +1,72 @@
+package org.jetbrains.jet.lang.resolve.calls;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+
+import java.util.Collection;
+import java.util.Set;
+
+/**
+* @author abreslav
+*/
+/*package*/ interface TracingStrategy {
+    TracingStrategy EMPTY = new TracingStrategy() {
+        @Override
+        public void bindReference(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor receiver, @NotNull CallableDescriptor descriptor) {}
+
+        @Override
+        public void unresolvedReference(@NotNull BindingTrace trace) {}
+
+        @Override
+        public <D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<D> candidates) {}
+
+        @Override
+        public void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver) {}
+
+        @Override
+        public void noReceiverAllowed(@NotNull BindingTrace trace) {}
+
+        @Override
+        public void noValueForParameter(@NotNull BindingTrace trace, @NotNull ValueParameterDescriptor valueParameter) {}
+
+        @Override
+        public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) {}
+
+        @Override
+        public void ambiguity(@NotNull BindingTrace trace, @NotNull Set<? extends CallableDescriptor> descriptors) {}
+
+        @Override
+        public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set<? extends CallableDescriptor> descriptors) {}
+
+        @Override
+        public void instantiationOfAbstractClass(@NotNull BindingTrace trace) {}
+
+        @Override
+        public void typeInferenceFailed(@NotNull BindingTrace trace) {}
+    };
+
+    void bindReference(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor receiver, @NotNull CallableDescriptor descriptor);
+
+    void unresolvedReference(@NotNull BindingTrace trace);
+
+    <D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<D> candidates);
+
+    void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver);
+
+    void noReceiverAllowed(@NotNull BindingTrace trace);
+
+    void noValueForParameter(@NotNull BindingTrace trace, @NotNull ValueParameterDescriptor valueParameter);
+
+    void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount);
+
+    void ambiguity(@NotNull BindingTrace trace, @NotNull Set<? extends CallableDescriptor> descriptors);
+
+    void noneApplicable(@NotNull BindingTrace trace, @NotNull Set<? extends CallableDescriptor> descriptors);
+
+    void instantiationOfAbstractClass(@NotNull BindingTrace trace);
+
+    void typeInferenceFailed(@NotNull BindingTrace trace);
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java
new file mode 100644
index 00000000000..a044f24d0da
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java
@@ -0,0 +1,164 @@
+package org.jetbrains.jet.lang.resolve.calls;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.types.CallMaker;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
+
+/**
+ * @author abreslav
+ */
+/*package*/ class ValueArgumentsToParametersMapper {
+    public static <Descriptor extends CallableDescriptor> boolean mapValueArgumentsToParameters(
+            @NotNull ResolutionTask<Descriptor> task,
+            @NotNull TracingStrategy tracing,
+            @NotNull Descriptor candidate,
+            @NotNull BindingTrace temporaryTrace,
+            @NotNull Map<ValueArgument, ValueParameterDescriptor> argumentsToParameters
+    ) {
+        Set<ValueParameterDescriptor> usedParameters = Sets.newHashSet();
+
+        List<ValueParameterDescriptor> valueParameters = candidate.getValueParameters();
+
+        Map<String, ValueParameterDescriptor> parameterByName = Maps.newHashMap();
+        for (ValueParameterDescriptor valueParameter : valueParameters) {
+            parameterByName.put(valueParameter.getName(), valueParameter);
+        }
+
+        List<? extends ValueArgument> valueArguments = task.getValueArguments();
+
+        boolean error = false;
+        boolean someNamed = false;
+        boolean somePositioned = false;
+        for (int i = 0; i < valueArguments.size(); i++) {
+            ValueArgument valueArgument = valueArguments.get(i);
+            if (valueArgument.isNamed()) {
+                someNamed = true;
+                JetReferenceExpression nameReference = valueArgument.getArgumentName().getReferenceExpression();
+                ValueParameterDescriptor valueParameterDescriptor = parameterByName.get(valueArgument.getArgumentName().getReferenceExpression().getReferencedName());
+                if (valueParameterDescriptor == null) {
+//                        temporaryTrace.getErrorHandler().genericError(nameNode, "Cannot find a parameter with this name");
+                    temporaryTrace.report(NAMED_PARAMETER_NOT_FOUND.on(nameReference));
+                    error = true;
+                }
+                else {
+                    if (!usedParameters.add(valueParameterDescriptor)) {
+//                        temporaryTrace.getErrorHandler().genericError(nameNode, "An argument is already passed for this parameter");
+                        temporaryTrace.report(ARGUMENT_PASSED_TWICE.on(nameReference));
+                    }
+                    temporaryTrace.record(REFERENCE_TARGET, nameReference, valueParameterDescriptor);
+                    argumentsToParameters.put(valueArgument, valueParameterDescriptor);
+                }
+                if (somePositioned) {
+//                    temporaryTrace.getErrorHandler().genericError(nameNode, "Mixing named and positioned arguments in not allowed");
+                    temporaryTrace.report(MIXING_NAMED_AND_POSITIONED_ARGUMENTS.on(nameReference));
+                    error = true;
+                }
+            }
+            else {
+                somePositioned = true;
+                if (someNamed) {
+//                    temporaryTrace.getErrorHandler().genericError(valueArgument.asElement().getNode(), "Mixing named and positioned arguments in not allowed");
+                    temporaryTrace.report(MIXING_NAMED_AND_POSITIONED_ARGUMENTS.on(valueArgument.asElement()));
+                    error = true;
+                }
+                else {
+                    int parameterCount = valueParameters.size();
+                    if (i < parameterCount) {
+                        ValueParameterDescriptor valueParameterDescriptor = valueParameters.get(i);
+                        usedParameters.add(valueParameterDescriptor);
+                        argumentsToParameters.put(valueArgument, valueParameterDescriptor);
+                    }
+                    else if (!valueParameters.isEmpty()) {
+                        ValueParameterDescriptor valueParameterDescriptor = valueParameters.get(valueParameters.size() - 1);
+                        if (valueParameterDescriptor.isVararg()) {
+                            argumentsToParameters.put(valueArgument, valueParameterDescriptor);
+                            usedParameters.add(valueParameterDescriptor);
+                        }
+                        else {
+//                            temporaryTrace.getErrorHandler().genericError(valueArgument.asElement().getNode(), getTooManyArgumentsMessage(candidate));
+                            temporaryTrace.report(TOO_MANY_ARGUMENTS.on(valueArgument.asElement(), candidate));
+                            error = true;
+                        }
+                    }
+                    else {
+//                        temporaryTrace.getErrorHandler().genericError(valueArgument.asElement().getNode(), getTooManyArgumentsMessage(candidate));
+                        temporaryTrace.report(TOO_MANY_ARGUMENTS.on(valueArgument.asElement(), candidate));
+                        error = true;
+                    }
+                }
+            }
+        }
+
+        List<JetExpression> functionLiteralArguments = task.getFunctionLiteralArguments();
+        if (!functionLiteralArguments.isEmpty()) {
+            JetExpression possiblyLabeledFunctionLiteral = functionLiteralArguments.get(0);
+
+            if (valueParameters.isEmpty()) {
+//                temporaryTrace.getErrorHandler().genericError(possiblyLabeledFunctionLiteral.getNode(), getTooManyArgumentsMessage(candidate));
+                temporaryTrace.report(TOO_MANY_ARGUMENTS.on(possiblyLabeledFunctionLiteral, candidate));
+                error = true;
+            } else {
+                JetFunctionLiteralExpression functionLiteral;
+                if (possiblyLabeledFunctionLiteral instanceof JetLabelQualifiedExpression) {
+                    JetLabelQualifiedExpression labeledFunctionLiteral = (JetLabelQualifiedExpression) possiblyLabeledFunctionLiteral;
+                    functionLiteral = (JetFunctionLiteralExpression) labeledFunctionLiteral.getLabeledExpression();
+                }
+                else {
+                    functionLiteral = (JetFunctionLiteralExpression) possiblyLabeledFunctionLiteral;
+                }
+
+                ValueParameterDescriptor parameterDescriptor = valueParameters.get(valueParameters.size() - 1);
+                if (parameterDescriptor.isVararg()) {
+//                    temporaryTrace.getErrorHandler().genericError(possiblyLabeledFunctionLiteral.getNode(), "Passing value as a vararg is only allowed inside a parenthesized argument list");
+                    temporaryTrace.report(VARARG_OUTSIDE_PARENTHESES.on(possiblyLabeledFunctionLiteral));
+                    error = true;
+                }
+                else {
+                    if (!usedParameters.add(parameterDescriptor)) {
+//                        temporaryTrace.getErrorHandler().genericError(possiblyLabeledFunctionLiteral.getNode(), getTooManyArgumentsMessage(candidate));
+                        temporaryTrace.report(TOO_MANY_ARGUMENTS.on(possiblyLabeledFunctionLiteral, candidate));
+                        error = true;
+                    }
+                    else {
+                        argumentsToParameters.put(CallMaker.makeValueArgument(functionLiteral), parameterDescriptor);
+                    }
+                }
+            }
+
+            for (int i = 1; i < functionLiteralArguments.size(); i++) {
+                JetExpression argument = functionLiteralArguments.get(i);
+//                temporaryTrace.getErrorHandler().genericError(argument.getNode(), "Only one function literal is allowed outside a parenthesized argument list");
+                temporaryTrace.report(MANY_FUNCTION_LITERAL_ARGUMENTS.on(argument));
+                error = true;
+            }
+        }
+
+
+        for (ValueParameterDescriptor valueParameter : valueParameters) {
+            if (!usedParameters.contains(valueParameter)) {
+                if (!valueParameter.hasDefaultValue() && !valueParameter.isVararg()) {
+//                    tracing.reportWrongValueArguments(temporaryTrace, "No value passed for parameter " + valueParameter.getName());
+                    tracing.noValueForParameter(temporaryTrace, valueParameter);
+                    error = true;
+                }
+            }
+        }
+        return error;
+    }
+
+//    private static <Descriptor extends CallableDescriptor> String getTooManyArgumentsMessage(Descriptor candidate) {
+//        return "Too many arguments for " + DescriptorRenderer.TEXT.render(candidate);
+//    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/BooleanValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/BooleanValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/BooleanValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/BooleanValue.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/ByteValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ByteValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/ByteValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ByteValue.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/CharValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CharValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/CharValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CharValue.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstant.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstant.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstant.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstant.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/DoubleValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/DoubleValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/DoubleValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/DoubleValue.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/ErrorValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ErrorValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/ErrorValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ErrorValue.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/FloatValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/FloatValue.java
new file mode 100644
index 00000000000..5f8442cca26
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/FloatValue.java
@@ -0,0 +1,38 @@
+package org.jetbrains.jet.lang.resolve.constants;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor;
+import org.jetbrains.jet.lang.types.JetStandardLibrary;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * @author alex.tkachman
+ */
+public class FloatValue implements CompileTimeConstant<Float> {
+    private final float value;
+
+    public FloatValue(float value) {
+        this.value = value;
+    }
+
+    @Override
+    public Float getValue() {
+        return value;
+    }
+
+    @NotNull
+    @Override
+    public JetType getType(@NotNull JetStandardLibrary standardLibrary) {
+        return standardLibrary.getFloatType();
+    }
+
+    @Override
+    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
+        return visitor.visitFloatValue(this, data);
+    }
+
+    @Override
+    public String toString() {
+        return value + ".flt";
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/IntValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/IntValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/IntValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/IntValue.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/LongValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/LongValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/LongValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/LongValue.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/NullValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NullValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/NullValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NullValue.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/ShortValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ShortValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/ShortValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ShortValue.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/constants/StringValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/StringValue.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/resolve/constants/StringValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/StringValue.java
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java
similarity index 81%
rename from idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java
index 11d4755a41e..6e457d2ebce 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java
@@ -1,12 +1,15 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -54,20 +57,31 @@ public class ChainedScope implements JetScope {
 
     @NotNull
     @Override
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        for (JetScope jetScope : scopeChain) {
-            FunctionGroup functionGroup = jetScope.getFunctionGroup(name);
-            if (!functionGroup.isEmpty()) return functionGroup;
+    public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        if (scopeChain.length == 0) {
+            return Collections.emptySet();
         }
-        return FunctionGroup.EMPTY;
+
+        Set<FunctionDescriptor> result = Sets.newLinkedHashSet();
+        for (JetScope jetScope : scopeChain) {
+            result.addAll(jetScope.getFunctions(name));
+        }
+        return result;
     }
 
     @NotNull
     @Override
-    public JetType getThisType() {
+    public ReceiverDescriptor getImplicitReceiver() {
         throw new UnsupportedOperationException(); // TODO
     }
 
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+        for (JetScope jetScope : scopeChain) {
+            jetScope.getImplicitReceiversHierarchy(result);
+        }
+    }
+
     @NotNull
     @Override
     public DeclarationDescriptor getContainingDeclaration() {
@@ -110,6 +124,7 @@ public class ChainedScope implements JetScope {
         return null;
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (allDescriptors == null) {
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java
similarity index 64%
rename from idea/src/org/jetbrains/jet/lang/resolve/JetScope.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java
index 93dcfa946eb..6f4495e1bef 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java
@@ -1,11 +1,13 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
+import java.util.List;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -15,7 +17,7 @@ public interface JetScope {
         @NotNull
         @Override
         public DeclarationDescriptor getContainingDeclaration() {
-            throw new UnsupportedOperationException(); // TODO
+            throw new UnsupportedOperationException();
         }
 
         @Override
@@ -34,10 +36,7 @@ public interface JetScope {
     VariableDescriptor getVariable(@NotNull String name);
 
     @NotNull
-    FunctionGroup getFunctionGroup(@NotNull String name);
-
-    @NotNull
-    JetType getThisType();
+    Set<FunctionDescriptor> getFunctions(@NotNull String name);
 
     @NotNull
     DeclarationDescriptor getContainingDeclaration();
@@ -55,5 +54,18 @@ public interface JetScope {
     @Nullable
     DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis();
 
+    @NotNull
     Collection<DeclarationDescriptor> getAllDescriptors();
+
+    /**
+     * @return EFFECTIVE implicit receiver at this point (may be corresponding to an outer scope)
+     */
+    @NotNull
+    ReceiverDescriptor getImplicitReceiver();
+
+    /**
+     * Adds receivers to the list in order of locality, so that the closest (the most local) receiver goes first
+     * @param result
+     */
+    void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result);
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeAdapter.java
similarity index 77%
rename from idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeAdapter.java
index a3b531bd831..248f00bee77 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeAdapter.java
@@ -1,6 +1,7 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter;
 
 /**
  * @author abreslav
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java
similarity index 69%
rename from idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java
index fbbe8cf99e8..b738d76a50c 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java
@@ -1,11 +1,13 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
+import java.util.Set;
 
 /**
 * @author abreslav
@@ -28,14 +30,14 @@ public abstract class JetScopeImpl implements JetScope {
 
     @NotNull
     @Override
-    public JetType getThisType() {
-        return JetStandardClasses.getNothingType();
+    public ReceiverDescriptor getImplicitReceiver() {
+        return ReceiverDescriptor.NO_RECEIVER;
     }
 
     @NotNull
     @Override
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        return FunctionGroup.EMPTY;
+    public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        return Collections.emptySet();
     }
 
     @NotNull
@@ -54,8 +56,13 @@ public abstract class JetScopeImpl implements JetScope {
         return null;
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         return Collections.emptyList();
     }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/LazyScopeAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java
similarity index 79%
rename from idea/src/org/jetbrains/jet/lang/resolve/LazyScopeAdapter.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java
index 40a39ff5ca7..4cd937f0e76 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/LazyScopeAdapter.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java
@@ -1,6 +1,7 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter;
 import org.jetbrains.jet.lang.types.LazyValue;
 
 /**
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/RedeclarationHandler.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/RedeclarationHandler.java
new file mode 100644
index 00000000000..c123871fa46
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/RedeclarationHandler.java
@@ -0,0 +1,23 @@
+package org.jetbrains.jet.lang.resolve.scopes;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+
+/**
+ * @author abreslav
+ */
+public interface RedeclarationHandler {
+    RedeclarationHandler DO_NOTHING = new RedeclarationHandler() {
+        @Override
+        public void handleRedeclaration(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) {
+        }
+    };
+    RedeclarationHandler THROW_EXCEPTION = new RedeclarationHandler() {
+        @Override
+        public void handleRedeclaration(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) {
+            throw new IllegalStateException("Redeclaration: " + first + " and " + second + "(no line info available)");
+        }
+    };
+
+    void handleRedeclaration(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second);
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java
new file mode 100644
index 00000000000..f09364216e1
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java
@@ -0,0 +1,131 @@
+package org.jetbrains.jet.lang.resolve.scopes;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
+
+import java.util.*;
+
+/**
+ * @author abreslav
+ */
+public class SubstitutingScope implements JetScope {
+
+    private final JetScope workerScope;
+    private final TypeSubstitutor substitutor;
+
+    private Map<DeclarationDescriptor, DeclarationDescriptor> substitutedDescriptors = null;
+    private Collection<DeclarationDescriptor> allDescriptors = null;
+
+    public SubstitutingScope(JetScope workerScope, @NotNull TypeSubstitutor substitutor) {
+        this.workerScope = workerScope;
+        this.substitutor = substitutor;
+    }
+
+    @Nullable
+    private <D extends DeclarationDescriptor> D substitute(@Nullable D descriptor) {
+        if (descriptor == null) return null;
+        if (substitutor.isEmpty()) return descriptor;
+
+        if (substitutedDescriptors == null) {
+            substitutedDescriptors = Maps.newHashMap();
+        }
+
+        DeclarationDescriptor substituted = substitutedDescriptors.get(descriptor);
+        if (substituted == null) {
+            substituted = descriptor.substitute(substitutor);
+            substitutedDescriptors.put(descriptor, substituted);
+        }
+        //noinspection unchecked
+        return (D) substituted;
+    }
+
+    @NotNull
+    private <D extends DeclarationDescriptor> Set<D> substitute(@NotNull Set<D> descriptors) {
+        if (substitutor.isEmpty()) return descriptors;
+        if (descriptors.isEmpty()) return descriptors;
+
+        Set<D> result = Sets.newHashSet();
+        for (D descriptor : descriptors) {
+            D substitute = substitute(descriptor);
+            if (substitute != null) {
+                result.add(substitute);
+            }
+        }
+
+        return result;
+    }
+
+    @Override
+    public VariableDescriptor getVariable(@NotNull String name) {
+        return substitute(workerScope.getVariable(name));
+    }
+
+    @Override
+    public ClassifierDescriptor getClassifier(@NotNull String name) {
+        return substitute(workerScope.getClassifier(name));
+    }
+
+    @NotNull
+    @Override
+    public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        return substitute(workerScope.getFunctions(name));
+    }
+
+    @Override
+    public NamespaceDescriptor getNamespace(@NotNull String name) {
+        return workerScope.getNamespace(name); // TODO
+    }
+
+    @NotNull
+    @Override
+    public ReceiverDescriptor getImplicitReceiver() {
+        throw new UnsupportedOperationException(); // TODO
+    }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+        throw new UnsupportedOperationException(); // TODO
+    }
+
+    @NotNull
+    @Override
+    public DeclarationDescriptor getContainingDeclaration() {
+        return workerScope.getContainingDeclaration();
+    }
+
+    @NotNull
+    @Override
+    public Collection<DeclarationDescriptor> getDeclarationsByLabel(String labelName) {
+        throw new UnsupportedOperationException(); // TODO
+    }
+
+    @Override
+    public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) {
+        throw new UnsupportedOperationException(); // TODO
+    }
+
+    @Override
+    @Nullable
+    public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() {
+        return workerScope.getDeclarationDescriptorForUnqualifiedThis();
+    }
+
+    @NotNull
+    @Override
+    public Collection<DeclarationDescriptor> getAllDescriptors() {
+        if (allDescriptors == null) {
+            allDescriptors = Sets.newHashSet();
+            for (DeclarationDescriptor descriptor : workerScope.getAllDescriptors()) {
+                DeclarationDescriptor substitute = substitute(descriptor);
+                assert substitute != null;
+                allDescriptors.add(substitute);
+            }
+        }
+        return allDescriptors;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WritableScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java
similarity index 84%
rename from idea/src/org/jetbrains/jet/lang/resolve/WritableScope.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java
index 0e7485b4d2f..f37b8ae6b16 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/WritableScope.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java
@@ -1,9 +1,9 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 /**
  * @author abreslav
@@ -30,5 +30,5 @@ public interface WritableScope extends JetScope {
 
     void importScope(@NotNull JetScope imported);
 
-    void setThisType(@NotNull JetType thisType);
+    void setImplicitReceiver(@NotNull ReceiverDescriptor implicitReceiver);
 }
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java
similarity index 69%
rename from idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java
index eb516af6b52..b63ee731480 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java
@@ -1,13 +1,12 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
+import com.google.common.collect.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ErrorHandler;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.util.CommonSuppliers;
 
 import java.util.*;
 
@@ -16,7 +15,7 @@ import java.util.*;
  */
 public class WritableScopeImpl extends WritableScopeWithImports {
 
-    private final Collection<DeclarationDescriptor> allDescriptors = Sets.newHashSet();
+    private final Collection<DeclarationDescriptor> allDescriptors = Sets.newLinkedHashSet();
     private boolean allDescriptorsDone = false;
 
     @NotNull
@@ -27,19 +26,18 @@ public class WritableScopeImpl extends WritableScopeWithImports {
     private Map<String, PropertyDescriptor> propertyDescriptorsByFieldNames;
 
     @Nullable
-    private Map<String, WritableFunctionGroup> functionGroups;
+    private SetMultimap<String, FunctionDescriptor> functionGroups;
     @Nullable
     private Map<String, DeclarationDescriptor> variableClassOrNamespaceDescriptors;
 
     @Nullable
     private Map<String, List<DeclarationDescriptor>> labelsToDescriptors;
+
     @Nullable
-    private JetType thisType;
+    private ReceiverDescriptor implicitReceiver;
 
-    private List<VariableDescriptor> variableDescriptors;
-
-    public WritableScopeImpl(@NotNull JetScope scope, @NotNull DeclarationDescriptor owner, @NotNull ErrorHandler errorHandler) {
-        super(scope, errorHandler);
+    public WritableScopeImpl(@NotNull JetScope scope, @NotNull DeclarationDescriptor owner, @NotNull RedeclarationHandler redeclarationHandler) {
+        super(scope, redeclarationHandler);
         this.ownerDeclarationDescriptor = owner;
     }
 
@@ -68,6 +66,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         super.importClassifierAlias(importedClassifierName, classifierDescriptor);
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (!allDescriptorsDone) {
@@ -124,26 +123,16 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         return variableClassOrNamespaceDescriptors;
     }
 
-    @NotNull
-    private List<VariableDescriptor> getVariableDescriptors() {
-        if (variableDescriptors == null) {
-            variableDescriptors = Lists.newArrayList();
-        }
-        return variableDescriptors;
-    }
-
     @Override
     public void addVariableDescriptor(@NotNull VariableDescriptor variableDescriptor) {
         Map<String, DeclarationDescriptor> variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors();
         DeclarationDescriptor existingDescriptor = variableClassOrNamespaceDescriptors.get(variableDescriptor.getName());
         if (existingDescriptor != null) {
-            errorHandler.redeclaration(existingDescriptor, variableDescriptor);
+            redeclarationHandler.handleRedeclaration(existingDescriptor, variableDescriptor);
         }
         // TODO : Should this always happen?
         variableClassOrNamespaceDescriptors.put(variableDescriptor.getName(), variableDescriptor);
         allDescriptors.add(variableDescriptor);
-
-        getVariableDescriptors().add(variableDescriptor);
     }
 
     @Override
@@ -154,13 +143,6 @@ public class WritableScopeImpl extends WritableScopeWithImports {
             return (VariableDescriptor) descriptor;
         }
 
-        if (thisType != null) {
-            VariableDescriptor variable = getThisType().getMemberScope().getVariable(name);
-            if (variable != null) {
-                return variable;
-            }
-        }
-
         VariableDescriptor variableDescriptor = getWorkerScope().getVariable(name);
         if (variableDescriptor != null) {
             return variableDescriptor;
@@ -169,87 +151,29 @@ public class WritableScopeImpl extends WritableScopeWithImports {
     }
 
     @NotNull
-    private Map<String, WritableFunctionGroup> getFunctionGroups() {
+    private SetMultimap<String, FunctionDescriptor> getFunctionGroups() {
         if (functionGroups == null) {
-            functionGroups = new HashMap<String, WritableFunctionGroup>();
+            functionGroups = CommonSuppliers.newLinkedHashSetHashSetMultimap();
         }
         return functionGroups;
     }
 
     @Override
     public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
-        String name = functionDescriptor.getName();
-        Map<String, WritableFunctionGroup> functionGroups = getFunctionGroups();
-
-        @Nullable
-        WritableFunctionGroup functionGroup = functionGroups.get(name);
-        if (functionGroup == null) {
-            functionGroup = new WritableFunctionGroup(name);
-            functionGroups.put(name, functionGroup);
-        }
-        functionGroup.addFunction(functionDescriptor);
+        getFunctionGroups().put(functionDescriptor.getName(), functionDescriptor);
         allDescriptors.add(functionDescriptor);
     }
 
     @Override
     @NotNull
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        addVariablesAsFunctions();
+    public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        Set<FunctionDescriptor> result = Sets.newLinkedHashSet(getFunctionGroups().get(name));
 
-        FunctionGroup functionGroup = getFunctionGroups().get(name);
-        FunctionGroup constructors = null;
-        ClassifierDescriptor classifier = getClassifier(name);
-        if (classifier instanceof ClassDescriptor) {
-            ClassDescriptor classDescriptor = (ClassDescriptor) classifier;
-            constructors = classDescriptor.getConstructors();
-        }
-        if (functionGroup != null && !functionGroup.isEmpty()) {
-            if (constructors != null) {
-                WritableFunctionGroup result = new WritableFunctionGroup(name);
-                for (FunctionDescriptor functionDescriptor : functionGroup.getFunctionDescriptors()) {
-                    result.addFunction(functionDescriptor);
-                }
-                for (FunctionDescriptor functionDescriptor : constructors.getFunctionDescriptors()) {
-                    result.addFunction(functionDescriptor);
-                }
-                return result;
-            }
-            return functionGroup;
-        }
+        result.addAll(getWorkerScope().getFunctions(name));
 
-        if (constructors != null && !constructors.isEmpty()) {
-            return constructors;
-        }
+        result.addAll(super.getFunctions(name));
 
-        if (thisType != null) {
-            functionGroup = getThisType().getMemberScope().getFunctionGroup(name);
-            if (!functionGroup.isEmpty()) {
-                return functionGroup;
-            }
-        }
-
-        // TODO : this logic is questionable
-        functionGroup = getWorkerScope().getFunctionGroup(name);
-        if (!functionGroup.isEmpty()) return functionGroup;
-//        for (JetScope imported : getImports()) {
-//            FunctionGroup importedDescriptor = imported.getFunctionGroup(name);
-//            if (!importedDescriptor.isEmpty()) {
-//                return importedDescriptor;
-//            }
-//        }
-//        return functionGroup;
-        return super.getFunctionGroup(name);
-    }
-
-    private void addVariablesAsFunctions() {
-        List<VariableDescriptor> variableDescriptors = getVariableDescriptors();
-        this.variableDescriptors = null;
-        for (VariableDescriptor variableDescriptor : variableDescriptors) {
-            JetType outType = variableDescriptor.getOutType();
-            if (outType != null && JetStandardClasses.isFunctionType(outType)) {
-                addFunctionDescriptor(VariableAsFunctionDescriptor.create(variableDescriptor));
-            }
-        }
+        return result;
     }
 
     @Override
@@ -268,7 +192,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         Map<String, DeclarationDescriptor> variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors();
         DeclarationDescriptor originalDescriptor = variableClassOrNamespaceDescriptors.get(name);
         if (originalDescriptor != null) {
-            errorHandler.redeclaration(originalDescriptor, classifierDescriptor);
+            redeclarationHandler.handleRedeclaration(originalDescriptor, classifierDescriptor);
         }
         variableClassOrNamespaceDescriptors.put(name, classifierDescriptor);
         allDescriptors.add(classifierDescriptor);
@@ -288,11 +212,11 @@ public class WritableScopeImpl extends WritableScopeWithImports {
 
     @NotNull
     @Override
-    public JetType getThisType() {
-        if (thisType == null) {
-            return super.getThisType();
+    public ReceiverDescriptor getImplicitReceiver() {
+        if (implicitReceiver == null) {
+            return super.getImplicitReceiver();
         }
-        return thisType;
+        return implicitReceiver;
     }
 
     @Override
@@ -300,7 +224,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         Map<String, DeclarationDescriptor> variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors();
         DeclarationDescriptor oldValue = variableClassOrNamespaceDescriptors.put(namespaceDescriptor.getName(), namespaceDescriptor);
         if (oldValue != null) {
-            errorHandler.redeclaration(oldValue, namespaceDescriptor);
+            redeclarationHandler.handleRedeclaration(oldValue, namespaceDescriptor);
         }
         allDescriptors.add(namespaceDescriptor);
     }
@@ -324,11 +248,19 @@ public class WritableScopeImpl extends WritableScopeWithImports {
     }
 
     @Override
-    public void setThisType(@NotNull JetType thisType) {
-        if (this.thisType != null) {
+    public void setImplicitReceiver(@NotNull ReceiverDescriptor implicitReceiver) {
+        if (this.implicitReceiver != null) {
             throw new UnsupportedOperationException("Receiver redeclared");
         }
-        this.thisType = thisType;
+        this.implicitReceiver = implicitReceiver;
+    }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+        if (implicitReceiver != null && implicitReceiver.exists()) {
+            result.add(implicitReceiver);
+        }
+        super.getImplicitReceiversHierarchy(result);
     }
 
     @SuppressWarnings({"NullableProblems"})
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java
similarity index 79%
rename from idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java
index 8fdb9473559..b88a8d17be3 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java
@@ -1,15 +1,17 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ErrorHandler;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionGroup;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -21,11 +23,11 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
     @Nullable
     private List<JetScope> imports;
     private WritableScope currentIndividualImportScope;
-    protected final ErrorHandler errorHandler;
+    protected final RedeclarationHandler redeclarationHandler;
 
-    public WritableScopeWithImports(@NotNull JetScope scope, @NotNull ErrorHandler errorHandler) {
+    public WritableScopeWithImports(@NotNull JetScope scope, @NotNull RedeclarationHandler redeclarationHandler) {
         super(scope);
-        this.errorHandler = errorHandler;
+        this.redeclarationHandler = redeclarationHandler;
     }
 
     public WritableScopeWithImports setDebugName(@NotNull String debugName) {
@@ -62,14 +64,15 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
 
     @NotNull
     @Override
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        for (JetScope imported : getImports()) {
-            FunctionGroup importedDescriptor = imported.getFunctionGroup(name);
-            if (!importedDescriptor.isEmpty()) {
-                return importedDescriptor;
-            }
+    public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        if (getImports().isEmpty()) {
+            return Collections.emptySet();
         }
-        return FunctionGroup.EMPTY;
+        Set<FunctionDescriptor> result = Sets.newLinkedHashSet();
+        for (JetScope imported : getImports()) {
+            result.addAll(imported.getFunctions(name));
+        }
+        return result;
     }
 
     @Override
@@ -96,7 +99,7 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
 
     public void importClassifierAlias(@NotNull String importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor) {
         if (currentIndividualImportScope == null) {
-            WritableScopeImpl writableScope = new WritableScopeImpl(JetScope.EMPTY, getContainingDeclaration(), ErrorHandler.DO_NOTHING).setDebugName("Individual import scope");
+            WritableScopeImpl writableScope = new WritableScopeImpl(EMPTY, getContainingDeclaration(), RedeclarationHandler.DO_NOTHING).setDebugName("Individual import scope");
             importScope(writableScope);
             currentIndividualImportScope = writableScope;
         }
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WriteThroughScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java
similarity index 82%
rename from idea/src/org/jetbrains/jet/lang/resolve/WriteThroughScope.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java
index f154255f6ad..fb5e6e6a8b5 100644
--- a/idea/src/org/jetbrains/jet/lang/resolve/WriteThroughScope.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java
@@ -1,13 +1,14 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ErrorHandler;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -16,8 +17,8 @@ public class WriteThroughScope extends WritableScopeWithImports {
     private final WritableScope writableWorker;
     private Collection<DeclarationDescriptor> allDescriptors;
 
-    public WriteThroughScope(@NotNull JetScope outerScope, @NotNull WritableScope scope, @NotNull ErrorHandler errorHandler) {
-        super(outerScope, errorHandler);
+    public WriteThroughScope(@NotNull JetScope outerScope, @NotNull WritableScope scope, @NotNull RedeclarationHandler redeclarationHandler) {
+        super(outerScope, redeclarationHandler);
         this.writableWorker = scope;
     }
 
@@ -41,20 +42,22 @@ public class WriteThroughScope extends WritableScopeWithImports {
 
     @Override
     @NotNull
-    public JetType getThisType() {
-        return writableWorker.getThisType();
+    public ReceiverDescriptor getImplicitReceiver() {
+        return writableWorker.getImplicitReceiver();
     }
 
     @Override
     @NotNull
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        FunctionGroup functionGroup = writableWorker.getFunctionGroup(name);
-        if (!functionGroup.isEmpty()) return functionGroup; // TODO : Overloads from different places
+    public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        Set<FunctionDescriptor> result = Sets.newLinkedHashSet();
 
-        functionGroup = getWorkerScope().getFunctionGroup(name);
-        if (!functionGroup.isEmpty()) return functionGroup; // TODO : Overloads from different places
+        result.addAll(writableWorker.getFunctions(name));
 
-        return super.getFunctionGroup(name); // Imports
+        result.addAll(getWorkerScope().getFunctions(name));
+
+        result.addAll(super.getFunctions(name)); // Imports
+
+        return result;
     }
 
     @Override
@@ -145,10 +148,11 @@ public class WriteThroughScope extends WritableScopeWithImports {
     }
 
     @Override
-    public void setThisType(@NotNull JetType thisType) {
-        writableWorker.setThisType(thisType);
+    public void setImplicitReceiver(@NotNull ReceiverDescriptor implicitReceiver) {
+        writableWorker.setImplicitReceiver(implicitReceiver);
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (allDescriptors == null) {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/AbstractReceiverDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/AbstractReceiverDescriptor.java
new file mode 100644
index 00000000000..64cf9dcbbf8
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/AbstractReceiverDescriptor.java
@@ -0,0 +1,26 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * @author abreslav
+ */
+public abstract class AbstractReceiverDescriptor implements ReceiverDescriptor {
+    protected final JetType receiverType;
+
+    public AbstractReceiverDescriptor(@NotNull JetType receiverType) {
+        this.receiverType = receiverType;
+    }
+
+    @Override
+    @NotNull
+    public JetType getType() {
+        return receiverType;
+    }
+
+    @Override
+    public boolean exists() {
+        return true;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ClassReceiver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ClassReceiver.java
new file mode 100644
index 00000000000..85be4e2f593
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ClassReceiver.java
@@ -0,0 +1,19 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+
+/**
+ * @author abreslav
+ */
+public class ClassReceiver extends ImplicitReceiverDescriptor {
+
+    public ClassReceiver(ClassDescriptor classDescriptor) {
+        super(classDescriptor, classDescriptor.getDefaultType());
+    }
+
+    @Override
+    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitClassReceiver(this, data);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExpressionReceiver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExpressionReceiver.java
new file mode 100644
index 00000000000..d7a50974481
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExpressionReceiver.java
@@ -0,0 +1,28 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * @author abreslav
+ */
+public class ExpressionReceiver extends AbstractReceiverDescriptor implements ReceiverDescriptor {
+
+    private final JetExpression expression;
+
+    public ExpressionReceiver(@NotNull JetExpression expression, @NotNull JetType type) {
+        super(type);
+        this.expression = expression;
+    }
+
+    @NotNull
+    public JetExpression getExpression() {
+        return expression;
+    }
+
+    @Override
+    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitExpressionReceiver(this, data);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExtensionReceiver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExtensionReceiver.java
new file mode 100644
index 00000000000..834b1420c42
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExtensionReceiver.java
@@ -0,0 +1,20 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * @author abreslav
+ */
+public class ExtensionReceiver extends ImplicitReceiverDescriptor {
+
+    public ExtensionReceiver(@NotNull CallableDescriptor callableDescriptor, @NotNull JetType receiverType) {
+        super(callableDescriptor, receiverType);
+    }
+
+    @Override
+    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitExtensionReceiver(this, data);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ImplicitReceiverDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ImplicitReceiverDescriptor.java
new file mode 100644
index 00000000000..4c566658f83
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ImplicitReceiverDescriptor.java
@@ -0,0 +1,25 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * Describes a "this" receiver
+ *
+ * @author abreslav
+ */
+public abstract class ImplicitReceiverDescriptor extends AbstractReceiverDescriptor {
+    private final DeclarationDescriptor declarationDescriptor;
+
+    protected ImplicitReceiverDescriptor(@NotNull DeclarationDescriptor declarationDescriptor, @NotNull JetType receiverType) {
+        super(receiverType);
+        this.declarationDescriptor = declarationDescriptor;
+    }
+
+    @NotNull
+    public DeclarationDescriptor getDeclarationDescriptor() {
+        return declarationDescriptor;
+    }
+}
+
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverDescriptor.java
new file mode 100644
index 00000000000..df07e5769d5
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverDescriptor.java
@@ -0,0 +1,40 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * @author abreslav
+ */
+public interface ReceiverDescriptor {
+
+    ReceiverDescriptor NO_RECEIVER = new ReceiverDescriptor() {
+        @NotNull
+        @Override
+        public JetType getType() {
+            throw new UnsupportedOperationException("NO_RECEIVER.getType()");
+        }
+
+        @Override
+        public boolean exists() {
+            return false;
+        }
+
+        @Override
+        public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+            return visitor.visitNoReceiver(this, data);
+        }
+
+        @Override
+        public String toString() {
+            return "NO_RECEIVER";
+        }
+    };
+
+    @NotNull
+    JetType getType();
+
+    boolean exists();
+
+    <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data);
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverDescriptorVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverDescriptorVisitor.java
new file mode 100644
index 00000000000..f7ba43b15aa
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverDescriptorVisitor.java
@@ -0,0 +1,26 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+/**
+ * @author abreslav
+ */
+public class ReceiverDescriptorVisitor<R, D> {
+    public R visitNoReceiver(ReceiverDescriptor noReceiver, D data) {
+        return null;
+    }
+
+    public R visitTransientReceiver(TransientReceiver receiver, D data) {
+        return null;
+    }
+
+    public R visitExtensionReceiver(ExtensionReceiver receiver, D data) {
+        return null;
+    }
+
+    public R visitExpressionReceiver(ExpressionReceiver receiver, D data) {
+        return null;
+    }
+
+    public R visitClassReceiver(ClassReceiver classReceiver, D data) {
+        return null;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/TransientReceiver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/TransientReceiver.java
new file mode 100644
index 00000000000..ca79ac48409
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/TransientReceiver.java
@@ -0,0 +1,21 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * This represents the receiver of hasNext and next() in for-loops
+ * Cannot be an expression receiver because there is no expression for the iterator() call
+ *
+ * @author abreslav
+ */
+public class TransientReceiver extends AbstractReceiverDescriptor {
+    public TransientReceiver(@NotNull JetType type) {
+        super(type);
+    }
+
+    @Override
+    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitTransientReceiver(this, data);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/CallMaker.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/CallMaker.java
new file mode 100644
index 00000000000..8da61d725d0
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/CallMaker.java
@@ -0,0 +1,135 @@
+package org.jetbrains.jet.lang.types;
+
+import com.google.common.collect.Lists;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.psi.*;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author abreslav
+ */
+public class CallMaker {
+
+    private static class ExpressionValueArgument implements ValueArgument {
+
+        private final JetExpression expression;
+        private final PsiElement reportErrorsOn;
+
+        private ExpressionValueArgument(@NotNull JetExpression expression) {
+            this(expression, expression);
+        }
+
+        private ExpressionValueArgument(@Nullable JetExpression expression, @NotNull PsiElement reportErrorsOn) {
+            this.expression = expression;
+            this.reportErrorsOn = expression == null ? reportErrorsOn : expression;
+        }
+
+        @Override
+        public JetExpression getArgumentExpression() {
+            return expression;
+        }
+
+        @Override
+        public JetValueArgumentName getArgumentName() {
+            return null;
+        }
+
+        @Override
+        public boolean isNamed() {
+            return false;
+        }
+
+        @Override
+        public boolean isOut() {
+            return false;
+        }
+
+        @Override
+        public boolean isRef() {
+            return false;
+        }
+
+        @NotNull
+        @Override
+        public PsiElement asElement() {
+            return reportErrorsOn;
+        }
+
+    }
+    private static abstract class CallStub implements Call {
+
+        @Override
+        public JetValueArgumentList getValueArgumentList() {
+            return null;
+        }
+        @NotNull
+        @Override
+        public List<JetExpression> getFunctionLiteralArguments() {
+            return Collections.emptyList();
+        }
+
+        @NotNull
+        @Override
+        public List<JetTypeProjection> getTypeArguments() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public JetTypeArgumentList getTypeArgumentList() {
+            return null;
+        }
+
+    }
+    public static Call makeCallWithArguments(final JetExpression calleeExpression, final List<? extends ValueArgument> valueArguments) {
+        return new CallStub() {
+            @Override
+            public JetExpression getCalleeExpression() {
+                return calleeExpression;
+            }
+
+            @NotNull
+            @Override
+            public List<? extends ValueArgument> getValueArguments() {
+                return valueArguments;
+            }
+        };
+    }
+
+    public static Call makeCall(final JetExpression calleeExpression, final List<JetExpression> argumentExpressions) {
+        List<ValueArgument> arguments = Lists.newArrayList();
+        for (JetExpression argumentExpression : argumentExpressions) {
+            arguments.add(makeValueArgument(argumentExpression, calleeExpression));
+        }
+        return makeCallWithArguments(calleeExpression, arguments);
+    }
+
+    public static Call makeCall(final JetBinaryExpression expression) {
+        return makeCall(expression.getOperationReference(), Collections.singletonList(expression.getRight()));
+    }
+
+    public static Call makeCall(final JetUnaryExpression expression) {
+        return makeCallWithArguments(expression.getOperationSign(), Collections.<ValueArgument>emptyList());
+    }
+
+    public static Call makeCall(final JetArrayAccessExpression arrayAccessExpression, final JetExpression rightHandSide) {
+        List<JetExpression> arguments = Lists.newArrayList(arrayAccessExpression.getIndexExpressions());
+        arguments.add(rightHandSide);
+        return makeCall(arrayAccessExpression, arguments);
+    }
+
+    public static ValueArgument makeValueArgument(@NotNull JetExpression expression) {
+        return makeValueArgument(expression, expression);
+    }
+
+    public static ValueArgument makeValueArgument(@Nullable JetExpression expression, @NotNull PsiElement reportErrorsOn) {
+        return new ExpressionValueArgument(expression, reportErrorsOn);
+    }
+
+    public static Call makePropertyCall(@NotNull JetSimpleNameExpression nameExpression) {
+        return makeCall(nameExpression, Collections.<JetExpression>emptyList());
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/CompositeTypeSubstitution.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/CompositeTypeSubstitution.java
new file mode 100644
index 00000000000..55cf5134be5
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/CompositeTypeSubstitution.java
@@ -0,0 +1,31 @@
+package org.jetbrains.jet.lang.types;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class CompositeTypeSubstitution implements TypeSubstitutor.TypeSubstitution {
+    private final TypeSubstitutor.TypeSubstitution[] inner;
+
+    public CompositeTypeSubstitution(@NotNull TypeSubstitutor.TypeSubstitution... inner) {
+        this.inner = inner;
+    }
+
+    @Override
+    public TypeProjection get(TypeConstructor key) {
+        for (TypeSubstitutor.TypeSubstitution substitution : inner) {
+            TypeProjection value = substitution.get(key);
+            if (value != null) return value;
+        }
+        return null;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        for (TypeSubstitutor.TypeSubstitution substitution : inner) {
+            if (!substitution.isEmpty()) return false;
+        }
+        return true;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/types/DataFlowInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/DataFlowInfo.java
similarity index 96%
rename from idea/src/org/jetbrains/jet/lang/types/DataFlowInfo.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/DataFlowInfo.java
index 43df5303f56..04ac9f08f6b 100644
--- a/idea/src/org/jetbrains/jet/lang/types/DataFlowInfo.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/DataFlowInfo.java
@@ -1,10 +1,10 @@
 package org.jetbrains.jet.lang.types;
 
-import com.google.common.base.Supplier;
 import com.google.common.collect.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
+import org.jetbrains.jet.util.CommonSuppliers;
 
 import java.util.*;
 
@@ -31,13 +31,7 @@ public class DataFlowInfo {
         }
     };
 
-    public static final Supplier<List<JetType>> ARRAY_LIST_SUPPLIER = new Supplier<List<JetType>>() {
-        @Override
-        public List<JetType> get() {
-            return Lists.newArrayList();
-        }
-    };
-    private static DataFlowInfo EMPTY = new DataFlowInfo(ImmutableMap.<VariableDescriptor, NullabilityFlags>of(), Multimaps.newListMultimap(Collections.<VariableDescriptor, Collection<JetType>>emptyMap(), ARRAY_LIST_SUPPLIER));
+    private static DataFlowInfo EMPTY = new DataFlowInfo(ImmutableMap.<VariableDescriptor, NullabilityFlags>of(), Multimaps.newListMultimap(Collections.<VariableDescriptor, Collection<JetType>>emptyMap(), CommonSuppliers.<JetType>getArrayListSupplier()));
 
     public static DataFlowInfo getEmpty() {
         return EMPTY;
@@ -147,7 +141,7 @@ public class DataFlowInfo {
     }
 
     private ListMultimap<VariableDescriptor, JetType> copyTypeInfo() {
-        ListMultimap<VariableDescriptor, JetType> newTypeInfo = Multimaps.newListMultimap(Maps.<VariableDescriptor, Collection<JetType>>newHashMap(), ARRAY_LIST_SUPPLIER);
+        ListMultimap<VariableDescriptor, JetType> newTypeInfo = Multimaps.newListMultimap(Maps.<VariableDescriptor, Collection<JetType>>newHashMap(), CommonSuppliers.<JetType>getArrayListSupplier());
         newTypeInfo.putAll(typeInfo);
         return newTypeInfo;
     }
@@ -163,7 +157,7 @@ public class DataFlowInfo {
             builder.put(variableDescriptor, thisFlags.or(otherFlags));
         }
 
-        ListMultimap<VariableDescriptor, JetType> newTypeInfo = copyTypeInfo();
+        ListMultimap<VariableDescriptor, JetType> newTypeInfo = Multimaps.newListMultimap(Maps.<VariableDescriptor, Collection<JetType>>newHashMap(), CommonSuppliers.<JetType>getArrayListSupplier());
 
         Set<VariableDescriptor> keys = newTypeInfo.keySet();
         keys.retainAll(other.typeInfo.keySet());
diff --git a/idea/src/org/jetbrains/jet/lang/types/DeferredType.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java
similarity index 73%
rename from idea/src/org/jetbrains/jet/lang/types/DeferredType.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java
index fae49326ec9..d97ae1c5a64 100644
--- a/idea/src/org/jetbrains/jet/lang/types/DeferredType.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java
@@ -2,17 +2,28 @@ package org.jetbrains.jet.lang.types;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.List;
 
+import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE;
+import static org.jetbrains.jet.lang.resolve.BindingContext.DeferredTypeKey.DEFERRED_TYPE_KEY;
+
 /**
  * @author abreslav
  */
 public class DeferredType implements JetType {
+    
+    public static DeferredType create(BindingTrace trace, LazyValue<JetType> lazyValue) {
+        DeferredType deferredType = new DeferredType(lazyValue);
+        trace.record(DEFERRED_TYPE, DEFERRED_TYPE_KEY, deferredType);
+        return deferredType;
+    }
+    
     private final LazyValue<JetType> lazyValue;
 
-    public DeferredType(LazyValue<JetType> lazyValue) {
+    private DeferredType(LazyValue<JetType> lazyValue) {
         this.lazyValue = lazyValue;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/DescriptorSubstitutor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/DescriptorSubstitutor.java
new file mode 100644
index 00000000000..3d29ab80a1d
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/DescriptorSubstitutor.java
@@ -0,0 +1,59 @@
+package org.jetbrains.jet.lang.types;
+
+import com.google.common.collect.Maps;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author abreslav
+ */
+public class DescriptorSubstitutor {
+
+    @NotNull
+    public static TypeSubstitutor substituteTypeParameters(
+            @NotNull List<TypeParameterDescriptor> typeParameters,
+            @NotNull final TypeSubstitutor originalSubstitutor,
+            @NotNull DeclarationDescriptor newContainingDeclaration,
+            @NotNull List<TypeParameterDescriptor> result) {
+        final Map<TypeConstructor, TypeProjection> mutableSubstitution = Maps.newHashMap();
+        TypeSubstitutor substitutor = TypeSubstitutor.create(new TypeSubstitutor.TypeSubstitution() {
+
+            @Override
+            public TypeProjection get(TypeConstructor key) {
+                if (originalSubstitutor.inRange(key)) {
+                    return originalSubstitutor.getSubstitution().get(key);
+                }
+                return mutableSubstitution.get(key);
+            }
+
+            @Override
+            public boolean isEmpty() {
+                return originalSubstitutor.isEmpty() && mutableSubstitution.isEmpty();
+            }
+        });
+
+        for (TypeParameterDescriptor descriptor : typeParameters) {
+            TypeParameterDescriptor substituted = TypeParameterDescriptor.createForFurtherModification(
+                    newContainingDeclaration,
+                    descriptor.getAnnotations(),
+                    descriptor.getVariance(),
+                    descriptor.getName(),
+                    descriptor.getIndex());
+
+            mutableSubstitution.put(descriptor.getTypeConstructor(), new TypeProjection(substituted.getDefaultType()));
+
+            for (JetType upperBound : descriptor.getUpperBounds()) {
+                substituted.getUpperBounds().add(substitutor.substitute(upperBound, Variance.INVARIANT));
+            }
+
+            result.add(substituted);
+        }
+
+        return substitutor;
+    }
+
+}
diff --git a/idea/src/org/jetbrains/jet/lang/types/DfsNodeHandler.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/DfsNodeHandler.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/types/DfsNodeHandler.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/DfsNodeHandler.java
diff --git a/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java
similarity index 83%
rename from idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java
index da723b2ce6d..6e5761683d0 100644
--- a/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java
@@ -3,8 +3,8 @@ package org.jetbrains.jet.lang.types;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.OverloadResolutionResult;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.*;
 
@@ -33,13 +33,17 @@ public class ErrorUtils {
 
         @NotNull
         @Override
-        public JetType getThisType() {
-            return createErrorType("<ERROR TYPE>");
+        public ReceiverDescriptor getImplicitReceiver() {
+            return ReceiverDescriptor.NO_RECEIVER;
+        }
+
+        @Override
+        public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
         }
 
         @NotNull
         @Override
-        public FunctionGroup getFunctionGroup(@NotNull String name) {
+        public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
             return ERROR_FUNCTION_GROUP;
         }
 
@@ -65,6 +69,7 @@ public class ErrorUtils {
             return ERROR_CLASS; // TODO : review
         }
 
+        @NotNull
         @Override
         public Collection<DeclarationDescriptor> getAllDescriptors() {
             return Collections.emptyList();
@@ -72,40 +77,17 @@ public class ErrorUtils {
 
     };
 
-    private static final FunctionGroup ERROR_FUNCTION_GROUP = new FunctionGroup() {
-        @NotNull
-        @Override
-        public String getName() {
-            return "<ERROR FUNCTION>";
-        }
-
-        @NotNull
-        @Override
-        public OverloadResolutionResult getPossiblyApplicableFunctions(@NotNull List<JetType> typeArguments, @NotNull List<JetType> positionedValueArgumentTypes) {
-            List<TypeParameterDescriptor> typeParameters = Collections.<TypeParameterDescriptor>emptyList();
-            return OverloadResolutionResult.success(createErrorFunction(typeParameters, positionedValueArgumentTypes));
-        }
-
-        @Override
-        public boolean isEmpty() {
-            return false;
-        }
-
-        @NotNull
-        @Override
-        public Set<FunctionDescriptor> getFunctionDescriptors() {
-            return Collections.singleton(createErrorFunction(0, Collections.<JetType>emptyList()));
-        }
-    };
-
     private static final ClassDescriptorImpl ERROR_CLASS = new ClassDescriptorImpl(ERROR_MODULE, Collections.<AnnotationDescriptor>emptyList(), "<ERROR CLASS>") {
         @NotNull
         @Override
-        public FunctionGroup getConstructors() {
+        public Set<FunctionDescriptor> getConstructors() {
             return ERROR_FUNCTION_GROUP;
         }
     };
+
+    private static final Set<FunctionDescriptor> ERROR_FUNCTION_GROUP = Collections.singleton(createErrorFunction(0, Collections.<JetType>emptyList()));
     private static final ConstructorDescriptor ERROR_CONSTRUCTOR = new ConstructorDescriptorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), true);
+
     static {
         ERROR_CLASS.initialize(
             true, Collections.<TypeParameterDescriptor>emptyList(), Collections.<JetType>emptyList(), getErrorScope(), ERROR_FUNCTION_GROUP, ERROR_CONSTRUCTOR);
@@ -119,7 +101,8 @@ public class ErrorUtils {
     private static final VariableDescriptor ERROR_PROPERTY = new PropertyDescriptor(
             ERROR_CLASS,
             Collections.<AnnotationDescriptor>emptyList(),
-            new MemberModifiers(false, false, false),
+            Modality.OPEN,
+            Visibility.INTERNAL,
             true,
             null,
             "<ERROR PROPERTY>",
@@ -131,7 +114,9 @@ public class ErrorUtils {
                 null,
                 typeParameters,
                 getValueParameters(functionDescriptor, positionedValueArgumentTypes),
-                createErrorType("<ERROR FUNCTION RETURN>")
+                createErrorType("<ERROR FUNCTION RETURN>"),
+                Modality.OPEN,
+                Visibility.INTERNAL
         );
     }
 
@@ -140,7 +125,9 @@ public class ErrorUtils {
                 null,
                 Collections.<TypeParameterDescriptor>emptyList(), // TODO
                 Collections.<ValueParameterDescriptor>emptyList(), // TODO
-                createErrorType("<ERROR FUNCTION RETURN TYPE>")
+                createErrorType("<ERROR FUNCTION RETURN TYPE>"),
+                Modality.OPEN,
+                Visibility.INTERNAL
         );
     }
 
@@ -189,6 +176,10 @@ public class ErrorUtils {
                isError(type.getConstructor()));
     }
 
+    public static boolean isError(@NotNull DeclarationDescriptor candidate) {
+        return candidate.getContainingDeclaration() == getErrorClass() || candidate == ERROR_MODULE;
+    }
+
     private static class ErrorTypeImpl implements JetType {
 
         private final TypeConstructor constructor;
diff --git a/idea/src/org/jetbrains/jet/lang/types/JetStandardClasses.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java
similarity index 95%
rename from idea/src/org/jetbrains/jet/lang/types/JetStandardClasses.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java
index 99908070b95..41774dc14c4 100644
--- a/idea/src/org/jetbrains/jet/lang/types/JetStandardClasses.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java
@@ -4,13 +4,9 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ErrorHandler;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.JetScopeImpl;
-import org.jetbrains.jet.lang.resolve.WritableScope;
-import org.jetbrains.jet.lang.resolve.WritableScopeImpl;
+import org.jetbrains.jet.lang.resolve.scopes.*;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
@@ -52,7 +48,8 @@ public class JetStandardClasses {
                 }
             },
             JetScope.EMPTY,
-            FunctionGroup.EMPTY,
+            Collections.<FunctionDescriptor>emptySet(),
+            null,
             null
     );
 
@@ -74,7 +71,8 @@ public class JetStandardClasses {
             Collections.<TypeParameterDescriptor>emptyList(),
             Collections.<JetType>emptySet(),
             JetScope.EMPTY,
-            FunctionGroup.EMPTY,
+            Collections.<FunctionDescriptor>emptySet(),
+            null,
             null
     );
 
@@ -99,7 +97,6 @@ public class JetStandardClasses {
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     public static final JetScope STUB = JetScope.EMPTY;
-    public static final FunctionGroup STUB_FG = FunctionGroup.EMPTY;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -126,7 +123,7 @@ public class JetStandardClasses {
                     parameters,
                     Collections.singleton(getAnyType()),
                     STUB,
-                    STUB_FG,
+                    Collections.<FunctionDescriptor>emptySet(), // TODO
                     null); // TODO : constructor
             TUPLE_CONSTRUCTORS.add(TUPLE[i].getTypeConstructor());
         }
@@ -151,7 +148,7 @@ public class JetStandardClasses {
             FUNCTION[i] = function.initialize(
                     false,
                     createTypeParameters(i, function),
-                    Collections.singleton(getAnyType()), STUB, FunctionGroup.EMPTY, null);
+                    Collections.singleton(getAnyType()), STUB, Collections.<FunctionDescriptor>emptySet(), null);
             FUNCTION_TYPE_CONSTRUCTORS.add(FUNCTION[i].getTypeConstructor());
 
             ClassDescriptorImpl receiverFunction = new ClassDescriptorImpl(
@@ -166,7 +163,7 @@ public class JetStandardClasses {
             RECEIVER_FUNCTION[i] = receiverFunction.initialize(
                     false,
                     parameters,
-                    Collections.singleton(getAnyType()), STUB, FunctionGroup.EMPTY, null);
+                    Collections.singleton(getAnyType()), STUB, Collections.<FunctionDescriptor>emptySet(), null);
             RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.add(RECEIVER_FUNCTION[i].getTypeConstructor());
         }
     }
@@ -196,7 +193,7 @@ public class JetStandardClasses {
     /*package*/ static final JetScope STANDARD_CLASSES;
 
     static {
-        WritableScope writableScope = new WritableScopeImpl(JetScope.EMPTY, STANDARD_CLASSES_NAMESPACE, ErrorHandler.DO_NOTHING).setDebugName("JetStandardClasses.STANDARD_CLASSES");
+        WritableScope writableScope = new WritableScopeImpl(JetScope.EMPTY, STANDARD_CLASSES_NAMESPACE, RedeclarationHandler.DO_NOTHING).setDebugName("JetStandardClasses.STANDARD_CLASSES");
         STANDARD_CLASSES = writableScope;
         writableScope.addClassifierAlias("Unit", getTuple(0));
 
diff --git a/idea/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java
similarity index 59%
rename from idea/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java
index 29c67d84591..2036d25cafb 100644
--- a/idea/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java
@@ -4,12 +4,16 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.psi.PsiFileFactory;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ErrorHandler;
 import org.jetbrains.jet.lang.JetSemanticServices;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.plugin.JetFileType;
 
 import java.io.IOException;
@@ -17,6 +21,7 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -66,10 +71,44 @@ public class JetStandardLibrary {
     private final JetType doubleType;
     private final JetType booleanType;
     private final JetType stringType;
+
+    private final JetType nullableByteType;
+    private final JetType nullableCharType;
+    private final JetType nullableShortType;
+    private final JetType nullableIntType;
+    private final JetType nullableLongType;
+    private final JetType nullableFloatType;
+    private final JetType nullableDoubleType;
+    private final JetType nullableBooleanType;
+    private final JetType nullableTuple0Type;
+
+    private final ClassDescriptor byteArrayClass;
+    private final ClassDescriptor charArrayClass;
+    private final ClassDescriptor shortArrayClass;
+    private final ClassDescriptor intArrayClass;
+    private final ClassDescriptor longArrayClass;
+    private final ClassDescriptor floatArrayClass;
+    private final ClassDescriptor doubleArrayClass;
+    private final ClassDescriptor booleanArrayClass;
+
+    private final JetType byteArrayType;
+    private final JetType charArrayType;
+    private final JetType shortArrayType;
+    private final JetType intArrayType;
+    private final JetType longArrayType;
+    private final JetType floatArrayType;
+    private final JetType doubleArrayType;
+    private final JetType booleanArrayType;
+
+    public JetType getTuple0Type() {
+        return tuple0Type;
+    }
+
+    private final JetType tuple0Type;
     private final JetType nullableStringType;
 
     private final NamespaceDescriptor typeInfoNamespace;
-    private final FunctionGroup typeInfoFunction;
+    private final Set<FunctionDescriptor> typeInfoFunction;
 
     private JetStandardLibrary(@NotNull Project project) {
         // TODO : review
@@ -81,13 +120,13 @@ public class JetStandardLibrary {
 
             JetSemanticServices bootstrappingSemanticServices = JetSemanticServices.createSemanticServices(this);
             BindingTraceContext bindingTraceContext = new BindingTraceContext();
-            TopDownAnalyzer bootstrappingTDA = new TopDownAnalyzer(bootstrappingSemanticServices, bindingTraceContext);
-            WritableScopeImpl writableScope = new WritableScopeImpl(JetStandardClasses.STANDARD_CLASSES, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, ErrorHandler.THROW_EXCEPTION).setDebugName("Root bootstrap scope");
+            WritableScopeImpl writableScope = new WritableScopeImpl(JetStandardClasses.STANDARD_CLASSES, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, RedeclarationHandler.THROW_EXCEPTION).setDebugName("Root bootstrap scope");
 //            this.libraryScope = bootstrappingTDA.process(JetStandardClasses.STANDARD_CLASSES, file.getRootNamespace().getDeclarations());
 //            bootstrappingTDA.process(writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file.getRootNamespace().getDeclarations());
-            bootstrappingTDA.processStandardLibraryNamespace(writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file.getRootNamespace());
+            TopDownAnalyzer.processStandardLibraryNamespace(bootstrappingSemanticServices, bindingTraceContext, writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file.getRootNamespace());
             this.libraryScope = JetStandardClasses.STANDARD_CLASSES_NAMESPACE.getMemberScope();
-            AnalyzingUtils.applyHandler(ErrorHandler.THROW_EXCEPTION, bindingTraceContext.getBindingContext());
+
+            AnalyzingUtils.throwExceptionOnErrors(bindingTraceContext.getBindingContext());
 
             this.byteClass = (ClassDescriptor) libraryScope.getClassifier("Byte");
             this.charClass = (ClassDescriptor) libraryScope.getClassifier("Char");
@@ -102,7 +141,7 @@ public class JetStandardLibrary {
             this.iterableClass = (ClassDescriptor) libraryScope.getClassifier("Iterable");
             typeInfoNamespace = libraryScope.getNamespace("typeinfo");
             this.typeInfoClass = (ClassDescriptor) typeInfoNamespace.getMemberScope().getClassifier("TypeInfo");
-            typeInfoFunction = typeInfoNamespace.getMemberScope().getFunctionGroup("typeinfo");
+            typeInfoFunction = typeInfoNamespace.getMemberScope().getFunctions("typeinfo");
 
             this.byteType = new JetTypeImpl(getByte());
             this.charType = new JetTypeImpl(getChar());
@@ -113,7 +152,36 @@ public class JetStandardLibrary {
             this.doubleType = new JetTypeImpl(getDouble());
             this.booleanType = new JetTypeImpl(getBoolean());
             this.stringType = new JetTypeImpl(getString());
+            this.tuple0Type = new JetTypeImpl(JetStandardClasses.getTuple(0));
+
+            this.byteArrayClass = (ClassDescriptor) libraryScope.getClassifier("ByteArray");
+            this.charArrayClass = (ClassDescriptor) libraryScope.getClassifier("CharArray");
+            this.shortArrayClass = (ClassDescriptor) libraryScope.getClassifier("ShortArray");
+            this.intArrayClass = (ClassDescriptor) libraryScope.getClassifier("IntArray");
+            this.longArrayClass = (ClassDescriptor) libraryScope.getClassifier("LongArray");
+            this.floatArrayClass = (ClassDescriptor) libraryScope.getClassifier("FloatArray");
+            this.doubleArrayClass = (ClassDescriptor) libraryScope.getClassifier("DoubleArray");
+            this.booleanArrayClass = (ClassDescriptor) libraryScope.getClassifier("BooleanArray");
+
+            this.byteArrayType = new JetTypeImpl(byteArrayClass);
+            this.charArrayType = new JetTypeImpl(charArrayClass);
+            this.shortArrayType = new JetTypeImpl(shortArrayClass);
+            this.intArrayType = new JetTypeImpl(intArrayClass);
+            this.longArrayType = new JetTypeImpl(longArrayClass);
+            this.floatArrayType = new JetTypeImpl(floatArrayClass);
+            this.doubleArrayType = new JetTypeImpl(doubleArrayClass);
+            this.booleanArrayType = new JetTypeImpl(booleanArrayClass);
+
+            this.nullableByteType = TypeUtils.makeNullable(byteType);
+            this.nullableCharType = TypeUtils.makeNullable(charType);
+            this.nullableShortType = TypeUtils.makeNullable(shortType);
+            this.nullableIntType = TypeUtils.makeNullable(intType);
+            this.nullableLongType = TypeUtils.makeNullable(longType);
+            this.nullableFloatType = TypeUtils.makeNullable(floatType);
+            this.nullableDoubleType = TypeUtils.makeNullable(doubleType);
+            this.nullableBooleanType = TypeUtils.makeNullable(booleanType);
             this.nullableStringType = TypeUtils.makeNullable(stringType);
+            this.nullableTuple0Type = TypeUtils.makeNullable(tuple0Type);
         } catch (IOException e) {
             throw new IllegalStateException(e);
         }
@@ -186,7 +254,7 @@ public class JetStandardLibrary {
         return typeInfoClass;
     }
 
-    public FunctionGroup getTypeInfoFunctionGroup() {
+    public Set<FunctionDescriptor> getTypeInfoFunctions() {
         return typeInfoFunction;
     }
 
@@ -275,4 +343,104 @@ public class JetStandardLibrary {
     public JetType getNullableStringType() {
         return nullableStringType;
     }
+
+    public JetType getNullableByteType() {
+        return nullableByteType;
+    }
+
+    public JetType getNullableCharType() {
+        return nullableCharType;
+    }
+
+    public JetType getNullableShortType() {
+        return nullableShortType;
+    }
+
+    public JetType getNullableIntType() {
+        return nullableIntType;
+    }
+
+    public JetType getNullableLongType() {
+        return nullableLongType;
+    }
+
+    public JetType getNullableFloatType() {
+        return nullableFloatType;
+    }
+
+    public JetType getNullableDoubleType() {
+        return nullableDoubleType;
+    }
+
+    public JetType getNullableBooleanType() {
+        return nullableBooleanType;
+    }
+
+    public JetType getNullableTuple0Type() {
+        return nullableTuple0Type;
+    }
+
+    public JetType getBooleanArrayType() {
+        return booleanArrayType;
+    }
+
+    public JetType getByteArrayType() {
+        return byteArrayType;
+    }
+
+    public JetType getCharArrayType() {
+        return charArrayType;
+    }
+
+    public JetType getShortArrayType() {
+        return shortArrayType;
+    }
+
+    public JetType getIntArrayType() {
+        return intArrayType;
+    }
+
+    public JetType getLongArrayType() {
+        return longArrayType;
+    }
+
+    public JetType getFloatArrayType() {
+        return floatArrayType;
+    }
+
+    public JetType getDoubleArrayType() {
+        return doubleArrayType;
+    }
+
+    public ClassDescriptor getByteArrayClass() {
+        return byteArrayClass;
+    }
+
+    public ClassDescriptor getCharArrayClass() {
+        return charArrayClass;
+    }
+
+    public ClassDescriptor getShortArrayClass() {
+        return shortArrayClass;
+    }
+
+    public ClassDescriptor getIntArrayClass() {
+        return intArrayClass;
+    }
+
+    public ClassDescriptor getLongArrayClass() {
+        return longArrayClass;
+    }
+
+    public ClassDescriptor getFloatArrayClass() {
+        return floatArrayClass;
+    }
+
+    public ClassDescriptor getDoubleArrayClass() {
+        return doubleArrayClass;
+    }
+
+    public ClassDescriptor getBooleanArrayClass() {
+        return booleanArrayClass;
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/types/JetType.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetType.java
similarity index 89%
rename from idea/src/org/jetbrains/jet/lang/types/JetType.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/JetType.java
index 930e9c2ae22..35d0c24f26a 100644
--- a/idea/src/org/jetbrains/jet/lang/types/JetType.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetType.java
@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.types;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.List;
 
diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeChecker.java
similarity index 99%
rename from idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeChecker.java
index ba36527a44e..4da7a4baddf 100644
--- a/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeChecker.java
@@ -334,6 +334,10 @@ public class JetTypeChecker {
         return new TypeCheckingProcedure().run(subtype, supertype);
     }
 
+    public boolean equalTypes(@NotNull JetType a, @NotNull JetType b) {
+        return isSubtypeOf(a, b) && isSubtypeOf(b, a);
+    }
+
     private static class OldProcedure {
         public static boolean isSubtypeOf(@NotNull JetType subtype, @NotNull JetType supertype) {
             if (ErrorUtils.isErrorType(subtype) || ErrorUtils.isErrorType(supertype)) {
@@ -593,7 +597,5 @@ public class JetTypeChecker {
         protected Boolean result() {
             return result;
         }
-
-
     }
 }
diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeImpl.java
similarity index 95%
rename from idea/src/org/jetbrains/jet/lang/types/JetTypeImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeImpl.java
index 202f16c9628..69be07784c9 100644
--- a/idea/src/org/jetbrains/jet/lang/types/JetTypeImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeImpl.java
@@ -3,10 +3,10 @@ package org.jetbrains.jet.lang.types;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotatedImpl;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.Collections;
 import java.util.Iterator;
@@ -17,7 +17,7 @@ import java.util.List;
  */
 public final class JetTypeImpl extends AnnotatedImpl implements JetType {
 
-    private static final HashBiMap<TypeConstructor,TypeConstructor> EMPTY_AXIOMS = HashBiMap.<TypeConstructor, TypeConstructor>create();
+    public static final HashBiMap<TypeConstructor,TypeConstructor> EMPTY_AXIOMS = HashBiMap.<TypeConstructor, TypeConstructor>create();
 
     private final TypeConstructor constructor;
     private final List<TypeProjection> arguments;
@@ -96,7 +96,7 @@ public final class JetTypeImpl extends AnnotatedImpl implements JetType {
         JetTypeImpl type = (JetTypeImpl) o;
 
         // TODO
-        return equalTypes(this, type, EMPTY_AXIOMS);
+        return nullable == type.nullable && equalTypes(this, type, EMPTY_AXIOMS);
 //        if (nullable != type.nullable) return false;
 //        if (arguments != null ? !arguments.equals(type.arguments) : type.arguments != null) return false;
 //        if (constructor != null ? !constructor.equals(type.constructor) : type.constructor != null) return false;
@@ -113,7 +113,6 @@ public final class JetTypeImpl extends AnnotatedImpl implements JetType {
         return result;
     }
 
-
     public static boolean equalTypes(@NotNull JetType type1, @NotNull JetType type2, @NotNull BiMap<TypeConstructor, TypeConstructor> equalityAxioms) {
         if (type1.isNullable() != type2.isNullable()) {
             return false;
diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
similarity index 60%
rename from idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
index a03f9500ca3..bc1770da090 100644
--- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
@@ -7,6 +7,7 @@ import com.google.common.collect.Sets;
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
@@ -14,25 +15,43 @@ import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
-import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
-import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver;
-import org.jetbrains.jet.lang.resolve.constants.ErrorValue;
+import org.jetbrains.jet.lang.resolve.calls.CallResolver;
+import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResult;
+import org.jetbrains.jet.lang.resolve.constants.*;
 import org.jetbrains.jet.lang.resolve.constants.StringValue;
-import org.jetbrains.jet.lang.types.inference.ConstraintSystem;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.TransientReceiver;
 import org.jetbrains.jet.lexer.JetTokens;
-import org.jetbrains.jet.resolve.DescriptorRenderer;
-import org.jetbrains.jet.util.WritableSlice;
+import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 import java.util.*;
 
-import static org.jetbrains.jet.lang.resolve.BindingContext.STATEMENT;
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+import static org.jetbrains.jet.lang.resolve.BindingContext.*;
 
 /**
  * @author abreslav
  */
 public class JetTypeInferrer {
+    
+    private static final Set<String> numberConversions = new HashSet();
+
+    static {
+        numberConversions.add("dbl");
+        numberConversions.add("flt");
+        numberConversions.add("lng");
+        numberConversions.add("sht");
+        numberConversions.add("byt");
+        numberConversions.add("int");
+    }
 
     private static final JetType FORBIDDEN = new JetType() {
         @NotNull
@@ -62,6 +81,11 @@ public class JetTypeInferrer {
         public List<AnnotationDescriptor> getAnnotations() {
             throw new UnsupportedOperationException(); // TODO
         }
+
+        @Override
+        public String toString() {
+            return "FORBIDDEN";
+        }
     };
     public static final JetType NO_EXPECTED_TYPE = new JetType() {
         @NotNull
@@ -91,6 +115,11 @@ public class JetTypeInferrer {
         public List<AnnotationDescriptor> getAnnotations() {
             throw new UnsupportedOperationException(); // TODO
         }
+
+        @Override
+        public String toString() {
+            return "NO_EXPECTED_TYPE";
+        }
     };
 
     private static final ImmutableMap<IElementType, String> unaryOperationNames = ImmutableMap.<IElementType, String>builder()
@@ -132,33 +161,34 @@ public class JetTypeInferrer {
 
     private final JetSemanticServices semanticServices;
     private final JetFlowInformationProvider flowInformationProvider;
+    private final CallResolver callResolver;
     private final Map<JetPattern, DataFlowInfo> patternsToDataFlowInfo = Maps.newHashMap();
+
     private final Map<JetPattern, List<VariableDescriptor>> patternsToBoundVariableLists = Maps.newHashMap();
-    
+
     public JetTypeInferrer(@NotNull JetFlowInformationProvider flowInformationProvider, @NotNull JetSemanticServices semanticServices) {
         this.semanticServices = semanticServices;
         this.flowInformationProvider = flowInformationProvider;
+        this.callResolver = new CallResolver(semanticServices, this);
     }
 
     public Services getServices(@NotNull BindingTrace trace) {
         return new Services(trace);
     }
 
+    public CallResolver getCallResolver() {
+        return callResolver;
+    }
+
     public class Services {
         private final BindingTrace trace;
-        private final ClassDescriptorResolver classDescriptorResolver;
-        private final TypeResolver typeResolver;
         private final CompileTimeConstantResolver compileTimeConstantResolver;
-        private final AnnotationResolver annotationResolver;
 
         private final TypeInferrerVisitor typeInferrerVisitor;
         private final TypeInferrerVisitorWithNamespaces typeInferrerVisitorWithNamespaces;
 
         private Services(BindingTrace trace) {
             this.trace = trace;
-            this.annotationResolver = new AnnotationResolver(semanticServices, trace);
-            this.typeResolver = new TypeResolver(semanticServices, trace, true);
-            this.classDescriptorResolver = semanticServices.getClassDescriptorResolver(trace);
             this.compileTimeConstantResolver = new CompileTimeConstantResolver(semanticServices, trace);
             this.typeInferrerVisitor = new TypeInferrerVisitor();
             this.typeInferrerVisitorWithNamespaces = new TypeInferrerVisitorWithNamespaces();
@@ -169,8 +199,8 @@ public class JetTypeInferrer {
         }
 
         @NotNull
-        public JetType safeGetType(@NotNull final JetScope scope, @NotNull JetExpression expression, boolean preferBlock, @NotNull JetType expectedType) {
-            JetType type = getType(scope, expression, preferBlock, expectedType);
+        public JetType safeGetType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType) {
+            JetType type = getType(scope, expression, expectedType);
             if (type != null) {
                 return type;
             }
@@ -178,190 +208,46 @@ public class JetTypeInferrer {
         }
 
         @Nullable
-        public JetType getType(@NotNull final JetScope scope, @NotNull JetExpression expression, boolean preferBlock, @NotNull JetType expectedType) {
-            return typeInferrerVisitor.getType(expression, new TypeInferenceContext(trace, scope, preferBlock, DataFlowInfo.getEmpty(), expectedType, FORBIDDEN));
+        public JetType getType(@NotNull final JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType) {
+            return typeInferrerVisitor.getType(expression, newContext(trace, scope, DataFlowInfo.getEmpty(), expectedType, FORBIDDEN));
         }
 
-        public JetType getTypeWithNamespaces(@NotNull final JetScope scope, @NotNull JetExpression expression, boolean preferBlock) {
-            return typeInferrerVisitorWithNamespaces.getType(expression, new TypeInferenceContext(trace, scope, preferBlock, DataFlowInfo.getEmpty(), NO_EXPECTED_TYPE, NO_EXPECTED_TYPE));
+        public JetType getTypeWithNamespaces(@NotNull final JetScope scope, @NotNull JetExpression expression) {
+            return typeInferrerVisitorWithNamespaces.getType(expression, newContext(trace, scope, DataFlowInfo.getEmpty(), NO_EXPECTED_TYPE, NO_EXPECTED_TYPE));
         }
 
-        @Nullable
-        private FunctionDescriptor lookupFunction(
-                @NotNull JetScope scope,
-                @NotNull JetReferenceExpression reference,
-                @NotNull String name,
-                @NotNull JetType receiverType,
-                @NotNull List<JetType> argumentTypes,
-                boolean reportUnresolved) {
-            OverloadDomain overloadDomain = semanticServices.getOverloadResolver().getOverloadDomain(receiverType, scope, name);
-            // No generics. Guaranteed
-            overloadDomain = wrapForTracing(overloadDomain, reference, null, reportUnresolved);
-            OverloadResolutionResult resolutionResult = overloadDomain.getFunctionDescriptorForPositionedArguments(Collections.<JetType>emptyList(), argumentTypes);
-            return resolutionResult.isSuccess() ? resolutionResult.getFunctionDescriptor() : null;
+        public CallResolver getCallResolver() {
+            return callResolver;
         }
 
-        @NotNull
-        private OverloadResolutionResult resolveNoParametersFunction(@NotNull JetType receiverType, @NotNull JetScope scope, @NotNull String name) {
-            OverloadDomain overloadDomain = semanticServices.getOverloadResolver().getOverloadDomain(receiverType, scope, name);
-            // No generics. Guaranteed
-            return overloadDomain.getFunctionDescriptorForPositionedArguments(Collections.<JetType>emptyList(), Collections.<JetType>emptyList());
-        }
-
-        private OverloadDomain getOverloadDomain(
-                @Nullable final JetType receiverType,
-                @NotNull final JetScope scope,
-                @NotNull JetExpression calleeExpression,
-                @Nullable PsiElement argumentList
-        ) {
-            final OverloadDomain[] result = new OverloadDomain[1];
-            final JetSimpleNameExpression[] reference = new JetSimpleNameExpression[1];
-            calleeExpression.accept(new JetVisitorVoid() {
-
-                @Override
-                public void visitHashQualifiedExpression(JetHashQualifiedExpression expression) {
-                    // a#b -- create a domain for all overloads of b in a
-                    throw new UnsupportedOperationException(); // TODO
-                }
-
-                @Override
-                public void visitPredicateExpression(JetPredicateExpression expression) {
-                    // overload lookup for checking, but the type is receiver's type + nullable
-                    throw new UnsupportedOperationException(); // TODO
-                }
-
-                @Override
-                public void visitQualifiedExpression(JetQualifiedExpression expression) {
-                    trace.getErrorHandler().genericError(expression.getNode(), "Unsupported [JetTypeInferrer]");
-
-                    // . or ?.
-    //                JetType receiverType = getType(scope, expression.getReceiverExpression(), false);
-    //                checkNullSafety(receiverType, expression.getOperationTokenNode());
-    //
-    //                JetExpression selectorExpression = expression.getSelectorExpression();
-    //                if (selectorExpression instanceof JetSimpleNameExpression) {
-    //                    JetSimpleNameExpression referenceExpression = (JetSimpleNameExpression) selectorExpression;
-    //                    String referencedName = referenceExpression.getReferencedName();
-    //
-    //                    if (receiverType != null && referencedName != null) {
-    //                        // No generics. Guaranteed
-    //                        result[0] = semanticServices.getOverloadResolver().getOverloadDomain(receiverType, scope, referencedName);
-    //                        reference[0] = referenceExpression;
-    //                    }
-    //                } else {
-    //                    throw new UnsupportedOperationException(); // TODO
-    //                }
-                }
-
-                @Override
-                public void visitSimpleNameExpression(JetSimpleNameExpression expression) {
-                    // a -- create a hierarchical lookup domain for this.a
-                    String referencedName = expression.getReferencedName();
-                    if (referencedName != null) {
-                        // No generics. Guaranteed
-                        result[0] = semanticServices.getOverloadResolver().getOverloadDomain(receiverType, scope, referencedName);
-                        reference[0] = expression;
-                    }
-                }
-
-                @Override
-                public void visitExpression(JetExpression expression) {
-                    // <e> create a dummy domain for the type of e
-                    throw new UnsupportedOperationException(expression.getText()); // TODO
-                }
-
-                @Override
-                public void visitJetElement(JetElement element) {
-                    trace.getErrorHandler().genericError(element.getNode(), "Unsupported in call element"); // TODO : Message
-                }
-            });
-            return wrapForTracing(result[0], reference[0], argumentList, true);
-        }
-
-        private void checkNullSafety(@Nullable JetType receiverType, @NotNull ASTNode operationTokenNode, @Nullable FunctionDescriptor callee) {
+        //TODO JetElement -> JetWhenConditionCall || JetQualifiedExpression
+        private void checkNullSafety(@Nullable JetType receiverType, @NotNull ASTNode operationTokenNode, @Nullable FunctionDescriptor callee, @NotNull JetElement element) {
             if (receiverType != null && callee != null) {
                 boolean namespaceType = receiverType instanceof NamespaceType;
-                JetType calleeReceiverType = callee.getReceiverType();
                 boolean nullableReceiver = !namespaceType && receiverType.isNullable();
-                boolean calleeForbidsNullableReceiver = calleeReceiverType == null || !calleeReceiverType.isNullable();
+                ReceiverDescriptor calleeReceiver = callee.getReceiver();
+                boolean calleeForbidsNullableReceiver = !calleeReceiver.exists() || !calleeReceiver.getType().isNullable();
 
                 IElementType operationSign = operationTokenNode.getElementType();
                 if (nullableReceiver && calleeForbidsNullableReceiver && operationSign == JetTokens.DOT) {
-                    trace.getErrorHandler().genericError(operationTokenNode, "Only safe calls (?.) are allowed on a nullable receiver of type " + receiverType);
+//                    trace.getErrorHandler().genericError(operationTokenNode, "Only safe calls (?.) are allowed on a nullable receiver of type " + receiverType);
+                    trace.report(UNSAFE_CALL.on(operationTokenNode, receiverType));
                 }
                 else if ((!nullableReceiver || !calleeForbidsNullableReceiver) && operationSign == JetTokens.SAFE_ACCESS) {
                     if (namespaceType) {
-                        trace.getErrorHandler().genericError(operationTokenNode, "Safe calls are not allowed on namespaces");
+//                        trace.getErrorHandler().genericError(operationTokenNode, "Safe calls are not allowed on namespaces");
+                        trace.report(SAFE_CALLS_ARE_NOT_ALLOWED_ON_NAMESPACES.on(operationTokenNode));
                     }
                     else {
-                        trace.getErrorHandler().genericWarning(operationTokenNode, "Unnecessary safe call on a non-null receiver of type  " + receiverType);
+//                        trace.getErrorHandler().genericWarning(operationTokenNode, "Unnecessary safe call on a non-null receiver of type  " + receiverType);
+
+                        trace.report(UNNECESSARY_SAFE_CALL.on(element, operationTokenNode, receiverType));
+
                     }
                 }
             }
         }
 
-        private OverloadDomain wrapForTracing(
-                @NotNull final OverloadDomain overloadDomain,
-                @NotNull final JetReferenceExpression referenceExpression,
-                @Nullable final PsiElement argumentList,
-                final boolean reportErrors) {
-            return new OverloadDomain() {
-                @NotNull
-                @Override
-                public OverloadResolutionResult getFunctionDescriptorForNamedArguments(@NotNull List<JetType> typeArguments, @NotNull Map<String, JetType> valueArgumentTypes, @Nullable JetType functionLiteralArgumentType) {
-                    OverloadResolutionResult resolutionResult = overloadDomain.getFunctionDescriptorForNamedArguments(typeArguments, valueArgumentTypes, functionLiteralArgumentType);
-                    report(resolutionResult);
-                    return resolutionResult;
-                }
-
-                @NotNull
-                @Override
-                public OverloadResolutionResult getFunctionDescriptorForPositionedArguments(@NotNull List<JetType> typeArguments, @NotNull List<JetType> positionedValueArgumentTypes) {
-                    OverloadResolutionResult resolutionResult = overloadDomain.getFunctionDescriptorForPositionedArguments(typeArguments, positionedValueArgumentTypes);
-                    report(resolutionResult);
-                    return resolutionResult;
-                }
-
-                private void report(OverloadResolutionResult resolutionResult) {
-                    if (resolutionResult.isSuccess() || resolutionResult.singleFunction()) {
-                        trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, resolutionResult.getFunctionDescriptor());
-                    }
-                    if (reportErrors) {
-                        switch (resolutionResult.getResultCode()) {
-                            case NAME_NOT_FOUND:
-                                trace.getErrorHandler().unresolvedReference(referenceExpression);
-                                break;
-                            case SINGLE_FUNCTION_ARGUMENT_MISMATCH:
-                                if (argumentList != null) {
-                                    // TODO : More helpful message. NOTE: there's a separate handling for this for constructors
-                                    trace.getErrorHandler().genericError(argumentList.getNode(), "Arguments do not match " + DescriptorRenderer.TEXT.render(resolutionResult.getFunctionDescriptor()));
-                                }
-                                else {
-                                    trace.getErrorHandler().unresolvedReference(referenceExpression);
-                                }
-                                break;
-                            case AMBIGUITY:
-                                if (argumentList != null) {
-                                    // TODO : More helpful message. NOTE: there's a separate handling for this for constructors
-                                    trace.getErrorHandler().genericError(argumentList.getNode(), "Overload ambiguity [TODO : more helpful message]");
-                                }
-                                else {
-                                    trace.getErrorHandler().unresolvedReference(referenceExpression);
-                                }
-                                break;
-                            default:
-                                // Not a success
-                        }
-                    }
-                }
-
-                @Override
-                public boolean isEmpty() {
-                    return overloadDomain.isEmpty();
-                }
-            };
-        }
-
         public void checkFunctionReturnType(@NotNull JetScope outerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor) {
             checkFunctionReturnType(outerScope, function, functionDescriptor, DataFlowInfo.getEmpty());
         }
@@ -396,7 +282,7 @@ public class JetTypeInferrer {
     //                    }
     //                    else if (element instanceof JetExpression) {
     //                        JetExpression expression = (JetExpression) element;
-    //                        context.trace.getErrorHandler().typeMismatch(expression, expectedReturnType, actualType);
+    //                        context.trace.report(TYPE_MISMATCH.on(expression, expectedReturnType, actualType));
     //                    }
     //                    else {
     //                        context.trace.getErrorHandler().genericError(element.getNode(), "This function must return a value of type " + expectedReturnType);
@@ -417,10 +303,16 @@ public class JetTypeInferrer {
             final boolean blockBody = function.hasBlockBody();
             final TypeInferenceContext context =
                     blockBody
-                    ? new TypeInferenceContext(trace, functionInnerScope, function.hasBlockBody(), dataFlowInfo, NO_EXPECTED_TYPE, expectedReturnType)
-                    : new TypeInferenceContext(trace, functionInnerScope, function.hasBlockBody(), dataFlowInfo, expectedReturnType, FORBIDDEN);
+                    ? newContext(trace, functionInnerScope, dataFlowInfo, NO_EXPECTED_TYPE, expectedReturnType)
+                    : newContext(trace, functionInnerScope, dataFlowInfo, expectedReturnType, FORBIDDEN);
 
-            typeInferrerVisitor.getType(bodyExpression, context);
+            if (function instanceof JetFunctionLiteralExpression) {
+                JetFunctionLiteralExpression functionLiteralExpression = (JetFunctionLiteralExpression) function;
+                getBlockReturnedType(functionInnerScope, functionLiteralExpression.getBodyExpression(), CoercionStrategy.COERCION_TO_UNIT, context);
+            }
+            else {
+                typeInferrerVisitor.getType(bodyExpression, context);
+            }
 
             List<JetElement> unreachableElements = Lists.newArrayList();
             flowInformationProvider.collectUnreachableExpressions(function.asElement(), unreachableElements);
@@ -433,7 +325,8 @@ public class JetTypeInferrer {
             //        though it'd better be reported more specifically
 
             for (JetElement element : rootUnreachableElements) {
-                trace.getErrorHandler().genericError(element.getNode(), "Unreachable code");
+//                trace.getErrorHandler().genericError(element.getNode(), "Unreachable code");
+                trace.report(UNREACHABLE_CODE.on(element));
             }
 
             List<JetExpression> returnedExpressions = Lists.newArrayList();
@@ -444,7 +337,8 @@ public class JetTypeInferrer {
             returnedExpressions.remove(function); // This will be the only "expression" if the body is empty
 
             if (expectedReturnType != NO_EXPECTED_TYPE && !JetStandardClasses.isUnit(expectedReturnType) && returnedExpressions.isEmpty() && !nothingReturned) {
-                trace.getErrorHandler().genericError(bodyExpression.getNode(), "This function must return a value of type " + expectedReturnType);
+//                trace.getErrorHandler().genericError(bodyExpression.getNode(), "This function must return a value of type " + expectedReturnType);
+                trace.report(RETURN_TYPE_MISMATCH.on(bodyExpression, expectedReturnType));
             }
 
             for (JetExpression returnedExpression : returnedExpressions) {
@@ -452,7 +346,8 @@ public class JetTypeInferrer {
                     @Override
                     public void visitReturnExpression(JetReturnExpression expression) {
                         if (!blockBody) {
-                            trace.getErrorHandler().genericError(expression.getNode(), "Returns are not allowed for functions with expression body. Use block body in '{...}'");
+//                            trace.getErrorHandler().genericError(expression.getNode(), "Returns are not allowed for functions with expression body. Use block body in '{...}'");
+                            trace.report(RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY.on(expression));
                         }
                     }
 
@@ -462,7 +357,8 @@ public class JetTypeInferrer {
                             //TODO move to pseudocode
                             JetType type = typeInferrerVisitor.getType(expression, context.replaceExpectedType(NO_EXPECTED_TYPE));
                             if (type == null || !JetStandardClasses.isNothing(type)) {
-                                trace.getErrorHandler().genericError(expression.getNode(), "A 'return' expression required in a function with a block body ('{...}')");
+//                                trace.getErrorHandler().genericError(expression.getNode(), "A 'return' expression required in a function with a block body ('{...}')");
+                                trace.report(NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY.on(expression));
                             }
                         }
                     }
@@ -470,6 +366,18 @@ public class JetTypeInferrer {
             }
         }
 
+        @Nullable
+        private JetType getBlockReturnedType(@NotNull JetScope outerScope, @NotNull JetBlockExpression expression, @NotNull CoercionStrategy coercionStrategyForLastExpression, TypeInferenceContext context) {
+            List<JetElement> block = expression.getStatements();
+            if (block.isEmpty()) {
+                return checkType(JetStandardClasses.getUnitType(), expression, context);
+            }
+
+            DeclarationDescriptor containingDescriptor = outerScope.getContainingDeclaration();
+            WritableScope scope = new WritableScopeImpl(outerScope, containingDescriptor, new TraceBasedRedeclarationHandler(context.trace)).setDebugName("getBlockReturnedType");
+            return getBlockReturnedTypeWithWritableScope(scope, block, coercionStrategyForLastExpression, context);
+        }
+
         @NotNull
         public JetType inferFunctionReturnType(@NotNull JetScope outerScope, JetDeclarationWithBody function, FunctionDescriptor functionDescriptor) {
             Map<JetElement, JetType> typeMap = collectReturnedExpressionsWithTypes(trace, outerScope, function, functionDescriptor);
@@ -487,7 +395,7 @@ public class JetTypeInferrer {
             JetExpression bodyExpression = function.getBodyExpression();
             assert bodyExpression != null;
             JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(outerScope, functionDescriptor, trace);
-            typeInferrerVisitor.getType(bodyExpression, new TypeInferenceContext(trace, functionInnerScope, function.hasBlockBody(), DataFlowInfo.getEmpty(), NO_EXPECTED_TYPE, FORBIDDEN));
+            typeInferrerVisitor.getType(bodyExpression, newContext(trace, functionInnerScope, DataFlowInfo.getEmpty(), NO_EXPECTED_TYPE, FORBIDDEN));
             Collection<JetExpression> returnedExpressions = new ArrayList<JetExpression>();
             Collection<JetElement> elementsReturningUnit = new ArrayList<JetElement>();
             flowInformationProvider.collectReturnedInformation(function.asElement(), returnedExpressions, elementsReturningUnit);
@@ -505,304 +413,78 @@ public class JetTypeInferrer {
             return typeMap;
         }
 
-        private JetType getBlockReturnedTypeWithWritableScope(@NotNull WritableScope scope, @NotNull List<? extends JetElement> block, TypeInferenceContext context) {
+        private JetType getBlockReturnedTypeWithWritableScope(@NotNull WritableScope scope, @NotNull List<? extends JetElement> block, @NotNull CoercionStrategy coercionStrategyForLastExpression, TypeInferenceContext context) {
             if (block.isEmpty()) {
                 return JetStandardClasses.getUnitType();
             }
 
             TypeInferrerVisitorWithWritableScope blockLevelVisitor = newTypeInferrerVisitorWithWritableScope(scope);
-            TypeInferenceContext newContext = new TypeInferenceContext(trace, scope, true, context.dataFlowInfo, NO_EXPECTED_TYPE, context.expectedReturnType);
+            TypeInferenceContext newContext = newContext(trace, scope, context.dataFlowInfo, NO_EXPECTED_TYPE, context.expectedReturnType);
 
             JetType result = null;
             for (Iterator<? extends JetElement> iterator = block.iterator(); iterator.hasNext(); ) {
-                JetElement statement = iterator.next();
+                final JetElement statement = iterator.next();
                 trace.record(STATEMENT, statement);
-                JetExpression statementExpression = (JetExpression) statement;
+                final JetExpression statementExpression = (JetExpression) statement;
                 //TODO constructor assert context.expectedType != FORBIDDEN : ""
                 if (!iterator.hasNext() && context.expectedType != NO_EXPECTED_TYPE) {
-                    newContext = new TypeInferenceContext(trace, scope, true, newContext.dataFlowInfo, context.expectedType, context.expectedReturnType);
+                    if (coercionStrategyForLastExpression == CoercionStrategy.COERCION_TO_UNIT && JetStandardClasses.isUnit(context.expectedType)) {
+                        // This implements coercion to Unit
+                        TemporaryBindingTrace temporaryTraceExpectingUnit = TemporaryBindingTrace.create(trace);
+                        final boolean[] mismatch = new boolean[1];
+                        ObservableBindingTrace errorInterceptingTrace = makeTraceInterceptingTypeMismatch(temporaryTraceExpectingUnit, statementExpression, mismatch);
+                        newContext = newContext(errorInterceptingTrace, scope, newContext.dataFlowInfo, context.expectedType, context.expectedReturnType);
+                        result = blockLevelVisitor.getType(statementExpression, newContext);
+                        if (mismatch[0]) {
+                            TemporaryBindingTrace temporaryTraceNoExpectedType = TemporaryBindingTrace.create(trace);
+                            mismatch[0] = false;
+                            ObservableBindingTrace interceptingTrace = makeTraceInterceptingTypeMismatch(temporaryTraceNoExpectedType, statementExpression, mismatch);
+                            newContext = newContext(interceptingTrace, scope, newContext.dataFlowInfo, NO_EXPECTED_TYPE, context.expectedReturnType);
+                            result = blockLevelVisitor.getType(statementExpression, newContext);
+                            if (mismatch[0]) {
+                                temporaryTraceExpectingUnit.commit();
+                            }
+                            else {
+                                temporaryTraceNoExpectedType.commit();
+                            }
+                        }
+                        else {
+                            temporaryTraceExpectingUnit.commit();
+                        }
+
+                    }
+                    else {
+                        newContext = newContext(trace, scope, newContext.dataFlowInfo, context.expectedType, context.expectedReturnType);
+                        result = blockLevelVisitor.getType(statementExpression, newContext);
+                    }
+                }
+                else {
+                    result = blockLevelVisitor.getType(statementExpression, newContext);
                 }
 
-                result = blockLevelVisitor.getType(statementExpression, newContext);
                 DataFlowInfo newDataFlowInfo = blockLevelVisitor.getResultingDataFlowInfo();
                 if (newDataFlowInfo == null) {
                     newDataFlowInfo = context.dataFlowInfo;
                 }
                 if (newDataFlowInfo != context.dataFlowInfo) {
-                    newContext = new TypeInferenceContext(trace, scope, true, newDataFlowInfo, NO_EXPECTED_TYPE, context.expectedReturnType);
+                    newContext = newContext(trace, scope, newDataFlowInfo, NO_EXPECTED_TYPE, context.expectedReturnType);
                 }
                 blockLevelVisitor.resetResult(); // TODO : maybe it's better to recreate the visitors with the same scope?
             }
             return result;
         }
 
-        @Nullable
-        private JetType resolveCall(
-            @NotNull JetScope scope,
-            @NotNull JetCall call,
-            @NotNull JetType expectedType
-        ) {
-            if (call.getTypeArguments().isEmpty()) {
-                JetExpression calleeExpression = call.getCalleeExpression();
-                Collection<FunctionDescriptor> candidates;
-                if (calleeExpression instanceof JetSimpleNameExpression) {
-                    JetSimpleNameExpression expression = (JetSimpleNameExpression) calleeExpression;
-                    candidates = scope.getFunctionGroup(expression.getReferencedName()).getFunctionDescriptors();
-                }
-                else {
-                    throw new UnsupportedOperationException("Type argument inference not implemented");
-                }
+        private ObservableBindingTrace makeTraceInterceptingTypeMismatch(final BindingTrace trace, final JetExpression expressionToWatch, final boolean[] mismatchFound) {
+            return new ObservableBindingTrace(trace) {
 
-                assert candidates.size() == 1;
-
-                FunctionDescriptor candidate = candidates.iterator().next();
-
-                assert candidate.getTypeParameters().size() == call.getTypeArguments().size();
-
-                ConstraintSystem constraintSystem = new ConstraintSystem();
-                for (TypeParameterDescriptor typeParameterDescriptor : candidate.getTypeParameters()) {
-                    constraintSystem.registerTypeVariable(typeParameterDescriptor, Variance.INVARIANT); // TODO
-                }
-
-                Iterator<ValueParameterDescriptor> parameters = candidate.getValueParameters().iterator();
-                for (JetValueArgument valueArgument : call.getValueArguments()) {
-                    assert !valueArgument.isNamed();
-                    ValueParameterDescriptor valueParameterDescriptor = parameters.next();
-                    JetExpression expression = valueArgument.getArgumentExpression();
-                    JetType type = getType(scope, expression, false, NO_EXPECTED_TYPE);
-                    constraintSystem.addSubtypingConstraint(type, valueParameterDescriptor.getOutType());
-                }
-
-                if (expectedType != NO_EXPECTED_TYPE) {
-                    System.out.println("expectedType = " + expectedType);
-                    constraintSystem.addSubtypingConstraint(candidate.getReturnType(), expectedType);
-                }
-
-                ConstraintSystem.Solution solution = constraintSystem.solve();
-                if (!solution.isSuccessful()) {
-                    trace.getErrorHandler().genericError(calleeExpression.getNode(), "Type inference failed");
-//                    for (Inconsistency inconsistency : solution.getInconsistencies()) {
-//                        System.out.println("inconsistency = " + inconsistency);
-//                    }
-                    return null;
-                }
-                else {
-                    for (TypeParameterDescriptor typeParameterDescriptor : candidate.getTypeParameters()) {
-                        JetType value = solution.getValue(typeParameterDescriptor);
-                        System.out.println("typeParameterDescriptor = " + typeParameterDescriptor);
-                        System.out.println("value = " + value);
+                @Override
+                public void report(@NotNull Diagnostic diagnostic) {
+                    if (diagnostic.getFactory() == TYPE_MISMATCH && ((DiagnosticWithPsiElement) diagnostic).getPsiElement() == expressionToWatch) {
+                        mismatchFound[0] = true;
                     }
-                    return solution.getSubstitutor().substitute(candidate.getReturnType(), Variance.INVARIANT); // TODO
+                    super.report(diagnostic);
                 }
-//                return null;
-            }
-            else {
-                throw new UnsupportedOperationException("Explicit type arguments not implemented");
-            }
-        }
-
-        @Nullable
-        private JetType resolveCall(
-                @NotNull JetScope scope,
-                @NotNull OverloadDomain overloadDomain,
-                @NotNull JetCall call) {
-            // 1) ends with a name -> (scope, name) to look up
-            // 2) ends with something else -> just check types
-
-            final List<JetTypeProjection> jetTypeArguments = call.getTypeArguments();
-
-            for (JetTypeProjection typeArgument : jetTypeArguments) {
-                if (typeArgument.getProjectionKind() != JetProjectionKind.NONE) {
-                    trace.getErrorHandler().genericError(typeArgument.getNode(), "Projections are not allowed on type parameters for methods"); // TODO : better positioning
-                }
-            }
-
-            List<JetType> typeArguments = new ArrayList<JetType>();
-            for (JetTypeProjection projection : jetTypeArguments) {
-                // TODO : check that there's no projection
-                JetTypeReference typeReference = projection.getTypeReference();
-                if (typeReference != null) {
-                    typeArguments.add(new TypeResolver(semanticServices, trace, true).resolveType(scope, typeReference));
-                }
-            }
-
-            return resolveCallWithTypeArguments(scope, overloadDomain, call, typeArguments);
-        }
-
-        private JetType resolveCallWithTypeArguments(JetScope scope, OverloadDomain overloadDomain, JetCall call, List<JetType> typeArguments) {
-            final List<JetValueArgument> valueArguments = call.getValueArguments();
-
-            boolean someNamed = false;
-            for (JetValueArgument argument : valueArguments) {
-                if (argument.isNamed()) {
-                    someNamed = true;
-                    break;
-                }
-            }
-
-            final List<JetExpression> functionLiteralArguments = call.getFunctionLiteralArguments();
-
-            // TODO : must be a check
-            assert functionLiteralArguments.size() <= 1;
-
-            if (someNamed) {
-                // TODO : check that all are named
-                trace.getErrorHandler().genericError(call.asElement().getNode(), "Named arguments are not supported"); // TODO
-
-            } else {
-                List<JetExpression> positionedValueArguments = new ArrayList<JetExpression>();
-                for (JetValueArgument argument : valueArguments) {
-                    JetExpression argumentExpression = argument.getArgumentExpression();
-                    if (argumentExpression != null) {
-                        positionedValueArguments.add(argumentExpression);
-                    }
-                }
-
-                positionedValueArguments.addAll(functionLiteralArguments);
-
-                List<JetType> valueArgumentTypes = new ArrayList<JetType>();
-                for (JetExpression valueArgument : positionedValueArguments) {
-                    valueArgumentTypes.add(safeGetType(scope, valueArgument, false, NO_EXPECTED_TYPE)); // TODO
-                }
-
-                OverloadResolutionResult resolutionResult = overloadDomain.getFunctionDescriptorForPositionedArguments(typeArguments, valueArgumentTypes);
-                if (resolutionResult.isSuccess()) {
-                    final FunctionDescriptor functionDescriptor = resolutionResult.getFunctionDescriptor();
-
-                    checkGenericBoundsInAFunctionCall(call.getTypeArguments(), typeArguments, functionDescriptor);
-                    return functionDescriptor.getReturnType();
-                }
-            }
-            return null;
-        }
-
-        private void checkGenericBoundsInAFunctionCall(List<JetTypeProjection> jetTypeArguments, List<JetType> typeArguments, FunctionDescriptor functionDescriptor) {
-            Map<TypeConstructor, TypeProjection> context = Maps.newHashMap();
-
-            List<TypeParameterDescriptor> typeParameters = functionDescriptor.getOriginal().getTypeParameters();
-            for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
-                TypeParameterDescriptor typeParameter = typeParameters.get(i);
-                JetType typeArgument = typeArguments.get(i);
-                context.put(typeParameter.getTypeConstructor(), new TypeProjection(typeArgument));
-            }
-            TypeSubstitutor substitutor = TypeSubstitutor.create(context);
-            for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
-                TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i);
-                JetType typeArgument = typeArguments.get(i);
-                JetTypeReference typeReference = jetTypeArguments.get(i).getTypeReference();
-                assert typeReference != null;
-                classDescriptorResolver.checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor);
-            }
-        }
-
-        @Nullable
-        public JetType checkTypeInitializerCall(JetScope scope, @NotNull JetTypeReference typeReference, @NotNull JetCall call) {
-            JetTypeElement typeElement = typeReference.getTypeElement();
-            if (typeElement instanceof JetUserType) {
-                JetUserType userType = (JetUserType) typeElement;
-                // TODO : to infer constructor parameters, one will need to
-                //  1) resolve a _class_ from the typeReference
-                //  2) rely on the overload domain of constructors of this class to infer type arguments
-                // For now we assume that the type arguments are provided, and thus the typeReference can be
-                // resolved into a valid type
-                JetType receiverType = typeResolver.resolveType(scope, typeReference);
-                DeclarationDescriptor declarationDescriptor = receiverType.getConstructor().getDeclarationDescriptor();
-                if (declarationDescriptor instanceof ClassDescriptor) {
-                    ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor;
-
-                    for (JetTypeProjection typeProjection : userType.getTypeArguments()) {
-                        switch (typeProjection.getProjectionKind()) {
-                            case IN:
-                            case OUT:
-                            case STAR:
-                                // TODO : Bug in the editor
-                                trace.getErrorHandler().genericError(typeProjection.getProjectionNode(), "Projections are not allowed in constructor type arguments");
-                                break;
-                            case NONE:
-                                break;
-                        }
-                    }
-
-                    JetSimpleNameExpression referenceExpression = userType.getReferenceExpression();
-                    if (referenceExpression != null) {
-                        return checkClassConstructorCall(scope, referenceExpression, classDescriptor, receiverType, call);
-                    }
-                }
-                else {
-                    trace.getErrorHandler().genericError(((JetElement) call).getNode(), "Calling a constructor is only supported for ordinary classes"); // TODO : review the message
-                }
-                return null;
-            }
-            else {
-                if (typeElement != null) {
-                    trace.getErrorHandler().genericError(typeElement.getNode(), "Calling a constructor is only supported for ordinary classes"); // TODO : Better message
-                }
-            }
-            return null;
-        }
-
-        @Nullable
-        public JetType checkClassConstructorCall(
-                @NotNull JetScope scope,
-                @NotNull JetReferenceExpression referenceExpression,
-                @NotNull ClassDescriptor classDescriptor,
-                @NotNull JetType receiverType,
-                @NotNull JetCall call) {
-            // When one writes 'new Array<in T>(...)' this does not make much sense, and an instance
-            // of 'Array<T>' must be created anyway.
-            // Thus, we should either prohibit projections in type arguments in such contexts,
-            // or treat them as an automatic upcast to the desired type, i.e. for the user not
-            // to be forced to write
-            //   val a : Array<in T> = new Array<T>(...)
-            // NOTE: Array may be a bad example here, some classes may have substantial functionality
-            //       not involving their type parameters
-            //
-            // The code below upcasts the type automatically
-
-
-            FunctionGroup constructors = classDescriptor.getConstructors();
-            OverloadDomain constructorsOverloadDomain = semanticServices.getOverloadResolver().getOverloadDomain(null, constructors);
-
-            JetType constructorReturnedType;
-            if (call instanceof JetDelegatorToThisCall) {
-                List<TypeProjection> typeArguments = receiverType.getArguments();
-
-                List<JetType> projectionsStripped = Lists.newArrayList();
-                for (TypeProjection typeArgument : typeArguments) {
-                    projectionsStripped.add(typeArgument.getType());
-                }
-
-                constructorReturnedType = resolveCallWithTypeArguments(
-                        scope,
-                        wrapForTracing(constructorsOverloadDomain, referenceExpression, call.getValueArgumentList(), false),
-                        call, projectionsStripped);
-            }
-            else {
-                constructorReturnedType = resolveCall(
-                        scope,
-                        wrapForTracing(constructorsOverloadDomain, referenceExpression, call.getValueArgumentList(), false),
-                        call);
-            }
-            if (constructorReturnedType == null && !ErrorUtils.isErrorType(receiverType)) {
-                DeclarationDescriptor declarationDescriptor = receiverType.getConstructor().getDeclarationDescriptor();
-                assert declarationDescriptor != null;
-                trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, declarationDescriptor);
-                // TODO : more helpful message
-                JetValueArgumentList argumentList = call.getValueArgumentList();
-                final String errorMessage = "Cannot find a constructor overload for class " + classDescriptor.getName() + " with these arguments";
-                if (argumentList != null) {
-                    trace.getErrorHandler().genericError(argumentList.getNode(), errorMessage);
-                }
-                else {
-                    trace.getErrorHandler().genericError(call.asElement().getNode(), errorMessage);
-                }
-                constructorReturnedType = receiverType;
-            }
-            // If no upcast needed:
-            return constructorReturnedType;
-
-            // Automatic upcast:
-    //                            result = receiverType;
+            };
         }
 
         //TODO
@@ -819,7 +501,7 @@ public class JetTypeInferrer {
         private JetType checkType(@Nullable JetType expressionType, @NotNull JetExpression expression, @NotNull TypeInferenceContext context) {
             if (expressionType != null && context.expectedType != null && context.expectedType != NO_EXPECTED_TYPE) {
                 if (!semanticServices.getTypeChecker().isSubtypeOf(expressionType, context.expectedType)) {
-                    context.trace.getErrorHandler().typeMismatch(expression, context.expectedType, expressionType);
+                    context.trace.report(TYPE_MISMATCH.on(expression, context.expectedType, expressionType));
                 }
             }
             return expressionType;
@@ -832,30 +514,39 @@ public class JetTypeInferrer {
                 return expressionType;
             }
             VariableDescriptor variableDescriptor = getVariableDescriptorFromSimpleName(expression, context);
-            if (variableDescriptor == null) return expressionType;
-
-            JetType enrichedType = null;
-            List<JetType> possibleTypes = Lists.newArrayList(context.dataFlowInfo.getPossibleTypes(variableDescriptor));
-            Collections.reverse(possibleTypes);
-            for (JetType possibleType: possibleTypes) {
-                if (semanticServices.getTypeChecker().isSubtypeOf(possibleType, context.expectedType)) {
-                    enrichedType = possibleType;
-                    break;
+            boolean appropriateTypeFound = false;
+            if (variableDescriptor != null) {
+                List<JetType> possibleTypes = Lists.newArrayList(context.dataFlowInfo.getPossibleTypes(variableDescriptor));
+                Collections.reverse(possibleTypes);
+                for (JetType possibleType : possibleTypes) {
+                    if (semanticServices.getTypeChecker().isSubtypeOf(possibleType, context.expectedType)) {
+                        appropriateTypeFound = true;
+                        break;
+                    }
+                }
+                if (!appropriateTypeFound) {
+                    JetType notnullType = context.dataFlowInfo.getOutType(variableDescriptor);
+                    if (notnullType != null && semanticServices.getTypeChecker().isSubtypeOf(notnullType, context.expectedType)) {
+                        appropriateTypeFound = true;
+                    }
                 }
             }
-            if (enrichedType == null) {
-                enrichedType = context.dataFlowInfo.getOutType(variableDescriptor);
-            }
-            if (enrichedType == null) {
-                enrichedType = expressionType;
+            if (!appropriateTypeFound) {
+//                context.trace.getErrorHandler().typeMismatch(expression, context.expectedType, expressionType);
+                context.trace.report(TYPE_MISMATCH.on(expression, context.expectedType, expressionType));
+                return expressionType;
             }
+            checkAutoCast(expression, context.expectedType, variableDescriptor, context.trace);
+            return context.expectedType;
+        }
 
-            if (!semanticServices.getTypeChecker().isSubtypeOf(enrichedType, context.expectedType)) {
-                context.trace.getErrorHandler().typeMismatch(expression, context.expectedType, expressionType);
+        private void checkAutoCast(JetExpression expression, JetType type, VariableDescriptor variableDescriptor, BindingTrace trace) {
+            if (variableDescriptor.isVar()) {
+//                trace.getErrorHandler().genericError(expression.getNode(), "Automatic cast to " + type + " is impossible, because variable " + variableDescriptor.getName() + " is mutable");
+                trace.report(AUTOCAST_IMPOSSIBLE.on(expression, type, variableDescriptor));
             } else {
-                context.trace.record(BindingContext.AUTOCAST, expression, context.expectedType);
+                trace.record(BindingContext.AUTOCAST, expression, type);
             }
-            return enrichedType;
         }
 
         @NotNull
@@ -881,35 +572,50 @@ public class JetTypeInferrer {
             VariableDescriptor variableDescriptor = null;
             if (receiverExpression instanceof JetSimpleNameExpression) {
                 JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) receiverExpression;
-                DeclarationDescriptor declarationDescriptor = context.trace.getBindingContext().get(BindingContext.REFERENCE_TARGET, nameExpression);
+                DeclarationDescriptor declarationDescriptor = context.trace.getBindingContext().get(REFERENCE_TARGET, nameExpression);
                 if (declarationDescriptor instanceof VariableDescriptor) {
                     variableDescriptor = (VariableDescriptor) declarationDescriptor;
                 }
             }
             return variableDescriptor;
         }
-
     }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    private enum CoercionStrategy {
+        NO_COERCION,
+        COERCION_TO_UNIT
+    }
+
+    @NotNull
+    private TypeInferenceContext newContext(
+            @NotNull BindingTrace trace,
+            @NotNull JetScope scope,
+            @NotNull DataFlowInfo dataFlowInfo,
+            @NotNull JetType expectedType,
+            @NotNull JetType expectedReturnType) {
+        return new TypeInferenceContext(trace, scope, dataFlowInfo, expectedType, expectedReturnType);
+    }
+
     private class TypeInferenceContext {
+
         public final BindingTrace trace;
+
         public final TypeResolver typeResolver;
         public final ClassDescriptorResolver classDescriptorResolver;
-
         public final JetScope scope;
+
         public final Services services;
-        public final boolean preferBlock;
         public final DataFlowInfo dataFlowInfo;
 
         public final JetType expectedType;
         public final JetType expectedReturnType;
 
+        @Deprecated // Only factory methods
         private TypeInferenceContext(
                 @NotNull BindingTrace trace,
                 @NotNull JetScope scope,
-                boolean preferBlock,
                 @NotNull DataFlowInfo dataFlowInfo,
                 @NotNull JetType expectedType,
                 @NotNull JetType expectedReturnType) {
@@ -918,32 +624,47 @@ public class JetTypeInferrer {
             this.classDescriptorResolver = semanticServices.getClassDescriptorResolver(trace);
             this.scope = scope;
             this.services = getServices(trace);
-            this.preferBlock = preferBlock;
             this.dataFlowInfo = dataFlowInfo;
             this.expectedType = expectedType;
             this.expectedReturnType = expectedReturnType;
-            
         }
 
         public TypeInferenceContext replaceDataFlowInfo(DataFlowInfo newDataFlowInfo) {
-            return new TypeInferenceContext(trace, scope, preferBlock, newDataFlowInfo, expectedType, expectedReturnType);
+            return newContext(trace, scope, newDataFlowInfo, expectedType, expectedReturnType);
         }
         
         public TypeInferenceContext replaceExpectedType(@Nullable JetType newExpectedType) {
             if (newExpectedType == null) return replaceExpectedType(NO_EXPECTED_TYPE);
             if (expectedType == newExpectedType) return this;
-            return new TypeInferenceContext(trace, scope, preferBlock, dataFlowInfo, newExpectedType, expectedReturnType);
+            return newContext(trace, scope, dataFlowInfo, newExpectedType, expectedReturnType);
         }
         
         public TypeInferenceContext replaceExpectedReturnType(@Nullable JetType newExpectedReturnType) {
             if (newExpectedReturnType == null) return replaceExpectedReturnType(NO_EXPECTED_TYPE);
             if (expectedReturnType == newExpectedReturnType) return this;
-            return new TypeInferenceContext(trace, scope, preferBlock, dataFlowInfo, expectedType, newExpectedReturnType);
+            return newContext(trace, scope, dataFlowInfo, expectedType, newExpectedReturnType);
         }
 
         public TypeInferenceContext replaceBindingTrace(@NotNull BindingTrace newTrace) {
             if (newTrace == trace) return this;
-            return new TypeInferenceContext(newTrace, scope, preferBlock, dataFlowInfo, expectedType, expectedReturnType);
+            return newContext(newTrace, scope, dataFlowInfo, expectedType, expectedReturnType);
+        }
+
+        public TypeInferenceContext replaceExpectedTypeAndTrace(@NotNull JetType newExpectedType, @NotNull BindingTrace newTrace) {
+            if (newExpectedType == expectedType && newTrace == trace) return this;
+            return newContext(newTrace, scope, dataFlowInfo, newExpectedType, expectedReturnType);
+        }
+
+        @NotNull
+        public TypeInferenceContext replaceScope(@NotNull JetScope newScope) {
+            if (newScope == scope) return this;
+            return newContext(trace, newScope, dataFlowInfo, expectedType, expectedReturnType);
+        }
+
+        @NotNull
+        public TypeInferenceContext replaceExpectedTypes(@NotNull JetType newExpectedType, @NotNull JetType newExpectedReturnType) {
+            if (expectedType == newExpectedType && expectedReturnType == newExpectedReturnType) return this;
+            return newContext(trace, scope, dataFlowInfo, newExpectedType, newExpectedReturnType);
         }
     }
 
@@ -956,13 +677,27 @@ public class JetTypeInferrer {
             return resultDataFlowInfo;
         }
 
+        @NotNull
+        public final JetType safeGetType(@NotNull JetExpression expression, TypeInferenceContext context) {
+            JetType type = getType(expression, context);
+            if (type != null) {
+                return type;
+            }
+            return ErrorUtils.createErrorType("Type for " + expression.getText());
+        }
+        
         @Nullable
-        public JetType getType(@NotNull JetScope scope, @NotNull JetExpression expression, boolean preferBlock, TypeInferenceContext context) {
-            return getType(expression, new TypeInferenceContext(context.trace, scope, preferBlock, context.dataFlowInfo, context.expectedType, context.expectedReturnType));
+        public final ExpressionReceiver getExpressionReceiver(@NotNull JetExpression expression, TypeInferenceContext context) {
+            JetType type = getType(expression, context);
+            if (type == null) {
+                return null;
+            }
+            return new ExpressionReceiver(expression, type);
         }
 
-        private JetType getTypeWithNewDataFlowInfo(JetScope scope, JetExpression expression, boolean preferBlock, @NotNull DataFlowInfo newDataFlowInfo, TypeInferenceContext context) {
-            return getType(expression, new TypeInferenceContext(context.trace, scope, preferBlock, newDataFlowInfo, context.expectedType, context.expectedReturnType));
+        @NotNull
+        public final ExpressionReceiver safeGetExpressionReceiver(@NotNull JetExpression expression, TypeInferenceContext context) {
+            return new ExpressionReceiver(expression, safeGetType(expression, context));
         }
 
         @Nullable
@@ -974,7 +709,7 @@ public class JetTypeInferrer {
             try {
                 result = expression.visit(this, context);
                 // Some recursive definitions (object expressions) must put their types in the cache manually:
-                if ((boolean) context.trace.get(BindingContext.PROCESSED, expression)) {
+                if (context.trace.get(BindingContext.PROCESSED, expression)) {
                     return context.trace.getBindingContext().get(BindingContext.EXPRESSION_TYPE, expression);
                 }
 
@@ -989,17 +724,23 @@ public class JetTypeInferrer {
                 }
             }
             catch (ReenteringLazyValueComputationException e) {
-                context.trace.getErrorHandler().genericError(expression.getNode(), "Type inference has run into a recursive problem"); // TODO : message
+//                context.trace.getErrorHandler().genericError(expression.getNode(), "Type checking has run into a recursive problem"); // TODO : message
+                context.trace.report(TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM.on(expression));
                 result = null;
             }
 
-            if (!(boolean) context.trace.get(BindingContext.PROCESSED, expression)) {
+            if (!context.trace.get(BindingContext.PROCESSED, expression)) {
                 context.trace.record(BindingContext.RESOLUTION_SCOPE, expression, context.scope);
             }
             context.trace.record(BindingContext.PROCESSED, expression);
             return result;
         }
 
+        private JetType getTypeWithNewScopeAndDataFlowInfo(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull DataFlowInfo newDataFlowInfo, @NotNull TypeInferenceContext context) {
+            return getType(expression, newContext(context.trace, scope, newDataFlowInfo, context.expectedType, context.expectedReturnType));
+        }
+
+
         public void resetResult() {
 //            result = null;
             resultDataFlowInfo = null;
@@ -1013,23 +754,12 @@ public class JetTypeInferrer {
             flowInformationProvider.collectDominatedExpressions(expression, dominated);
             Set<JetElement> rootExpressions = JetPsiUtil.findRootExpressions(dominated);
             for (JetElement rootExpression : rootExpressions) {
-                context.trace.getErrorHandler().genericError(rootExpression.getNode(),
-                        "This code is unreachable, because '" + expression.getText() + "' never terminates normally");
+//                context.trace.getErrorHandler().genericError(rootExpression.getNode(),
+//                        "This code is unreachable, because '" + expression.getText() + "' never terminates normally");
+                context.trace.report(UNREACHABLE_BECAUSE_OF_NOTHING.on(rootExpression, expression.getText()));
             }
         }
 
-        @Nullable
-        private JetType getBlockReturnedType(@NotNull JetScope outerScope, @NotNull JetBlockExpression expression, TypeInferenceContext context) {
-            List<JetElement> block = expression.getStatements();
-            if (block.isEmpty()) {
-                return context.services.checkType(JetStandardClasses.getUnitType(), expression, context);
-            }
-
-            DeclarationDescriptor containingDescriptor = outerScope.getContainingDeclaration();
-            WritableScope scope = new WritableScopeImpl(outerScope, containingDescriptor, context.trace.getErrorHandler()).setDebugName("getBlockReturnedType");
-            return context.services.getBlockReturnedTypeWithWritableScope(scope, block, context);
-        }
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
         @Override
@@ -1041,49 +771,79 @@ public class JetTypeInferrer {
                     && referencedName != null) {
                 PropertyDescriptor property = context.scope.getPropertyByFieldReference(referencedName);
                 if (property == null) {
-                    context.trace.getErrorHandler().unresolvedReference(expression);
+                    context.trace.report(UNRESOLVED_REFERENCE.on(expression));
                 }
                 else {
-                    context.trace.record(BindingContext.REFERENCE_TARGET, expression, property);
+                    context.trace.record(REFERENCE_TARGET, expression, property);
                     return context.services.checkEnrichedType(property.getOutType(), expression, context);
                 }
             }
             else {
-                assert JetTokens.IDENTIFIER == expression.getReferencedNameElementType();
-                if (referencedName != null) {
-                    VariableDescriptor variable = context.scope.getVariable(referencedName);
-                    if (variable != null) {
-                        context.trace.record(BindingContext.REFERENCE_TARGET, expression, variable);
-                        JetType result = variable.getOutType();
-                        if (result == null) {
-                            context.trace.getErrorHandler().genericError(expression.getNode(), "This variable is not readable in this context");
-                        }
-                        return context.services.checkEnrichedType(result, expression, context);
-                    }
-                    else {
-                        ClassifierDescriptor classifier = context.scope.getClassifier(referencedName);
-                        if (classifier != null) {
-                            JetType classObjectType = classifier.getClassObjectType();
-                            JetType result = null;
-                            if (classObjectType != null && (isNamespacePosition() || classifier.isClassObjectAValue())) {
-                                result = classObjectType;
-                            }
-                            else {
-                                context.trace.getErrorHandler().genericError(expression.getNode(), "Classifier " + classifier.getName() +  " does not have a class object");
-                            }
-                            context.trace.record(BindingContext.REFERENCE_TARGET, expression, classifier);
-                            return context.services.checkEnrichedType(result, expression, context);
-                        }
-                        else {
-                            JetType[] result = new JetType[1];
-                            if (furtherNameLookup(expression, referencedName, result, context)) {
-                                return context.services.checkEnrichedType(result[0], expression, context);
-                            }
-                            
-                        }
-                    }
-                    context.trace.getErrorHandler().unresolvedReference(expression);
+                return getSelectorReturnType(ReceiverDescriptor.NO_RECEIVER, expression, context); // TODO : Extensions to this
+//                assert JetTokens.IDENTIFIER == expression.getReferencedNameElementType();
+//                if (referencedName != null) {
+//                    VariableDescriptor variable = context.scope.getVariable(referencedName);
+//                    if (variable != null) {
+//                        context.trace.record(REFERENCE_TARGET, expression, variable);
+//                        JetType result = variable.getOutType();
+//                        if (result == null) {
+//                            context.trace.getErrorHandler().genericError(expression.getNode(), "This variable is not readable in this context");
+//                        }
+//                        return context.services.checkEnrichedType(result, expression, context);
+//                    }
+//                    else {
+//                        return lookupNamespaceOrClassObject(expression, referencedName, context);
+//                        ClassifierDescriptor classifier = context.scope.getClassifier(referencedName);
+//                        if (classifier != null) {
+//                            JetType classObjectType = classifier.getClassObjectType();
+//                            JetType result = null;
+//                            if (classObjectType != null && (isNamespacePosition() || classifier.isClassObjectAValue())) {
+//                                result = classObjectType;
+//                            }
+//                            else {
+//                                context.trace.getErrorHandler().genericError(expression.getNode(), "Classifier " + classifier.getName() +  " does not have a class object");
+//                            }
+//                            context.trace.record(REFERENCE_TARGET, expression, classifier);
+//                            return context.services.checkEnrichedType(result, expression, context);
+//                        }
+//                        else {
+//                            JetType[] result = new JetType[1];
+//                            if (furtherNameLookup(expression, referencedName, result, context)) {
+//                                return context.services.checkEnrichedType(result[0], expression, context);
+//                            }
+//
+//                        }
+//                    }
+//                    context.trace.report(UNRESOLVED_REFERENCE.on(expression));
+//                }
+            }
+            return null;
+        }
+
+        private JetType lookupNamespaceOrClassObject(JetSimpleNameExpression expression, String referencedName, TypeInferenceContext context) {
+            ClassifierDescriptor classifier = context.scope.getClassifier(referencedName);
+            if (classifier != null) {
+                JetType classObjectType = classifier.getClassObjectType();
+                JetType result = null;
+                if (classObjectType != null && (isNamespacePosition() || classifier.isClassObjectAValue())) {
+                    result = classObjectType;
                 }
+                else {
+//                    context.trace.getErrorHandler().genericError(expression.getNode(), "Classifier " + classifier.getName() +  " does not have a class object");
+                    context.trace.report(NO_CLASS_OBJECT.on(expression, classifier));
+                }
+                context.trace.record(REFERENCE_TARGET, expression, classifier);
+                if (result == null) {
+                    return ErrorUtils.createErrorType("No class object in " + expression.getReferencedName());
+                }
+                return context.services.checkEnrichedType(result, expression, context);
+            }
+            else {
+                JetType[] result = new JetType[1];
+                if (furtherNameLookup(expression, referencedName, result, context)) {
+                    return context.services.checkEnrichedType(result[0], expression, context);
+                }
+
             }
             return null;
         }
@@ -1095,7 +855,8 @@ public class JetTypeInferrer {
         protected boolean furtherNameLookup(@NotNull JetSimpleNameExpression expression, @NotNull String referencedName, @NotNull JetType[] result, TypeInferenceContext context) {
             NamespaceType namespaceType = lookupNamespaceType(expression, referencedName, context);
             if (namespaceType != null) {
-                context.trace.getErrorHandler().genericError(expression.getNode(), "Expression expected, but a namespace name found");
+//                context.trace.getErrorHandler().genericError(expression.getNode(), "Expression expected, but a namespace name found");
+                context.trace.report(EXPRESSION_EXPECTED_NAMESPACE_FOUND.on(expression));
                 return true;
             }
             return false;
@@ -1107,56 +868,49 @@ public class JetTypeInferrer {
             if (namespace == null) {
                 return null;
             }
-            context.trace.record(BindingContext.REFERENCE_TARGET, expression, namespace);
+            context.trace.record(REFERENCE_TARGET, expression, namespace);
             return namespace.getNamespaceType();
         }
 
         @Override
         public JetType visitObjectLiteralExpression(final JetObjectLiteralExpression expression, final TypeInferenceContext context) {
             final JetType[] result = new JetType[1];
-            BindingTraceAdapter.RecordHandler<PsiElement, DeclarationDescriptor> handler = new BindingTraceAdapter.RecordHandler<PsiElement, DeclarationDescriptor>() {
+            ObservableBindingTrace.RecordHandler<PsiElement, ClassDescriptor> handler = new ObservableBindingTrace.RecordHandler<PsiElement, ClassDescriptor>() {
 
                 @Override
-                public void handleRecord(WritableSlice<PsiElement, DeclarationDescriptor> slice, PsiElement declaration, final DeclarationDescriptor descriptor) {
-                    if (declaration == expression.getObjectDeclaration()) {
-                        JetType defaultType = new DeferredType(new LazyValue<JetType>() {
+                public void handleRecord(WritableSlice<PsiElement, ClassDescriptor> slice, PsiElement declaration, final ClassDescriptor descriptor) {
+                    if (slice == CLASS && declaration == expression.getObjectDeclaration()) {
+                        JetType defaultType = DeferredType.create(context.trace, new LazyValueWithDefault<JetType>(ErrorUtils.createErrorType("Recursive dependency")) {
                             @Override
                             protected JetType compute() {
-                                return ((ClassDescriptor) descriptor).getDefaultType();
+                                return descriptor.getDefaultType();
                             }
                         });
                         result[0] = defaultType;
-                        if (!context.trace.get(BindingContext.PROCESSED, expression)) {
-                            context.trace.record(BindingContext.EXPRESSION_TYPE, expression, defaultType);
-                            context.trace.record(BindingContext.PROCESSED, expression);
+                        if (!context.trace.get(PROCESSED, expression)) {
+                            context.trace.record(EXPRESSION_TYPE, expression, defaultType);
+                            context.trace.record(PROCESSED, expression);
                         }
                     }
                 }
             };
-            BindingTraceAdapter traceAdapter = new BindingTraceAdapter(context.trace);
-            for (WritableSlice slice : BindingContext.DECLARATIONS_TO_DESCRIPTORS) {
-                //noinspection unchecked
-                traceAdapter.addHandler(slice, handler);
-            }
-            TopDownAnalyzer topDownAnalyzer = new TopDownAnalyzer(semanticServices, traceAdapter);
-            topDownAnalyzer.processObject(context.scope, context.scope.getContainingDeclaration(), expression.getObjectDeclaration());
+            ObservableBindingTrace traceAdapter = new ObservableBindingTrace(context.trace);
+            traceAdapter.addHandler(CLASS, handler);
+            TopDownAnalyzer.processObject(semanticServices, traceAdapter, context.scope, context.scope.getContainingDeclaration(), expression.getObjectDeclaration());
             return context.services.checkType(result[0], expression, context);
         }
 
         @Override
         public JetType visitFunctionLiteralExpression(JetFunctionLiteralExpression expression, TypeInferenceContext context) {
             JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
-            if (context.preferBlock && !functionLiteral.hasParameterSpecification()) {
-                context.trace.record(BindingContext.BLOCK, expression);
-                return context.services.checkType(getBlockReturnedType(context.scope, functionLiteral.getBodyExpression(), context), expression, context);
-            }
 
             JetTypeReference receiverTypeRef = functionLiteral.getReceiverTypeRef();
             final JetType receiverType;
             if (receiverTypeRef != null) {
                 receiverType = context.typeResolver.resolveType(context.scope, receiverTypeRef);
             } else {
-                receiverType = context.scope.getThisType();
+                ReceiverDescriptor implicitReceiver = context.scope.getImplicitReceiver();
+                receiverType = implicitReceiver.exists() ? implicitReceiver.getType() : null;
             }
 
             FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(
@@ -1164,26 +918,61 @@ public class JetTypeInferrer {
 
             List<JetType> parameterTypes = new ArrayList<JetType>();
             List<ValueParameterDescriptor> valueParameterDescriptors = Lists.newArrayList();
-            List<JetParameter> parameters = functionLiteral.getValueParameters();
-            for (int i = 0, parametersSize = parameters.size(); i < parametersSize; i++) {
-                JetParameter parameter = parameters.get(i);
-                JetTypeReference typeReference = parameter.getTypeReference();
+            List<JetParameter> declaredValueParameters = functionLiteral.getValueParameters();
+            JetType expectedType = context.expectedType;
 
-                JetType type;
-                if (typeReference != null) {
-                    type = context.typeResolver.resolveType(context.scope, typeReference);
+            boolean functionTypeExpected = expectedType != NO_EXPECTED_TYPE && JetStandardClasses.isFunctionType(expectedType);
+            List<ValueParameterDescriptor> expectedValueParameters =  (functionTypeExpected)
+                                                              ? JetStandardClasses.getValueParameters(functionDescriptor, expectedType)
+                                                              : null;
+
+            if (functionTypeExpected && declaredValueParameters.isEmpty() && expectedValueParameters.size() == 1) {
+                ValueParameterDescriptor valueParameterDescriptor = expectedValueParameters.get(0);
+                ValueParameterDescriptor it = new ValueParameterDescriptorImpl(
+                        functionDescriptor, 0, Collections.<AnnotationDescriptor>emptyList(), "it", valueParameterDescriptor.getInType(), valueParameterDescriptor.getOutType(), valueParameterDescriptor.hasDefaultValue(), valueParameterDescriptor.isVararg()
+                );
+                valueParameterDescriptors.add(it);
+                parameterTypes.add(it.getOutType());
+                context.trace.record(AUTO_CREATED_IT, it);
+            }
+            else {
+                for (int i = 0; i < declaredValueParameters.size(); i++) {
+                    JetParameter declaredParameter = declaredValueParameters.get(i);
+                    JetTypeReference typeReference = declaredParameter.getTypeReference();
+
+                    JetType type;
+                    if (typeReference != null) {
+                        type = context.typeResolver.resolveType(context.scope, typeReference);
+                    }
+                    else {
+                        if (expectedValueParameters != null && i < expectedValueParameters.size()) {
+                            type = expectedValueParameters.get(i).getOutType();
+                        }
+                        else {
+    //                        context.trace.getErrorHandler().genericError(declaredParameter.getNode(), "Cannot infer a type for this declaredParameter. To specify it explicitly use the {(p : Type) => ...} notation");
+                            context.trace.report(CANNOT_INFER_PARAMETER_TYPE.on(declaredParameter));
+                            type = ErrorUtils.createErrorType("Cannot be inferred");
+                        }
+                    }
+                    ValueParameterDescriptor valueParameterDescriptor = context.classDescriptorResolver.resolveValueParameterDescriptor(functionDescriptor, declaredParameter, i, type);
+                    parameterTypes.add(valueParameterDescriptor.getOutType());
+                    valueParameterDescriptors.add(valueParameterDescriptor);
                 }
-                else {
-                    context.trace.getErrorHandler().genericError(parameter.getNode(), "Type inference for parameters is not implemented yet");
-                    type = ErrorUtils.createErrorType("Not inferred");
-                }
-                ValueParameterDescriptor valueParameterDescriptor = context.classDescriptorResolver.resolveValueParameterDescriptor(functionDescriptor, parameter, i, type);
-                parameterTypes.add(valueParameterDescriptor.getOutType());
-                valueParameterDescriptors.add(valueParameterDescriptor);
             }
 
-            JetType effectiveReceiverType = receiverTypeRef == null ? null : receiverType;
-            functionDescriptor.initialize(effectiveReceiverType, Collections.<TypeParameterDescriptor>emptyList(), valueParameterDescriptors, null);
+            JetType effectiveReceiverType;
+            if (receiverTypeRef == null) {
+                if (functionTypeExpected) {
+                    effectiveReceiverType = JetStandardClasses.getReceiverType(expectedType);
+                }
+                else {
+                    effectiveReceiverType = null;
+                }
+            }
+            else {
+                effectiveReceiverType = receiverType;
+            }
+            functionDescriptor.initialize(effectiveReceiverType, Collections.<TypeParameterDescriptor>emptyList(), valueParameterDescriptors, null, Modality.FINAL, Visibility.LOCAL);
             context.trace.record(BindingContext.FUNCTION, expression, functionDescriptor);
 
             JetType returnType = NO_EXPECTED_TYPE;
@@ -1194,21 +983,31 @@ public class JetTypeInferrer {
                 context.services.checkFunctionReturnType(functionInnerScope, expression, returnType, context.dataFlowInfo);
             }
             else {
-                if (context.expectedType != NO_EXPECTED_TYPE && JetStandardClasses.isFunctionType(context.expectedType)) {
-                    returnType = JetStandardClasses.getReturnType(context.expectedType);
+                if (functionTypeExpected) {
+                    returnType = JetStandardClasses.getReturnType(expectedType);
                 }
-                returnType = getBlockReturnedType(functionInnerScope, functionLiteral.getBodyExpression(), context.replaceExpectedType(returnType));
+                returnType = context.services.getBlockReturnedType(functionInnerScope, functionLiteral.getBodyExpression(), CoercionStrategy.COERCION_TO_UNIT, context.replaceExpectedType(returnType));
             }
             JetType safeReturnType = returnType == null ? ErrorUtils.createErrorType("<return type>") : returnType;
             functionDescriptor.setReturnType(safeReturnType);
 
+            if (functionTypeExpected) {
+                JetType expectedReturnType = JetStandardClasses.getReturnType(expectedType);
+                if (JetStandardClasses.isUnit(expectedReturnType)) {
+                    return context.services.checkType(JetStandardClasses.getFunctionType(Collections.<AnnotationDescriptor>emptyList(), effectiveReceiverType, parameterTypes, expectedReturnType), expression, context);
+                }
 
+            }
             return context.services.checkType(JetStandardClasses.getFunctionType(Collections.<AnnotationDescriptor>emptyList(), effectiveReceiverType, parameterTypes, safeReturnType), expression, context);
         }
 
         @Override
         public JetType visitParenthesizedExpression(JetParenthesizedExpression expression, TypeInferenceContext context) {
-            return context.services.checkType(getType(context.scope, expression.getExpression(), false, context), expression, context);
+            JetExpression innerExpression = expression.getExpression();
+            if (innerExpression == null) {
+                return null;
+            }
+            return context.services.checkType(getType(innerExpression, context.replaceScope(context.scope)), expression, context);
         }
 
         @Override
@@ -1243,8 +1042,9 @@ public class JetTypeInferrer {
             }
             if (value instanceof ErrorValue) {
                 ErrorValue errorValue = (ErrorValue) value;
-                context.trace.getErrorHandler().genericError(node, errorValue.getMessage());
-                return null;
+//                context.trace.getErrorHandler().genericError(node, errorValue.getMessage());
+                context.trace.report(ERROR_COMPILE_TIME_VALUE.on(node, errorValue.getMessage()));
+                return getDefaultType(elementType);
             }
             else {
                 context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, value);
@@ -1252,11 +1052,36 @@ public class JetTypeInferrer {
             }
         }
 
+        @NotNull
+        private JetType getDefaultType(IElementType constantType) {
+            if (constantType == JetNodeTypes.INTEGER_CONSTANT) {
+                return semanticServices.getStandardLibrary().getIntType();
+            }
+            else if (constantType == JetNodeTypes.FLOAT_CONSTANT) {
+                return semanticServices.getStandardLibrary().getDoubleType();
+            }
+            else if (constantType == JetNodeTypes.BOOLEAN_CONSTANT) {
+                return semanticServices.getStandardLibrary().getBooleanType();
+            }
+            else if (constantType == JetNodeTypes.CHARACTER_CONSTANT) {
+                return semanticServices.getStandardLibrary().getCharType();
+            }
+            else if (constantType == JetNodeTypes.RAW_STRING_CONSTANT) {
+                return semanticServices.getStandardLibrary().getStringType();
+            }
+            else if (constantType == JetNodeTypes.NULL) {
+                return JetStandardClasses.getNullableNothingType();
+            }
+            else {
+                throw new IllegalArgumentException("Unsupported constant type: " + constantType);
+            }
+        }
+
         @Override
         public JetType visitThrowExpression(JetThrowExpression expression, TypeInferenceContext context) {
             JetExpression thrownExpression = expression.getThrownExpression();
             if (thrownExpression != null) {
-                JetType type = getType(context.scope, thrownExpression, false, context.replaceExpectedType(NO_EXPECTED_TYPE));
+                JetType type = getType(thrownExpression, context.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(context.scope));
                 // TODO : check that it inherits Throwable
             }
             return context.services.checkType(JetStandardClasses.getNothingType(), expression, context);
@@ -1265,18 +1090,20 @@ public class JetTypeInferrer {
         @Override
         public JetType visitReturnExpression(JetReturnExpression expression, TypeInferenceContext context) {
             if (context.expectedReturnType == FORBIDDEN) {
-                context.trace.getErrorHandler().genericError(expression.getNode(), "'return' is not allowed here");
+//                context.trace.getErrorHandler().genericError(expression.getNode(), "'return' is not allowed here");
+                context.trace.report(RETURN_NOT_ALLOWED.on(expression));
                 return null;
             }
             JetExpression returnedExpression = expression.getReturnedExpression();
 
             JetType returnedType = JetStandardClasses.getUnitType();
             if (returnedExpression != null) {
-                getType(context.scope, returnedExpression, false, context.replaceExpectedType(context.expectedReturnType));
+                getType(returnedExpression, context.replaceExpectedType(context.expectedReturnType).replaceScope(context.scope));
             }
             else {
                 if (context.expectedReturnType != NO_EXPECTED_TYPE && !JetStandardClasses.isUnit(context.expectedReturnType)) {
-                    context.trace.getErrorHandler().genericError(expression.getNode(), "This function must return a value of type " + context.expectedReturnType);
+//                    context.trace.getErrorHandler().genericError(expression.getNode(), "This function must return a value of type " + context.expectedReturnType);
+                    context.trace.report(RETURN_TYPE_MISMATCH.on(expression, context.expectedReturnType));
                 }
             }
             return context.services.checkType(JetStandardClasses.getNothingType(), expression, context);
@@ -1294,49 +1121,93 @@ public class JetTypeInferrer {
 
         @Override
         public JetType visitBinaryWithTypeRHSExpression(JetBinaryExpressionWithTypeRHS expression, TypeInferenceContext context) {
-            IElementType operationType = expression.getOperationSign().getReferencedNameElementType();
-            JetType actualType = getType(context.scope, expression.getLeft(), false, context.replaceExpectedType(NO_EXPECTED_TYPE));
             JetTypeReference right = expression.getRight();
-            JetType result = null; 
+            JetType result = null;
             if (right != null) {
                 JetType targetType = context.typeResolver.resolveType(context.scope, right);
-                if (operationType == JetTokens.COLON) {
-                    if (actualType != null && !semanticServices.getTypeChecker().isSubtypeOf(actualType, targetType)) {
-                        context.trace.getErrorHandler().typeMismatch(expression.getLeft(), targetType, actualType);
+
+                if (isTypeFlexible(expression.getLeft())) {
+                    TemporaryBindingTrace temporaryTraceWithExpectedType = TemporaryBindingTrace.create(context.trace);
+                    boolean success = checkBinaryWithTypeRHS(expression, context, targetType, targetType, temporaryTraceWithExpectedType);
+                    if (success) {
+                        temporaryTraceWithExpectedType.commit();
+                    }
+                    else {
+                        TemporaryBindingTrace temporaryTraceWithoutExpectedType = TemporaryBindingTrace.create(context.trace);
+                        checkBinaryWithTypeRHS(expression, context, targetType, NO_EXPECTED_TYPE, temporaryTraceWithoutExpectedType);
+                        temporaryTraceWithoutExpectedType.commit();
                     }
-                    result = targetType;
-                }
-                else if (operationType == JetTokens.AS_KEYWORD) {
-                    checkForCastImpossibility(expression, actualType, targetType, context);
-                    result = targetType;
-                }
-                else if (operationType == JetTokens.AS_SAFE) {
-                    checkForCastImpossibility(expression, actualType, targetType, context);
-                    result = TypeUtils.makeNullable(targetType);
                 }
                 else {
-                    context.trace.getErrorHandler().genericError(expression.getOperationSign().getNode(), "Unsupported binary operation");
+                    TemporaryBindingTrace temporaryTraceWithoutExpectedType = TemporaryBindingTrace.create(context.trace);
+                    checkBinaryWithTypeRHS(expression, context, targetType, NO_EXPECTED_TYPE, temporaryTraceWithoutExpectedType);
+                    temporaryTraceWithoutExpectedType.commit();
                 }
+
+                IElementType operationType = expression.getOperationSign().getReferencedNameElementType();
+                result = operationType == JetTokens.AS_SAFE ? TypeUtils.makeNullable(targetType) : targetType;
+            }
+            else {
+                getType(expression.getLeft(), context.replaceExpectedType(NO_EXPECTED_TYPE));
             }
             return context.services.checkType(result, expression, context);
         }
 
+        private boolean isTypeFlexible(@Nullable JetExpression expression) {
+            if (expression == null) return false;
+
+            return TokenSet.create(
+                    JetNodeTypes.INTEGER_CONSTANT,
+                    JetNodeTypes.FLOAT_CONSTANT
+            ).contains(expression.getNode().getElementType());
+        }
+
+        private boolean checkBinaryWithTypeRHS(JetBinaryExpressionWithTypeRHS expression, TypeInferenceContext context, @NotNull JetType targetType, @NotNull JetType expectedType, TemporaryBindingTrace temporaryTrace) {
+            TypeInferenceContext newContext = context.replaceExpectedTypeAndTrace(expectedType, temporaryTrace);
+
+            JetType actualType = getType(expression.getLeft(), newContext);
+            if (actualType == null) return false;
+            
+            JetSimpleNameExpression operationSign = expression.getOperationSign();
+            IElementType operationType = operationSign.getReferencedNameElementType();
+            if (operationType == JetTokens.COLON) {
+                if (targetType != NO_EXPECTED_TYPE && !semanticServices.getTypeChecker().isSubtypeOf(actualType, targetType)) {
+//                    context.trace.getErrorHandler().typeMismatch(expression.getLeft(), targetType, actualType);
+                    context.trace.report(TYPE_MISMATCH.on(expression.getLeft(), targetType, actualType));
+                    return false;
+                }
+                return true;
+            }
+            else if (operationType == JetTokens.AS_KEYWORD || operationType == JetTokens.AS_SAFE) {
+                checkForCastImpossibility(expression, actualType, targetType, context);
+                return true;
+            }
+            else {
+//                context.trace.getErrorHandler().genericError(operationSign.getNode(), "Unknown binary operation");\
+                context.trace.report(UNSUPPORTED.on(operationSign, "binary operation with type RHS"));
+                return false;
+            }
+        }
+
         private void checkForCastImpossibility(JetBinaryExpressionWithTypeRHS expression, JetType actualType, JetType targetType, TypeInferenceContext context) {
-            if (actualType == null) return;
+            if (actualType == null || targetType == NO_EXPECTED_TYPE) return;
 
             JetTypeChecker typeChecker = semanticServices.getTypeChecker();
             if (!typeChecker.isSubtypeOf(targetType, actualType)) {
                 if (typeChecker.isSubtypeOf(actualType, targetType)) {
-                    context.trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "No cast needed, use ':' instead");
+//                    context.trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "No cast needed, use ':' instead");
+                    context.trace.report(USELESS_CAST_STATIC_ASSERT_IS_FINE.on(expression, expression.getOperationSign()));
                 }
                 else {
                     // See JET-58 Make 'as never succeeds' a warning, or even never check for Java (external) types
-                    context.trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "This cast can never succeed");
+//                    context.trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "This cast can never succeed");
+                    context.trace.report(CAST_NEVER_SUCCEEDS.on(expression.getOperationSign()));
                 }
             }
             else {
                 if (typeChecker.isSubtypeOf(actualType, targetType)) {
-                    context.trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "No cast needed");
+//                    context.trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "No cast needed");
+                    context.trace.report(USELESS_CAST.on(expression, expression.getOperationSign()));
                 }
             }
         }
@@ -1346,7 +1217,7 @@ public class JetTypeInferrer {
             List<JetExpression> entries = expression.getEntries();
             List<JetType> types = new ArrayList<JetType>();
             for (JetExpression entry : entries) {
-                types.add(context.services.safeGetType(context.scope, entry, false, NO_EXPECTED_TYPE)); // TODO
+                types.add(context.services.safeGetType(context.scope, entry, NO_EXPECTED_TYPE)); // TODO
             }
             if (context.expectedType != NO_EXPECTED_TYPE && JetStandardClasses.isTupleType(context.expectedType)) {
                 List<JetType> enrichedTypes = context.services.checkArgumentTypes(types, entries, context.expectedType.getArguments(), context);
@@ -1361,7 +1232,7 @@ public class JetTypeInferrer {
         @Override
         public JetType visitThisExpression(JetThisExpression expression, TypeInferenceContext context) {
             JetType result = null;
-            JetType thisType = null;
+            ReceiverDescriptor thisReceiver = null;
             String labelName = expression.getLabelName();
             if (labelName != null) {
                 Collection<DeclarationDescriptor> declarationsByLabel = context.scope.getDeclarationsByLabel(labelName);
@@ -1372,17 +1243,17 @@ public class JetTypeInferrer {
                     DeclarationDescriptor declarationDescriptor = declarationsByLabel.iterator().next();
                     if (declarationDescriptor instanceof ClassDescriptor) {
                         ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor;
-                        thisType = classDescriptor.getDefaultType();
+                        thisReceiver = classDescriptor.getImplicitReceiver();
                     }
                     else if (declarationDescriptor instanceof FunctionDescriptor) {
                         FunctionDescriptor functionDescriptor = (FunctionDescriptor) declarationDescriptor;
-                        thisType = functionDescriptor.getReceiverType();
+                        thisReceiver = functionDescriptor.getReceiver();
                     }
                     else {
                         throw new UnsupportedOperationException(); // TODO
                     }
-                    context.trace.record(BindingContext.REFERENCE_TARGET, targetLabel, declarationDescriptor);
-                    context.trace.record(BindingContext.REFERENCE_TARGET, expression.getThisReference(), declarationDescriptor);
+                    context.trace.record(REFERENCE_TARGET, targetLabel, declarationDescriptor);
+                    context.trace.record(REFERENCE_TARGET, expression.getThisReference(), declarationDescriptor);
                 }
                 else if (size == 0) {
                     // This uses the info written by the control flow processor
@@ -1390,39 +1261,38 @@ public class JetTypeInferrer {
                     if (psiElement instanceof JetFunctionLiteralExpression) {
                         DeclarationDescriptor declarationDescriptor = context.trace.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, psiElement);
                         if (declarationDescriptor instanceof FunctionDescriptor) {
-                            thisType = ((FunctionDescriptor) declarationDescriptor).getReceiverType();
-                            if (thisType == null) {
-                                thisType = JetStandardClasses.getNothingType();
-                            }
-                            else {
-                                context.trace.record(BindingContext.REFERENCE_TARGET, targetLabel, declarationDescriptor);
-                                context.trace.record(BindingContext.REFERENCE_TARGET, expression.getThisReference(), declarationDescriptor);
+                            thisReceiver = ((FunctionDescriptor) declarationDescriptor).getReceiver();
+                            if (thisReceiver.exists()) {
+                                context.trace.record(REFERENCE_TARGET, targetLabel, declarationDescriptor);
+                                context.trace.record(REFERENCE_TARGET, expression.getThisReference(), declarationDescriptor);
                             }
                         }
                         else {
-                            context.trace.getErrorHandler().unresolvedReference(targetLabel);
+                            context.trace.report(UNRESOLVED_REFERENCE.on(targetLabel));
                         }
                     }
                     else {
-                        context.trace.getErrorHandler().unresolvedReference(targetLabel);
+                        context.trace.report(UNRESOLVED_REFERENCE.on(targetLabel));
                     }
                 }
                 else {
-                    context.trace.getErrorHandler().genericError(targetLabel.getNode(), "Ambiguous label");
+//                    context.trace.getErrorHandler().genericError(targetLabel.getNode(), "Ambiguous label");
+                    context.trace.report(AMBIGUOUS_LABEL.on(targetLabel));
                 }
             }
             else {
-                thisType = context.scope.getThisType();
+                thisReceiver = context.scope.getImplicitReceiver();
 
                 DeclarationDescriptor declarationDescriptorForUnqualifiedThis = context.scope.getDeclarationDescriptorForUnqualifiedThis();
                 if (declarationDescriptorForUnqualifiedThis != null) {
-                    context.trace.record(BindingContext.REFERENCE_TARGET, expression.getThisReference(), declarationDescriptorForUnqualifiedThis);
+                    context.trace.record(REFERENCE_TARGET, expression.getThisReference(), declarationDescriptorForUnqualifiedThis);
                 }
             }
 
-            if (thisType != null) {
-                if (JetStandardClasses.isNothing(thisType)) {
-                    context.trace.getErrorHandler().genericError(expression.getNode(), "'this' is not defined in this context");
+            if (thisReceiver != null) {
+                if (!thisReceiver.exists()) {
+//                    context.trace.getErrorHandler().genericError(expression.getNode(), "'this' is not defined in this context");
+                    context.trace.report(NO_THIS.on(expression));
                 }
                 else {
                     JetTypeReference superTypeQualifier = expression.getSuperTypeQualifier();
@@ -1436,6 +1306,7 @@ public class JetTypeInferrer {
                             if (classifierCandidate instanceof ClassDescriptor) {
                                 ClassDescriptor superclass = (ClassDescriptor) classifierCandidate;
 
+                                JetType thisType = thisReceiver.getType();
                                 Collection<? extends JetType> supertypes = thisType.getConstructor().getSupertypes();
                                 TypeSubstitutor substitutor = TypeSubstitutor.create(thisType);
                                 for (JetType declaredSupertype : supertypes) {
@@ -1445,12 +1316,14 @@ public class JetTypeInferrer {
                                     }
                                 }
                                 if (result == null) {
-                                    context.trace.getErrorHandler().genericError(superTypeElement.getNode(), "Not a superclass");
+//                                    context.trace.getErrorHandler().genericError(superTypeElement.getNode(), "Not a superclass");
+                                    context.trace.report(NOT_A_SUPERTYPE.on(superTypeElement));
                                 }
                             }
                         }
-                    } else {
-                        result = thisType;
+                    }
+                    else {
+                        result = thisReceiver.getType();
                     }
                     if (result != null) {
                         context.trace.record(BindingContext.EXPRESSION_TYPE, expression.getThisReference(), result);
@@ -1462,7 +1335,7 @@ public class JetTypeInferrer {
 
         @Override
         public JetType visitBlockExpression(JetBlockExpression expression, TypeInferenceContext context) {
-            return context.services.checkType(getBlockReturnedType(context.scope, expression, context), expression, context);
+            return context.services.getBlockReturnedType(context.scope, expression, CoercionStrategy.NO_COERCION, context);
         }
 
         @Override
@@ -1471,7 +1344,7 @@ public class JetTypeInferrer {
             // TODO :change scope according to the bound value in the when header
             final JetExpression subjectExpression = expression.getSubjectExpression();
 
-            final JetType subjectType = subjectExpression != null ? context.services.safeGetType(context.scope, subjectExpression, false, NO_EXPECTED_TYPE) : ErrorUtils.createErrorType("Unknown type");
+            final JetType subjectType = subjectExpression != null ? context.services.safeGetType(context.scope, subjectExpression, NO_EXPECTED_TYPE) : ErrorUtils.createErrorType("Unknown type");
             final VariableDescriptor variableDescriptor = subjectExpression != null ? context.services.getVariableDescriptorFromSimpleName(subjectExpression, context) : null;
 
             // TODO : exhaustive patterns
@@ -1510,7 +1383,7 @@ public class JetTypeInferrer {
                 }
                 JetExpression bodyExpression = whenEntry.getExpression();
                 if (bodyExpression != null) {
-                    JetType type = getTypeWithNewDataFlowInfo(scopeToExtend, bodyExpression, true, newDataFlowInfo, contextWithExpectedType);
+                    JetType type = getTypeWithNewScopeAndDataFlowInfo(scopeToExtend, bodyExpression, newDataFlowInfo, contextWithExpectedType);
                     if (type != null) {
                         expressionTypes.add(type);
                     }
@@ -1521,7 +1394,8 @@ public class JetTypeInferrer {
                 return semanticServices.getTypeChecker().commonSupertype(expressionTypes);
             }
             else if (expression.getEntries().isEmpty()) {
-                context.trace.getErrorHandler().genericError(expression.getNode(), "Entries required for when-expression"); // TODO : Scope, and maybe this should not an error
+//                context.trace.getErrorHandler().genericError(expression.getNode(), "Entries required for when-expression");
+                context.trace.report(NO_WHEN_ENTRIES.on(expression));
             }
             return null;
         }
@@ -1533,11 +1407,13 @@ public class JetTypeInferrer {
                 @Override
                 public void visitWhenConditionCall(JetWhenConditionCall condition) {
                     JetExpression callSuffixExpression = condition.getCallSuffixExpression();
-                    JetScope compositeScope = new ScopeWithReceiver(context.scope, subjectType, semanticServices.getTypeChecker());
+//                    JetScope compositeScope = new ScopeWithReceiver(context.scope, subjectType, semanticServices.getTypeChecker());
                     if (callSuffixExpression != null) {
-                        JetType selectorReturnType = getType(compositeScope, callSuffixExpression, false, context);
+//                        JetType selectorReturnType = getType(compositeScope, callSuffixExpression, false, context);
+                        assert subjectExpression != null;
+                        JetType selectorReturnType = getSelectorReturnType(new ExpressionReceiver(subjectExpression, subjectType), callSuffixExpression, context);//getType(compositeScope, callSuffixExpression, false, context);
                         ensureBooleanResultWithCustomSubject(callSuffixExpression, selectorReturnType, "This expression", context);
-                        context.services.checkNullSafety(subjectType, condition.getOperationTokenNode(), getCalleeFunctionDescriptor(callSuffixExpression, context));
+                        context.services.checkNullSafety(subjectType, condition.getOperationTokenNode(), getCalleeFunctionDescriptor(callSuffixExpression, context), condition);
                     }
                 }
 
@@ -1560,7 +1436,8 @@ public class JetTypeInferrer {
 
                 @Override
                 public void visitJetElement(JetElement element) {
-                    context.trace.getErrorHandler().genericError(element.getNode(), "Unsupported [JetTypeInferrer] : " + element);
+//                    context.trace.getErrorHandler().genericError(element.getNode(), "Unsupported [JetTypeInferrer] : " + element);
+                    context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName()));
                 }
             });
             return newDataFlowInfo[0];
@@ -1585,7 +1462,8 @@ public class JetTypeInferrer {
                     TypeConstructor typeConstructor = subjectType.getConstructor();
                     if (!JetStandardClasses.getTuple(entries.size()).getTypeConstructor().equals(typeConstructor)
                         || typeConstructor.getParameters().size() != entries.size()) {
-                        context.trace.getErrorHandler().genericError(pattern.getNode(), "Type mismatch: subject is of type " + subjectType + " but the pattern is of type Tuple" + entries.size()); // TODO : message
+//                        context.trace.getErrorHandler().genericError(pattern.getNode(), "Type mismatch: subject is of type " + subjectType + " but the pattern is of type Tuple" + entries.size());
+                        context.trace.report(TYPE_MISMATCH_IN_TUPLE_PATTERN.on(pattern, subjectType, entries.size()));
                     }
                     else {
                         for (int i = 0, entriesSize = entries.size(); i < entriesSize; i++) {
@@ -1595,7 +1473,8 @@ public class JetTypeInferrer {
                             // TODO : is a name always allowed, ie for tuple patterns, not decomposer arg lists?
                             ASTNode nameLabelNode = entry.getNameLabelNode();
                             if (nameLabelNode != null) {
-                                context.trace.getErrorHandler().genericError(nameLabelNode, "Unsupported [JetTypeInferrer]");
+//                                context.trace.getErrorHandler().genericError(nameLabelNode, "Unsupported [JetTypeInferrer]");
+                                context.trace.report(UNSUPPORTED.on(nameLabelNode, getClass().getCanonicalName()));
                             }
 
                             JetPattern entryPattern = entry.getPattern();
@@ -1608,9 +1487,13 @@ public class JetTypeInferrer {
 
                 @Override
                 public void visitDecomposerPattern(JetDecomposerPattern pattern) {
-                    JetType selectorReturnType = getSelectorReturnType(subjectType, pattern.getDecomposerExpression(), context);
+                    JetExpression decomposerExpression = pattern.getDecomposerExpression();
+                    if (decomposerExpression != null) {
+                        ReceiverDescriptor receiver = new TransientReceiver(subjectType);
+                        JetType selectorReturnType = getSelectorReturnType(receiver, decomposerExpression, context);
 
-                    result[0] = checkPatternType(pattern.getArgumentList(), selectorReturnType == null ? ErrorUtils.createErrorType("No type") : selectorReturnType, scopeToExtend, context);
+                        result[0] = checkPatternType(pattern.getArgumentList(), selectorReturnType == null ? ErrorUtils.createErrorType("No type") : selectorReturnType, scopeToExtend, context);
+                    }
                 }
 
                 @Override
@@ -1622,7 +1505,7 @@ public class JetTypeInferrer {
                 public void visitExpressionPattern(JetExpressionPattern pattern) {
                     JetExpression expression = pattern.getExpression();
                     if (expression != null) {
-                        JetType type = getType(scopeToExtend, expression, false, context);
+                        JetType type = getType(expression, context.replaceScope(scopeToExtend));
                         checkTypeCompatibility(type, subjectType, pattern);
                     }
                 }
@@ -1636,7 +1519,8 @@ public class JetTypeInferrer {
                     scopeToExtend.addVariableDescriptor(variableDescriptor);
                     if (propertyTypeRef != null) {
                         if (!semanticServices.getTypeChecker().isSubtypeOf(subjectType, type)) {
-                            context.trace.getErrorHandler().genericError(propertyTypeRef.getNode(), type + " must be a supertype of " + subjectType + ". Use 'is' to match against " + type);
+//                            context.trace.getErrorHandler().genericError(propertyTypeRef.getNode(), type + " must be a supertype of " + subjectType + ". Use 'is' to match against " + type);
+                            context.trace.report(TYPE_MISMATCH_IN_BINDING_PATTERN.on(propertyTypeRef, type, subjectType));
                         }
                     }
 
@@ -1656,13 +1540,15 @@ public class JetTypeInferrer {
                         return;
                     }
                     if (TypeUtils.intersect(semanticServices.getTypeChecker(), Sets.newHashSet(type, subjectType)) == null) {
-                        context.trace.getErrorHandler().genericError(reportErrorOn.getNode(), "Incompatible types: " + type + " and " + subjectType); // TODO : message
+//                        context.trace.getErrorHandler().genericError(reportErrorOn.getNode(), "Incompatible types: " + type + " and " + subjectType);
+                        context.trace.report(INCOMPATIBLE_TYPES.on(reportErrorOn, type, subjectType));
                     }
                 }
 
                 @Override
                 public void visitJetElement(JetElement element) {
-                    context.trace.getErrorHandler().genericError(element.getNode(), "Unsupported [JetTypeInferrer]");
+//                    context.trace.getErrorHandler().genericError(element.getNode(), "Unsupported [JetTypeInferrer]");
+                    context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName()));
                 }
             });
             return result[0];
@@ -1682,7 +1568,7 @@ public class JetTypeInferrer {
                     if (catchBody != null) {
                         WritableScope catchScope = newWritableScopeImpl(context.scope, context.trace).setDebugName("Catch scope");
                         catchScope.addVariableDescriptor(variableDescriptor);
-                        JetType type = getType(catchScope, catchBody, true, context);
+                        JetType type = getType(catchBody, context.replaceScope(catchScope));
                         if (type != null) {
                             types.add(type);
                         }
@@ -1691,12 +1577,12 @@ public class JetTypeInferrer {
             }
             if (finallyBlock != null) {
                 types.clear(); // Do not need the list for the check, but need the code above to typecheck catch bodies
-                JetType type = getType(context.scope, finallyBlock.getFinalExpression(), true, context);
+                JetType type = getType(finallyBlock.getFinalExpression(), context.replaceScope(context.scope));
                 if (type != null) {
                     types.add(type);
                 }
             }
-            JetType type = getType(context.scope, tryBlock, true, context);
+            JetType type = getType(tryBlock, context.replaceScope(context.scope));
             if (type != null) {
                 types.add(type);
             }
@@ -1723,7 +1609,7 @@ public class JetTypeInferrer {
 
             if (elseBranch == null) {
                 if (thenBranch != null) {
-                    JetType type = getTypeWithNewDataFlowInfo(thenScope, thenBranch, true, thenInfo, context);
+                    JetType type = getTypeWithNewScopeAndDataFlowInfo(thenScope, thenBranch, thenInfo, context);
                     if (type != null && JetStandardClasses.isNothing(type)) {
                         resultDataFlowInfo = elseInfo;
 //                        resultScope = elseScope;
@@ -1733,15 +1619,15 @@ public class JetTypeInferrer {
                 return null;
             }
             if (thenBranch == null) {
-                JetType type = getTypeWithNewDataFlowInfo(context.scope, elseBranch, true, elseInfo, context);
+                JetType type = getTypeWithNewScopeAndDataFlowInfo(context.scope, elseBranch, elseInfo, context);
                 if (type != null && JetStandardClasses.isNothing(type)) {
                     resultDataFlowInfo = thenInfo;
 //                    resultScope = thenScope;
                 }
                 return context.services.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType);
             }
-            JetType thenType = getTypeWithNewDataFlowInfo(thenScope, thenBranch, true, thenInfo, contextWithExpectedType);
-            JetType elseType = getTypeWithNewDataFlowInfo(context.scope, elseBranch, true, elseInfo, contextWithExpectedType);
+            JetType thenType = getTypeWithNewScopeAndDataFlowInfo(thenScope, thenBranch, thenInfo, contextWithExpectedType);
+            JetType elseType = getTypeWithNewScopeAndDataFlowInfo(context.scope, elseBranch, elseInfo, contextWithExpectedType);
 
             JetType result;
             if (thenType == null) {
@@ -1904,10 +1790,11 @@ public class JetTypeInferrer {
 
         private void checkCondition(@NotNull JetScope scope, @Nullable JetExpression condition, TypeInferenceContext context) {
             if (condition != null) {
-                JetType conditionType = getType(scope, condition, false, context);
+                JetType conditionType = getType(condition, context.replaceScope(scope));
 
                 if (conditionType != null && !isBoolean(conditionType)) {
-                    context.trace.getErrorHandler().genericError(condition.getNode(), "Condition must be of type Boolean, but was of type " + conditionType);
+//                    context.trace.getErrorHandler().genericError(condition.getNode(), "Condition must be of type Boolean, but was of type " + conditionType);
+                    context.trace.report(TYPE_MISMATCH_IN_CONDITION.on(condition, conditionType));
                 }
             }
         }
@@ -1921,7 +1808,7 @@ public class JetTypeInferrer {
             if (body != null) {
                 WritableScopeImpl scopeToExtend = newWritableScopeImpl(context.scope, context.trace).setDebugName("Scope extended in while's condition");
                 DataFlowInfo conditionInfo = condition == null ? context.dataFlowInfo : extractDataFlowInfoFromCondition(condition, true, scopeToExtend, context);
-                getTypeWithNewDataFlowInfo(scopeToExtend, body, true, conditionInfo, context);
+                getTypeWithNewScopeAndDataFlowInfo(scopeToExtend, body, conditionInfo, context);
             }
             if (!flowInformationProvider.isBreakable(expression)) {
 //                resultScope = newWritableScopeImpl();
@@ -1940,16 +1827,16 @@ public class JetTypeInferrer {
                 if (!function.getFunctionLiteral().hasParameterSpecification()) {
                     WritableScope writableScope = newWritableScopeImpl(context.scope, context.trace).setDebugName("do..while body scope");
                     conditionScope = writableScope;
-                    context.services.getBlockReturnedTypeWithWritableScope(writableScope, function.getFunctionLiteral().getBodyExpression().getStatements(), context);
+                    context.services.getBlockReturnedTypeWithWritableScope(writableScope, function.getFunctionLiteral().getBodyExpression().getStatements(), CoercionStrategy.NO_COERCION, context);
                     context.trace.record(BindingContext.BLOCK, function);
                 } else {
-                    getType(context.scope, body, true, context);
+                    getType(body, context.replaceScope(context.scope));
                 }
             }
             else if (body != null) {
                 WritableScope writableScope = newWritableScopeImpl(context.scope, context.trace).setDebugName("do..while body scope");
                 conditionScope = writableScope;
-                context.services.getBlockReturnedTypeWithWritableScope(writableScope, Collections.singletonList(body), context);
+                context.services.getBlockReturnedTypeWithWritableScope(writableScope, Collections.singletonList(body), CoercionStrategy.NO_COERCION, context);
             }
             JetExpression condition = expression.getCondition();
             checkCondition(conditionScope, condition, context);
@@ -1961,7 +1848,7 @@ public class JetTypeInferrer {
         }
 
         protected WritableScopeImpl newWritableScopeImpl(JetScope scope, BindingTrace trace) {
-            return new WritableScopeImpl(scope, scope.getContainingDeclaration(), trace.getErrorHandler());
+            return new WritableScopeImpl(scope, scope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(trace));
         }
 
         @Override
@@ -1969,13 +1856,12 @@ public class JetTypeInferrer {
             TypeInferenceContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
             JetParameter loopParameter = expression.getLoopParameter();
             JetExpression loopRange = expression.getLoopRange();
-            JetType loopRangeType = null;
-            if (loopRange != null) {
-                loopRangeType = getType(context.scope, loopRange, false, context);
-            }
             JetType expectedParameterType = null;
-            if (loopRangeType != null) {
-                expectedParameterType = checkIterableConvention(loopRangeType, loopRange.getNode(), context);
+            if (loopRange != null) {
+                ExpressionReceiver loopRangeReceiver = getExpressionReceiver(loopRange, context.replaceScope(context.scope));
+                if (loopRangeReceiver != null) {
+                    expectedParameterType = checkIterableConvention(loopRangeReceiver, context);
+                }
             }
 
             WritableScope loopScope = newWritableScopeImpl(context.scope, context.trace).setDebugName("Scope with for-loop index");
@@ -1989,7 +1875,8 @@ public class JetTypeInferrer {
                     if (expectedParameterType != null &&
                             actualParameterType != null &&
                             !semanticServices.getTypeChecker().isSubtypeOf(expectedParameterType, actualParameterType)) {
-                        context.trace.getErrorHandler().genericError(typeReference.getNode(), "The loop iterates over values of type " + expectedParameterType + " but the parameter is declared to be " + actualParameterType);
+//                        context.trace.getErrorHandler().genericError(typeReference.getNode(), "The loop iterates over values of type " + expectedParameterType + " but the parameter is declared to be " + actualParameterType);
+                        context.trace.report(TYPE_MISMATCH_IN_FOR_LOOP.on(typeReference, expectedParameterType, actualParameterType));
                     }
                 }
                 else {
@@ -2003,165 +1890,113 @@ public class JetTypeInferrer {
 
             JetExpression body = expression.getBody();
             if (body != null) {
-                getType(loopScope, body, true, context); // TODO
+                getType(body, context.replaceScope(loopScope));
             }
 
             return context.services.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType);
         }
 
         @Nullable
-        private JetType checkIterableConvention(@NotNull JetType type, @NotNull ASTNode reportErrorsOn, TypeInferenceContext context) {
-            OverloadResolutionResult iteratorResolutionResult = context.services.resolveNoParametersFunction(type, context.scope, "iterator");
+        private JetType checkIterableConvention(@NotNull ExpressionReceiver loopRange, TypeInferenceContext context) {
+            JetExpression loopRangeExpression = loopRange.getExpression();
+            OverloadResolutionResult<FunctionDescriptor> iteratorResolutionResult = callResolver.resolveExactSignature(context.scope, loopRange, "iterator", Collections.<JetType>emptyList());
             if (iteratorResolutionResult.isSuccess()) {
-                JetType iteratorType = iteratorResolutionResult.getFunctionDescriptor().getReturnType();
-                boolean hasNextFunctionSupported = checkHasNextFunctionSupport(reportErrorsOn, iteratorType, context);
-                boolean hasNextPropertySupported = checkHasNextPropertySupport(reportErrorsOn, iteratorType, context);
+                FunctionDescriptor iteratorFunction = iteratorResolutionResult.getDescriptor();
+                
+                context.trace.record(LOOP_RANGE_ITERATOR, loopRangeExpression, iteratorFunction);
+                
+                JetType iteratorType = iteratorFunction.getReturnType();
+                FunctionDescriptor hasNextFunction = checkHasNextFunctionSupport(loopRangeExpression, iteratorType, context);
+                boolean hasNextFunctionSupported = hasNextFunction != null;
+                VariableDescriptor hasNextProperty = checkHasNextPropertySupport(loopRangeExpression, iteratorType, context);
+                boolean hasNextPropertySupported = hasNextProperty != null;
                 if (hasNextFunctionSupported && hasNextPropertySupported && !ErrorUtils.isErrorType(iteratorType)) {
                     // TODO : overload resolution rules impose priorities here???
-                    context.trace.getErrorHandler().genericError(reportErrorsOn, "An ambiguity between 'iterator().hasNext()' function and 'iterator().hasNext()' property");
+//                    context.trace.getErrorHandler().genericError(reportErrorsOn, "An ambiguity between 'iterator().hasNext()' function and 'iterator().hasNext' property");
+                    context.trace.report(HAS_NEXT_PROPERTY_AND_FUNCTION_AMBIGUITY.on(loopRangeExpression));
                 }
                 else if (!hasNextFunctionSupported && !hasNextPropertySupported) {
-                    context.trace.getErrorHandler().genericError(reportErrorsOn, "Loop range must have an 'iterator().hasNext()' function or an 'iterator().hasNext' property");
+//                    context.trace.getErrorHandler().genericError(reportErrorsOn, "Loop range must have an 'iterator().hasNext()' function or an 'iterator().hasNext' property");
+                    context.trace.report(HAS_NEXT_MISSING.on(loopRangeExpression));
+                }
+                else {
+                    context.trace.record(LOOP_RANGE_HAS_NEXT, loopRange.getExpression(), hasNextFunctionSupported ? hasNextFunction : hasNextProperty);
                 }
 
-                OverloadResolutionResult nextResolutionResult = context.services.resolveNoParametersFunction(iteratorType, context.scope, "next");
+                OverloadResolutionResult<FunctionDescriptor> nextResolutionResult = callResolver.resolveExactSignature(context.scope, new TransientReceiver(iteratorType), "next", Collections.<JetType>emptyList());
                 if (nextResolutionResult.isAmbiguity()) {
-                    context.trace.getErrorHandler().genericError(reportErrorsOn, "Method 'iterator().next()' is ambiguous for this expression");
+//                    context.trace.getErrorHandler().genericError(reportErrorsOn, "Method 'iterator().next()' is ambiguous for this expression");
+                    context.trace.report(NEXT_AMBIGUITY.on(loopRangeExpression));
                 } else if (nextResolutionResult.isNothing()) {
-                    context.trace.getErrorHandler().genericError(reportErrorsOn, "Loop range must have an 'iterator().next()' method");
+//                    context.trace.getErrorHandler().genericError(reportErrorsOn, "Loop range must have an 'iterator().next()' method");
+                    context.trace.report(NEXT_MISSING.on(loopRangeExpression));
                 } else {
-                    return nextResolutionResult.getFunctionDescriptor().getReturnType();
+                    FunctionDescriptor nextFunction = nextResolutionResult.getDescriptor();
+                    context.trace.record(LOOP_RANGE_NEXT, loopRange.getExpression(), nextFunction);
+                    return nextFunction.getReturnType();
                 }
             }
             else {
-                String errorMessage = "For-loop range must have an iterator() method";
                 if (iteratorResolutionResult.isAmbiguity()) {
-                    errorMessage = "Method 'iterator()' is ambiguous for this expression";
+//                    StringBuffer stringBuffer = new StringBuffer("Method 'iterator()' is ambiguous for this expression: ");
+//                    for (FunctionDescriptor functionDescriptor : iteratorResolutionResult.getDescriptors()) {
+//                        stringBuffer.append(DescriptorRenderer.TEXT.render(functionDescriptor)).append(" ");
+//                    }
+//                    errorMessage = stringBuffer.toString();
+                    context.trace.report(ITERATOR_AMBIGUITY.on(loopRangeExpression, iteratorResolutionResult.getDescriptors()));
+                }
+                else {
+//                    context.trace.getErrorHandler().genericError(reportErrorsOn, errorMessage);
+                    context.trace.report(ITERATOR_MISSING.on(loopRangeExpression));
                 }
-                context.trace.getErrorHandler().genericError(reportErrorsOn, errorMessage);
             }
             return null;
         }
 
-        private boolean checkHasNextFunctionSupport(@NotNull ASTNode reportErrorsOn, @NotNull JetType iteratorType, TypeInferenceContext context) {
-            OverloadResolutionResult hasNextResolutionResult = context.services.resolveNoParametersFunction(iteratorType, context.scope, "hasNext");
+        @Nullable
+        private FunctionDescriptor checkHasNextFunctionSupport(@NotNull JetExpression loopRange, @NotNull JetType iteratorType, TypeInferenceContext context) {
+            OverloadResolutionResult<FunctionDescriptor> hasNextResolutionResult = callResolver.resolveExactSignature(context.scope, new TransientReceiver(iteratorType), "hasNext", Collections.<JetType>emptyList());
             if (hasNextResolutionResult.isAmbiguity()) {
-                context.trace.getErrorHandler().genericError(reportErrorsOn, "Method 'iterator().hasNext()' is ambiguous for this expression");
+//                context.trace.getErrorHandler().genericError(loopRange.getNode(), "Method 'iterator().hasNext()' is ambiguous for this expression");
+                context.trace.report(HAS_NEXT_FUNCTION_AMBIGUITY.on(loopRange));
             } else if (hasNextResolutionResult.isNothing()) {
-                return false;
+                return null;
             } else {
-                JetType hasNextReturnType = hasNextResolutionResult.getFunctionDescriptor().getReturnType();
+                assert hasNextResolutionResult.isSuccess();
+                JetType hasNextReturnType = hasNextResolutionResult.getDescriptor().getReturnType();
                 if (!isBoolean(hasNextReturnType)) {
-                    context.trace.getErrorHandler().genericError(reportErrorsOn, "The 'iterator().hasNext()' method of the loop range must return Boolean, but returns " + hasNextReturnType);
+//                    context.trace.getErrorHandler().genericError(loopRange.getNode(), "The 'iterator().hasNext()' method of the loop range must return Boolean, but returns " + hasNextReturnType);
+                    context.trace.report(HAS_NEXT_FUNCTION_TYPE_MISMATCH.on(loopRange, hasNextReturnType));
                 }
             }
-            return true;
+            return hasNextResolutionResult.getDescriptor();
         }
 
-        private boolean checkHasNextPropertySupport(@NotNull ASTNode reportErrorsOn, @NotNull JetType iteratorType, TypeInferenceContext context) {
+        @Nullable
+        private VariableDescriptor checkHasNextPropertySupport(@NotNull JetExpression loopRange, @NotNull JetType iteratorType, TypeInferenceContext context) {
             VariableDescriptor hasNextProperty = iteratorType.getMemberScope().getVariable("hasNext");
             // TODO :extension properties
             if (hasNextProperty == null) {
-                return false;
+                return null;
             } else {
                 JetType hasNextReturnType = hasNextProperty.getOutType();
                 if (hasNextReturnType == null) {
                     // TODO : accessibility
-                    context.trace.getErrorHandler().genericError(reportErrorsOn, "The 'iterator().hasNext' property of the loop range must be readable");
+//                    context.trace.getErrorHandler().genericError(loopRange.getNode(), "The 'iterator().hasNext' property of the loop range must be readable");
+                    context.trace.report(HAS_NEXT_MUST_BE_READABLE.on(loopRange));
                 }
                 else if (!isBoolean(hasNextReturnType)) {
-                    context.trace.getErrorHandler().genericError(reportErrorsOn, "The 'iterator().hasNext' property of the loop range must return Boolean, but returns " + hasNextReturnType);
+//                    context.trace.getErrorHandler().genericError(loopRange.getNode(), "The 'iterator().hasNext' property of the loop range must return Boolean, but returns " + hasNextReturnType);
+                    context.trace.report(HAS_NEXT_PROPERTY_TYPE_MISMATCH.on(loopRange, hasNextReturnType));
                 }
             }
-            return true;
+            return hasNextProperty;
         }
 
-//        @Override
-//        public void visitNewExpression(JetNewExpression expression) {
-//            // TODO : type argument inference
-//            JetTypeReference typeReference = expression.getTypeReference();
-//            if (typeReference != null) {
-//                result = checkTypeInitializerCall(scope, typeReference, expression);
-//            }
-//        }
-
-//        private void resolveCallWithExplicitName(@NotNull JetScope scope, JetExpression receiver, String functionName, List<JetType> resolvedTypeArguments, List<ValueArgumentPsi> valueArguments) {
-//
-//            boolean someNamed = false;
-//            boolean allNamed = true;
-//            for (ValueArgumentPsi valueArgument : valueArguments) {
-//                if (valueArgument.isNamed()) {
-//                    context.trace.getErrorHandler().genericError(valueArgument.asElement().getNode(), "Named arguments are not supported");
-//                    someNamed = true;
-//                }
-//                else {
-//                    allNamed = false;
-//                }
-//            }
-//            if (someNamed) {
-//                return; // TODO
-//            }
-//            if (someNamed && !allNamed) {
-//                // TODO function literals outside parentheses
-//            }
-//
-//            ErrorHandlerWithRegions errorHandler = context.trace.getErrorHandler();
-//
-//            // 1. resolve 'receiver' in 'scope' with expected type 'NO_EXPECTED_TYPE'
-//            errorHandler.openRegion();
-//            JetType receiverType = JetTypeInferrer.this.getType(scope, receiver, false, NO_EXPECTED_TYPE);
-//            // for each applicable function in 'receiverType'
-//            Set<FunctionDescriptor> allFunctions = receiverType.getMemberScope().getFunctionGroup(functionName).getFunctionDescriptors();
-//            Map<FunctionDescriptor, List<JetType>> applicableFunctions = Maps.newHashMap();
-//            int typeArgCount = resolvedTypeArguments.size();
-//            int valueArgCount = valueArguments.size();
-//            for (FunctionDescriptor functionDescriptor : allFunctions) {
-//                if (typeArgCount == 0 || functionDescriptor.getTypeParameters().size() == typeArgCount) {
-//                    if (FunctionDescriptorUtil.getMinimumArity(functionDescriptor) <= valueArgCount &&
-//                            valueArgCount <= FunctionDescriptorUtil.getMaximumArity(functionDescriptor)) {
-//                        //   get expected types for value parameters
-//                        if (typeArgCount > 0) {
-//                            FunctionDescriptor substitutedFunctionDescriptor = FunctionDescriptorUtil.substituteFunctionDescriptor(resolvedTypeArguments, functionDescriptor);
-//                        }
-//                        else {
-//                            FunctionDescriptor substitutedFunctionDescriptor = FunctionDescriptorUtil.substituteFunctionDescriptor(TypeUtils.getDefaultTypes(functionDescriptor.getTypeParameters()), functionDescriptor);
-//                            List<JetType> valueArgumentTypes = getArgumentTypes(substitutedFunctionDescriptor, valueArguments);
-//                            if (valueArgumentTypes == null) {
-//                                Map<TypeConstructor, TypeProjection> noExpectedTypes = Maps.newHashMap();
-//                                for (TypeParameterDescriptor typeParameterDescriptor : functionDescriptor.getTypeParameters()) {
-//                                    noExpectedTypes.put(typeParameterDescriptor.getTypeConstructor(), new TypeProjection(NO_EXPECTED_TYPE));
-//                                }
-//                                substitutedFunctionDescriptor = functionDescriptor.substitute(TypeSubstitutor.create(noExpectedTypes));
-//                                valueArgumentTypes = getArgumentTypes(substitutedFunctionDescriptor, valueArguments);
-//                            }
-//                            if (valueArgumentTypes != null) {
-//                                List<JetType> typeArguments = solveConstraintSystem(functionDescriptor, valueArgumentTypes, expectedReturnType);
-//                                if (typeArguments != null) {
-//                                    applicableFunctions.put(functionDescriptor, typeArguments);
-//                                }
-//                            }
-//                        }
-//                        //   type-check the parameters
-//                        // if something was found (one or many options
-//                        errorHandler.closeAndCommitCurrentRegion();
-//                        // otherwise
-//                        errorHandler.closeAndReturnCurrentRegion();
-//
-//                    }
-//                }
-//            }
-//            //   get expected types for value parameters
-//            //   type-check the parameters
-//            // if something was found (one or many options
-//            errorHandler.closeAndCommitCurrentRegion();
-//            // otherwise
-//            errorHandler.closeAndReturnCurrentRegion();
-//
-//        }
-
         @Override
         public JetType visitHashQualifiedExpression(JetHashQualifiedExpression expression, TypeInferenceContext context) {
-            context.trace.getErrorHandler().genericError(expression.getOperationTokenNode(), "Unsupported");
+//            context.trace.getErrorHandler().genericError(expression.getOperationTokenNode(), "Unsupported");
+            context.trace.report(UNSUPPORTED.on(expression, getClass().getCanonicalName()));
             return null;
         }
 
@@ -2171,15 +2006,18 @@ public class JetTypeInferrer {
             // TODO : functions as values
             JetExpression selectorExpression = expression.getSelectorExpression();
             JetExpression receiverExpression = expression.getReceiverExpression();
-            JetType receiverType = context.services.typeInferrerVisitorWithNamespaces.getType(receiverExpression, new TypeInferenceContext(context.trace, context.scope, false, context.dataFlowInfo, NO_EXPECTED_TYPE, NO_EXPECTED_TYPE));
-            if (receiverType == null) return null;
+            JetType receiverType = context.services.typeInferrerVisitorWithNamespaces.getType(receiverExpression, context.replaceExpectedTypes(NO_EXPECTED_TYPE, NO_EXPECTED_TYPE));
+            if (selectorExpression == null) return null;
+            if (receiverType == null) receiverType = ErrorUtils.createErrorType("Type for " + expression.getText());
+
+            if (selectorExpression instanceof JetSimpleNameExpression) {
+                propagateConstantValues(expression, context, (JetSimpleNameExpression) selectorExpression);
+            }
 
             // Clean resolution: no autocasts
-            TemporaryBindingTrace cleanResolutionTrace = new TemporaryBindingTrace(context.trace.getBindingContext());
+            TemporaryBindingTrace cleanResolutionTrace = TemporaryBindingTrace.create(context.trace);
             TypeInferenceContext cleanResolutionContext = context.replaceBindingTrace(cleanResolutionTrace);
-//            ErrorHandler errorHandler = context.trace.getErrorHandler();
-//            errorHandler.openRegion();
-            JetType selectorReturnType = getSelectorReturnType(receiverType, selectorExpression, cleanResolutionContext);
+            JetType selectorReturnType = getSelectorReturnType(new ExpressionReceiver(receiverExpression, receiverType), selectorExpression, cleanResolutionContext);
 
             //TODO move further
             if (expression.getOperationSign() == JetTokens.SAFE_ACCESS) {
@@ -2197,24 +2035,24 @@ public class JetTypeInferrer {
                     List<JetType> possibleTypes = Lists.newArrayList(context.dataFlowInfo.getPossibleTypes(variableDescriptor));
                     Collections.reverse(possibleTypes);
 
-                    TemporaryBindingTrace autocastResolutionTrace = new TemporaryBindingTrace(context.trace.getBindingContext());
+                    TemporaryBindingTrace autocastResolutionTrace = TemporaryBindingTrace.create(context.trace);
                     TypeInferenceContext autocastResolutionContext = context.replaceBindingTrace(autocastResolutionTrace);
                     for (JetType possibleType : possibleTypes) {
-                        selectorReturnType = getSelectorReturnType(possibleType, selectorExpression, autocastResolutionContext);
+                        selectorReturnType = getSelectorReturnType(new ExpressionReceiver(receiverExpression, possibleType), selectorExpression, autocastResolutionContext);
                         if (selectorReturnType != null) {
-                            autocastResolutionTrace.record(BindingContext.AUTOCAST, receiverExpression, possibleType);
-                            autocastResolutionTrace.addAllMyDataTo(context.trace);
+                            context.services.checkAutoCast(receiverExpression, possibleType, variableDescriptor, autocastResolutionTrace);
+                            autocastResolutionTrace.commit();
                             somethingFound = true;
                             break;
                         }
                         else {
-                            autocastResolutionTrace = new TemporaryBindingTrace(context.trace.getBindingContext());
+                            autocastResolutionTrace = TemporaryBindingTrace.create(context.trace);
                             autocastResolutionContext = context.replaceBindingTrace(autocastResolutionTrace);
                         }
                     }
                 }
                 if (!somethingFound) {
-                    cleanResolutionTrace.addAllMyDataTo(context.trace);
+                    cleanResolutionTrace.commit();
                 }
             }
 
@@ -2222,7 +2060,8 @@ public class JetTypeInferrer {
             if (expression.getOperationSign() == JetTokens.QUEST) {
                 if (selectorReturnType != null && !isBoolean(selectorReturnType) && selectorExpression != null) {
                     // TODO : more comprehensible error message
-                    context.trace.getErrorHandler().typeMismatch(selectorExpression, semanticServices.getStandardLibrary().getBooleanType(), selectorReturnType);
+//                    context.trace.getErrorHandler().typeMismatch(selectorExpression, semanticServices.getStandardLibrary().getBooleanType(), selectorReturnType);
+                    context.trace.report(TYPE_MISMATCH.on(selectorExpression, semanticServices.getStandardLibrary().getBooleanType(), selectorReturnType));
                 }
                 result = TypeUtils.makeNullable(receiverType);
             }
@@ -2237,12 +2076,42 @@ public class JetTypeInferrer {
                 if (selectorExpression != null) {
                     receiverType = context.services.enrichOutType(receiverExpression, receiverType, context);
 
-                    context.services.checkNullSafety(receiverType, expression.getOperationTokenNode(), getCalleeFunctionDescriptor(selectorExpression, context));
+                    context.services.checkNullSafety(receiverType, expression.getOperationTokenNode(), getCalleeFunctionDescriptor(selectorExpression, context), expression);
                 }
             }
             return context.services.checkType(result, expression, contextWithExpectedType);
         }
 
+        private void propagateConstantValues(JetQualifiedExpression expression, TypeInferenceContext context, JetSimpleNameExpression selectorExpression) {
+            JetExpression receiverExpression = expression.getReceiverExpression();
+            CompileTimeConstant<?> receiverValue = context.trace.getBindingContext().get(BindingContext.COMPILE_TIME_VALUE, receiverExpression);
+            CompileTimeConstant<?> wholeExpressionValue = context.trace.getBindingContext().get(BindingContext.COMPILE_TIME_VALUE, expression);
+            if (wholeExpressionValue == null && receiverValue != null && !(receiverValue instanceof ErrorValue) && receiverValue.getValue() instanceof Number) {
+                Number value = (Number) receiverValue.getValue();
+                String referencedName = selectorExpression.getReferencedName();
+                if (numberConversions.contains(referencedName)) {
+                    if ("dbl".equals(referencedName)) {
+                        context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new DoubleValue(value.doubleValue()));
+                    }
+                    else if ("flt".equals(referencedName)) {
+                        context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new FloatValue(value.floatValue()));
+                    }
+                    else if ("lng".equals(referencedName)) {
+                        context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new LongValue(value.longValue()));
+                    }
+                    else if ("sht".equals(referencedName)) {
+                        context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new ShortValue(value.shortValue()));
+                    }
+                    else if ("byt".equals(referencedName)) {
+                        context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new ByteValue(value.byteValue()));
+                    }
+                    else if ("int".equals(referencedName)) {
+                        context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new IntValue(value.intValue()));
+                    }
+                }
+            }
+        }
+
 
         @NotNull
         private FunctionDescriptor getCalleeFunctionDescriptor(@NotNull JetExpression selectorExpression, final TypeInferenceContext context) {
@@ -2258,7 +2127,7 @@ public class JetTypeInferrer {
 
                 @Override
                 public void visitReferenceExpression(JetReferenceExpression referenceExpression) {
-                    DeclarationDescriptor declarationDescriptor = context.trace.getBindingContext().get(BindingContext.REFERENCE_TARGET, referenceExpression);
+                    DeclarationDescriptor declarationDescriptor = context.trace.getBindingContext().get(REFERENCE_TARGET, referenceExpression);
                     if (declarationDescriptor instanceof FunctionDescriptor) {
                         result[0] = (FunctionDescriptor) declarationDescriptor;
                     }
@@ -2281,7 +2150,8 @@ public class JetTypeInferrer {
 
                 @Override
                 public void visitJetElement(JetElement element) {
-                    context.trace.getErrorHandler().genericError(element.getNode(), "Unsupported [getCalleeFunctionDescriptor]: " + element);
+//                    context.trace.getErrorHandler().genericError(element.getNode(), "Unsupported [getCalleeFunctionDescriptor]: " + element);
+                    context.trace.report(UNSUPPORTED.on(element, "getCalleeFunctionDescriptor"));
                 }
             });
             if (result[0] == null) {
@@ -2290,42 +2160,58 @@ public class JetTypeInferrer {
             return result[0];
         }
 
-        private JetType getCallExpressionType(@Nullable JetType receiverType, @NotNull JetCallExpression callExpression, TypeInferenceContext context) {
-            JetExpression calleeExpression = callExpression.getCalleeExpression();
-            if (calleeExpression == null) {
-                return null;
-            }
-            OverloadDomain overloadDomain = context.services.getOverloadDomain(receiverType, context.scope, calleeExpression, callExpression.getValueArgumentList());
-            return context.services.resolveCall(context.scope, overloadDomain, callExpression);
-        }
-
-        private JetType getSelectorReturnType(JetType receiverType, JetExpression selectorExpression, TypeInferenceContext context) {
+        @Nullable
+        private JetType getSelectorReturnType(@NotNull ReceiverDescriptor receiver, @NotNull JetExpression selectorExpression, @NotNull TypeInferenceContext context) {
             if (selectorExpression instanceof JetCallExpression) {
-                return getCallExpressionType(receiverType, (JetCallExpression) selectorExpression, context);
+                return callResolver.resolveCall(context.trace, context.scope, receiver, (JetCallExpression) selectorExpression, context.expectedType);
             }
             else if (selectorExpression instanceof JetSimpleNameExpression) {
-                JetScope compositeScope = new ScopeWithReceiver(context.scope, receiverType, semanticServices.getTypeChecker());
-                return getType(compositeScope, selectorExpression, false, context);
+                JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) selectorExpression;
+
+                TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace);
+                VariableDescriptor variableDescriptor = callResolver.resolveSimpleProperty(temporaryTrace, context.scope, receiver, nameExpression, context.expectedType);
+                if (variableDescriptor != null) {
+                    temporaryTrace.commit();
+                    return context.services.checkEnrichedType(variableDescriptor.getOutType(), nameExpression, context);
+                }
+                TypeInferenceContext newContext = receiver.exists() ? context.replaceScope(receiver.getType().getMemberScope()) : context;
+                JetType jetType = lookupNamespaceOrClassObject(nameExpression, nameExpression.getReferencedName(), newContext);
+                if (jetType == null) {
+                    context.trace.report(UNRESOLVED_REFERENCE.on(nameExpression));
+                }
+                return context.services.checkEnrichedType(jetType, nameExpression, context);
+//                JetScope scope = receiverType != null ? receiverType.getMemberScope() : context.scope;
+//                return getType(selectorExpression, context.replaceScope(scope));
             }
-            else if (selectorExpression != null) {
+            else if (selectorExpression instanceof JetQualifiedExpression) {
+                JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) selectorExpression;
+                JetExpression newReceiverExpression = qualifiedExpression.getReceiverExpression();
+                JetType newReceiverType = getSelectorReturnType(receiver, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE));
+                JetExpression newSelectorExpression = qualifiedExpression.getSelectorExpression();
+                if (newReceiverType != null && newSelectorExpression != null) {
+                    return getSelectorReturnType(new ExpressionReceiver(newReceiverExpression, newReceiverType), newSelectorExpression, context);
+                }
+            }
+            else {
                 // TODO : not a simple name -> resolve in scope, expect property type or a function type
-                context.trace.getErrorHandler().genericError(selectorExpression.getNode(), "Unsupported selector element type: " + selectorExpression);
+//                context.trace.getErrorHandler().genericError(selectorExpression.getNode(), "Unsupported selector element type: " + selectorExpression);
+                context.trace.report(UNSUPPORTED.on(selectorExpression, "getSelectorReturnType"));
             }
             return null;
         }
 
         @Override
         public JetType visitCallExpression(JetCallExpression expression, TypeInferenceContext context) {
-//            return context.services.checkType(context.services.resolveCall(context.scope, expression, context.expectedType), expression, context);
-            return context.services.checkType(getCallExpressionType(null, expression, context), expression, context);
+            JetType expressionType = callResolver.resolveCall(context.trace, context.scope, ReceiverDescriptor.NO_RECEIVER, expression, context.expectedType);
+            return context.services.checkType(expressionType, expression, context);
         }
 
         @Override
         public JetType visitIsExpression(JetIsExpression expression, TypeInferenceContext contextWithExpectedType) {
             TypeInferenceContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
-            JetType knownType = getType(context.scope, expression.getLeftHandSide(), false, context);
+            JetType knownType = safeGetType(expression.getLeftHandSide(), context.replaceScope(context.scope));
             JetPattern pattern = expression.getPattern();
-            if (pattern != null && knownType != null) {
+            if (pattern != null) {
                 WritableScopeImpl scopeToExtend = newWritableScopeImpl(context.scope, context.trace).setDebugName("Scope extended in 'is'");
                 DataFlowInfo newDataFlowInfo = checkPatternType(pattern, knownType, scopeToExtend, context, context.services.getVariableDescriptorFromSimpleName(expression.getLeftHandSide(), context));
                 patternsToDataFlowInfo.put(pattern, newDataFlowInfo);
@@ -2346,12 +2232,22 @@ public class JetTypeInferrer {
             IElementType operationType = operationSign.getReferencedNameElementType();
             String name = unaryOperationNames.get(operationType);
             if (name == null) {
-                context.trace.getErrorHandler().genericError(operationSign.getNode(), "Unknown unary operation");
+//                context.trace.getErrorHandler().genericError(operationSign.getNode(), "Unknown unary operation");
+                context.trace.report(UNSUPPORTED.on(operationSign, "visitUnaryExpression"));
                 return null;
             }
-            JetType receiverType = getType(context.scope, baseExpression, false, context.replaceExpectedType(NO_EXPECTED_TYPE));
-            if (receiverType == null) return null;
-            FunctionDescriptor functionDescriptor = context.services.lookupFunction(context.scope, expression.getOperationSign(), name, receiverType, Collections.<JetType>emptyList(), true);
+            ExpressionReceiver receiver = getExpressionReceiver(baseExpression, context.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(context.scope));
+            if (receiver == null) return null;
+
+            FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName(
+                    context.trace,
+                    context.scope,
+                    CallMaker.makeCall(expression),
+                    expression.getOperationSign(),
+                    name,
+                    receiver,
+                    context.expectedType);
+
             if (functionDescriptor == null) return null;
             JetType returnType = functionDescriptor.getReturnType();
             JetType result;
@@ -2360,8 +2256,10 @@ public class JetTypeInferrer {
                     result = JetStandardClasses.getUnitType();
                 }
                 else {
+                    JetType receiverType = receiver.getType();
                     if (!semanticServices.getTypeChecker().isSubtypeOf(returnType, receiverType)) {
-                        context.trace.getErrorHandler().genericError(operationSign.getNode(), name + " must return " + receiverType + " but returns " + returnType);
+//                        context.trace.getErrorHandler().genericError(operationSign.getNode(), name + " must return " + receiverType + " but returns " + returnType);
+                        context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, name, receiverType, returnType));
                     }
                     else {
                         context.trace.record(BindingContext.VARIABLE_REASSIGNMENT, expression);
@@ -2389,11 +2287,11 @@ public class JetTypeInferrer {
             if (operationType == JetTokens.IDENTIFIER) {
                 String referencedName = operationSign.getReferencedName();
                 if (referencedName != null) {
-                    result = getTypeForBinaryCall(expression, referencedName, context.scope, true, context);
+                    result = getTypeForBinaryCall(context.scope, referencedName, context, expression);
                 }
             }
             else if (binaryOperationNames.containsKey(operationType)) {
-                result = getTypeForBinaryCall(expression, binaryOperationNames.get(operationType), context.scope, true, context);
+                result = getTypeForBinaryCall(context.scope, binaryOperationNames.get(operationType), context, expression);
             }
             else if (operationType == JetTokens.EQ) {
                 result = visitAssignment(expression, context);
@@ -2402,7 +2300,7 @@ public class JetTypeInferrer {
                 result = visitAssignmentOperation(expression, context);
             }
             else if (comparisonOperations.contains(operationType)) {
-                JetType compareToReturnType = getTypeForBinaryCall(expression, "compareTo", context.scope, true, context);
+                JetType compareToReturnType = getTypeForBinaryCall(context.scope, "compareTo", context, expression);
                 if (compareToReturnType != null) {
                     TypeConstructor constructor = compareToReturnType.getConstructor();
                     JetStandardLibrary standardLibrary = semanticServices.getStandardLibrary();
@@ -2410,28 +2308,37 @@ public class JetTypeInferrer {
                     if (constructor.equals(intTypeConstructor)) {
                         result = standardLibrary.getBooleanType();
                     } else {
-                        context.trace.getErrorHandler().genericError(operationSign.getNode(), "compareTo must return Int, but returns " + compareToReturnType);
+//                        context.trace.getErrorHandler().genericError(operationSign.getNode(), "compareTo() must return Int, but returns " + compareToReturnType);
+                        context.trace.report(COMPARE_TO_TYPE_MISMATCH.on(operationSign, compareToReturnType));
                     }
                 }
             }
             else if (equalsOperations.contains(operationType)) {
                 String name = "equals";
                 if (right != null) {
-                    JetType leftType = getType(context.scope, left, false, context);
-                    if (leftType != null) {
-                        JetType rightType = getType(context.scope, right, false, context);
-                        if (rightType != null) {
-                            FunctionDescriptor equals = context.services.lookupFunction(
-                                    context.scope, operationSign, "equals",
-                                    leftType, Collections.singletonList(JetStandardClasses.getNullableAnyType()), false);
-                            if (equals != null) {
-                                if (ensureBooleanResult(operationSign, name, equals.getReturnType(), context)) {
-                                    ensureNonemptyIntersectionOfOperandTypes(expression, context);
-                                }
-                            }
-                            else {
-                                context.trace.getErrorHandler().genericError(operationSign.getNode(), "No method 'equals(Any?) : Boolean' available");
-                            }
+                    ExpressionReceiver receiver = safeGetExpressionReceiver(left, context.replaceScope(context.scope));
+                    OverloadResolutionResult<FunctionDescriptor> resolutionResult = callResolver.resolveExactSignature(
+                            context.scope, receiver, "equals",
+                            Collections.singletonList(JetStandardClasses.getNullableAnyType()));
+                    if (resolutionResult.isSuccess()) {
+                        FunctionDescriptor equals = resolutionResult.getDescriptor();
+                        context.trace.record(REFERENCE_TARGET, operationSign, equals);
+                        if (ensureBooleanResult(operationSign, name, equals.getReturnType(), context)) {
+                            ensureNonemptyIntersectionOfOperandTypes(expression, context);
+                        }
+                    }
+                    else {
+                        if (resolutionResult.isAmbiguity()) {
+//                            StringBuilder stringBuilder = new StringBuilder();
+//                            for (FunctionDescriptor functionDescriptor : resolutionResult.getDescriptors()) {
+//                                stringBuilder.append(DescriptorRenderer.TEXT.render(functionDescriptor)).append(" ");
+//                            }
+//                            context.trace.getErrorHandler().genericError(operationSign.getNode(), "Ambiguous function: " + stringBuilder);
+                            context.trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(operationSign, resolutionResult.getDescriptors()));
+                        }
+                        else {
+//                            context.trace.getErrorHandler().genericError(operationSign.getNode(), "No method 'equals(Any?) : Boolean' available");
+                            context.trace.report(EQUALS_MISSING.on(operationSign));
                         }
                     }
                 }
@@ -2452,25 +2359,28 @@ public class JetTypeInferrer {
                 result = semanticServices.getStandardLibrary().getBooleanType();
             }
             else if (operationType == JetTokens.ANDAND || operationType == JetTokens.OROR) {
-                JetType leftType = getType(context.scope, left, false, context);
+                JetType leftType = getType(left, context.replaceScope(context.scope));
                 WritableScopeImpl leftScope = newWritableScopeImpl(context.scope, context.trace).setDebugName("Left scope of && or ||");
                 DataFlowInfo flowInfoLeft = extractDataFlowInfoFromCondition(left, operationType == JetTokens.ANDAND, leftScope, context);  // TODO: This gets computed twice: here and in extractDataFlowInfoFromCondition() for the whole condition
                 WritableScopeImpl rightScope = operationType == JetTokens.ANDAND ? leftScope : newWritableScopeImpl(context.scope, context.trace).setDebugName("Right scope of && or ||");
-                JetType rightType = right == null ? null : getTypeWithNewDataFlowInfo(rightScope, right, false, flowInfoLeft, context);
+                JetType rightType = right == null ? null : getType(right, context.replaceDataFlowInfo(flowInfoLeft).replaceScope(rightScope));
                 if (leftType != null && !isBoolean(leftType)) {
-                    context.trace.getErrorHandler().typeMismatch(left, semanticServices.getStandardLibrary().getBooleanType(), leftType);
+//                    context.trace.getErrorHandler().typeMismatch(left, semanticServices.getStandardLibrary().getBooleanType(), leftType);
+                    context.trace.report(TYPE_MISMATCH.on(left, semanticServices.getStandardLibrary().getBooleanType(), leftType));
                 }
                 if (rightType != null && !isBoolean(rightType)) {
-                    context.trace.getErrorHandler().typeMismatch(right, semanticServices.getStandardLibrary().getBooleanType(), rightType);
+//                    context.trace.getErrorHandler().typeMismatch(right, semanticServices.getStandardLibrary().getBooleanType(), rightType);
+                    context.trace.report(TYPE_MISMATCH.on(right, semanticServices.getStandardLibrary().getBooleanType(), rightType));
                 }
                 result = semanticServices.getStandardLibrary().getBooleanType();
             }
             else if (operationType == JetTokens.ELVIS) {
-                JetType leftType = getType(context.scope, left, false, context);
-                JetType rightType = right == null ? null : getType(context.scope, right, false, contextWithExpectedType);
+                JetType leftType = getType(left, context.replaceScope(context.scope));
+                JetType rightType = right == null ? null : getType(right, contextWithExpectedType.replaceScope(context.scope));
                 if (leftType != null) {
                     if (!leftType.isNullable()) {
-                        context.trace.getErrorHandler().genericWarning(left.getNode(), "Elvis operator (?:) is always returns the left operand of non-nullable type " + leftType);
+//                        context.trace.getErrorHandler().genericWarning(left.getNode(), "Elvis operator (?:) always returns the left operand of non-nullable type " + leftType);
+                        context.trace.report(USELESS_ELVIS.on(expression, left, leftType));
                     }
                     if (rightType != null) {
                         context.services.checkType(TypeUtils.makeNullableAsSpecified(leftType, rightType.isNullable()), left, contextWithExpectedType);
@@ -2479,14 +2389,22 @@ public class JetTypeInferrer {
                 }
             }
             else {
-                context.trace.getErrorHandler().genericError(operationSign.getNode(), "Unknown operation");
+//                context.trace.getErrorHandler().genericError(operationSign.getNode(), "Unknown operation");
+                context.trace.report(UNSUPPORTED.on(operationSign, "Unknown operation"));
             }
             return context.services.checkType(result, expression, contextWithExpectedType);
         }
 
         private void checkInExpression(JetSimpleNameExpression operationSign, JetExpression left, JetExpression right, TypeInferenceContext context) {
             String name = "contains";
-            JetType containsType = getTypeForBinaryCall(context.scope, right, operationSign, left, name, true, context);
+            ExpressionReceiver receiver = safeGetExpressionReceiver(right, context.replaceExpectedType(NO_EXPECTED_TYPE));
+            FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName(
+                    context.trace,
+                    context.scope,
+                    CallMaker.makeCall(operationSign, Collections.singletonList(left)),
+                    operationSign,
+                    name, receiver, context.expectedType);
+            JetType containsType = functionDescriptor != null ? functionDescriptor.getReturnType() : null;
             ensureBooleanResult(operationSign, name, containsType, context);
         }
 
@@ -2496,14 +2414,15 @@ public class JetTypeInferrer {
             JetExpression right = expression.getRight();
 
             // TODO : duplicated effort for == and !=
-            JetType leftType = getType(context.scope, left, false, context);
+            JetType leftType = getType(left, context.replaceScope(context.scope));
             if (leftType != null && right != null) {
-                JetType rightType = getType(context.scope, right, false, context);
+                JetType rightType = getType(right, context.replaceScope(context.scope));
 
                 if (rightType != null) {
                     JetType intersect = TypeUtils.intersect(semanticServices.getTypeChecker(), new HashSet<JetType>(Arrays.asList(leftType, rightType)));
                     if (intersect == null) {
-                        context.trace.getErrorHandler().genericError(expression.getNode(), "Operator " + operationSign.getReferencedName() + " cannot be applied to " + leftType + " and " + rightType);
+//                        context.trace.getErrorHandler().genericError(expression.getNode(), "Operator " + operationSign.getReferencedName() + " cannot be applied to " + leftType + " and " + rightType);
+                        context.trace.report(EQUALITY_NOT_APPLICABLE.on(expression, operationSign, leftType, rightType));
                     }
                 }
             }
@@ -2518,7 +2437,8 @@ public class JetTypeInferrer {
         }
 
         private JetType assignmentIsNotAnExpressionError(JetBinaryExpression expression, TypeInferenceContext context) {
-            context.trace.getErrorHandler().genericError(expression.getNode(), "Assignments are not expressions, and only expressions are allowed in this context");
+//            context.trace.getErrorHandler().genericError(expression.getNode(), "Assignments are not expressions, and only expressions are allowed in this context");
+            context.trace.report(ASSIGNMENT_IN_EXPRESSION_CONTEXT.on(expression));
             return null;
         }
 
@@ -2530,7 +2450,8 @@ public class JetTypeInferrer {
             if (resultType != null) {
                 // TODO : Relax?
                 if (!isBoolean(resultType)) {
-                    context.trace.getErrorHandler().genericError(operationSign.getNode(), subjectName + " must return Boolean but returns " + resultType);
+//                    context.trace.getErrorHandler().genericError(operationSign.getNode(), subjectName + " must return Boolean but returns " + resultType);
+                    context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, subjectName, semanticServices.getStandardLibrary().getBooleanType(), resultType));
                     return false;
                 }
             }
@@ -2541,34 +2462,22 @@ public class JetTypeInferrer {
             return semanticServices.getTypeChecker().isConvertibleTo(type,  semanticServices.getStandardLibrary().getBooleanType());
         }
 
-        @Nullable
-        protected List<JetType> getTypes(JetScope scope, List<JetExpression> indexExpressions, TypeInferenceContext context) {
-            List<JetType> argumentTypes = new ArrayList<JetType>();
-            TypeInferenceContext newContext = new TypeInferenceContext(context.trace, scope, false, context.dataFlowInfo, NO_EXPECTED_TYPE, NO_EXPECTED_TYPE);
-            for (JetExpression indexExpression : indexExpressions) {
-                JetType type = context.services.typeInferrerVisitor.getType(indexExpression, newContext);
-                if (type == null) {
-                    return null;
-                }
-                argumentTypes.add(type);
-                context.services.typeInferrerVisitor.resetResult(); // TODO : recreate?
-            }
-            return argumentTypes;
-        }
-
         @Override
         public JetType visitArrayAccessExpression(JetArrayAccessExpression expression, TypeInferenceContext contextWithExpectedType) {
             TypeInferenceContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
             JetExpression arrayExpression = expression.getArrayExpression();
-            JetType receiverType = getType(context.scope, arrayExpression, false, context);
-            List<JetExpression> indexExpressions = expression.getIndexExpressions();
-            List<JetType> argumentTypes = getTypes(context.scope, indexExpressions, context);
-            if (argumentTypes == null) return null;
+            ExpressionReceiver receiver = getExpressionReceiver(arrayExpression, context.replaceScope(context.scope));
 
-            if (receiverType != null) {
-                FunctionDescriptor functionDescriptor = context.services.lookupFunction(context.scope, expression, "get", receiverType, argumentTypes, true);
+            if (receiver != null) {
+                FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName(
+                        context.trace,
+                        context.scope,
+                        CallMaker.makeCall(expression, expression.getIndexExpressions()),
+                        expression, 
+                        "get",
+                        receiver,
+                        context.expectedType);
                 if (functionDescriptor != null) {
-//                    checkNullSafety(receiverType, expression.getIndexExpressions().get(0).getNode(), functionDescriptor);
                     return context.services.checkType(functionDescriptor.getReturnType(), expression, contextWithExpectedType);
                 }
             }
@@ -2576,45 +2485,30 @@ public class JetTypeInferrer {
         }
 
         @Nullable
-        protected JetType getTypeForBinaryCall(
-                @NotNull JetBinaryExpression expression,
-                @NotNull String name,
-                @NotNull JetScope scope,
-                boolean reportUnresolved,
-                @NotNull TypeInferenceContext context) {
-            JetExpression left = expression.getLeft();
-            JetExpression right = expression.getRight();
-            if (right == null) {
-                return null;
-            }
-            JetSimpleNameExpression operationSign = expression.getOperationReference();
-            return getTypeForBinaryCall(scope, left, operationSign, right, name, reportUnresolved, context);
-        }
-
-        @Nullable
-        private JetType getTypeForBinaryCall(
-                @NotNull JetScope scope,
-                @NotNull JetExpression left,
-                @NotNull JetSimpleNameExpression operationSign,
-                @NotNull JetExpression right,
-                @NotNull String name,
-                boolean reportUnresolved,
-                @NotNull TypeInferenceContext context) {
-            JetType leftType = getType(scope, left, false, context);
-            JetType rightType = getType(scope, right, false, context);
-            if (leftType == null || rightType == null) {
-                return null;
-            }
-            FunctionDescriptor functionDescriptor = context.services.lookupFunction(scope, operationSign, name, leftType, Collections.singletonList(rightType), reportUnresolved);
+        protected JetType getTypeForBinaryCall(JetScope scope, String name, TypeInferenceContext context, JetBinaryExpression binaryExpression) {
+            ExpressionReceiver receiver = safeGetExpressionReceiver(binaryExpression.getLeft(), context.replaceScope(scope));
+            FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName(
+                    context.trace,
+                    scope,
+                    CallMaker.makeCall(binaryExpression),
+                    binaryExpression.getOperationReference(),
+                    name,
+                    receiver,
+                    context.expectedType);
             if (functionDescriptor != null) {
-                if (leftType.isNullable()) {
+                if (receiver.getType().isNullable()) {
                     // TODO : better error message for '1 + nullableVar' case
-                    context.trace.getErrorHandler().genericError(operationSign.getNode(),
-                            "Infix call corresponds to a dot-qualified call '" +
-                            left.getText() + "." + name + "(" + right.getText() + ")'" +
-                            " which is not allowed on a nullable receiver '" + right.getText() + "'." +
-                            " Use '?.'-qualified call instead");
+                    JetExpression right = binaryExpression.getRight();
+                    String rightText = right == null ? "" : right.getText();
+                    String leftText = binaryExpression.getLeft().getText();
+//                    context.trace.getErrorHandler().genericError(binaryExpression.getOperationReference().getNode(),
+//                                                                 "Infix call corresponds to a dot-qualified call '" +
+//                                                                 leftText + "." + name + "(" + rightText + ")'" +
+//                                                                 " which is not allowed on a nullable receiver '" + leftText + "'." +
+//                                                                 " Use '?.'-qualified call instead");
+                    context.trace.report(UNSAFE_INFIX_CALL.on(binaryExpression.getOperationReference(), leftText, name, rightText));
                 }
+                
 
                 return functionDescriptor.getReturnType();
             }
@@ -2623,13 +2517,15 @@ public class JetTypeInferrer {
 
         @Override
         public JetType visitDeclaration(JetDeclaration dcl, TypeInferenceContext context) {
-            context.trace.getErrorHandler().genericError(dcl.getNode(), "Declarations are not allowed in this position");
+//            context.trace.getErrorHandler().genericError(dcl.getNode(), "Declarations are not allowed in this position");
+            context.trace.report(DECLARATION_IN_ILLEGAL_CONTEXT.on(dcl));
             return null;
         }
 
         @Override
         public JetType visitRootNamespaceExpression(JetRootNamespaceExpression expression, TypeInferenceContext context) {
-            context.trace.getErrorHandler().genericError(expression.getNode(), "'namespace' is not an expression");
+//            context.trace.getErrorHandler().genericError(expression.getNode(), "'namespace' is not an expression");
+            context.trace.report(NAMESPACE_IS_NOT_AN_EXPRESSION.on(expression));
             return null;
         }
 
@@ -2646,7 +2542,7 @@ public class JetTypeInferrer {
                     public void visitStringTemplateEntryWithExpression(JetStringTemplateEntryWithExpression entry) {
                         JetExpression entryExpression = entry.getExpression();
                         if (entryExpression != null) {
-                            getType(context.scope, entryExpression, true, context);
+                            getType(entryExpression, context.replaceScope(context.scope));
                         }
                         value[0] = CompileTimeConstantResolver.OUT_OF_RANGE;
                     }
@@ -2665,7 +2561,8 @@ public class JetTypeInferrer {
 
                         Character character = CompileTimeConstantResolver.translateEscape(escaped);
                         if (character == null) {
-                            context.trace.getErrorHandler().genericError(entry.getNode(), "Illegal escape sequence");
+//                            context.trace.getErrorHandler().genericError(entry.getNode(), "Illegal escape sequence");
+                            context.trace.report(ILLEGAL_ESCAPE_SEQUENCE.on(entry));
                             value[0] = CompileTimeConstantResolver.OUT_OF_RANGE;
                         }
                         else {
@@ -2682,7 +2579,8 @@ public class JetTypeInferrer {
 
         @Override
         public JetType visitJetElement(JetElement element, TypeInferenceContext context) {
-            context.trace.getErrorHandler().genericError(element.getNode(), "[JetTypeInferrer] Unsupported element: " + element + " " + element.getClass().getCanonicalName());
+//            context.trace.getErrorHandler().genericError(element.getNode(), "[JetTypeInferrer] Unsupported element: " + element + " " + element.getClass().getCanonicalName());
+            context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName()));
             return null;
         }
     }
@@ -2712,17 +2610,10 @@ public class JetTypeInferrer {
         public TypeInferrerVisitorWithWritableScope(@NotNull WritableScope scope) {
             this.scope = scope;
         }
-        
-//        public TypeInferrerVisitorWithWritableScope(@NotNull BindingTrace trace, @NotNull JetScope scope) {
-//            super(trace);
-//            this.scope = newWritableScopeImpl(scope, trace).setDebugName("Block scope");
-//        }
-
 
         @Override
         public JetType visitObjectDeclaration(JetObjectDeclaration declaration, TypeInferenceContext context) {
-            TopDownAnalyzer topDownAnalyzer = new TopDownAnalyzer(semanticServices, context.trace);
-            topDownAnalyzer.processObject(scope, scope.getContainingDeclaration(), declaration);
+            TopDownAnalyzer.processObject(semanticServices, context.trace, scope, scope.getContainingDeclaration(), declaration);
             ClassDescriptor classDescriptor = context.trace.getBindingContext().get(BindingContext.CLASS, declaration);
             if (classDescriptor != null) {
                 PropertyDescriptor propertyDescriptor = context.classDescriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(scope.getContainingDeclaration(), declaration, classDescriptor);
@@ -2735,28 +2626,31 @@ public class JetTypeInferrer {
         public JetType visitProperty(JetProperty property, TypeInferenceContext context) {
             JetTypeReference receiverTypeRef = property.getReceiverTypeRef();
             if (receiverTypeRef != null) {
-                context.trace.getErrorHandler().genericError(receiverTypeRef.getNode(), "Local receiver-properties are not allowed");
+//                context.trace.getErrorHandler().genericError(receiverTypeRef.getNode(), "Local receiver-properties are not allowed");
+                context.trace.report(LOCAL_EXTENSION_PROPERTY.on(receiverTypeRef));
             }
 
             JetPropertyAccessor getter = property.getGetter();
             if (getter != null) {
-                context.trace.getErrorHandler().genericError(getter.getNode(), "Local variables are not allowed to have getters");
+//                context.trace.getErrorHandler().genericError(getter.getNode(), "Local variables are not allowed to have getters");
+                context.trace.report(LOCAL_VARIABLE_WITH_GETTER.on(getter));
             }
 
             JetPropertyAccessor setter = property.getSetter();
             if (setter != null) {
-                context.trace.getErrorHandler().genericError(setter.getNode(), "Local variables are not allowed to have setters");
+//                context.trace.getErrorHandler().genericError(setter.getNode(), "Local variables are not allowed to have setters");
+                context.trace.report(LOCAL_VARIABLE_WITH_SETTER.on(setter));
             }
 
             VariableDescriptor propertyDescriptor = context.classDescriptorResolver.resolveLocalVariableDescriptor(scope.getContainingDeclaration(), scope, property);
             JetExpression initializer = property.getInitializer();
             if (property.getPropertyTypeRef() != null && initializer != null) {
                 JetType outType = propertyDescriptor.getOutType();
-                JetType initializerType = getType(scope, initializer, false, context.replaceExpectedType(outType));
+                JetType initializerType = getType(initializer, context.replaceExpectedType(outType).replaceScope(scope));
 //                if (outType != null &&
 //                    initializerType != null &&
 //                    !semanticServices.getTypeChecker().isConvertibleTo(initializerType, outType)) {
-//                    context.trace.getErrorHandler().typeMismatch(initializer, outType, initializerType);
+//                    context.trace.report(TYPE_MISMATCH.on(initializer, outType, initializerType));
 //                }
             }
 
@@ -2791,15 +2685,21 @@ public class JetTypeInferrer {
         protected JetType visitAssignmentOperation(JetBinaryExpression expression, TypeInferenceContext context) {
             IElementType operationType = expression.getOperationReference().getReferencedNameElementType();
             String name = assignmentOperationNames.get(operationType);
-            JetType assignmentOperationType = getTypeForBinaryCall(expression, name, scope, false, context);
+
+            TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create(context.trace);
+            JetType assignmentOperationType = getTypeForBinaryCall(scope, name, context.replaceBindingTrace(temporaryBindingTrace), expression);
 
             if (assignmentOperationType == null) {
                 String counterpartName = binaryOperationNames.get(assignmentOperationCounterparts.get(operationType));
-                JetType typeForBinaryCall = getTypeForBinaryCall(expression, counterpartName, scope, true, context);
+
+                JetType typeForBinaryCall = getTypeForBinaryCall(scope, counterpartName, context, expression);
                 if (typeForBinaryCall != null) {
                     context.trace.record(BindingContext.VARIABLE_REASSIGNMENT, expression);
                 }
             }
+            else {
+                temporaryBindingTrace.commit();
+            }
             return null;
         }
 
@@ -2812,39 +2712,55 @@ public class JetTypeInferrer {
                 JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) deparenthesized;
                 return resolveArrayAccessToLValue(arrayAccessExpression, right, expression.getOperationReference(), context);
             }
-            JetType leftType = getType(scope, left, false, context.replaceExpectedType(NO_EXPECTED_TYPE));
+            JetType leftType = getType(left, context.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(scope));
             if (right != null) {
-                JetType rightType = getType(scope, right, false, context.replaceExpectedType(leftType));
+                JetType rightType = getType(right, context.replaceExpectedType(leftType).replaceScope(scope));
 //                if (rightType != null &&
 //                    leftType != null &&
 //                    !semanticServices.getTypeChecker().isConvertibleTo(rightType, leftType)) {
-//                    context.trace.getErrorHandler().typeMismatch(right, leftType, rightType);
+//                    context.trace.report(TYPE_MISMATCH.on(right, leftType, rightType));
 //                }
             }
+            if (left instanceof JetSimpleNameExpression) {
+                JetSimpleNameExpression variable = (JetSimpleNameExpression) left;
+                String referencedName = variable.getReferencedName();
+                if (variable.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER
+                    && referencedName != null) {
+                    PropertyDescriptor property = context.scope.getPropertyByFieldReference(referencedName);
+                    if (property != null) {
+                        context.trace.record(BindingContext.VARIABLE_ASSIGNMENT, variable, property);
+                    }
+                }
+            }
             return null;
         }
 
-        private JetType resolveArrayAccessToLValue(JetArrayAccessExpression arrayAccessExpression, JetExpression rightHandSide, JetSimpleNameExpression operationSign, TypeInferenceContext contextWithExpectedType) {
-            TypeInferenceContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
-            List<JetType> argumentTypes = getTypes(scope, arrayAccessExpression.getIndexExpressions(), context);
-            if (argumentTypes == null) return null;
-            JetType rhsType = getType(scope, rightHandSide, false, context);
-            if (rhsType == null) return null;
-            argumentTypes.add(rhsType);
-
-            JetType receiverType = getType(scope, arrayAccessExpression.getArrayExpression(), false, context);
-            if (receiverType == null) return null;
-
-            // TODO : nasty hack: effort is duplicated
-            context.services.lookupFunction(scope, arrayAccessExpression, "set", receiverType, argumentTypes, true);
-            FunctionDescriptor functionDescriptor = context.services.lookupFunction(scope, operationSign, "set", receiverType, argumentTypes, true);
+        private JetType resolveArrayAccessToLValue(JetArrayAccessExpression arrayAccessExpression, JetExpression rightHandSide, JetSimpleNameExpression operationSign, TypeInferenceContext context) {
+            ExpressionReceiver receiver = getExpressionReceiver(arrayAccessExpression.getArrayExpression(), context.replaceScope(scope));
+            if (receiver == null) return null;
+//
+            Call call = CallMaker.makeCall(arrayAccessExpression, rightHandSide);
+//            // TODO : nasty hack: effort is duplicated
+//            callResolver.resolveCallWithGivenName(
+//                    scope,
+//                    call,
+//                    arrayAccessExpression,
+//                    "set", arrayAccessExpression.getArrayExpression(), NO_EXPECTED_TYPE);
+            FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName(
+                    context.trace,
+                    scope,
+                    call,
+                    arrayAccessExpression,
+                    "set", receiver, NO_EXPECTED_TYPE);
             if (functionDescriptor == null) return null;
-            return context.services.checkType(functionDescriptor.getReturnType(), arrayAccessExpression, contextWithExpectedType);
+            context.trace.record(REFERENCE_TARGET, operationSign, functionDescriptor);
+            return context.services.checkType(functionDescriptor.getReturnType(), arrayAccessExpression, context);
         }
 
         @Override
         public JetType visitJetElement(JetElement element, TypeInferenceContext context) {
-            context.trace.getErrorHandler().genericError(element.getNode(), "Unsupported element in a block: " + element + " " + element.getClass().getCanonicalName());
+            context.trace.report(UNSUPPORTED.on(element, "in a block"));
+//            context.trace.getErrorHandler().genericError(element.getNode(), "Unsupported element in a block: " + element + " " + element.getClass().getCanonicalName());
             return null;
         }
     }
diff --git a/idea/src/org/jetbrains/jet/lang/types/LazyValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/LazyValue.java
similarity index 85%
rename from idea/src/org/jetbrains/jet/lang/types/LazyValue.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/LazyValue.java
index 482df0533c3..ef310e545cc 100644
--- a/idea/src/org/jetbrains/jet/lang/types/LazyValue.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/LazyValue.java
@@ -17,6 +17,10 @@ public abstract class LazyValue<T> {
 
     protected abstract T compute();
 
+    protected T getValueOnErrorReentry() {
+        throw new ReenteringLazyValueComputationException();
+    }
+
     public boolean isComputed() {
         return state == State.ERROR || state == State.COMPUTED;
     }
@@ -34,7 +38,7 @@ public abstract class LazyValue<T> {
             case COMPUTED:
                 return value;
             case ERROR:
-                throw new ReenteringLazyValueComputationException();
+                return getValueOnErrorReentry();
         }
         throw new IllegalStateException("Unreachable");
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/LazyValueWithDefault.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/LazyValueWithDefault.java
new file mode 100644
index 00000000000..bd9f15fa26c
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/LazyValueWithDefault.java
@@ -0,0 +1,17 @@
+package org.jetbrains.jet.lang.types;
+
+/**
+ * @author abreslav
+ */
+public abstract class LazyValueWithDefault<T> extends LazyValue<T> {
+    private final T defaultValue;
+
+    protected LazyValueWithDefault(T defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+
+    @Override
+    protected T getValueOnErrorReentry() {
+        return defaultValue;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/types/NamespaceType.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/NamespaceType.java
similarity index 96%
rename from idea/src/org/jetbrains/jet/lang/types/NamespaceType.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/NamespaceType.java
index dad72cb210c..35702cf2dba 100644
--- a/idea/src/org/jetbrains/jet/lang/types/NamespaceType.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/NamespaceType.java
@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.types;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.List;
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/ReenteringLazyValueComputationException.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/ReenteringLazyValueComputationException.java
new file mode 100644
index 00000000000..1005fb72df7
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/ReenteringLazyValueComputationException.java
@@ -0,0 +1,14 @@
+package org.jetbrains.jet.lang.types;
+
+/**
+ * @author abreslav
+ */
+public class ReenteringLazyValueComputationException extends RuntimeException {
+    public ReenteringLazyValueComputationException() {
+    }
+
+    @Override
+    public synchronized Throwable fillInStackTrace() {
+        return this;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/lang/types/TypeConstructor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeConstructor.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/types/TypeConstructor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/TypeConstructor.java
diff --git a/idea/src/org/jetbrains/jet/lang/types/TypeConstructorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeConstructorImpl.java
similarity index 89%
rename from idea/src/org/jetbrains/jet/lang/types/TypeConstructorImpl.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/TypeConstructorImpl.java
index cb5167563de..ed11cc2e5d4 100644
--- a/idea/src/org/jetbrains/jet/lang/types/TypeConstructorImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeConstructorImpl.java
@@ -2,13 +2,14 @@ package org.jetbrains.jet.lang.types;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotatedImpl;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotatedImpl;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -34,8 +35,8 @@ public class TypeConstructorImpl extends AnnotatedImpl implements TypeConstructo
         this.declarationDescriptor = declarationDescriptor;
         this.sealed = sealed;
         this.debugName = debugName;
-        this.parameters = new ArrayList<TypeParameterDescriptor>(parameters);
-        this.supertypes = supertypes;
+        this.parameters = Collections.unmodifiableList(new ArrayList<TypeParameterDescriptor>(parameters));
+        this.supertypes = Collections.unmodifiableCollection(supertypes);
     }
 
     @Override
diff --git a/idea/src/org/jetbrains/jet/lang/types/TypeProjection.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeProjection.java
similarity index 97%
rename from idea/src/org/jetbrains/jet/lang/types/TypeProjection.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/TypeProjection.java
index d401d388834..f85c20a6e2d 100644
--- a/idea/src/org/jetbrains/jet/lang/types/TypeProjection.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeProjection.java
@@ -31,7 +31,7 @@ public class TypeProjection {
     @Override
     public String toString() {
         if (projection == Variance.INVARIANT) {
-            return type + "";
+            return type.toString();
         }
         return projection + " " + type;
     }
diff --git a/idea/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java
similarity index 87%
rename from idea/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java
index 441054b7b3f..d6a5094cacc 100644
--- a/idea/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java
@@ -3,10 +3,9 @@ package org.jetbrains.jet.lang.types;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-import org.jetbrains.jet.lang.resolve.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -16,6 +15,18 @@ import java.util.Map;
 public class TypeSubstitutor {
 
     public interface TypeSubstitution {
+        TypeSubstitution EMPTY = new TypeSubstitution() {
+            @Override
+            public TypeProjection get(TypeConstructor key) {
+                return null;
+            }
+
+            @Override
+            public boolean isEmpty() {
+                return true;
+            }
+        };
+        
         @Nullable
         TypeProjection get(TypeConstructor key);
         boolean isEmpty();
@@ -39,7 +50,7 @@ public class TypeSubstitutor {
         }
     }
 
-    public static final TypeSubstitutor EMPTY = create(Collections.<TypeConstructor, TypeProjection>emptyMap());
+    public static final TypeSubstitutor EMPTY = create(TypeSubstitution.EMPTY);
 
     public static final class SubstitutionException extends Exception {
         public SubstitutionException(String message) {
@@ -51,6 +62,10 @@ public class TypeSubstitutor {
         return new TypeSubstitutor(substitution);
     }
 
+    public static TypeSubstitutor create(@NotNull TypeSubstitution... substitutions) {
+        return create(new CompositeTypeSubstitution(substitutions));
+    }
+
     public static TypeSubstitutor create(@NotNull Map<TypeConstructor, TypeProjection> substitutionContext) {
         return create(new MapToTypeSubstitutionAdapter(substitutionContext));
     }
@@ -61,14 +76,23 @@ public class TypeSubstitutor {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    private final @NotNull TypeSubstitution substitutionContext;
+    private final @NotNull TypeSubstitution substitution;
 
-    private TypeSubstitutor(@NotNull TypeSubstitution substitutionContext) {
-        this.substitutionContext = substitutionContext;
+    protected TypeSubstitutor(@NotNull TypeSubstitution substitution) {
+        this.substitution = substitution;
+    }
+
+    public boolean inRange(@NotNull TypeConstructor typeConstructor) {
+        return substitution.get(typeConstructor) != null;
     }
 
     public boolean isEmpty() {
-        return substitutionContext.isEmpty();
+        return substitution.isEmpty();
+    }
+
+    @NotNull
+    public TypeSubstitution getSubstitution() {
+        return substitution;
     }
 
     @NotNull
@@ -100,7 +124,7 @@ public class TypeSubstitutor {
     @NotNull
     private JetType unsafeSubstitute(@NotNull JetType type, @NotNull Variance howThisTypeIsUsed) throws SubstitutionException {
         TypeConstructor constructor = type.getConstructor();
-        TypeProjection value = substitutionContext.get(constructor);
+        TypeProjection value = substitution.get(constructor);
         if (value != null) {
             assert constructor.getDeclarationDescriptor() instanceof TypeParameterDescriptor;
 
@@ -122,7 +146,7 @@ public class TypeSubstitutor {
             TypeProjection argument = arguments.get(i);
             TypeParameterDescriptor parameterDescriptor = subjectType.getConstructor().getParameters().get(i);
             newArguments.add(substituteInProjection(
-                    substitutionContext,
+                    substitution,
                     argument,
                     parameterDescriptor,
                     callSiteVariance));
diff --git a/idea/src/org/jetbrains/jet/lang/types/TypeUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java
similarity index 82%
rename from idea/src/org/jetbrains/jet/lang/types/TypeUtils.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java
index c20be85a0c1..5d5cd433cc5 100644
--- a/idea/src/org/jetbrains/jet/lang/types/TypeUtils.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java
@@ -1,15 +1,15 @@
 package org.jetbrains.jet.lang.types;
 
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
+import com.google.common.collect.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-import org.jetbrains.jet.lang.resolve.ChainedScope;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.ChainedScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.util.CommonSuppliers;
 
 import java.util.*;
 
@@ -228,15 +228,25 @@ public class TypeUtils {
      */
     @NotNull
     public static TypeSubstitutor buildDeepSubstitutor(@NotNull JetType type) {
-        HashMap<TypeConstructor, TypeProjection> substitution = Maps.<TypeConstructor, TypeProjection>newHashMap();
+        Map<TypeConstructor, TypeProjection> substitution = Maps.newHashMap();
         TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitution);
         // we use the mutability of the map here
-        fillInDeepSubstitutor(type, typeSubstitutor, substitution);
+        fillInDeepSubstitutor(type, typeSubstitutor, substitution, null);
         return typeSubstitutor;
     }
 
+    @NotNull
+    public static Multimap<TypeConstructor, TypeProjection> buildDeepSubstitutionMultimap(@NotNull JetType type) {
+        Multimap<TypeConstructor, TypeProjection> fullSubstitution = CommonSuppliers.newLinkedHashSetHashSetMultimap();
+        Map<TypeConstructor, TypeProjection> substitution = Maps.newHashMap();
+        TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitution);
+        // we use the mutability of the map here
+        fillInDeepSubstitutor(type, typeSubstitutor, substitution, fullSubstitution);
+        return fullSubstitution;
+    }
+
     // we use the mutability of the substitution map here
-    private static void fillInDeepSubstitutor(JetType context, TypeSubstitutor substitutor, Map<TypeConstructor, TypeProjection> substitution) {
+    private static void fillInDeepSubstitutor(@NotNull JetType context, @NotNull TypeSubstitutor substitutor, @NotNull Map<TypeConstructor, TypeProjection> substitution, @Nullable Multimap<TypeConstructor, TypeProjection> fullSubstitution) {
         List<TypeParameterDescriptor> parameters = context.getConstructor().getParameters();
         List<TypeProjection> arguments = context.getArguments();
         for (int i = 0; i < arguments.size(); i++) {
@@ -247,9 +257,12 @@ public class TypeUtils {
             assert substitute != null;
             TypeProjection substitutedTypeProjection = new TypeProjection(argument.getProjectionKind(), substitute);
             substitution.put(typeParameterDescriptor.getTypeConstructor(), substitutedTypeProjection);
+            if (fullSubstitution != null) {
+                fullSubstitution.put(typeParameterDescriptor.getTypeConstructor(), substitutedTypeProjection);
+            }
         }
         for (JetType supertype : context.getConstructor().getSupertypes()) {
-            fillInDeepSubstitutor(supertype, substitutor, substitution);
+            fillInDeepSubstitutor(supertype, substitutor, substitution, fullSubstitution);
         }
     }
 
@@ -311,4 +324,35 @@ public class TypeUtils {
         }
         return false;
     }
+
+    public static boolean equalClasses(@NotNull JetType type1, @NotNull JetType type2) {
+        DeclarationDescriptor declarationDescriptor1 = type1.getConstructor().getDeclarationDescriptor();
+        if (declarationDescriptor1 == null) return false; // No class, classes are not equal
+        DeclarationDescriptor declarationDescriptor2 = type2.getConstructor().getDeclarationDescriptor();
+        if (declarationDescriptor2 == null) return false; // Class of type1 is not null
+        return declarationDescriptor1.getOriginal().equals(declarationDescriptor2.getOriginal());
+    }
+
+    @Nullable
+    public static ClassDescriptor getClassDescriptor(@NotNull JetType type) {
+        DeclarationDescriptor declarationDescriptor = type.getConstructor().getDeclarationDescriptor();
+        if (declarationDescriptor instanceof ClassDescriptor) {
+            return (ClassDescriptor) declarationDescriptor;
+        }
+        return null;
+    }
+
+    public static boolean hasUnsubstitutedTypeParameters(JetType type) {
+        if(type.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor)
+            return true;
+
+        for(TypeProjection proj : type.getArguments()) {
+            if(hasUnsubstitutedTypeParameters(proj.getType())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
 }
diff --git a/idea/src/org/jetbrains/jet/lang/types/Variance.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/Variance.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lang/types/Variance.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/Variance.java
diff --git a/idea/src/org/jetbrains/jet/lang/types/inference/ConstraintSystem.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/inference/ConstraintSystem.java
similarity index 94%
rename from idea/src/org/jetbrains/jet/lang/types/inference/ConstraintSystem.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/types/inference/ConstraintSystem.java
index 7e42f7d2939..175f6647891 100644
--- a/idea/src/org/jetbrains/jet/lang/types/inference/ConstraintSystem.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/inference/ConstraintSystem.java
@@ -102,7 +102,7 @@ public class ConstraintSystem {
                                 }
                             }
 
-                            System.out.println("minimal solution from lowerbounds for " + this + " is " + commonSupertype);
+                            println("minimal solution from lowerbounds for " + this + " is " + commonSupertype);
                             value = new KnownType(commonSupertype);
                         }
                         else {
@@ -121,7 +121,7 @@ public class ConstraintSystem {
 
             return value;
         }
-        
+
         private Set<JetType> getTypes(Set<TypeValue> lowerBounds) {
             Set<JetType> types = Sets.newHashSet();
             for (TypeValue lowerBound : lowerBounds) {
@@ -194,19 +194,19 @@ public class ConstraintSystem {
     private UnknownType getTypeVariable(TypeParameterDescriptor typeParameterDescriptor) {
         UnknownType unknownType = unknownTypes.get(typeParameterDescriptor);
         if (unknownType == null) {
-            throw new IllegalArgumentException("This type parameter is not an unknown in this constraint system");
+            throw new IllegalArgumentException("This type parameter is not an unknown in this constraint system: " + typeParameterDescriptor);
         }
         return unknownType;
     }
 
-    public void addSubtypingConstraint(JetType lower, JetType upper) {
+    public void addSubtypingConstraint(@NotNull JetType lower, @NotNull JetType upper) {
         TypeValue typeValueForLower = getTypeValueFor(lower);
         TypeValue typeValueForUpper = getTypeValueFor(upper);
         addSubtypingConstraintOnTypeValues(typeValueForLower, typeValueForUpper);
     }
 
     private void addSubtypingConstraintOnTypeValues(TypeValue typeValueForLower, TypeValue typeValueForUpper) {
-        System.out.println(typeValueForLower + " :< " + typeValueForUpper);
+        println(typeValueForLower + " :< " + typeValueForUpper);
         typeValueForLower.getUpperBounds().add(typeValueForUpper);
         typeValueForUpper.getLowerBounds().add(typeValueForLower);
     }
@@ -271,14 +271,14 @@ public class ConstraintSystem {
                 JetType boundingType = solution.getSubstitutor().substitute(upperBound.getValue().getType(), Variance.INVARIANT);
                 if (!typeChecker.isSubtypeOf(type, boundingType)) { // TODO
                     solution.registerError();
-                    System.out.println("Constraint violation: " + type + " :< " + boundingType);
+                    println("Constraint violation: " + type + " :< " + boundingType);
                 }
             }
             for (TypeValue lowerBound : typeValue.getLowerBounds()) {
                 JetType boundingType = solution.getSubstitutor().substitute(lowerBound.getValue().getType(), Variance.INVARIANT);
                 if (!typeChecker.isSubtypeOf(boundingType, type)) {
                     solution.registerError();
-                    System.out.println("Constraint violation: " + boundingType + " :< " + type);
+                    println("Constraint violation: " + boundingType + " :< " + type);
                 }
             }
         }
@@ -309,7 +309,7 @@ public class ConstraintSystem {
                 DeclarationDescriptor declarationDescriptor = key.getDeclarationDescriptor();
                 if (declarationDescriptor instanceof TypeParameterDescriptor) {
                     TypeParameterDescriptor descriptor = (TypeParameterDescriptor) declarationDescriptor;
-                    System.out.println(descriptor + " |-> " + getValue(descriptor));
+                    println(descriptor + " |-> " + getValue(descriptor));
                     return new TypeProjection(getValue(descriptor));
                 }
                 return null;
@@ -368,12 +368,6 @@ public class ConstraintSystem {
                 addSubtypingConstraintOnTypeValues(subtypeValue, supertypeValue);
             }
             return StatusAction.PROCEED;
-
-//            // both types are known
-//            if (typeChecker.isSubtypeOf(subtype, supertype)) {
-//                return StatusAction.PROCEED;
-//            }
-//            return fail();
         }
 
         private boolean someUnknown(TypeValue subtypeValue, TypeValue supertypeValue) {
@@ -412,4 +406,8 @@ public class ConstraintSystem {
         }
     }
 
+    private static void println(String message) {
+//        System.out.println(message);
+    }
+
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/jet/lexer/Jet.flex b/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex
similarity index 98%
rename from idea/src/org/jetbrains/jet/lexer/Jet.flex
rename to compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex
index 2f40c693df6..db4f16d661b 100644
--- a/idea/src/org/jetbrains/jet/lexer/Jet.flex
+++ b/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex
@@ -164,6 +164,7 @@ LONG_TEMPLATE_ENTRY_END=\}
 "while"      { return JetTokens.WHILE_KEYWORD ;}
 "break"      { return JetTokens.BREAK_KEYWORD ;}
 "class"      { return JetTokens.CLASS_KEYWORD ;}
+"trait"      { return JetTokens.TRAIT_KEYWORD ;}
 "throw"      { return JetTokens.THROW_KEYWORD ;}
 "false"      { return JetTokens.FALSE_KEYWORD ;}
 "when"       { return JetTokens.WHEN_KEYWORD ;}
@@ -202,8 +203,8 @@ LONG_TEMPLATE_ENTRY_END=\}
 "!="         { return JetTokens.EXCLEQ    ; }
 "&&"         { return JetTokens.ANDAND    ; }
 "||"         { return JetTokens.OROR      ; }
-"?."         { return JetTokens.SAFE_ACCESS;}
-"?:"         { return JetTokens.ELVIS     ; }
+//"?."         { return JetTokens.SAFE_ACCESS;}
+//"?:"         { return JetTokens.ELVIS     ; }
 //".*"         { return JetTokens.MAP       ; }
 //".?"         { return JetTokens.FILTER    ; }
 "*="         { return JetTokens.MULTEQ    ; }
diff --git a/idea/src/org/jetbrains/jet/lexer/JetKeywordToken.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetKeywordToken.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lexer/JetKeywordToken.java
rename to compiler/frontend/src/org/jetbrains/jet/lexer/JetKeywordToken.java
diff --git a/idea/src/org/jetbrains/jet/lexer/JetLexer.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetLexer.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lexer/JetLexer.java
rename to compiler/frontend/src/org/jetbrains/jet/lexer/JetLexer.java
diff --git a/idea/src/org/jetbrains/jet/lexer/JetToken.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetToken.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/lexer/JetToken.java
rename to compiler/frontend/src/org/jetbrains/jet/lexer/JetToken.java
diff --git a/idea/src/org/jetbrains/jet/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java
similarity index 92%
rename from idea/src/org/jetbrains/jet/lexer/JetTokens.java
rename to compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java
index 818b9860135..476d1e20751 100644
--- a/idea/src/org/jetbrains/jet/lexer/JetTokens.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java
@@ -56,6 +56,7 @@ public interface JetTokens {
     JetKeywordToken WHILE_KEYWORD            = JetKeywordToken.keyword("while");
     JetKeywordToken DO_KEYWORD               = JetKeywordToken.keyword("do");
     JetKeywordToken WHEN_KEYWORD            = JetKeywordToken.keyword("when");
+    JetKeywordToken TRAIT_KEYWORD     = JetKeywordToken.keyword("trait");
     // TODO: Discuss "This" keyword
     JetKeywordToken CAPITALIZED_THIS_KEYWORD = JetKeywordToken.keyword("This");
 
@@ -118,17 +119,15 @@ public interface JetTokens {
     JetToken COMMA       = new JetToken("COMMA");
 
     JetToken EOL_OR_SEMICOLON   = new JetToken("EOL_OR_SEMICOLON");
-    JetKeywordToken WRAPS_KEYWORD     = JetKeywordToken.softKeyword("wraps");
     JetKeywordToken IMPORT_KEYWORD    = JetKeywordToken.softKeyword("import");
     JetKeywordToken WHERE_KEYWORD     = JetKeywordToken.softKeyword("where");
     JetKeywordToken BY_KEYWORD        = JetKeywordToken.softKeyword("by");
     JetKeywordToken GET_KEYWORD       = JetKeywordToken.softKeyword("get");
     JetKeywordToken SET_KEYWORD       = JetKeywordToken.softKeyword("set");
     JetKeywordToken ABSTRACT_KEYWORD  = JetKeywordToken.softKeyword("abstract");
-    JetKeywordToken VIRTUAL_KEYWORD   = JetKeywordToken.softKeyword("virtual");
     JetKeywordToken ENUM_KEYWORD      = JetKeywordToken.softKeyword("enum");
     JetKeywordToken OPEN_KEYWORD      = JetKeywordToken.softKeyword("open");
-    JetKeywordToken ATTRIBUTE_KEYWORD = JetKeywordToken.softKeyword("attribute");
+    JetKeywordToken ANNOTATION_KEYWORD = JetKeywordToken.softKeyword("annotation");
     JetKeywordToken OVERRIDE_KEYWORD  = JetKeywordToken.softKeyword("override");
     JetKeywordToken PRIVATE_KEYWORD   = JetKeywordToken.softKeyword("private");
     JetKeywordToken PUBLIC_KEYWORD    = JetKeywordToken.softKeyword("public");
@@ -136,13 +135,15 @@ public interface JetTokens {
     JetKeywordToken PROTECTED_KEYWORD = JetKeywordToken.softKeyword("protected");
     JetKeywordToken CATCH_KEYWORD     = JetKeywordToken.softKeyword("catch");
     JetKeywordToken OUT_KEYWORD       = JetKeywordToken.softKeyword("out");
+    JetKeywordToken VARARG_KEYWORD       = JetKeywordToken.softKeyword("vararg");
 
     JetKeywordToken FINALLY_KEYWORD   = JetKeywordToken.softKeyword("finally");
+    JetKeywordToken FINAL_KEYWORD   = JetKeywordToken.softKeyword("final");
 
     // TODO: support this as an annotation on arguments. Then, they it probably can not be a soft keyword
     JetKeywordToken REF_KEYWORD       = JetKeywordToken.softKeyword("ref");
 
-    TokenSet KEYWORDS = TokenSet.create(NAMESPACE_KEYWORD, AS_KEYWORD, TYPE_KEYWORD, CLASS_KEYWORD,
+    TokenSet KEYWORDS = TokenSet.create(NAMESPACE_KEYWORD, AS_KEYWORD, TYPE_KEYWORD, CLASS_KEYWORD, TRAIT_KEYWORD,
             THIS_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, FOR_KEYWORD,
             NULL_KEYWORD,
             TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD,
@@ -151,15 +152,15 @@ public interface JetTokens {
             NOT_IN, NOT_IS, CAPITALIZED_THIS_KEYWORD, AS_SAFE
     );
 
-    TokenSet SOFT_KEYWORDS = TokenSet.create(WRAPS_KEYWORD, IMPORT_KEYWORD, WHERE_KEYWORD, BY_KEYWORD, GET_KEYWORD,
-            SET_KEYWORD, ABSTRACT_KEYWORD, VIRTUAL_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, ATTRIBUTE_KEYWORD,
+    TokenSet SOFT_KEYWORDS = TokenSet.create(IMPORT_KEYWORD, WHERE_KEYWORD, BY_KEYWORD, GET_KEYWORD,
+            SET_KEYWORD, ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, ANNOTATION_KEYWORD,
             OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD,
-            CATCH_KEYWORD, FINALLY_KEYWORD, REF_KEYWORD, OUT_KEYWORD
+            CATCH_KEYWORD, FINALLY_KEYWORD, REF_KEYWORD, OUT_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD
     );
 
-    TokenSet MODIFIER_KEYWORDS = TokenSet.create(ABSTRACT_KEYWORD, VIRTUAL_KEYWORD, ENUM_KEYWORD,
-            OPEN_KEYWORD, ATTRIBUTE_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD,
-            PROTECTED_KEYWORD, REF_KEYWORD, OUT_KEYWORD, IN_KEYWORD
+    TokenSet MODIFIER_KEYWORDS = TokenSet.create(ABSTRACT_KEYWORD, ENUM_KEYWORD,
+            OPEN_KEYWORD, ANNOTATION_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD,
+            PROTECTED_KEYWORD, REF_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD
     );
     TokenSet WHITE_SPACE_OR_COMMENT_BIT_SET = TokenSet.create(WHITE_SPACE, BLOCK_COMMENT, EOL_COMMENT, DOC_COMMENT);
     TokenSet WHITESPACES = TokenSet.create(TokenType.WHITE_SPACE);
diff --git a/idea/src/org/jetbrains/jet/lexer/_JetLexer.java b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java
similarity index 70%
rename from idea/src/org/jetbrains/jet/lexer/_JetLexer.java
rename to compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java
index 21527660d1d..cba44325158 100644
--- a/idea/src/org/jetbrains/jet/lexer/_JetLexer.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java
@@ -1,21 +1,20 @@
-/* The following code was generated by JFlex 1.4.3 on 7/12/11 9:55 PM */
+/* The following code was generated by JFlex 1.4.3 on 9/13/11 8:32 PM */
 
 /* It's an automatically generated code. Do not modify it. */
 package org.jetbrains.jet.lexer;
 
-import java.util.*;
-import com.intellij.lexer.*;
-import com.intellij.psi.*;
+import com.intellij.lexer.FlexLexer;
+import com.intellij.psi.TokenType;
 import com.intellij.psi.tree.IElementType;
 
-import org.jetbrains.jet.lexer.JetTokens;
+import java.util.Stack;
 
 
 /**
  * This class is a scanner generated by 
  * <a href="http://www.jflex.de/">JFlex</a> 1.4.3
- * on 7/12/11 9:55 PM from the specification file
- * <tt>/Users/abreslav/work/jet/idea/src/org/jetbrains/jet/lexer/Jet.flex</tt>
+ * on 9/13/11 8:32 PM from the specification file
+ * <tt>/Users/abreslav/work/jet/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex</tt>
  */
 class _JetLexer implements FlexLexer {
   /** initial size of the lookahead buffer */
@@ -42,72 +41,72 @@ class _JetLexer implements FlexLexer {
    */
   private static final String ZZ_CMAP_PACKED = 
     "\11\0\1\3\1\13\1\0\1\3\23\0\1\3\1\60\1\25\1\77"+
-    "\1\7\1\70\1\65\1\23\1\73\1\74\1\12\1\62\1\76\1\21"+
-    "\1\17\1\11\1\14\11\1\1\67\1\75\1\63\1\57\1\64\1\61"+
-    "\1\10\1\2\1\16\2\2\1\20\1\2\5\4\1\4\3\4\1\22"+
-    "\3\4\1\54\3\4\1\15\2\4\1\71\1\24\1\72\1\0\1\4"+
-    "\1\6\1\31\1\44\1\36\1\56\1\33\1\52\1\4\1\47\1\41"+
-    "\1\45\1\51\1\50\1\32\1\30\1\37\1\35\1\4\1\43\1\34"+
-    "\1\40\1\42\1\55\1\46\1\15\1\53\1\4\1\26\1\66\1\27"+
-    "\54\0\1\4\12\0\1\4\4\0\1\4\5\0\27\4\1\0\37\4"+
-    "\1\0\u013f\4\31\0\162\4\4\0\14\4\16\0\5\4\11\0\1\4"+
-    "\213\0\1\4\13\0\1\4\1\0\3\4\1\0\1\4\1\0\24\4"+
-    "\1\0\54\4\1\0\46\4\1\0\5\4\4\0\202\4\10\0\105\4"+
-    "\1\0\46\4\2\0\2\4\6\0\20\4\41\0\46\4\2\0\1\4"+
-    "\7\0\47\4\110\0\33\4\5\0\3\4\56\0\32\4\5\0\13\4"+
-    "\25\0\12\5\4\0\2\4\1\0\143\4\1\0\1\4\17\0\2\4"+
-    "\7\0\2\4\12\5\3\4\2\0\1\4\20\0\1\4\1\0\36\4"+
-    "\35\0\3\4\60\0\46\4\13\0\1\4\u0152\0\66\4\3\0\1\4"+
-    "\22\0\1\4\7\0\12\4\4\0\12\5\25\0\10\4\2\0\2\4"+
-    "\2\0\26\4\1\0\7\4\1\0\1\4\3\0\4\4\3\0\1\4"+
-    "\36\0\2\4\1\0\3\4\4\0\12\5\2\4\23\0\6\4\4\0"+
-    "\2\4\2\0\26\4\1\0\7\4\1\0\2\4\1\0\2\4\1\0"+
-    "\2\4\37\0\4\4\1\0\1\4\7\0\12\5\2\0\3\4\20\0"+
-    "\11\4\1\0\3\4\1\0\26\4\1\0\7\4\1\0\2\4\1\0"+
-    "\5\4\3\0\1\4\22\0\1\4\17\0\2\4\4\0\12\5\25\0"+
-    "\10\4\2\0\2\4\2\0\26\4\1\0\7\4\1\0\2\4\1\0"+
-    "\5\4\3\0\1\4\36\0\2\4\1\0\3\4\4\0\12\5\1\0"+
-    "\1\4\21\0\1\4\1\0\6\4\3\0\3\4\1\0\4\4\3\0"+
-    "\2\4\1\0\1\4\1\0\2\4\3\0\2\4\3\0\3\4\3\0"+
-    "\10\4\1\0\3\4\55\0\11\5\25\0\10\4\1\0\3\4\1\0"+
-    "\27\4\1\0\12\4\1\0\5\4\46\0\2\4\4\0\12\5\25\0"+
-    "\10\4\1\0\3\4\1\0\27\4\1\0\12\4\1\0\5\4\3\0"+
-    "\1\4\40\0\1\4\1\0\2\4\4\0\12\5\25\0\10\4\1\0"+
-    "\3\4\1\0\27\4\1\0\20\4\46\0\2\4\4\0\12\5\25\0"+
-    "\22\4\3\0\30\4\1\0\11\4\1\0\1\4\2\0\7\4\72\0"+
-    "\60\4\1\0\2\4\14\0\7\4\11\0\12\5\47\0\2\4\1\0"+
-    "\1\4\2\0\2\4\1\0\1\4\2\0\1\4\6\0\4\4\1\0"+
-    "\7\4\1\0\3\4\1\0\1\4\1\0\1\4\2\0\2\4\1\0"+
-    "\4\4\1\0\2\4\11\0\1\4\2\0\5\4\1\0\1\4\11\0"+
-    "\12\5\2\0\2\4\42\0\1\4\37\0\12\5\26\0\10\4\1\0"+
-    "\42\4\35\0\4\4\164\0\42\4\1\0\5\4\1\0\2\4\25\0"+
-    "\12\5\6\0\6\4\112\0\46\4\12\0\51\4\7\0\132\4\5\0"+
-    "\104\4\5\0\122\4\6\0\7\4\1\0\77\4\1\0\1\4\1\0"+
-    "\4\4\2\0\7\4\1\0\1\4\1\0\4\4\2\0\47\4\1\0"+
-    "\1\4\1\0\4\4\2\0\37\4\1\0\1\4\1\0\4\4\2\0"+
-    "\7\4\1\0\1\4\1\0\4\4\2\0\7\4\1\0\7\4\1\0"+
-    "\27\4\1\0\37\4\1\0\1\4\1\0\4\4\2\0\7\4\1\0"+
-    "\47\4\1\0\23\4\16\0\11\5\56\0\125\4\14\0\u026c\4\2\0"+
-    "\10\4\12\0\32\4\5\0\113\4\25\0\15\4\1\0\4\4\16\0"+
-    "\22\4\16\0\22\4\16\0\15\4\1\0\3\4\17\0\64\4\43\0"+
-    "\1\4\4\0\1\4\3\0\12\5\46\0\12\5\6\0\130\4\10\0"+
-    "\51\4\127\0\35\4\51\0\12\5\36\4\2\0\5\4\u038b\0\154\4"+
-    "\224\0\234\4\4\0\132\4\6\0\26\4\2\0\6\4\2\0\46\4"+
-    "\2\0\6\4\2\0\10\4\1\0\1\4\1\0\1\4\1\0\1\4"+
-    "\1\0\37\4\2\0\65\4\1\0\7\4\1\0\1\4\3\0\3\4"+
-    "\1\0\7\4\3\0\4\4\2\0\6\4\4\0\15\4\5\0\3\4"+
-    "\1\0\7\4\164\0\1\4\15\0\1\4\202\0\1\4\4\0\1\4"+
-    "\2\0\12\4\1\0\1\4\3\0\5\4\6\0\1\4\1\0\1\4"+
-    "\1\0\1\4\1\0\4\4\1\0\3\4\1\0\7\4\3\0\3\4"+
-    "\5\0\5\4\u0ebb\0\2\4\52\0\5\4\5\0\2\4\4\0\126\4"+
-    "\6\0\3\4\1\0\132\4\1\0\4\4\5\0\50\4\4\0\136\4"+
-    "\21\0\30\4\70\0\20\4\u0200\0\u19b6\4\112\0\u51a6\4\132\0\u048d\4"+
-    "\u0773\0\u2ba4\4\u215c\0\u012e\4\2\0\73\4\225\0\7\4\14\0\5\4"+
-    "\5\0\1\4\1\0\12\4\1\0\15\4\1\0\5\4\1\0\1\4"+
-    "\1\0\2\4\1\0\2\4\1\0\154\4\41\0\u016b\4\22\0\100\4"+
-    "\2\0\66\4\50\0\14\4\164\0\5\4\1\0\207\4\23\0\12\5"+
-    "\7\0\32\4\6\0\32\4\13\0\131\4\3\0\6\4\2\0\6\4"+
-    "\2\0\6\4\2\0\3\4\43\0";
+    "\1\7\1\67\1\65\1\23\1\72\1\73\1\12\1\62\1\76\1\21"+
+    "\1\17\1\11\1\14\11\1\1\74\1\75\1\63\1\57\1\64\1\61"+
+    "\1\10\1\2\1\16\2\2\1\20\1\2\11\4\1\22\3\4\1\54"+
+    "\3\4\1\15\2\4\1\70\1\24\1\71\1\0\1\4\1\6\1\31"+
+    "\1\44\1\36\1\56\1\33\1\52\1\4\1\47\1\41\1\45\1\51"+
+    "\1\50\1\32\1\30\1\37\1\35\1\4\1\43\1\34\1\40\1\42"+
+    "\1\55\1\46\1\15\1\53\1\4\1\26\1\66\1\27\54\0\1\4"+
+    "\12\0\1\4\4\0\1\4\5\0\27\4\1\0\37\4\1\0\u013f\4"+
+    "\31\0\162\4\4\0\14\4\16\0\5\4\11\0\1\4\213\0\1\4"+
+    "\13\0\1\4\1\0\3\4\1\0\1\4\1\0\24\4\1\0\54\4"+
+    "\1\0\46\4\1\0\5\4\4\0\202\4\10\0\105\4\1\0\46\4"+
+    "\2\0\2\4\6\0\20\4\41\0\46\4\2\0\1\4\7\0\47\4"+
+    "\110\0\33\4\5\0\3\4\56\0\32\4\5\0\13\4\25\0\12\5"+
+    "\4\0\2\4\1\0\143\4\1\0\1\4\17\0\2\4\7\0\2\4"+
+    "\12\5\3\4\2\0\1\4\20\0\1\4\1\0\36\4\35\0\3\4"+
+    "\60\0\46\4\13\0\1\4\u0152\0\66\4\3\0\1\4\22\0\1\4"+
+    "\7\0\12\4\4\0\12\5\25\0\10\4\2\0\2\4\2\0\26\4"+
+    "\1\0\7\4\1\0\1\4\3\0\4\4\3\0\1\4\36\0\2\4"+
+    "\1\0\3\4\4\0\12\5\2\4\23\0\6\4\4\0\2\4\2\0"+
+    "\26\4\1\0\7\4\1\0\2\4\1\0\2\4\1\0\2\4\37\0"+
+    "\4\4\1\0\1\4\7\0\12\5\2\0\3\4\20\0\11\4\1\0"+
+    "\3\4\1\0\26\4\1\0\7\4\1\0\2\4\1\0\5\4\3\0"+
+    "\1\4\22\0\1\4\17\0\2\4\4\0\12\5\25\0\10\4\2\0"+
+    "\2\4\2\0\26\4\1\0\7\4\1\0\2\4\1\0\5\4\3\0"+
+    "\1\4\36\0\2\4\1\0\3\4\4\0\12\5\1\0\1\4\21\0"+
+    "\1\4\1\0\6\4\3\0\3\4\1\0\4\4\3\0\2\4\1\0"+
+    "\1\4\1\0\2\4\3\0\2\4\3\0\3\4\3\0\10\4\1\0"+
+    "\3\4\55\0\11\5\25\0\10\4\1\0\3\4\1\0\27\4\1\0"+
+    "\12\4\1\0\5\4\46\0\2\4\4\0\12\5\25\0\10\4\1\0"+
+    "\3\4\1\0\27\4\1\0\12\4\1\0\5\4\3\0\1\4\40\0"+
+    "\1\4\1\0\2\4\4\0\12\5\25\0\10\4\1\0\3\4\1\0"+
+    "\27\4\1\0\20\4\46\0\2\4\4\0\12\5\25\0\22\4\3\0"+
+    "\30\4\1\0\11\4\1\0\1\4\2\0\7\4\72\0\60\4\1\0"+
+    "\2\4\14\0\7\4\11\0\12\5\47\0\2\4\1\0\1\4\2\0"+
+    "\2\4\1\0\1\4\2\0\1\4\6\0\4\4\1\0\7\4\1\0"+
+    "\3\4\1\0\1\4\1\0\1\4\2\0\2\4\1\0\4\4\1\0"+
+    "\2\4\11\0\1\4\2\0\5\4\1\0\1\4\11\0\12\5\2\0"+
+    "\2\4\42\0\1\4\37\0\12\5\26\0\10\4\1\0\42\4\35\0"+
+    "\4\4\164\0\42\4\1\0\5\4\1\0\2\4\25\0\12\5\6\0"+
+    "\6\4\112\0\46\4\12\0\51\4\7\0\132\4\5\0\104\4\5\0"+
+    "\122\4\6\0\7\4\1\0\77\4\1\0\1\4\1\0\4\4\2\0"+
+    "\7\4\1\0\1\4\1\0\4\4\2\0\47\4\1\0\1\4\1\0"+
+    "\4\4\2\0\37\4\1\0\1\4\1\0\4\4\2\0\7\4\1\0"+
+    "\1\4\1\0\4\4\2\0\7\4\1\0\7\4\1\0\27\4\1\0"+
+    "\37\4\1\0\1\4\1\0\4\4\2\0\7\4\1\0\47\4\1\0"+
+    "\23\4\16\0\11\5\56\0\125\4\14\0\u026c\4\2\0\10\4\12\0"+
+    "\32\4\5\0\113\4\25\0\15\4\1\0\4\4\16\0\22\4\16\0"+
+    "\22\4\16\0\15\4\1\0\3\4\17\0\64\4\43\0\1\4\4\0"+
+    "\1\4\3\0\12\5\46\0\12\5\6\0\130\4\10\0\51\4\127\0"+
+    "\35\4\51\0\12\5\36\4\2\0\5\4\u038b\0\154\4\224\0\234\4"+
+    "\4\0\132\4\6\0\26\4\2\0\6\4\2\0\46\4\2\0\6\4"+
+    "\2\0\10\4\1\0\1\4\1\0\1\4\1\0\1\4\1\0\37\4"+
+    "\2\0\65\4\1\0\7\4\1\0\1\4\3\0\3\4\1\0\7\4"+
+    "\3\0\4\4\2\0\6\4\4\0\15\4\5\0\3\4\1\0\7\4"+
+    "\164\0\1\4\15\0\1\4\202\0\1\4\4\0\1\4\2\0\12\4"+
+    "\1\0\1\4\3\0\5\4\6\0\1\4\1\0\1\4\1\0\1\4"+
+    "\1\0\4\4\1\0\3\4\1\0\7\4\3\0\3\4\5\0\5\4"+
+    "\u0ebb\0\2\4\52\0\5\4\5\0\2\4\4\0\126\4\6\0\3\4"+
+    "\1\0\132\4\1\0\4\4\5\0\50\4\4\0\136\4\21\0\30\4"+
+    "\70\0\20\4\u0200\0\u19b6\4\112\0\u51a6\4\132\0\u048d\4\u0773\0\u2ba4\4"+
+    "\u215c\0\u012e\4\2\0\73\4\225\0\7\4\14\0\5\4\5\0\1\4"+
+    "\1\0\12\4\1\0\15\4\1\0\5\4\1\0\1\4\1\0\2\4"+
+    "\1\0\2\4\1\0\154\4\41\0\u016b\4\22\0\100\4\2\0\66\4"+
+    "\50\0\14\4\164\0\5\4\1\0\207\4\23\0\12\5\7\0\32\4"+
+    "\6\0\32\4\13\0\131\4\3\0\6\4\2\0\6\4\2\0\6\4"+
+    "\2\0\3\4\43\0";
 
   /** 
    * Translates characters to character classes
@@ -130,18 +129,18 @@ class _JetLexer implements FlexLexer {
     "\1\53\1\54\1\55\1\56\2\12\1\0\2\3\1\57"+
     "\7\3\1\60\1\61\1\62\10\3\1\63\1\64\1\65"+
     "\1\0\1\66\1\67\1\70\1\71\1\72\1\73\1\74"+
-    "\1\75\1\76\1\77\1\100\1\0\1\101\1\102\1\0"+
-    "\1\103\1\43\1\3\2\0\1\50\1\104\4\0\1\105"+
-    "\2\3\1\106\5\3\1\107\10\3\1\110\1\111\1\3"+
-    "\1\112\1\113\1\114\1\115\1\116\1\117\1\0\1\40"+
-    "\1\44\1\45\1\0\2\104\1\43\2\0\1\3\1\120"+
-    "\1\121\3\3\1\122\1\123\1\3\1\124\2\3\1\125"+
-    "\2\3\1\126\1\100\1\50\2\0\2\3\1\127\1\3"+
-    "\1\130\1\3\1\131\1\132\1\133\1\105\2\3\1\134"+
-    "\1\135\3\3\1\136\1\137";
+    "\1\75\1\76\1\0\1\77\1\100\1\0\1\101\1\43"+
+    "\1\3\2\0\1\50\1\102\4\0\1\103\2\3\1\104"+
+    "\6\3\1\105\10\3\1\106\1\107\1\3\1\110\1\111"+
+    "\1\112\1\113\1\114\1\115\1\0\1\40\1\44\1\45"+
+    "\1\0\2\102\1\43\2\0\1\3\1\116\1\117\4\3"+
+    "\1\120\1\121\1\3\1\122\2\3\1\123\2\3\1\124"+
+    "\1\76\1\50\2\0\2\3\1\125\1\3\1\126\1\127"+
+    "\1\3\1\130\1\131\1\132\1\103\2\3\1\133\1\134"+
+    "\3\3\1\135\1\136";
 
   private static int [] zzUnpackAction() {
-    int [] result = new int[210];
+    int [] result = new int[211];
     int offset = 0;
     offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
     return result;
@@ -170,32 +169,32 @@ class _JetLexer implements FlexLexer {
     "\0\u0200\0\u0240\0\u0280\0\u02c0\0\u0300\0\u0340\0\u0380\0\u03c0"+
     "\0\u0400\0\u0440\0\u0100\0\u0100\0\u0480\0\u04c0\0\u0500\0\u0540"+
     "\0\u0580\0\u05c0\0\u0600\0\u0640\0\u0680\0\u06c0\0\u0700\0\u0740"+
-    "\0\u0780\0\u07c0\0\u0800\0\u0840\0\u0880\0\u08c0\0\u0900\0\u0940"+
-    "\0\u0980\0\u09c0\0\u0100\0\u0a00\0\u0100\0\u0100\0\u0100\0\u0100"+
-    "\0\u0100\0\u0100\0\u0100\0\u0a40\0\u0a80\0\u0100\0\u0ac0\0\u0100"+
-    "\0\u0b00\0\u0b40\0\u0100\0\u0100\0\u0b80\0\u0bc0\0\u0c00\0\u0c40"+
-    "\0\u0c80\0\u0cc0\0\u0d00\0\u0100\0\u0d40\0\u0d80\0\u0100\0\u0100"+
-    "\0\u0dc0\0\u0e00\0\u0e40\0\u0e80\0\u0100\0\u0100\0\u0100\0\u0100"+
-    "\0\u0100\0\u0ec0\0\u0f00\0\u0f40\0\u0f80\0\u0fc0\0\u1000\0\u1040"+
-    "\0\u1080\0\u10c0\0\u1100\0\u1140\0\u1180\0\u0180\0\u0180\0\u0180"+
-    "\0\u11c0\0\u1200\0\u1240\0\u1280\0\u12c0\0\u1300\0\u1340\0\u1380"+
-    "\0\u0180\0\u13c0\0\u0100\0\u1400\0\u1440\0\u0100\0\u0100\0\u0100"+
-    "\0\u0100\0\u0100\0\u0100\0\u0100\0\u0100\0\u0100\0\u1480\0\u14c0"+
-    "\0\u0100\0\u0100\0\u1500\0\u0100\0\u1540\0\u0100\0\u1580\0\u15c0"+
-    "\0\u1600\0\u1640\0\u1680\0\u16c0\0\u1700\0\u1740\0\u1780\0\u17c0"+
-    "\0\u1800\0\u0100\0\u1840\0\u1880\0\u18c0\0\u1900\0\u1940\0\u0180"+
-    "\0\u1980\0\u19c0\0\u1a00\0\u1a40\0\u1a80\0\u1ac0\0\u1b00\0\u1b40"+
-    "\0\u0180\0\u0180\0\u1b80\0\u0180\0\u0180\0\u0100\0\u0100\0\u0100"+
-    "\0\u0100\0\u1bc0\0\u0100\0\u0100\0\u0100\0\u1c00\0\u1c40\0\u0100"+
-    "\0\u1c80\0\u1540\0\u1cc0\0\u1d00\0\u0180\0\u0180\0\u1d40\0\u1d80"+
-    "\0\u1dc0\0\u0180\0\u0180\0\u1e00\0\u0180\0\u1e40\0\u1e80\0\u0180"+
-    "\0\u1ec0\0\u1f00\0\u0180\0\u0100\0\u0100\0\u1f40\0\u1f80\0\u1fc0"+
-    "\0\u2000\0\u0180\0\u2040\0\u0180\0\u2080\0\u0180\0\u0180\0\u0180"+
-    "\0\u0100\0\u20c0\0\u2100\0\u0180\0\u0180\0\u2140\0\u2180\0\u21c0"+
-    "\0\u0180\0\u0180";
+    "\0\u0780\0\u07c0\0\u0800\0\u0840\0\u0100\0\u0880\0\u08c0\0\u0900"+
+    "\0\u0940\0\u0980\0\u09c0\0\u0100\0\u0100\0\u0100\0\u0100\0\u0100"+
+    "\0\u0100\0\u0100\0\u0100\0\u0a00\0\u0a40\0\u0100\0\u0a80\0\u0100"+
+    "\0\u0ac0\0\u0b00\0\u0100\0\u0100\0\u0b40\0\u0b80\0\u0bc0\0\u0c00"+
+    "\0\u0c40\0\u0c80\0\u0cc0\0\u0100\0\u0d00\0\u0d40\0\u0100\0\u0100"+
+    "\0\u0d80\0\u0dc0\0\u0e00\0\u0e40\0\u0100\0\u0100\0\u0100\0\u0100"+
+    "\0\u0100\0\u0e80\0\u0ec0\0\u0f00\0\u0f40\0\u0f80\0\u0fc0\0\u1000"+
+    "\0\u1040\0\u1080\0\u10c0\0\u1100\0\u1140\0\u0180\0\u0180\0\u0180"+
+    "\0\u1180\0\u11c0\0\u1200\0\u1240\0\u1280\0\u12c0\0\u1300\0\u1340"+
+    "\0\u0180\0\u1380\0\u0100\0\u13c0\0\u1400\0\u0100\0\u0100\0\u0100"+
+    "\0\u0100\0\u0100\0\u0100\0\u0100\0\u1440\0\u1480\0\u0100\0\u0100"+
+    "\0\u14c0\0\u0100\0\u1500\0\u0100\0\u1540\0\u1580\0\u15c0\0\u1600"+
+    "\0\u1640\0\u1680\0\u16c0\0\u1700\0\u1740\0\u1780\0\u17c0\0\u0100"+
+    "\0\u1800\0\u1840\0\u1880\0\u18c0\0\u1900\0\u1940\0\u0180\0\u1980"+
+    "\0\u19c0\0\u1a00\0\u1a40\0\u1a80\0\u1ac0\0\u1b00\0\u1b40\0\u0180"+
+    "\0\u0180\0\u1b80\0\u0180\0\u0180\0\u0100\0\u0100\0\u0100\0\u0100"+
+    "\0\u1bc0\0\u0100\0\u0100\0\u0100\0\u1c00\0\u1c40\0\u0100\0\u1c80"+
+    "\0\u1500\0\u1cc0\0\u1d00\0\u0180\0\u0180\0\u1d40\0\u1d80\0\u1dc0"+
+    "\0\u1e00\0\u0180\0\u0180\0\u1e40\0\u0180\0\u1e80\0\u1ec0\0\u0180"+
+    "\0\u1f00\0\u1f40\0\u0180\0\u0100\0\u0100\0\u1f80\0\u1fc0\0\u2000"+
+    "\0\u2040\0\u0180\0\u2080\0\u0180\0\u0180\0\u20c0\0\u0180\0\u0180"+
+    "\0\u0180\0\u0100\0\u2100\0\u2140\0\u0180\0\u0180\0\u2180\0\u21c0"+
+    "\0\u2200\0\u0180\0\u0180";
 
   private static int [] zzUnpackRowMap() {
-    int [] result = new int[210];
+    int [] result = new int[211];
     int offset = 0;
     offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
     return result;
@@ -276,149 +275,152 @@ class _JetLexer implements FlexLexer {
     "\1\7\1\0\1\7\5\0\1\7\1\150\25\7\22\0"+
     "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
     "\1\7\5\0\7\7\1\151\17\7\100\0\1\152\4\0"+
-    "\1\153\54\0\1\154\15\0\1\155\37\0\1\156\47\0"+
-    "\1\157\67\0\1\160\2\0\1\161\74\0\1\162\77\0"+
-    "\1\163\105\0\1\164\100\0\1\165\70\0\1\166\20\0"+
-    "\7\64\1\0\3\64\1\0\10\64\2\0\52\64\2\0"+
-    "\1\167\1\0\1\167\1\0\1\170\6\0\2\167\1\0"+
-    "\1\167\1\0\1\167\3\0\1\171\1\0\27\167\21\0"+
-    "\13\172\1\0\64\172\1\0\2\71\1\0\2\71\6\0"+
-    "\3\71\1\0\1\71\1\0\1\71\5\0\27\71\23\0"+
-    "\1\173\1\0\1\173\10\0\2\173\1\0\1\173\1\0"+
-    "\1\173\5\0\27\173\22\0\1\114\12\0\1\114\2\0"+
-    "\1\174\61\0\1\175\12\0\1\175\4\0\1\175\40\0"+
-    "\1\175\16\0\2\77\1\0\2\77\1\176\5\0\3\77"+
-    "\1\0\1\77\1\0\1\77\5\0\27\77\22\0\2\100"+
-    "\1\0\2\100\6\0\3\100\1\0\1\100\1\0\1\100"+
-    "\5\0\27\100\23\0\1\177\1\0\1\177\10\0\2\177"+
-    "\1\0\1\177\1\0\1\177\5\0\27\177\22\0\2\102"+
-    "\1\0\2\102\6\0\3\102\1\0\1\102\1\0\1\102"+
-    "\5\0\27\102\23\0\1\200\1\0\1\200\10\0\2\200"+
-    "\1\0\1\200\1\0\1\200\5\0\27\200\21\0\13\105"+
-    "\1\0\64\105\12\201\1\202\65\201\1\0\1\111\12\0"+
-    "\1\111\2\0\1\203\1\76\12\0\1\76\45\0\2\112"+
-    "\11\0\1\112\1\0\1\112\1\204\1\112\1\0\1\205"+
-    "\6\0\1\112\1\0\1\112\1\0\1\205\1\112\5\0"+
-    "\1\112\5\0\1\112\3\0\1\112\22\0\1\113\12\0"+
-    "\1\113\2\0\1\206\61\0\1\114\12\0\1\114\3\0"+
-    "\1\76\12\0\1\76\44\0\13\21\1\0\64\21\25\0"+
-    "\1\207\53\0\2\7\1\0\2\7\6\0\3\7\1\0"+
-    "\1\7\1\0\1\7\5\0\2\7\1\210\24\7\22\0"+
-    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
-    "\1\7\5\0\20\7\1\211\6\7\22\0\2\7\1\0"+
+    "\1\153\54\0\1\154\15\0\1\155\77\0\1\156\2\0"+
+    "\1\157\74\0\1\160\77\0\1\161\105\0\1\162\100\0"+
+    "\1\163\70\0\1\164\20\0\7\64\1\0\3\64\1\0"+
+    "\10\64\2\0\52\64\2\0\1\165\1\0\1\165\1\0"+
+    "\1\166\6\0\2\165\1\0\1\165\1\0\1\165\3\0"+
+    "\1\167\1\0\27\165\21\0\13\170\1\0\64\170\1\0"+
+    "\2\71\1\0\2\71\6\0\3\71\1\0\1\71\1\0"+
+    "\1\71\5\0\27\71\23\0\1\171\1\0\1\171\10\0"+
+    "\2\171\1\0\1\171\1\0\1\171\5\0\27\171\22\0"+
+    "\1\114\12\0\1\114\2\0\1\172\61\0\1\173\12\0"+
+    "\1\173\4\0\1\173\40\0\1\173\16\0\2\77\1\0"+
+    "\2\77\1\174\5\0\3\77\1\0\1\77\1\0\1\77"+
+    "\5\0\27\77\22\0\2\100\1\0\2\100\6\0\3\100"+
+    "\1\0\1\100\1\0\1\100\5\0\27\100\23\0\1\175"+
+    "\1\0\1\175\10\0\2\175\1\0\1\175\1\0\1\175"+
+    "\5\0\27\175\22\0\2\102\1\0\2\102\6\0\3\102"+
+    "\1\0\1\102\1\0\1\102\5\0\27\102\23\0\1\176"+
+    "\1\0\1\176\10\0\2\176\1\0\1\176\1\0\1\176"+
+    "\5\0\27\176\21\0\13\105\1\0\64\105\12\177\1\200"+
+    "\65\177\1\0\1\111\12\0\1\111\2\0\1\201\1\76"+
+    "\12\0\1\76\45\0\2\112\11\0\1\112\1\0\1\112"+
+    "\1\202\1\112\1\0\1\203\6\0\1\112\1\0\1\112"+
+    "\1\0\1\203\1\112\5\0\1\112\5\0\1\112\3\0"+
+    "\1\112\22\0\1\113\12\0\1\113\2\0\1\204\61\0"+
+    "\1\114\12\0\1\114\3\0\1\76\12\0\1\76\44\0"+
+    "\13\21\1\0\64\21\25\0\1\205\53\0\2\7\1\0"+
     "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
-    "\27\7\2\0\1\212\17\0\2\7\1\0\2\7\6\0"+
-    "\3\7\1\0\1\7\1\0\1\7\5\0\4\7\1\213"+
-    "\22\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
-    "\1\7\1\0\1\7\5\0\1\214\26\7\22\0\2\7"+
-    "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+
-    "\5\0\1\7\1\215\25\7\22\0\2\7\1\0\2\7"+
-    "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\15\7"+
-    "\1\216\11\7\22\0\2\7\1\0\2\7\6\0\3\7"+
-    "\1\0\1\7\1\0\1\7\5\0\12\7\1\217\10\7"+
-    "\1\220\3\7\22\0\2\7\1\0\2\7\6\0\3\7"+
-    "\1\0\1\7\1\0\1\7\5\0\11\7\1\221\1\7"+
-    "\1\222\13\7\22\0\2\7\1\0\2\7\6\0\3\7"+
-    "\1\0\1\7\1\0\1\7\5\0\5\7\1\223\21\7"+
+    "\2\7\1\206\24\7\22\0\2\7\1\0\2\7\6\0"+
+    "\3\7\1\0\1\7\1\0\1\7\5\0\20\7\1\207"+
+    "\6\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
+    "\1\7\1\0\1\7\5\0\27\7\2\0\1\210\17\0"+
+    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
+    "\1\7\5\0\4\7\1\211\22\7\22\0\2\7\1\0"+
+    "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
+    "\1\212\26\7\22\0\2\7\1\0\2\7\6\0\3\7"+
+    "\1\0\1\7\1\0\1\7\5\0\1\7\1\213\25\7"+
     "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
-    "\1\0\1\7\5\0\10\7\1\224\16\7\22\0\2\7"+
+    "\1\0\1\7\5\0\15\7\1\214\11\7\22\0\2\7"+
     "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+
-    "\5\0\3\7\1\225\23\7\22\0\2\7\1\0\2\7"+
+    "\5\0\1\7\1\215\10\7\1\216\10\7\1\217\3\7"+
+    "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
+    "\1\0\1\7\5\0\11\7\1\220\1\7\1\221\13\7"+
+    "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
+    "\1\0\1\7\5\0\5\7\1\222\21\7\22\0\2\7"+
+    "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+
+    "\5\0\10\7\1\223\16\7\22\0\2\7\1\0\2\7"+
     "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\3\7"+
-    "\1\226\5\7\1\227\15\7\22\0\2\7\1\0\2\7"+
-    "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\20\7"+
-    "\1\230\6\7\22\0\2\7\1\0\2\7\6\0\3\7"+
-    "\1\0\1\7\1\0\1\7\5\0\13\7\1\231\13\7"+
+    "\1\224\23\7\22\0\2\7\1\0\2\7\6\0\3\7"+
+    "\1\0\1\7\1\0\1\7\5\0\3\7\1\225\5\7"+
+    "\1\226\15\7\22\0\2\7\1\0\2\7\6\0\3\7"+
+    "\1\0\1\7\1\0\1\7\5\0\20\7\1\227\6\7"+
     "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
-    "\1\0\1\7\5\0\1\232\26\7\22\0\2\7\1\0"+
-    "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
-    "\11\7\1\233\15\7\22\0\2\7\1\0\2\7\6\0"+
-    "\3\7\1\0\1\7\1\0\1\7\5\0\13\7\1\234"+
-    "\4\7\1\235\6\7\100\0\1\236\50\0\1\237\3\0"+
-    "\1\240\122\0\1\241\21\0\2\167\1\0\2\167\6\0"+
-    "\3\167\1\0\1\167\1\0\1\167\5\0\27\167\23\0"+
-    "\1\242\1\0\1\242\10\0\2\242\1\0\1\242\1\0"+
-    "\1\242\5\0\27\242\22\0\2\173\1\0\2\173\1\243"+
-    "\5\0\3\173\1\0\1\173\1\0\1\173\5\0\27\173"+
-    "\22\0\1\175\12\0\1\175\64\0\2\177\1\0\2\177"+
-    "\1\244\5\0\3\177\1\0\1\177\1\0\1\177\5\0"+
-    "\27\177\22\0\2\200\1\0\2\200\1\245\5\0\3\200"+
-    "\1\0\1\200\1\0\1\200\5\0\27\200\21\0\12\201"+
-    "\1\246\65\201\11\247\1\250\1\202\65\247\1\0\1\114"+
-    "\12\0\1\114\64\0\2\251\11\0\1\251\1\0\1\251"+
-    "\1\174\1\251\10\0\1\251\1\0\1\251\2\0\1\251"+
-    "\5\0\1\251\5\0\1\251\3\0\1\251\22\0\1\175"+
-    "\12\0\1\175\4\0\1\252\40\0\1\252\34\0\1\174"+
-    "\60\0\25\207\1\253\52\207\1\0\2\7\1\0\2\7"+
-    "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\3\7"+
-    "\1\254\23\7\22\0\2\7\1\0\2\7\6\0\3\7"+
-    "\1\0\1\7\1\0\1\7\5\0\20\7\1\255\6\7"+
-    "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
-    "\1\0\1\7\5\0\3\7\1\256\23\7\22\0\2\7"+
+    "\1\0\1\7\5\0\13\7\1\230\13\7\22\0\2\7"+
     "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+
-    "\5\0\10\7\1\257\16\7\22\0\2\7\1\0\2\7"+
-    "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\4\7"+
-    "\1\260\22\7\22\0\2\7\1\0\2\7\6\0\3\7"+
-    "\1\0\1\7\1\0\1\7\5\0\3\7\1\261\23\7"+
+    "\5\0\1\231\26\7\22\0\2\7\1\0\2\7\6\0"+
+    "\3\7\1\0\1\7\1\0\1\7\5\0\11\7\1\232"+
+    "\15\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
+    "\1\7\1\0\1\7\5\0\13\7\1\233\4\7\1\234"+
+    "\6\7\100\0\1\235\50\0\1\236\3\0\1\237\122\0"+
+    "\1\240\21\0\2\165\1\0\2\165\6\0\3\165\1\0"+
+    "\1\165\1\0\1\165\5\0\27\165\23\0\1\241\1\0"+
+    "\1\241\10\0\2\241\1\0\1\241\1\0\1\241\5\0"+
+    "\27\241\22\0\2\171\1\0\2\171\1\242\5\0\3\171"+
+    "\1\0\1\171\1\0\1\171\5\0\27\171\22\0\1\173"+
+    "\12\0\1\173\64\0\2\175\1\0\2\175\1\243\5\0"+
+    "\3\175\1\0\1\175\1\0\1\175\5\0\27\175\22\0"+
+    "\2\176\1\0\2\176\1\244\5\0\3\176\1\0\1\176"+
+    "\1\0\1\176\5\0\27\176\21\0\12\177\1\245\65\177"+
+    "\11\246\1\247\1\200\65\246\1\0\1\114\12\0\1\114"+
+    "\64\0\2\250\11\0\1\250\1\0\1\250\1\172\1\250"+
+    "\10\0\1\250\1\0\1\250\2\0\1\250\5\0\1\250"+
+    "\5\0\1\250\3\0\1\250\22\0\1\173\12\0\1\173"+
+    "\4\0\1\251\40\0\1\251\34\0\1\172\60\0\25\205"+
+    "\1\252\52\205\1\0\2\7\1\0\2\7\6\0\3\7"+
+    "\1\0\1\7\1\0\1\7\5\0\3\7\1\253\23\7"+
     "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
-    "\1\0\1\7\5\0\3\7\1\262\23\7\22\0\2\7"+
+    "\1\0\1\7\5\0\20\7\1\254\6\7\22\0\2\7"+
     "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+
-    "\5\0\4\7\1\263\22\7\22\0\2\7\1\0\2\7"+
-    "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\7\7"+
-    "\1\264\17\7\22\0\2\7\1\0\2\7\6\0\3\7"+
-    "\1\0\1\7\1\0\1\7\5\0\3\7\1\265\23\7"+
-    "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
-    "\1\0\1\7\5\0\12\7\1\266\14\7\22\0\2\7"+
-    "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+
-    "\5\0\1\7\1\267\25\7\22\0\2\7\1\0\2\7"+
-    "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\1\270"+
-    "\26\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
-    "\1\7\1\0\1\7\5\0\20\7\1\271\6\7\22\0"+
-    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
-    "\1\7\5\0\4\7\1\272\22\7\22\0\2\7\1\0"+
-    "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
-    "\4\7\1\273\22\7\22\0\2\242\1\0\2\242\1\274"+
-    "\5\0\3\242\1\0\1\242\1\0\1\242\5\0\27\242"+
-    "\21\0\11\201\1\275\1\246\65\201\12\247\1\276\65\247"+
-    "\1\0\2\251\11\0\1\251\1\0\1\251\1\0\1\251"+
-    "\1\0\1\205\6\0\1\251\1\0\1\251\1\0\1\205"+
-    "\1\251\5\0\1\251\5\0\1\251\3\0\1\251\21\0"+
-    "\25\207\1\277\52\207\1\0\2\7\1\0\2\7\6\0"+
-    "\3\7\1\0\1\7\1\0\1\7\5\0\4\7\1\300"+
-    "\22\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
-    "\1\7\1\0\1\7\5\0\11\7\1\301\15\7\22\0"+
-    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
-    "\1\7\5\0\4\7\1\302\22\7\22\0\2\7\1\0"+
-    "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
-    "\6\7\1\303\20\7\22\0\2\7\1\0\2\7\6\0"+
-    "\3\7\1\0\1\7\1\0\1\7\5\0\16\7\1\304"+
-    "\10\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
-    "\1\7\1\0\1\7\5\0\13\7\1\305\13\7\22\0"+
-    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
-    "\1\7\5\0\21\7\1\306\5\7\22\0\2\7\1\0"+
-    "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
-    "\3\7\1\307\23\7\22\0\2\7\1\0\2\7\6\0"+
-    "\3\7\1\0\1\7\1\0\1\7\5\0\3\7\1\310"+
-    "\23\7\21\0\11\247\1\250\1\276\65\247\25\207\1\311"+
-    "\52\207\1\0\2\7\1\0\2\7\6\0\3\7\1\0"+
-    "\1\7\1\0\1\7\5\0\5\7\1\312\21\7\22\0"+
-    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
-    "\1\7\5\0\1\313\26\7\22\0\2\7\1\0\2\7"+
+    "\5\0\3\7\1\255\23\7\22\0\2\7\1\0\2\7"+
     "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\10\7"+
-    "\1\314\16\7\22\0\2\7\1\0\2\7\6\0\3\7"+
-    "\1\0\1\7\1\0\1\7\5\0\1\315\26\7\22\0"+
-    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
-    "\1\7\5\0\1\7\1\316\25\7\22\0\2\7\1\0"+
+    "\1\256\16\7\22\0\2\7\1\0\2\7\6\0\3\7"+
+    "\1\0\1\7\1\0\1\7\5\0\4\7\1\257\22\7"+
+    "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
+    "\1\0\1\7\5\0\3\7\1\260\23\7\22\0\2\7"+
+    "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+
+    "\5\0\11\7\1\261\15\7\22\0\2\7\1\0\2\7"+
+    "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\3\7"+
+    "\1\262\23\7\22\0\2\7\1\0\2\7\6\0\3\7"+
+    "\1\0\1\7\1\0\1\7\5\0\4\7\1\263\22\7"+
+    "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
+    "\1\0\1\7\5\0\7\7\1\264\17\7\22\0\2\7"+
+    "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+
+    "\5\0\3\7\1\265\23\7\22\0\2\7\1\0\2\7"+
+    "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\12\7"+
+    "\1\266\14\7\22\0\2\7\1\0\2\7\6\0\3\7"+
+    "\1\0\1\7\1\0\1\7\5\0\1\7\1\267\25\7"+
+    "\22\0\2\7\1\0\2\7\6\0\3\7\1\0\1\7"+
+    "\1\0\1\7\5\0\1\270\26\7\22\0\2\7\1\0"+
     "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
-    "\12\7\1\317\14\7\22\0\2\7\1\0\2\7\6\0"+
-    "\3\7\1\0\1\7\1\0\1\7\5\0\6\7\1\320"+
-    "\20\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
-    "\1\7\1\0\1\7\5\0\3\7\1\321\23\7\22\0"+
+    "\20\7\1\271\6\7\22\0\2\7\1\0\2\7\6\0"+
+    "\3\7\1\0\1\7\1\0\1\7\5\0\4\7\1\272"+
+    "\22\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
+    "\1\7\1\0\1\7\5\0\4\7\1\273\22\7\22\0"+
+    "\2\241\1\0\2\241\1\274\5\0\3\241\1\0\1\241"+
+    "\1\0\1\241\5\0\27\241\21\0\11\177\1\275\1\245"+
+    "\65\177\12\246\1\276\65\246\1\0\2\250\11\0\1\250"+
+    "\1\0\1\250\1\0\1\250\1\0\1\203\6\0\1\250"+
+    "\1\0\1\250\1\0\1\203\1\250\5\0\1\250\5\0"+
+    "\1\250\3\0\1\250\21\0\25\205\1\277\52\205\1\0"+
     "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
-    "\1\7\5\0\3\7\1\322\23\7\21\0";
+    "\1\7\5\0\4\7\1\300\22\7\22\0\2\7\1\0"+
+    "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
+    "\11\7\1\301\15\7\22\0\2\7\1\0\2\7\6\0"+
+    "\3\7\1\0\1\7\1\0\1\7\5\0\4\7\1\302"+
+    "\22\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
+    "\1\7\1\0\1\7\5\0\6\7\1\303\20\7\22\0"+
+    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
+    "\1\7\5\0\10\7\1\304\16\7\22\0\2\7\1\0"+
+    "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
+    "\16\7\1\305\10\7\22\0\2\7\1\0\2\7\6\0"+
+    "\3\7\1\0\1\7\1\0\1\7\5\0\13\7\1\306"+
+    "\13\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
+    "\1\7\1\0\1\7\5\0\21\7\1\307\5\7\22\0"+
+    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
+    "\1\7\5\0\3\7\1\310\23\7\22\0\2\7\1\0"+
+    "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
+    "\3\7\1\311\23\7\21\0\11\246\1\247\1\276\65\246"+
+    "\25\205\1\312\52\205\1\0\2\7\1\0\2\7\6\0"+
+    "\3\7\1\0\1\7\1\0\1\7\5\0\5\7\1\313"+
+    "\21\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
+    "\1\7\1\0\1\7\5\0\1\314\26\7\22\0\2\7"+
+    "\1\0\2\7\6\0\3\7\1\0\1\7\1\0\1\7"+
+    "\5\0\10\7\1\315\16\7\22\0\2\7\1\0\2\7"+
+    "\6\0\3\7\1\0\1\7\1\0\1\7\5\0\1\316"+
+    "\26\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
+    "\1\7\1\0\1\7\5\0\1\7\1\317\25\7\22\0"+
+    "\2\7\1\0\2\7\6\0\3\7\1\0\1\7\1\0"+
+    "\1\7\5\0\12\7\1\320\14\7\22\0\2\7\1\0"+
+    "\2\7\6\0\3\7\1\0\1\7\1\0\1\7\5\0"+
+    "\6\7\1\321\20\7\22\0\2\7\1\0\2\7\6\0"+
+    "\3\7\1\0\1\7\1\0\1\7\5\0\3\7\1\322"+
+    "\23\7\22\0\2\7\1\0\2\7\6\0\3\7\1\0"+
+    "\1\7\1\0\1\7\5\0\3\7\1\323\23\7\21\0";
 
   private static int [] zzUnpackTrans() {
-    int [] result = new int[8704];
+    int [] result = new int[8768];
     int offset = 0;
     offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result);
     return result;
@@ -459,17 +461,17 @@ class _JetLexer implements FlexLexer {
   private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();
 
   private static final String ZZ_ATTRIBUTE_PACKED_0 =
-    "\4\0\1\11\15\1\2\11\26\1\1\11\1\1\7\11"+
+    "\4\0\1\11\15\1\2\11\20\1\1\11\6\1\10\11"+
     "\2\1\1\11\1\0\1\11\1\1\1\0\2\11\1\0"+
     "\1\1\1\0\1\1\1\0\1\1\1\0\1\11\2\1"+
     "\2\11\4\1\5\11\1\1\1\0\27\1\1\11\1\0"+
-    "\1\1\11\11\1\1\1\0\2\11\1\0\1\11\1\1"+
-    "\1\11\2\0\2\1\4\0\3\1\1\11\23\1\4\11"+
-    "\1\0\3\11\1\0\1\1\1\11\1\1\2\0\20\1"+
-    "\2\11\2\0\11\1\1\11\11\1";
+    "\1\1\7\11\1\1\1\0\2\11\1\0\1\11\1\1"+
+    "\1\11\2\0\2\1\4\0\3\1\1\11\24\1\4\11"+
+    "\1\0\3\11\1\0\1\1\1\11\1\1\2\0\21\1"+
+    "\2\11\2\0\12\1\1\11\11\1";
 
   private static int [] zzUnpackAttribute() {
-    int [] result = new int[210];
+    int [] result = new int[211];
     int offset = 0;
     offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
     return result;
@@ -578,7 +580,7 @@ class _JetLexer implements FlexLexer {
     char [] map = new char[0x10000];
     int i = 0;  /* index in packed string  */
     int j = 0;  /* index in unpacked array */
-    while (i < 1330) {
+    while (i < 1326) {
       int  count = packed.charAt(i++);
       char value = packed.charAt(i++);
       do map[j++] = value; while (--count > 0);
@@ -803,23 +805,23 @@ class _JetLexer implements FlexLexer {
         case 3: 
           { return JetTokens.IDENTIFIER;
           }
-        case 96: break;
+        case 95: break;
         case 11: 
           { pushState(STRING); return JetTokens.OPEN_QUOTE;
           }
-        case 97: break;
-        case 72: 
+        case 96: break;
+        case 70: 
           { return JetTokens.FOR_KEYWORD ;
           }
-        case 98: break;
-        case 93: 
+        case 97: break;
+        case 92: 
           { return JetTokens.RETURN_KEYWORD ;
           }
-        case 99: break;
-        case 80: 
+        case 98: break;
+        case 78: 
           { return JetTokens.NULL_KEYWORD ;
           }
-        case 100: break;
+        case 99: break;
         case 34: 
           { if (lBraceCount == 0) {
                                              popState();
@@ -828,365 +830,361 @@ class _JetLexer implements FlexLexer {
                                            lBraceCount--;
                                            return JetTokens.RBRACE;
           }
-        case 101: break;
+        case 100: break;
         case 18: 
           { return JetTokens.LT        ;
           }
-        case 102: break;
+        case 101: break;
         case 51: 
           { return JetTokens.DO_KEYWORD ;
           }
-        case 103: break;
+        case 102: break;
         case 17: 
           { return JetTokens.PLUS      ;
           }
-        case 104: break;
-        case 69: 
+        case 103: break;
+        case 67: 
           { return JetTokens.RAW_STRING_LITERAL;
           }
-        case 105: break;
-        case 57: 
+        case 104: break;
+        case 55: 
           { return JetTokens.PLUSEQ    ;
           }
-        case 106: break;
+        case 105: break;
         case 27: 
           { return JetTokens.COMMA     ;
           }
-        case 107: break;
+        case 106: break;
         case 19: 
           { return JetTokens.GT        ;
           }
-        case 108: break;
+        case 107: break;
         case 4: 
           { return JetTokens.WHITE_SPACE;
           }
-        case 109: break;
-        case 25: 
+        case 108: break;
+        case 24: 
           { return JetTokens.RPAR      ;
           }
-        case 110: break;
+        case 109: break;
         case 53: 
           { return JetTokens.DOUBLE_ARROW;
           }
-        case 111: break;
-        case 82: 
+        case 110: break;
+        case 80: 
           { return JetTokens.TRUE_KEYWORD ;
           }
-        case 112: break;
+        case 111: break;
         case 36: 
           { return JetTokens.FIELD_IDENTIFIER;
           }
-        case 113: break;
-        case 61: 
+        case 112: break;
+        case 59: 
           { return JetTokens.ANDAND    ;
           }
-        case 114: break;
-        case 65: 
+        case 113: break;
+        case 63: 
           { pushState(LONG_TEMPLATE_ENTRY); return JetTokens.LONG_TEMPLATE_ENTRY_START;
           }
-        case 115: break;
-        case 68: 
+        case 114: break;
+        case 66: 
           { return JetTokens.DOC_COMMENT;
           }
-        case 116: break;
+        case 115: break;
         case 35: 
           { return JetTokens.FLOAT_LITERAL;
           }
-        case 117: break;
+        case 116: break;
         case 39: 
           { return JetTokens.EOL_COMMENT;
           }
-        case 118: break;
-        case 85: 
+        case 117: break;
+        case 83: 
           { return JetTokens.WHEN_KEYWORD ;
           }
-        case 119: break;
-        case 20: 
+        case 118: break;
+        case 25: 
           { return JetTokens.COLON     ;
           }
-        case 120: break;
-        case 59: 
+        case 119: break;
+        case 57: 
           { return JetTokens.LTEQ      ;
           }
-        case 121: break;
+        case 120: break;
         case 46: 
           { return JetTokens.ARROW     ;
           }
-        case 122: break;
+        case 121: break;
         case 32: 
           { popState(); return JetTokens.IDENTIFIER;
           }
-        case 123: break;
-        case 22: 
+        case 122: break;
+        case 21: 
           { return JetTokens.LBRACKET  ;
           }
-        case 124: break;
-        case 67: 
+        case 123: break;
+        case 65: 
           { yypushback(2); return JetTokens.INTEGER_LITERAL;
           }
-        case 125: break;
+        case 124: break;
         case 10: 
           { return JetTokens.CHARACTER_LITERAL;
           }
-        case 126: break;
-        case 74: 
+        case 125: break;
+        case 72: 
           { return JetTokens.VAR_KEYWORD ;
           }
-        case 127: break;
-        case 60: 
+        case 126: break;
+        case 58: 
           { return JetTokens.GTEQ      ;
           }
-        case 128: break;
+        case 127: break;
         case 2: 
           { return JetTokens.INTEGER_LITERAL;
           }
-        case 129: break;
+        case 128: break;
         case 13: 
           { return JetTokens.RBRACE    ;
           }
-        case 130: break;
-        case 87: 
+        case 129: break;
+        case 85: 
           { return JetTokens.CLASS_KEYWORD ;
           }
-        case 131: break;
+        case 130: break;
         case 15: 
           { return JetTokens.EXCL      ;
           }
-        case 132: break;
-        case 71: 
+        case 131: break;
+        case 69: 
           { return JetTokens.TRY_KEYWORD ;
           }
-        case 133: break;
+        case 132: break;
         case 54: 
           { return JetTokens.EXCLEQ    ;
           }
-        case 134: break;
+        case 133: break;
         case 45: 
           { return JetTokens.MINUSEQ   ;
           }
-        case 135: break;
-        case 88: 
+        case 134: break;
+        case 87: 
           { return JetTokens.THROW_KEYWORD ;
           }
-        case 136: break;
-        case 90: 
+        case 135: break;
+        case 89: 
           { return JetTokens.WHILE_KEYWORD ;
           }
-        case 137: break;
+        case 136: break;
         case 44: 
           { return JetTokens.MINUSMINUS;
           }
-        case 138: break;
-        case 94: 
+        case 137: break;
+        case 93: 
           { return JetTokens.CONTINUE_KEYWORD ;
           }
-        case 139: break;
-        case 77: 
+        case 138: break;
+        case 75: 
           { return JetTokens.NOT_IN;
           }
-        case 140: break;
+        case 139: break;
         case 38: 
           { return JetTokens.ATAT      ;
           }
-        case 141: break;
+        case 140: break;
         case 6: 
           { return JetTokens.DIV       ;
           }
-        case 142: break;
-        case 56: 
-          { return JetTokens.ELVIS     ;
-          }
-        case 143: break;
+        case 141: break;
         case 37: 
           { return JetTokens.LABEL_IDENTIFIER;
           }
-        case 144: break;
+        case 142: break;
         case 29: 
           { return JetTokens.REGULAR_STRING_PART;
           }
-        case 145: break;
+        case 143: break;
         case 16: 
           { return JetTokens.QUEST     ;
           }
-        case 146: break;
-        case 62: 
+        case 144: break;
+        case 60: 
           { return JetTokens.OROR      ;
           }
-        case 147: break;
-        case 21: 
+        case 145: break;
+        case 20: 
           { return JetTokens.PERC      ;
           }
-        case 148: break;
-        case 79: 
+        case 146: break;
+        case 77: 
           { return JetTokens.EXCLEQEQEQ;
           }
-        case 149: break;
-        case 63: 
+        case 147: break;
+        case 61: 
           { return JetTokens.PERCEQ    ;
           }
-        case 150: break;
+        case 148: break;
         case 43: 
           { return JetTokens.RANGE     ;
           }
-        case 151: break;
+        case 149: break;
         case 1: 
           { return TokenType.BAD_CHARACTER;
           }
-        case 152: break;
-        case 55: 
-          { return JetTokens.SAFE_ACCESS;
-          }
-        case 153: break;
-        case 95: 
+        case 150: break;
+        case 94: 
           { return JetTokens.NAMESPACE_KEYWORD ;
           }
-        case 154: break;
-        case 78: 
+        case 151: break;
+        case 76: 
           { return JetTokens.NOT_IS;
           }
-        case 155: break;
+        case 152: break;
         case 7: 
           { return JetTokens.MUL       ;
           }
-        case 156: break;
-        case 23: 
+        case 153: break;
+        case 22: 
           { return JetTokens.RBRACKET  ;
           }
-        case 157: break;
-        case 58: 
+        case 154: break;
+        case 56: 
           { return JetTokens.PLUSPLUS  ;
           }
-        case 158: break;
-        case 83: 
+        case 155: break;
+        case 81: 
           { return JetTokens.THIS_KEYWORD ;
           }
-        case 159: break;
+        case 156: break;
         case 8: 
           { return JetTokens.DOT       ;
           }
-        case 160: break;
+        case 157: break;
         case 26: 
           { return JetTokens.SEMICOLON ;
           }
-        case 161: break;
+        case 158: break;
         case 50: 
           { return JetTokens.IF_KEYWORD ;
           }
-        case 162: break;
-        case 66: 
+        case 159: break;
+        case 64: 
           { return JetTokens.ESCAPE_SEQUENCE;
           }
-        case 163: break;
+        case 160: break;
         case 31: 
           { popState(); return JetTokens.CLOSING_QUOTE;
           }
-        case 164: break;
+        case 161: break;
         case 14: 
           { return JetTokens.EQ        ;
           }
-        case 165: break;
+        case 162: break;
         case 5: 
           { return JetTokens.AT        ;
           }
-        case 166: break;
-        case 70: 
+        case 163: break;
+        case 68: 
           { return JetTokens.AS_SAFE;
           }
-        case 167: break;
-        case 24: 
+        case 164: break;
+        case 23: 
           { return JetTokens.LPAR      ;
           }
-        case 168: break;
+        case 165: break;
         case 9: 
           { return JetTokens.MINUS     ;
           }
-        case 169: break;
-        case 91: 
+        case 166: break;
+        case 90: 
           { return JetTokens.FALSE_KEYWORD ;
           }
-        case 170: break;
-        case 84: 
+        case 167: break;
+        case 82: 
           { return JetTokens.TYPE_KEYWORD ;
           }
-        case 171: break;
-        case 73: 
+        case 168: break;
+        case 71: 
           { return JetTokens.FUN_KEYWORD ;
           }
-        case 172: break;
+        case 169: break;
         case 49: 
           { return JetTokens.IS_KEYWORD ;
           }
-        case 173: break;
+        case 170: break;
         case 30: 
           { popState(); yypushback(1); return JetTokens.DANGLING_NEWLINE;
           }
-        case 174: break;
+        case 171: break;
         case 33: 
           { lBraceCount++; return JetTokens.LBRACE;
           }
-        case 175: break;
+        case 172: break;
         case 41: 
           { return JetTokens.DIVEQ     ;
           }
-        case 176: break;
-        case 81: 
+        case 173: break;
+        case 79: 
           { return JetTokens.ELSE_KEYWORD ;
           }
-        case 177: break;
+        case 174: break;
         case 47: 
           { return JetTokens.AS_KEYWORD ;
           }
-        case 178: break;
+        case 175: break;
         case 48: 
           { return JetTokens.IN_KEYWORD ;
           }
-        case 179: break;
+        case 176: break;
         case 52: 
           { return JetTokens.EQEQ      ;
           }
-        case 180: break;
-        case 76: 
+        case 177: break;
+        case 74: 
           { return JetTokens.EQEQEQ    ;
           }
-        case 181: break;
-        case 75: 
+        case 178: break;
+        case 73: 
           { return JetTokens.VAL_KEYWORD ;
           }
-        case 182: break;
-        case 86: 
+        case 179: break;
+        case 84: 
           { return JetTokens.CAPITALIZED_THIS_KEYWORD ;
           }
-        case 183: break;
+        case 180: break;
         case 42: 
           { return JetTokens.MULTEQ    ;
           }
-        case 184: break;
-        case 64: 
+        case 181: break;
+        case 62: 
           { pushState(SHORT_TEMPLATE_ENTRY);
                                             yypushback(yylength() - 1);
                                             return JetTokens.SHORT_TEMPLATE_ENTRY_START;
           }
-        case 185: break;
+        case 182: break;
         case 12: 
           { return JetTokens.LBRACE    ;
           }
-        case 186: break;
-        case 92: 
+        case 183: break;
+        case 91: 
           { return JetTokens.OBJECT_KEYWORD ;
           }
-        case 187: break;
-        case 89: 
+        case 184: break;
+        case 88: 
           { return JetTokens.BREAK_KEYWORD ;
           }
-        case 188: break;
+        case 185: break;
         case 40: 
           { return JetTokens.BLOCK_COMMENT;
           }
-        case 189: break;
+        case 186: break;
+        case 86: 
+          { return JetTokens.TRAIT_KEYWORD ;
+          }
+        case 187: break;
         case 28: 
           { return JetTokens.HASH      ;
           }
-        case 190: break;
+        case 188: break;
         default:
           if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
             zzAtEOF = true;
diff --git a/idea/src/org/jetbrains/jet/plugin/JetFileType.java b/compiler/frontend/src/org/jetbrains/jet/plugin/JetFileType.java
similarity index 100%
rename from idea/src/org/jetbrains/jet/plugin/JetFileType.java
rename to compiler/frontend/src/org/jetbrains/jet/plugin/JetFileType.java
diff --git a/compiler/frontend/src/org/jetbrains/jet/plugin/JetLanguage.java b/compiler/frontend/src/org/jetbrains/jet/plugin/JetLanguage.java
new file mode 100644
index 00000000000..40c5d1caaa0
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/plugin/JetLanguage.java
@@ -0,0 +1,14 @@
+/*
+ * @author max
+ */
+package org.jetbrains.jet.plugin;
+
+import com.intellij.lang.Language;
+
+public class JetLanguage extends Language {
+    public static JetLanguage INSTANCE = new JetLanguage();
+
+    private JetLanguage() {
+        super("jet");
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/resolve/DescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java
similarity index 79%
rename from idea/src/org/jetbrains/jet/resolve/DescriptorRenderer.java
rename to compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java
index 98e7a0bd41f..4e3542c197e 100644
--- a/idea/src/org/jetbrains/jet/resolve/DescriptorRenderer.java
+++ b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java
@@ -3,7 +3,10 @@ package org.jetbrains.jet.resolve;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.diagnostics.Renderer;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.JetStandardClasses;
+import org.jetbrains.jet.lang.types.JetType;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -13,7 +16,7 @@ import java.util.List;
 /**
  * @author abreslav
  */
-public class DescriptorRenderer {
+public class DescriptorRenderer implements Renderer {
 
     public static String getFQName(DeclarationDescriptor descriptor) {
         DeclarationDescriptor container = descriptor.getContainingDeclaration();
@@ -81,6 +84,13 @@ public class DescriptorRenderer {
         return escape("<");
     }
 
+    @NotNull
+    @Override
+    public String render(@Nullable Object object) {
+        assert object instanceof DeclarationDescriptor;
+        return render((DeclarationDescriptor) object);
+    }
+
     public String render(DeclarationDescriptor declarationDescriptor) {
         if (declarationDescriptor == null) return lt() + "null>";
         StringBuilder stringBuilder = new StringBuilder();
@@ -123,12 +133,15 @@ public class DescriptorRenderer {
         @Override
         public Void visitValueParameterDescriptor(ValueParameterDescriptor descriptor, StringBuilder builder) {
             builder.append(renderKeyword("value-parameter")).append(" ");
+            if (descriptor.isVararg()) {
+                builder.append(renderKeyword("vararg")).append(" ");
+            }
             return super.visitValueParameterDescriptor(descriptor, builder);
         }
 
         @Override
         public Void visitVariableDescriptor(VariableDescriptor descriptor, StringBuilder builder) {
-            String typeString = renderPropertyPrefixAndComputeTypeString(builder, Collections.<TypeParameterDescriptor>emptyList(), null, descriptor.getOutType(), descriptor.getInType());
+            String typeString = renderPropertyPrefixAndComputeTypeString(builder, Collections.<TypeParameterDescriptor>emptyList(), ReceiverDescriptor.NO_RECEIVER, descriptor.getOutType(), descriptor.getInType());
             renderName(descriptor, builder);
             builder.append(" : ").append(escape(typeString));
             return super.visitVariableDescriptor(descriptor, builder);
@@ -137,7 +150,7 @@ public class DescriptorRenderer {
         private String renderPropertyPrefixAndComputeTypeString(
                 @NotNull StringBuilder builder,
                 @NotNull List<TypeParameterDescriptor> typeParameters,
-                @Nullable JetType receiverType,
+                @NotNull ReceiverDescriptor receiver,
                 @Nullable JetType outType,
                 @Nullable JetType inType) {
             String typeString = lt() + "no type>";
@@ -161,8 +174,8 @@ public class DescriptorRenderer {
 
             renderTypeParameters(typeParameters, builder);
 
-            if (receiverType != null) {
-                builder.append(escape(renderType(receiverType))).append(".");
+            if (receiver.exists()) {
+                builder.append(escape(renderType(receiver.getType()))).append(".");
             }
 
             return typeString;
@@ -170,9 +183,10 @@ public class DescriptorRenderer {
 
         @Override
         public Void visitPropertyDescriptor(PropertyDescriptor descriptor, StringBuilder builder) {
+            renderModality(descriptor.getModality(), builder);
             String typeString = renderPropertyPrefixAndComputeTypeString(
-                    builder, descriptor.getTypeParemeters(),
-                    descriptor.getReceiverType(),
+                    builder, descriptor.getTypeParameters(),
+                    descriptor.getReceiver(),
                     descriptor.getOutType(),
                     descriptor.getInType());
             renderName(descriptor, builder);
@@ -180,18 +194,39 @@ public class DescriptorRenderer {
             return null;
         }
 
+        private void renderModality(Modality modality, StringBuilder builder) {
+            switch (modality) {
+                case FINAL:
+                    builder.append("final");
+                    break;
+                case OPEN:
+                    builder.append("open");
+                    break;
+                case ABSTRACT:
+                    builder.append("abstract");
+                    break;
+            }
+            builder.append(" ");
+        }
+
         @Override
         public Void visitFunctionDescriptor(FunctionDescriptor descriptor, StringBuilder builder) {
+            renderModality(descriptor.getModality(), builder);
             builder.append(renderKeyword("fun")).append(" ");
-            List<TypeParameterDescriptor> typeParameters = descriptor.getTypeParameters();
-            renderTypeParameters(typeParameters, builder);
+            renderTypeParameters(descriptor.getTypeParameters(), builder);
 
-            JetType receiverType = descriptor.getReceiverType();
-            if (receiverType != null) {
-                builder.append(escape(renderType(receiverType))).append(".");
+            ReceiverDescriptor receiver = descriptor.getReceiver();
+            if (receiver.exists()) {
+                builder.append(escape(renderType(receiver.getType()))).append(".");
             }
 
             renderName(descriptor, builder);
+            renderValueParameters(descriptor, builder);
+            builder.append(" : ").append(escape(renderType(descriptor.getReturnType())));
+            return super.visitFunctionDescriptor(descriptor, builder);
+        }
+
+        private void renderValueParameters(FunctionDescriptor descriptor, StringBuilder builder) {
             builder.append("(");
             for (Iterator<ValueParameterDescriptor> iterator = descriptor.getValueParameters().iterator(); iterator.hasNext(); ) {
                 ValueParameterDescriptor parameterDescriptor = iterator.next();
@@ -200,8 +235,19 @@ public class DescriptorRenderer {
                     builder.append(", ");
                 }
             }
-            builder.append(") : ").append(escape(renderType(descriptor.getReturnType())));
-            return super.visitFunctionDescriptor(descriptor, builder);
+            builder.append(")");
+        }
+
+        @Override
+        public Void visitConstructorDescriptor(ConstructorDescriptor constructorDescriptor, StringBuilder builder) {
+            builder.append(renderKeyword("ctor")).append(" ");
+
+            ClassDescriptor classDescriptor = constructorDescriptor.getContainingDeclaration();
+            builder.append(classDescriptor.getName());
+
+            renderTypeParameters(classDescriptor.getTypeConstructor().getParameters(), builder);
+            renderValueParameters(constructorDescriptor, builder);
+            return null;
         }
 
         private void renderTypeParameters(List<TypeParameterDescriptor> typeParameters, StringBuilder builder) {
@@ -235,12 +281,13 @@ public class DescriptorRenderer {
 
         @Override
         public Void visitClassDescriptor(ClassDescriptor descriptor, StringBuilder builder) {
-            String keyword = "class";
+            String keyword = descriptor.getKind() == ClassKind.TRAIT ? "trait" : "class";
             renderClassDescriptor(descriptor, builder, keyword);
             return super.visitClassDescriptor(descriptor, builder);
         }
 
         public void renderClassDescriptor(ClassDescriptor descriptor, StringBuilder builder, String keyword) {
+            renderModality(descriptor.getModality(), builder);
             builder.append(renderKeyword(keyword)).append(" ");
             renderName(descriptor, builder);
             renderTypeParameters(descriptor.getTypeConstructor().getParameters(), builder);
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/CommonSuppliers.java b/compiler/frontend/src/org/jetbrains/jet/util/CommonSuppliers.java
new file mode 100644
index 00000000000..d467debb201
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/util/CommonSuppliers.java
@@ -0,0 +1,43 @@
+package org.jetbrains.jet.util;
+
+import com.google.common.base.Supplier;
+import com.google.common.collect.*;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author abreslav
+ */
+public class CommonSuppliers {
+    private CommonSuppliers() {}
+
+    private static final Supplier<?> ARRAY_LIST_SUPPLIER = new Supplier() {
+        @Override
+        public List get() {
+            return Lists.newArrayList();
+        }
+    };
+
+    private static final Supplier<?> LINKED_HASH_SET_SUPPLIER = new Supplier() {
+        @Override
+        public Set get() {
+            return Sets.newLinkedHashSet();
+        }
+    };
+
+    public static <T> Supplier<List<T>> getArrayListSupplier() {
+        //noinspection unchecked
+        return (Supplier<List<T>>) ARRAY_LIST_SUPPLIER;
+    }
+
+    public static <T> Supplier<Set<T>> getLinkedHashSetSupplier() {
+        //noinspection unchecked
+        return (Supplier<Set<T>>) LINKED_HASH_SET_SUPPLIER;
+    }
+    
+    public static <K, V> SetMultimap<K, V> newLinkedHashSetHashSetMultimap() {
+        return Multimaps.newSetMultimap(Maps.<K, Collection<V>>newHashMap(), CommonSuppliers.<V>getLinkedHashSetSupplier());
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/util/BasicWritableSlice.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/BasicWritableSlice.java
similarity index 57%
rename from idea/src/org/jetbrains/jet/util/BasicWritableSlice.java
rename to compiler/frontend/src/org/jetbrains/jet/util/slicedmap/BasicWritableSlice.java
index 1b2da3c773c..cef0c263261 100644
--- a/idea/src/org/jetbrains/jet/util/BasicWritableSlice.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/BasicWritableSlice.java
@@ -1,4 +1,4 @@
-package org.jetbrains.jet.util;
+package org.jetbrains.jet.util.slicedmap;
 
 /**
 * @author abreslav
@@ -14,8 +14,8 @@ public class BasicWritableSlice<K, V> implements WritableSlice<K,V> {
     }
 
     @Override
-    public ManyMapKey<K, V> makeKey(K key) {
-        return new ManyMapKey<K, V>(this, key);
+    public SlicedMapKey<K, V> makeKey(K key) {
+        return new SlicedMapKey<K, V>(this, key);
     }
 
     // True to put, false to skip
@@ -27,24 +27,37 @@ public class BasicWritableSlice<K, V> implements WritableSlice<K,V> {
     }
 
     @Override
-    public void afterPut(MutableManyMap manyMap, K key, V value) {
+    public void afterPut(MutableSlicedMap map, K key, V value) {
         // Do nothing
     }
 
     @Override
-    public V computeValue(ManyMap map, K key, V value, boolean valueNotFound) {
+    public V computeValue(SlicedMap map, K key, V value, boolean valueNotFound) {
         if (valueNotFound) assert value == null;
         return value;
     }
 
-
     @Override
     public RewritePolicy getRewritePolicy() {
         return rewritePolicy;
     }
 
+
     @Override
     public String toString() {
         return debugName;
     }
+
+    @Override
+    public ReadOnlySlice<K, V> makeRawValueVersion() {
+        return new DelegatingSlice<K, V>(this) {
+            @Override
+            public V computeValue(SlicedMap map, K key, V value, boolean valueNotFound) {
+                if (valueNotFound) assert value == null;
+                return value;
+            }
+        };
+    }
+
+
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/CollectionSliceWrapper.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/CollectionSliceWrapper.java
new file mode 100644
index 00000000000..faded385ac3
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/CollectionSliceWrapper.java
@@ -0,0 +1,57 @@
+package org.jetbrains.jet.util.slicedmap;
+
+import com.google.common.base.Supplier;
+
+import java.util.Collection;
+
+/**
+ * @author abreslav
+ */
+public class CollectionSliceWrapper<K, V> implements WritableSlice<K, V> {
+    
+    private final WritableSlice<K, Collection<V>> wrapped;
+    private final SlicedMapKey<K, V> myKey;
+    private final Supplier<? extends Collection<V>> supplier;
+
+    public CollectionSliceWrapper(WritableSlice<K, Collection<V>> wrapped, Supplier<? extends Collection<V>> supplier) {
+        this.wrapped = wrapped;
+        this.supplier = supplier;
+        this.myKey = new SlicedMapKey<K, V>(this, null);
+    }
+
+    @Override
+    public SlicedMapKey<K, V> makeKey(K key) {
+        return myKey;
+    }
+
+    @Override
+    public boolean check(K key, V value) {
+        assert value != null;
+        return true;
+    }
+
+    @Override
+    public void afterPut(MutableSlicedMap map, K key, V value) {
+        Collection<V> collection = map.get(wrapped, key);
+        if (collection == null) {
+            collection = supplier.get();
+            map.put(wrapped, key, collection);
+        }
+        collection.add(value);
+    }
+
+    @Override
+    public RewritePolicy getRewritePolicy() {
+        return RewritePolicy.DO_NOTHING;
+    }
+
+    @Override
+    public V computeValue(SlicedMap map, K key, V value, boolean valueNotFound) {
+        throw new UnsupportedOperationException("Don't read by this slice, use the wrapped one");
+    }
+
+    @Override
+    public ReadOnlySlice<K, V> makeRawValueVersion() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/DelegatingSlice.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/DelegatingSlice.java
new file mode 100644
index 00000000000..cf415533340
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/DelegatingSlice.java
@@ -0,0 +1,40 @@
+package org.jetbrains.jet.util.slicedmap;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class DelegatingSlice<K, V> implements WritableSlice<K, V> {
+    private final WritableSlice<K, V> delegate;
+
+    public DelegatingSlice(@NotNull WritableSlice<K, V> delegate) {
+        this.delegate = delegate;
+    }
+
+    public boolean check(K key, V value) {
+        return delegate.check(key, value);
+    }
+
+    public void afterPut(MutableSlicedMap map, K key, V value) {
+        delegate.afterPut(map, key, value);
+    }
+
+    @Override
+    public RewritePolicy getRewritePolicy() {
+        return delegate.getRewritePolicy();
+    }
+
+    public SlicedMapKey<K, V> makeKey(K key) {
+        return delegate.makeKey(key);
+    }
+
+    public V computeValue(SlicedMap map, K key, V value, boolean valueNotFound) {
+        return delegate.computeValue(map, key, value, valueNotFound);
+    }
+
+    @Override
+    public ReadOnlySlice<K, V> makeRawValueVersion() {
+        return delegate.makeRawValueVersion();
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/util/MapSupplier.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MapSupplier.java
similarity index 92%
rename from idea/src/org/jetbrains/jet/util/MapSupplier.java
rename to compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MapSupplier.java
index 50b2a6c6483..30b6d52b7de 100644
--- a/idea/src/org/jetbrains/jet/util/MapSupplier.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MapSupplier.java
@@ -1,4 +1,4 @@
-package org.jetbrains.jet.util;
+package org.jetbrains.jet.util.slicedmap;
 
 import com.google.common.collect.Maps;
 
diff --git a/idea/src/org/jetbrains/jet/util/MutableManyMap.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MutableSlicedMap.java
similarity index 61%
rename from idea/src/org/jetbrains/jet/util/MutableManyMap.java
rename to compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MutableSlicedMap.java
index 8b9052e820e..a3706523fbf 100644
--- a/idea/src/org/jetbrains/jet/util/MutableManyMap.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MutableSlicedMap.java
@@ -1,9 +1,9 @@
-package org.jetbrains.jet.util;
+package org.jetbrains.jet.util.slicedmap;
 
 /**
  * @author abreslav
  */
-public interface MutableManyMap extends ManyMap {
+public interface MutableSlicedMap extends SlicedMap {
 
     <K, V> void put(WritableSlice<K, V> slice, K key, V value);
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/ReadOnlySlice.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/ReadOnlySlice.java
new file mode 100644
index 00000000000..696dd22440a
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/ReadOnlySlice.java
@@ -0,0 +1,15 @@
+package org.jetbrains.jet.util.slicedmap;
+
+/**
+ * @author abreslav
+ */
+public interface ReadOnlySlice<K, V> {
+    SlicedMapKey<K, V> makeKey(K key);
+
+    V computeValue(SlicedMap map, K key, V value, boolean valueNotFound);
+
+    /**
+     * @return a slice that only retrieves the value from the storage and skips any computeValue() calls
+     */
+    ReadOnlySlice<K, V> makeRawValueVersion();
+}
diff --git a/idea/src/org/jetbrains/jet/util/RemovableSlice.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/RemovableSlice.java
similarity index 70%
rename from idea/src/org/jetbrains/jet/util/RemovableSlice.java
rename to compiler/frontend/src/org/jetbrains/jet/util/slicedmap/RemovableSlice.java
index 2dc1b3cfba4..ebc412b7e91 100644
--- a/idea/src/org/jetbrains/jet/util/RemovableSlice.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/RemovableSlice.java
@@ -1,4 +1,4 @@
-package org.jetbrains.jet.util;
+package org.jetbrains.jet.util.slicedmap;
 
 /**
  * @author abreslav
diff --git a/idea/src/org/jetbrains/jet/util/RewritePolicy.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/RewritePolicy.java
similarity index 93%
rename from idea/src/org/jetbrains/jet/util/RewritePolicy.java
rename to compiler/frontend/src/org/jetbrains/jet/util/slicedmap/RewritePolicy.java
index 3a5ffca57a3..c021bc692d5 100644
--- a/idea/src/org/jetbrains/jet/util/RewritePolicy.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/RewritePolicy.java
@@ -1,4 +1,4 @@
-package org.jetbrains.jet.util;
+package org.jetbrains.jet.util.slicedmap;
 
 /**
  * @author abreslav
diff --git a/idea/src/org/jetbrains/jet/util/ManyMap.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMap.java
similarity index 60%
rename from idea/src/org/jetbrains/jet/util/ManyMap.java
rename to compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMap.java
index e401c74d923..7626cb2ddbc 100644
--- a/idea/src/org/jetbrains/jet/util/ManyMap.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMap.java
@@ -1,11 +1,11 @@
-package org.jetbrains.jet.util;
+package org.jetbrains.jet.util.slicedmap;
 
 import java.util.Map;
 
 /**
  * @author abreslav
  */
-public interface ManyMap extends Iterable<Map.Entry<ManyMapKey<?, ?>, ?>> {
+public interface SlicedMap extends Iterable<Map.Entry<SlicedMapKey<?, ?>, ?>> {
     <K, V> V get(ReadOnlySlice<K, V> slice, K key);
 
     <K, V> boolean containsKey(ReadOnlySlice<K, V> slice, K key);
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java
new file mode 100644
index 00000000000..36dbf297929
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java
@@ -0,0 +1,74 @@
+package org.jetbrains.jet.util.slicedmap;
+
+import com.google.common.collect.Maps;
+
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+* @author abreslav
+*/
+public class SlicedMapImpl implements MutableSlicedMap {
+
+    public static SlicedMapImpl create() {
+        return new SlicedMapImpl(Maps.<SlicedMapKey<?, ?>, Object>newLinkedHashMap());
+    }
+
+    public static SlicedMapImpl create(Map<SlicedMapKey<?, ?>, Object> map) {
+        return new SlicedMapImpl(map);
+    }
+
+    public static SlicedMapImpl create(MapSupplier mapSupplier) {
+        return new SlicedMapImpl(mapSupplier.<SlicedMapKey<?, ?>, Object>get());
+    }
+    
+    private final Map<SlicedMapKey<?, ?>, Object> map;
+
+    private SlicedMapImpl(Map<SlicedMapKey<?, ?>, Object> map) {
+        this.map = map;
+    }
+
+    @Override
+    public <K, V> void put(WritableSlice<K, V> slice, K key, V value) {
+        if (!slice.check(key, value)) {
+            return;
+        }
+        SlicedMapKey<K, V> slicedMapKey = slice.makeKey(key);
+        RewritePolicy rewritePolicy = slice.getRewritePolicy();
+        if (rewritePolicy.rewriteProcessingNeeded(key)) {
+            if (map.containsKey(slicedMapKey)) {
+                //noinspection unchecked
+                if (!rewritePolicy.processRewrite(slice, key, (V) map.get(slicedMapKey), value)) {
+                    return;
+                }
+            }
+        }
+        map.put(slicedMapKey, value);
+        slice.afterPut(this, key, value);
+    }
+
+    @Override
+    public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
+        SlicedMapKey<K, V> slicedMapKey = slice.makeKey(key);
+        //noinspection unchecked
+        V value = (V) map.get(slicedMapKey);
+        return slice.computeValue(this, key, value, value == null && !map.containsKey(slicedMapKey));
+    }
+
+    @Override
+    public <K, V> boolean containsKey(ReadOnlySlice<K, V> slice, K key) {
+        return map.containsKey(slice.makeKey(key));
+    }
+
+    @Override
+    public <K, V> V remove(RemovableSlice<K, V> slice, K key) {
+        //noinspection unchecked
+        return (V) map.remove(slice.makeKey(key));
+    }
+
+    @Override
+    public Iterator<Map.Entry<SlicedMapKey<?, ?>, ?>> iterator() {
+        //noinspection unchecked
+        return (Iterator) map.entrySet().iterator();
+    }
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/jet/util/ManyMapKey.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapKey.java
similarity index 74%
rename from idea/src/org/jetbrains/jet/util/ManyMapKey.java
rename to compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapKey.java
index 7f93575413a..3931e533ce1 100644
--- a/idea/src/org/jetbrains/jet/util/ManyMapKey.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapKey.java
@@ -1,16 +1,16 @@
-package org.jetbrains.jet.util;
+package org.jetbrains.jet.util.slicedmap;
 
 import org.jetbrains.annotations.NotNull;
 
 /**
 * @author abreslav
 */
-public final class ManyMapKey<K, V> {
+public final class SlicedMapKey<K, V> {
 
     private final WritableSlice<K, V> slice;
     private final K key;
 
-    public ManyMapKey(@NotNull WritableSlice<K, V> slice, K key) {
+    public SlicedMapKey(@NotNull WritableSlice<K, V> slice, K key) {
         this.slice = slice;
         this.key = key;
     }
@@ -28,7 +28,7 @@ public final class ManyMapKey<K, V> {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
 
-        ManyMapKey that = (ManyMapKey) o;
+        SlicedMapKey that = (SlicedMapKey) o;
 
         if (key != null ? !key.equals(that.key) : that.key != null) return false;
         if (!slice.equals(that.slice)) return false;
@@ -42,4 +42,9 @@ public final class ManyMapKey<K, V> {
         result = 31 * result + (key != null ? key.hashCode() : 0);
         return result;
     }
+
+    @Override
+    public String toString() {
+        return slice + " -> " + key;
+    }
 }
diff --git a/idea/src/org/jetbrains/jet/util/ManyMapSlices.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java
similarity index 91%
rename from idea/src/org/jetbrains/jet/util/ManyMapSlices.java
rename to compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java
index 192bec9224a..c5bbb7c135d 100644
--- a/idea/src/org/jetbrains/jet/util/ManyMapSlices.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java
@@ -1,4 +1,4 @@
-package org.jetbrains.jet.util;
+package org.jetbrains.jet.util.slicedmap;
 
 import java.util.Arrays;
 import java.util.List;
@@ -6,7 +6,7 @@ import java.util.List;
 /**
  * @author abreslav
  */
-public class ManyMapSlices {
+public class Slices {
 
     public static final RewritePolicy ONLY_REWRITE_TO_EQUAL = new RewritePolicy() {
         @Override
@@ -88,7 +88,7 @@ public class ManyMapSlices {
             if (defaultValue != null) {
                 return new SliceWithOpposite<K, V>(debugName, rewritePolicy, opposite, keyNormalizer) {
                     @Override
-                    public V computeValue(ManyMap map, K key, V value, boolean valueNotFound) {
+                    public V computeValue(SlicedMap map, K key, V value, boolean valueNotFound) {
                         if (valueNotFound) return defaultValue;
                         return super.computeValue(map, key, value, valueNotFound);
                     }
@@ -97,7 +97,7 @@ public class ManyMapSlices {
             if (furtherLookupSlices != null) {
                 return new SliceWithOpposite<K, V>(debugName, rewritePolicy, opposite, keyNormalizer) {
                     @Override
-                    public V computeValue(ManyMap map, K key, V value, boolean valueNotFound) {
+                    public V computeValue(SlicedMap map, K key, V value, boolean valueNotFound) {
                         if (valueNotFound) {
                             for (ReadOnlySlice<K, V> slice : furtherLookupSlices) {
                                 if (map.containsKey(slice, key)) {
@@ -143,13 +143,13 @@ public class ManyMapSlices {
         }
 
         @Override
-        public void afterPut(MutableManyMap manyMap, K key, V value) {
+        public void afterPut(MutableSlicedMap map, K key, V value) {
             if (opposite != null) {
-                manyMap.put(opposite, value, key);
+                map.put(opposite, value, key);
             }
         }
         @Override
-        public ManyMapKey<K, V> makeKey(K key) {
+        public SlicedMapKey<K, V> makeKey(K key) {
             if (keyNormalizer == null) {
                 return super.makeKey(key);
             }
@@ -160,12 +160,12 @@ public class ManyMapSlices {
 
     public static class SetSlice<K> extends BasicRemovableSlice<K, Boolean> {
 
-
         protected SetSlice(String debugName, RewritePolicy rewritePolicy) {
             super(debugName, rewritePolicy);
         }
+
         @Override
-        public Boolean computeValue(ManyMap map, K key, Boolean value, boolean valueNotFound) {
+        public Boolean computeValue(SlicedMap map, K key, Boolean value, boolean valueNotFound) {
             if (valueNotFound) return false;
             return super.computeValue(map, key, value, valueNotFound);
         }
diff --git a/idea/src/org/jetbrains/jet/util/WritableSlice.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/WritableSlice.java
similarity index 67%
rename from idea/src/org/jetbrains/jet/util/WritableSlice.java
rename to compiler/frontend/src/org/jetbrains/jet/util/slicedmap/WritableSlice.java
index 0551e8a662f..df173532564 100644
--- a/idea/src/org/jetbrains/jet/util/WritableSlice.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/WritableSlice.java
@@ -1,4 +1,4 @@
-package org.jetbrains.jet.util;
+package org.jetbrains.jet.util.slicedmap;
 
 /**
  * @author abreslav
@@ -7,7 +7,7 @@ public interface WritableSlice<K, V> extends ReadOnlySlice<K, V> {
     // True to put, false to skip
     boolean check(K key, V value);
 
-    void afterPut(MutableManyMap manyMap, K key, V value);
+    void afterPut(MutableSlicedMap map, K key, V value);
 
     RewritePolicy getRewritePolicy();
 }
diff --git a/confluence/buildConfluenceLexer.xml b/confluence/buildConfluenceLexer.xml
index cc4c4742f1a..eb1897d655a 100644
--- a/confluence/buildConfluenceLexer.xml
+++ b/confluence/buildConfluenceLexer.xml
@@ -1,6 +1,6 @@
 <project name="ConfluenceLexer" default="confluenceLexer">
     <property name="home" value="${basedir}"/>
-    <property file="${home}/../idea/idea.properties"/>
+    <property file="${home}/../frontend/idea.properties"/>
 
     <property name="flex.base" value="${idea.home}/tools/lexer/jflex-1.4"/>
     <property name="out.dir" value="${basedir}/tmpout"/>
diff --git a/confluence/src/main/java/org/jetbrains/jet/lexer/JetTokens.java b/confluence/src/main/java/org/jetbrains/jet/lexer/JetTokens.java
index d50cc507f1a..ad09df44b17 100644
--- a/confluence/src/main/java/org/jetbrains/jet/lexer/JetTokens.java
+++ b/confluence/src/main/java/org/jetbrains/jet/lexer/JetTokens.java
@@ -127,7 +127,7 @@ public interface JetTokens {
     JetKeywordToken GET_KEYWORD       = JetKeywordToken.softKeyword("get");
     JetKeywordToken SET_KEYWORD       = JetKeywordToken.softKeyword("set");
     JetKeywordToken ABSTRACT_KEYWORD  = JetKeywordToken.softKeyword("abstract");
-    JetKeywordToken VIRTUAL_KEYWORD   = JetKeywordToken.softKeyword("virtual");
+    JetKeywordToken VIRTUAL_KEYWORD   = JetKeywordToken.softKeyword("open");
     JetKeywordToken ENUM_KEYWORD      = JetKeywordToken.softKeyword("enum");
     JetKeywordToken OPEN_KEYWORD      = JetKeywordToken.softKeyword("open");
     JetKeywordToken ATTRIBUTE_KEYWORD = JetKeywordToken.softKeyword("attribute");
diff --git a/docs/JVMLS_talk_2011.ppt b/docs/JVMLS_talk_2011.ppt
new file mode 100755
index 00000000000..af8effa1b2b
Binary files /dev/null and b/docs/JVMLS_talk_2011.ppt differ
diff --git a/docs/JVMLS_workshop_2011.ppt b/docs/JVMLS_workshop_2011.ppt
new file mode 100755
index 00000000000..04f20e155a5
Binary files /dev/null and b/docs/JVMLS_workshop_2011.ppt differ
diff --git a/docs/Kotlin_OopenSystems.pages b/docs/Kotlin_OopenSystems.pages
new file mode 100644
index 00000000000..438eb3a0b96
Binary files /dev/null and b/docs/Kotlin_OopenSystems.pages differ
diff --git a/docs/OSCON_Kotlin.key b/docs/OSCON_Kotlin.key
new file mode 100755
index 00000000000..74011b5995b
Binary files /dev/null and b/docs/OSCON_Kotlin.key differ
diff --git a/docs/StrangeLoop_Kotlin.key b/docs/StrangeLoop_Kotlin.key
new file mode 100644
index 00000000000..cf94f3c845d
Binary files /dev/null and b/docs/StrangeLoop_Kotlin.key differ
diff --git a/examples/src/BitArith.jetl b/examples/src/BitArith.jetl
index d9bdf1dbcc0..6a410c1677c 100644
--- a/examples/src/BitArith.jetl
+++ b/examples/src/BitArith.jetl
@@ -21,7 +21,7 @@ fun countOnes(x : INumber) = if (x == 0) 0 else mostSignificantBit(x) + countOne
 
 fun Int.matchMask(mask : Int) = this and mask == mask
 
-virtual class INumber<T : this> : IComparable<T> {
+open class INumber<T : this> : IComparable<T> {
   val bits : Int
   [operator] fun plus(other : T) : T
   [operator] fun shl(bits : Int) : T
diff --git a/examples/src/IPushPop.jetl b/examples/src/IPushPop.jetl
index 09b1f2d8267..84725423fdc 100644
--- a/examples/src/IPushPop.jetl
+++ b/examples/src/IPushPop.jetl
@@ -1,4 +1,4 @@
-virtual class IPushPop<T> {
+open class IPushPop<T> {
   val isEmpty : Boolean
   fun push(item : T)
   fun pop() : T
diff --git a/examples/src/PolymorphicClassObjects.jetl b/examples/src/PolymorphicClassObjects.jetl
index 86fcb9ade5b..57ba9826889 100644
--- a/examples/src/PolymorphicClassObjects.jetl
+++ b/examples/src/PolymorphicClassObjects.jetl
@@ -1,9 +1,9 @@
-virtual class Builder<E, R> {
+open class Builder<E, R> {
   [operator] fun plusAssign(item : E)
   fun result() : R
 }
 
-virtual class Buildable {
+open class Buildable {
   fun newBuilder<E, R>() : Builder<E, R>
 }
 
diff --git a/examples/src/array/MutableArray.jetl b/examples/src/array/MutableArray.jetl
index 311279c875c..cb270fa33a8 100644
--- a/examples/src/array/MutableArray.jetl
+++ b/examples/src/array/MutableArray.jetl
@@ -2,11 +2,11 @@
   These declarations are "shallow" in the sense that they are not really compiled, only the type-checker uses them
 */
 
-virtual class ReadOnlyArray<out T> : ISized {
+open class ReadOnlyArray<out T> : ISized {
   [operator] fun get(index : Int) : T
 }
 
-virtual class WriteOnlyArray<in T> : ISized { // This is needed to keep IIterator's <T> covariant
+open class WriteOnlyArray<in T> : ISized { // This is needed to keep IIterator's <T> covariant
   [operator] fun set(index : Int, value : T)
 }
 
diff --git a/examples/src/collections/HashMap.jetl b/examples/src/collections/HashMap.jetl
index 7839372b766..ac690682d89 100644
--- a/examples/src/collections/HashMap.jetl
+++ b/examples/src/collections/HashMap.jetl
@@ -1,15 +1,15 @@
-virtual class IEquality {
+open class IEquality {
   fun equals(other : Any) : Boolean
     = (this as java.lang.Object).equals(other as java.lang.Object)
 }
 
-virtual class IHashable : IEquality {
+open class IHashable : IEquality {
   val hashCode : Integer
     get() = (this as java.lang.Object).hashCode()
 
 }
 
-virtual class IMap<K, V> {
+open class IMap<K, V> {
   fun get(key : K) : V
   fun set(key : K, value : V) : V
   fun remove(key : K) : V
@@ -21,7 +21,7 @@ class HashableWrapper wraps (val obj : Any) : IHashable
 
 [inline] fun Any.hashable() : HashableWrapper = new HashableWrapper(this)
 
-virtual class IHashingStrategy<K> {
+open class IHashingStrategy<K> {
   fun equals(a : K, b : K) : Boolean
   fun hashCode(a : K) : Integer
 }
diff --git a/examples/src/collections/IIterable.jetl b/examples/src/collections/IIterable.jetl
index 5e69296338c..c9a55af4058 100644
--- a/examples/src/collections/IIterable.jetl
+++ b/examples/src/collections/IIterable.jetl
@@ -1,3 +1,3 @@
-virtual class IIterable<out T> {
+open class IIterable<out T> {
   fun iterator() : IIterator<T>
 }
diff --git a/examples/src/collections/IIterator.jetl b/examples/src/collections/IIterator.jetl
index faeb4d40a5c..1739eae7a01 100644
--- a/examples/src/collections/IIterator.jetl
+++ b/examples/src/collections/IIterator.jetl
@@ -1,4 +1,4 @@
-virtual class IIterator<out T> {
+open class IIterator<out T> {
   fun next() : T
   val hasNext : Boolean
 
diff --git a/examples/src/collections/IList.jetl b/examples/src/collections/IList.jetl
index 6daa67bac0f..69fff05ca87 100644
--- a/examples/src/collections/IList.jetl
+++ b/examples/src/collections/IList.jetl
@@ -1,4 +1,4 @@
-virtual class IList<out T> : IIterable<T>, ISized {
+open class IList<out T> : IIterable<T>, ISized {
   [operator] fun get(index : Int) : T
   val isEmpty : Boolean
 }
\ No newline at end of file
diff --git a/examples/src/collections/IMutableIterable.jetl b/examples/src/collections/IMutableIterable.jetl
index 22b6e017d8e..1ad49e2aec9 100644
--- a/examples/src/collections/IMutableIterable.jetl
+++ b/examples/src/collections/IMutableIterable.jetl
@@ -1,3 +1,3 @@
-virtual class IMutableIterable<out T> : IIterable<T> {
+open class IMutableIterable<out T> : IIterable<T> {
   fun mutableIterator() : IMutableIterator<T>
 }
\ No newline at end of file
diff --git a/examples/src/collections/IMutableIterator.jetl b/examples/src/collections/IMutableIterator.jetl
index 51111049926..1449ab40dca 100644
--- a/examples/src/collections/IMutableIterator.jetl
+++ b/examples/src/collections/IMutableIterator.jetl
@@ -1,4 +1,4 @@
-virtual class IMutableIterator<out T> : IIterator<T> {
+open class IMutableIterator<out T> : IIterator<T> {
   fun remove() : T
 
 /*
diff --git a/examples/src/collections/IMutableList.jetl b/examples/src/collections/IMutableList.jetl
index 711f0d6bfc7..55fd048e7a7 100644
--- a/examples/src/collections/IMutableList.jetl
+++ b/examples/src/collections/IMutableList.jetl
@@ -1,4 +1,4 @@
-virtual class IMutableList<T> : IList<T>, IMutableIterable<T> {
+open class IMutableList<T> : IList<T>, IMutableIterable<T> {
   fun set(index : Int, value : T) : T
   fun add(index : Int, value : T)
   fun remove(index : Int) : T
diff --git a/examples/src/collections/IMutableSet.jetl b/examples/src/collections/IMutableSet.jetl
index eacb0d740ec..95eb05d2456 100644
--- a/examples/src/collections/IMutableSet.jetl
+++ b/examples/src/collections/IMutableSet.jetl
@@ -1,4 +1,4 @@
-virtual class IMutableSet<T> : ISet<T>, IMutableIterable<T> {
+open class IMutableSet<T> : ISet<T>, IMutableIterable<T> {
   fun add(item : T) : Boolean
   fun remove(item : T) : Boolean
 }
\ No newline at end of file
diff --git a/examples/src/collections/ISet.jetl b/examples/src/collections/ISet.jetl
index bfe2753b8df..0b6741470fd 100644
--- a/examples/src/collections/ISet.jetl
+++ b/examples/src/collections/ISet.jetl
@@ -1,3 +1,3 @@
-virtual class ISet<T> : IIterable<T>, ISized {
+open class ISet<T> : IIterable<T>, ISized {
   fun contains(item : T) : Boolean
 }
diff --git a/examples/src/collections/ISized.jetl b/examples/src/collections/ISized.jetl
index 9f12cb218b0..5e5977f253e 100644
--- a/examples/src/collections/ISized.jetl
+++ b/examples/src/collections/ISized.jetl
@@ -1,3 +1,3 @@
-virtual class ISized {
+open class ISized {
   val size : Int
 }
\ No newline at end of file
diff --git a/examples/src/io/IOSamples.jetl b/examples/src/io/IOSamples.jetl
index 4304fc00a38..621b6c0033b 100644
--- a/examples/src/io/IOSamples.jetl
+++ b/examples/src/io/IOSamples.jetl
@@ -1,8 +1,8 @@
-virtual class IAdder<in T> {
+open class IAdder<in T> {
   fun add(item : T) : Boolean
 }
 
-virtual class ICloseable {
+open class ICloseable {
   fun close()
 }
 
diff --git a/examples/src/map/IMap.jetl b/examples/src/map/IMap.jetl
index 0b912bb838d..da51189c006 100644
--- a/examples/src/map/IMap.jetl
+++ b/examples/src/map/IMap.jetl
@@ -1,4 +1,4 @@
-virtual class IMap<in K, out V> {
+open class IMap<in K, out V> {
   
 
 }
\ No newline at end of file
diff --git a/examples/src/priorityqueues/IPriorityQueue.jetl b/examples/src/priorityqueues/IPriorityQueue.jetl
index b343cd49cc3..ee694f5c9d4 100644
--- a/examples/src/priorityqueues/IPriorityQueue.jetl
+++ b/examples/src/priorityqueues/IPriorityQueue.jetl
@@ -1,4 +1,4 @@
-virtual class IPriorityQueue<T> {
+open class IPriorityQueue<T> {
   fun extract() : T
   fun add(item : T)
   val isEmpty : Boolean
diff --git a/examples/src/util/IComparable.jetl b/examples/src/util/IComparable.jetl
index b802c381464..1ce3f600ea6 100644
--- a/examples/src/util/IComparable.jetl
+++ b/examples/src/util/IComparable.jetl
@@ -1,3 +1,3 @@
-virtual class IComparable<in T> {
+open class IComparable<in T> {
   fun compareTo(other : T) : Int
 }
\ No newline at end of file
diff --git a/grammar/buildGrammarLexer.xml b/grammar/buildGrammarLexer.xml
index ecf2cfdc4ce..5fefcb1f163 100644
--- a/grammar/buildGrammarLexer.xml
+++ b/grammar/buildGrammarLexer.xml
@@ -1,6 +1,6 @@
 <project name="GrammarLexer" default="lexer">
     <property name="home" value="${basedir}"/>
-    <property file="${home}/../idea/idea.properties"/>
+    <property file="${home}/../frontend/idea.properties"/>
 
     <property name="flex.base" value="${idea.home}/tools/lexer/jflex-1.4"/>
     <property name="out.dir" value="${basedir}/tmpout"/>
diff --git a/grammar/src/class.grm b/grammar/src/class.grm
index 94e8cb09baf..8bf1e016edd 100644
--- a/grammar/src/class.grm
+++ b/grammar/src/class.grm
@@ -17,9 +17,9 @@ internal class Example<X, T : Comparable<X>>(protected val x : Foo<X, T>, y : So
 */
 
 class
-  : modifiers "class" SimpleName
+  : modifiers ("class" | "trait") SimpleName
       typeParameters?
-      ("wraps" valueParameters? | modifiers valueParameters?)?
+      modifiers ("(" primaryConstructorParameter{","} ")")?
       (":" annotations delegationSpecifier{","})?
       typeConstraints
       (classBody? | enumClassBody)
diff --git a/grammar/src/lexical.grm b/grammar/src/lexical.grm
index 9780cce228c..e62dbe96728 100644
--- a/grammar/src/lexical.grm
+++ b/grammar/src/lexical.grm
@@ -115,17 +115,15 @@ ref
 try
 
 Soft:
-wraps -- in a class header
 where -- in class, function and type headers
 by -- in a class header (Delegation specifier)
-lazy -- in a property/parameter declaration
 get, set -- in a property definition
 import
+final
 abstract
-virtual
 enum
 open
-attribute
+annotation
 override
 private
 public
diff --git a/grammar/src/modifiers.grm b/grammar/src/modifiers.grm
index c56bfa8a28f..0944c0e2c9b 100644
--- a/grammar/src/modifiers.grm
+++ b/grammar/src/modifiers.grm
@@ -17,7 +17,7 @@ modifier
 
 classModifier
   : "abstract"
-  : "virtual"
+  : "final"
   : "enum"
   : "open"
   : "attribute"
@@ -25,7 +25,8 @@ classModifier
 
 memberModifier
   : "override"
-  : "virtual"
+  : "open"
+  : "final"
   : "abstract"
   ;
 
diff --git a/grammar/src/org/jetbrains/jet/grammar/_GrammarLexer.java b/grammar/src/org/jetbrains/jet/grammar/_GrammarLexer.java
index f9007094888..b1348053be1 100644
--- a/grammar/src/org/jetbrains/jet/grammar/_GrammarLexer.java
+++ b/grammar/src/org/jetbrains/jet/grammar/_GrammarLexer.java
@@ -1,4 +1,4 @@
-/* The following code was generated by JFlex 1.4.3 on 6/28/11 5:58 PM */
+/* The following code was generated by JFlex 1.4.3 on 9/9/11 9:32 PM */
 
 /* It's an automatically generated code. Do not modify it. */
 package org.jetbrains.jet.grammar;
@@ -13,7 +13,7 @@ package org.jetbrains.jet.grammar;
 /**
  * This class is a scanner generated by 
  * <a href="http://www.jflex.de/">JFlex</a> 1.4.3
- * on 6/28/11 5:58 PM from the specification file
+ * on 9/9/11 9:32 PM from the specification file
  * <tt>/Users/abreslav/work/jet/grammar/src/org/jetbrains/jet/grammar/Grammar.flex</tt>
  */
 class _GrammarLexer {
diff --git a/idea/idea.iml b/idea/idea.iml
index d01e54ca4d0..23b8c669d6e 100644
--- a/idea/idea.iml
+++ b/idea/idea.iml
@@ -1,6 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="PLUGIN_MODULE" version="4">
   <component name="DevKit.ModuleBuildProperties" url="file://$MODULE_DIR$/src/META-INF/plugin.xml" />
+  <component name="EclipseModuleManager">
+    <libelement value="jar://$MODULE_DIR$/../lib/asm-util-3.3.1.jar!/" />
+    <src_description expected_position="1">
+      <src_folder value="file://$MODULE_DIR$/src" expected_position="1" />
+      <src_folder value="file://$MODULE_DIR$/tests" expected_position="2" />
+    </src_description>
+  </component>
   <component name="NewModuleRootManager" inherit-compiler-output="true">
     <exclude-output />
     <content url="file://$MODULE_DIR$">
@@ -9,7 +16,9 @@
     </content>
     <orderEntry type="jdk" jdkName="IDEA 10.x" jdkType="IDEA JDK" />
     <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="asm" level="project" />
+    <orderEntry type="module" module-name="backend" />
+    <orderEntry type="module" module-name="frontend" />
+    <orderEntry type="module" module-name="frontend.java" />
     <orderEntry type="module" module-name="stdlib" />
   </component>
 </module>
diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml
index 3e7739c9d4e..48949cbb3f0 100644
--- a/idea/src/META-INF/plugin.xml
+++ b/idea/src/META-INF/plugin.xml
@@ -19,6 +19,11 @@
          <keyboard-shortcut keymap="$default" first-keystroke="control shift Q"/>
          <add-to-group group-id="CodeMenu" anchor="last"/>
      </action>
+     <action id="CopyAsDiagnosticTest" class="org.jetbrains.jet.plugin.actions.CopyAsDiagnosticTestAction"
+             text="Copy Current File As Diagnostic Test">
+         <keyboard-shortcut keymap="$default" first-keystroke="control alt shift T"/>
+         <add-to-group group-id="CodeMenu" anchor="last"/>
+     </action>
      <action id="ToggleJetErrorReporting" class="org.jetbrains.jet.plugin.actions.ToggleErrorReportingAction"
              text="Toggle Error Reporting">
          <keyboard-shortcut keymap="$default" first-keystroke="control alt shift E"/>
@@ -28,6 +33,7 @@
 
   <extensions defaultExtensionNs="com.intellij">
       <fileTypeFactory implementation="org.jetbrains.jet.plugin.JetFileFactory"/>
+      <lang.syntaxHighlighterFactory key="jet" implementationClass="org.jetbrains.jet.plugin.JetSyntaxHighlighterFactory"/>
       <lang.braceMatcher language="jet" implementationClass="org.jetbrains.jet.plugin.JetPairMatcher"/>
       <lang.parserDefinition language="jet" implementationClass="org.jetbrains.jet.lang.parsing.JetParserDefinition"/>
       <lang.commenter language="jet" implementationClass="org.jetbrains.jet.plugin.JetCommenter"/>
@@ -35,9 +41,11 @@
       <lang.foldingBuilder language="jet" implementationClass="org.jetbrains.jet.plugin.JetFoldingBuilder"/>
       <lang.formatter language="jet" implementationClass="org.jetbrains.jet.plugin.formatter.JetFormattingModelBuilder"/>
       <lang.findUsagesProvider language="jet" implementationClass="org.jetbrains.jet.plugin.findUsages.JetFindUsagesProvider"/>
+      <psi.referenceContributor language="jet" implementation="org.jetbrains.jet.plugin.references.JetReferenceContributor"/>
       <annotator language="jet" implementationClass="org.jetbrains.jet.plugin.annotations.SoftKeywordsAnnotator"/>
       <annotator language="jet" implementationClass="org.jetbrains.jet.plugin.annotations.LabelsAnnotator"/>
       <annotator language="jet" implementationClass="org.jetbrains.jet.plugin.annotations.JetPsiChecker"/>
+      <annotator language="jet" implementationClass="org.jetbrains.jet.plugin.annotations.DebugInfoAnnotator"/>
       <documentationProvider implementation="org.jetbrains.jet.plugin.JetQuickDocumentationProvider"/>
       <configurationType implementation="org.jetbrains.jet.plugin.run.JetRunConfigurationType"/>
       <configurationProducer implementation="org.jetbrains.jet.plugin.run.JetRunConfigurationProducer"/>
diff --git a/idea/src/org/jetbrains/jet/checkers/CheckerTestUtil.java b/idea/src/org/jetbrains/jet/checkers/CheckerTestUtil.java
new file mode 100644
index 00000000000..edff0f640a1
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/checkers/CheckerTestUtil.java
@@ -0,0 +1,316 @@
+package org.jetbrains.jet.checkers;
+
+import com.google.common.collect.*;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author abreslav
+ */
+public class CheckerTestUtil {
+    public static final Comparator<Diagnostic> DIAGNOSTIC_COMPARATOR = new Comparator<Diagnostic>() {
+        @Override
+        public int compare(Diagnostic o1, Diagnostic o2) {
+            TextRange range1 = getTextRange(o1);
+            TextRange range2 = getTextRange(o2);
+            int startOffset1 = range1.getStartOffset();
+            int startOffset2 = range2.getStartOffset();
+            if (startOffset1 != startOffset2) {
+                // Start early -- go first
+                return startOffset1 - range2.getStartOffset();
+            }
+            // start at the same offset, the one who end later is the outer, i.e. goes first
+            return range2.getEndOffset() - range1.getEndOffset();
+        }
+    };
+    private static final Pattern RANGE_START_OR_END_PATTERN = Pattern.compile("(<!\\w+(,\\s*\\w+)*!>)|(<!>)");
+    private static final Pattern INDIVIDUAL_DIAGNOSTIC_PATTERN = Pattern.compile("\\w+");
+
+    public interface DiagnosticDiffCallbacks {
+        void missingDiagnostic(String type, int expectedStart, int expectedEnd);
+        void unexpectedDiagnostic(String type, int actualStart, int actualEnd);
+    }
+
+    public static void diagnosticsDiff(List<DiagnosedRange> expected, Collection<Diagnostic> actual, DiagnosticDiffCallbacks callbacks) {
+        Iterator<DiagnosedRange> expectedDiagnostics = expected.iterator();
+        List<DiagnosticDescriptor> sortedDiagnosticDescriptors = getSortedDiagnosticDescriptors(actual);
+        Iterator<DiagnosticDescriptor> actualDiagnostics = sortedDiagnosticDescriptors.iterator();
+
+        DiagnosedRange currentExpected = safeAdvance(expectedDiagnostics);
+        DiagnosticDescriptor currentActual = safeAdvance(actualDiagnostics);
+        while (currentExpected != null || currentActual != null) {
+            if (currentExpected != null) {
+                if (currentActual == null) {
+                    missingDiagnostics(callbacks, currentExpected);
+                    currentExpected = safeAdvance(expectedDiagnostics);
+                }
+                else {
+                    int expectedStart = currentExpected.getStart();
+                    int actualStart = currentActual.getStart();
+                    int expectedEnd = currentExpected.getEnd();
+                    int actualEnd = currentActual.getEnd();
+                    if (expectedStart < actualStart) {
+                        missingDiagnostics(callbacks, currentExpected);
+                        currentExpected = safeAdvance(expectedDiagnostics);
+                    }
+                    else if (expectedStart > actualStart) {
+                        unexpectedDiagnostics(currentActual.getDiagnostics(), callbacks);
+                        currentActual = safeAdvance(actualDiagnostics);
+                    }
+                    else if (expectedEnd > actualEnd) {
+                        assert expectedStart == actualStart;
+                        missingDiagnostics(callbacks, currentExpected);
+                        currentExpected = safeAdvance(expectedDiagnostics);
+                    }
+                    else if (expectedEnd < actualEnd) {
+                        assert expectedStart == actualStart;
+                        unexpectedDiagnostics(currentActual.getDiagnostics(), callbacks);
+                        currentActual = safeAdvance(actualDiagnostics);
+                    }
+                    else {
+                        assert expectedStart == actualStart && expectedEnd == actualEnd;
+                        Multiset<String> actualDiagnosticTypes = currentActual.getDiagnosticTypeStrings();
+                        Multiset<String> expectedDiagnosticTypes = currentExpected.getDiagnostics();
+                        if (!actualDiagnosticTypes.equals(expectedDiagnosticTypes)) {
+                            Multiset<String> expectedCopy = HashMultiset.create(expectedDiagnosticTypes);
+                            expectedCopy.removeAll(actualDiagnosticTypes);
+                            Multiset<String> actualCopy = HashMultiset.create(actualDiagnosticTypes);
+                            actualCopy.removeAll(expectedDiagnosticTypes);
+                            
+                            for (String type : expectedCopy) {
+                                callbacks.missingDiagnostic(type, expectedStart, expectedEnd);
+                            }
+                            for (String type : actualCopy) {
+                                callbacks.unexpectedDiagnostic(type, actualStart, actualEnd);
+                            }
+                        }
+                        currentExpected = safeAdvance(expectedDiagnostics);
+                        currentActual = safeAdvance(actualDiagnostics);
+                    }
+
+                }
+            }
+            else {
+                if (currentActual != null) {
+                    unexpectedDiagnostics(currentActual.getDiagnostics(), callbacks);
+                    currentActual = safeAdvance(actualDiagnostics);
+                }
+                else {
+                    break;
+                }
+            }
+
+//            assert expectedDiagnostics.hasNext() || actualDiagnostics.hasNext();
+        }
+    }
+
+    private static void unexpectedDiagnostics(List<Diagnostic> actual, DiagnosticDiffCallbacks callbacks) {
+        for (Diagnostic diagnostic : actual) {
+            TextRange textRange = getTextRange(diagnostic);
+            callbacks.unexpectedDiagnostic(diagnostic.getFactory().getName(), textRange.getStartOffset(), textRange.getEndOffset());
+        }
+    }
+
+    private static void missingDiagnostics(DiagnosticDiffCallbacks callbacks, DiagnosedRange currentExpected) {
+        for (String type : currentExpected.getDiagnostics()) {
+            callbacks.missingDiagnostic(type, currentExpected.getStart(), currentExpected.getEnd());
+        }
+    }
+
+    private static <T> T safeAdvance(Iterator<T> iterator) {
+        return iterator.hasNext() ? iterator.next() : null;
+    }
+
+    public static String parseDiagnosedRanges(String text, List<DiagnosedRange> result) {
+        Matcher matcher = RANGE_START_OR_END_PATTERN.matcher(text);
+
+        Stack<DiagnosedRange> opened = new Stack<DiagnosedRange>();
+
+        int offsetCompensation = 0;
+
+        while (matcher.find()) {
+            int effectiveOffset = matcher.start() - offsetCompensation;
+            String matchedText = matcher.group();
+            if ("<!>".equals(matchedText)) {
+                opened.pop().setEnd(effectiveOffset);
+            }
+            else {
+                Matcher diagnosticTypeMatcher = INDIVIDUAL_DIAGNOSTIC_PATTERN.matcher(matchedText);
+                DiagnosedRange range = new DiagnosedRange(effectiveOffset);
+                while (diagnosticTypeMatcher.find()) {
+                    range.addDiagnostic(diagnosticTypeMatcher.group());                    
+                }
+                opened.push(range);
+                result.add(range);
+            }
+            offsetCompensation += matchedText.length();
+        }
+
+        assert opened.isEmpty() : "Stack is not empty";
+
+        matcher.reset();
+        return matcher.replaceAll("");
+    }
+    
+    public static StringBuffer addDiagnosticMarkersToText(PsiFile psiFile, BindingContext bindingContext) {
+        Collection<Diagnostic> diagnostics = bindingContext.getDiagnostics();
+
+        StringBuffer result = new StringBuffer();
+        String text = psiFile.getText();
+        if (!diagnostics.isEmpty()) {
+            List<DiagnosticDescriptor> diagnosticDescriptors = getSortedDiagnosticDescriptors(diagnostics);
+
+            Stack<DiagnosticDescriptor> opened = new Stack<DiagnosticDescriptor>();
+            ListIterator<DiagnosticDescriptor> iterator = diagnosticDescriptors.listIterator();
+            DiagnosticDescriptor currentDescriptor = iterator.next();
+
+            for (int i = 0; i < text.length(); i++) {
+                char c = text.charAt(i);
+                while (!opened.isEmpty() && i == opened.peek().end) {
+                    closeDiagnosticString(result);
+                    opened.pop();
+                }
+                while (currentDescriptor != null && i == currentDescriptor.start) {
+                    openDiagnosticsString(result, currentDescriptor);
+                    if (currentDescriptor.getEnd() == i) {
+                        closeDiagnosticString(result);
+                    }
+                    else {
+                        opened.push(currentDescriptor);
+                    }
+                    if (iterator.hasNext()) {
+                        currentDescriptor = iterator.next();
+                    }
+                    else {
+                        currentDescriptor = null;
+                    }
+                }
+                result.append(c);
+            }
+            while (!opened.isEmpty() && text.length() == opened.peek().end) {
+                closeDiagnosticString(result);
+                opened.pop();
+            }
+
+            assert opened.isEmpty() : "Stack is not empty";
+
+        }
+        else {
+            result.append(text);
+        }
+        return result;
+    }
+
+    private static void openDiagnosticsString(StringBuffer result, DiagnosticDescriptor currentDescriptor) {
+        result.append("<!");
+        for (Iterator<Diagnostic> iterator = currentDescriptor.diagnostics.iterator(); iterator.hasNext(); ) {
+            Diagnostic diagnostic = iterator.next();
+            result.append(diagnostic.getFactory().getName());
+            if (iterator.hasNext()) {
+                result.append(", ");
+            }
+        }
+        result.append("!>");
+    }
+
+    private static void closeDiagnosticString(StringBuffer result) {
+        result.append("<!>");
+    }
+
+    private static List<DiagnosticDescriptor> getSortedDiagnosticDescriptors(Collection<Diagnostic> diagnostics) {
+        List<Diagnostic> list = Lists.newArrayList(diagnostics);
+        Collections.sort(list, DIAGNOSTIC_COMPARATOR);
+
+        List<DiagnosticDescriptor> diagnosticDescriptors = Lists.newArrayList();
+        DiagnosticDescriptor currentDiagnosticDescriptor = null;
+        for (Iterator<Diagnostic> iterator = list.iterator(); iterator.hasNext(); ) {
+            Diagnostic diagnostic = iterator.next();
+
+            TextRange textRange = getTextRange(diagnostic);
+            if (currentDiagnosticDescriptor != null && currentDiagnosticDescriptor.equalRange(textRange)) {
+                currentDiagnosticDescriptor.diagnostics.add(diagnostic);
+            }
+            else {
+                currentDiagnosticDescriptor = new DiagnosticDescriptor(textRange.getStartOffset(), textRange.getEndOffset(), diagnostic);
+                diagnosticDescriptors.add(currentDiagnosticDescriptor);
+            }
+        }
+        return diagnosticDescriptors;
+    }
+
+    private static TextRange getTextRange(Diagnostic currentDiagnostic) {
+        return currentDiagnostic.getFactory().getTextRange(currentDiagnostic);
+    }
+
+    private static class DiagnosticDescriptor {
+        private final int start;
+        private final int end;
+        private final List<Diagnostic> diagnostics = Lists.newArrayList();
+
+        DiagnosticDescriptor(int start, int end, Diagnostic diagnostic) {
+            this.start = start;
+            this.end = end;
+            this.diagnostics.add(diagnostic);
+        }
+
+        public boolean equalRange(TextRange textRange) {
+            return start == textRange.getStartOffset() && end == textRange.getEndOffset();
+        }
+
+        public Multiset<String> getDiagnosticTypeStrings() {
+            Multiset<String> actualDiagnosticTypes = HashMultiset.create();
+            for (Diagnostic diagnostic : diagnostics) {
+                actualDiagnosticTypes.add(diagnostic.getFactory().getName());
+            }
+            return actualDiagnosticTypes;
+        }
+
+        public int getStart() {
+            return start;
+        }
+
+        public int getEnd() {
+            return end;
+        }
+
+        public List<Diagnostic> getDiagnostics() {
+            return diagnostics;
+        }
+    }
+
+    public static class DiagnosedRange {
+        private final int start;
+        private int end;
+        private final Multiset<String> diagnostics = HashMultiset.create();
+
+        private DiagnosedRange(int start) {
+            this.start = start;
+        }
+
+        public int getStart() {
+            return start;
+        }
+
+        public int getEnd() {
+            return end;
+        }
+
+        public Multiset<String> getDiagnostics() {
+            return diagnostics;
+        }
+
+        public void setEnd(int end) {
+            this.end = end;
+        }
+        
+        public void addDiagnostic(String diagnostic) {
+            diagnostics.add(diagnostic);
+        }
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java
deleted file mode 100644
index 7918f500bdd..00000000000
--- a/idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java
+++ /dev/null
@@ -1,129 +0,0 @@
-package org.jetbrains.jet.codegen;
-
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
-import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.objectweb.asm.ClassVisitor;
-import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.commons.InstructionAdapter;
-import org.objectweb.asm.commons.Method;
-
-import java.util.Collections;
-import java.util.List;
-
-/**
- * @author max
- * @author yole
- */
-public class FunctionCodegen {
-    private final ClassContext owner;
-    private final ClassVisitor v;
-    private final GenerationState state;
-
-    public FunctionCodegen(ClassContext owner, ClassVisitor v, GenerationState state) {
-        this.owner = owner;
-        this.v = v;
-        this.state = state;
-    }
-
-    public void gen(JetNamedFunction f) {
-        Method method = state.getTypeMapper().mapToCallableMethod(f).getSignature();
-        final FunctionDescriptor functionDescriptor = state.getBindingContext().get(BindingContext.FUNCTION, f);
-        generateMethod(f, method, functionDescriptor);
-    }
-
-    public void generateMethod(JetDeclarationWithBody f, Method jvmMethod, FunctionDescriptor functionDescriptor) {
-        ClassContext funContext = owner.intoFunction(functionDescriptor);
-
-        final JetExpression bodyExpression = f.getBodyExpression();
-        final List<JetElement> bodyExpressions = bodyExpression != null ? Collections.<JetElement>singletonList(bodyExpression) : null;
-        generatedMethod(bodyExpressions, jvmMethod, funContext, functionDescriptor.getValueParameters(), functionDescriptor.getTypeParameters());
-    }
-
-    private void generatedMethod(List<JetElement> bodyExpressions,
-                                 Method jvmSignature,
-                                 ClassContext context,
-                                 List<ValueParameterDescriptor> paramDescrs,
-                                 List<TypeParameterDescriptor> typeParameters)
-    {
-        int flags = Opcodes.ACC_PUBLIC; // TODO.
-
-        OwnerKind kind = context.getContextKind();
-
-        boolean isStatic = kind == OwnerKind.NAMESPACE;
-        if (isStatic) flags |= Opcodes.ACC_STATIC;
-
-        boolean isAbstract = kind == OwnerKind.INTERFACE || bodyExpressions == null;
-        if (isAbstract) flags |= Opcodes.ACC_ABSTRACT;
-
-        if (isAbstract && (kind == OwnerKind.IMPLEMENTATION || kind == OwnerKind.DELEGATING_IMPLEMENTATION)) {
-            return;
-        }
-
-        final MethodVisitor mv = v.visitMethod(flags, jvmSignature.getName(), jvmSignature.getDescriptor(), null, null);
-        if (kind != OwnerKind.INTERFACE) {
-            mv.visitCode();
-            FrameMap frameMap = context.prepareFrame();
-
-            ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, jvmSignature.getReturnType(), context, state);
-
-            Type[] argTypes = jvmSignature.getArgumentTypes();
-            for (int i = 0; i < paramDescrs.size(); i++) {
-                ValueParameterDescriptor parameter = paramDescrs.get(i);
-                frameMap.enter(parameter, argTypes[i].getSize());
-            }
-
-            for (final TypeParameterDescriptor typeParameterDescriptor : typeParameters) {
-                int slot = frameMap.enterTemp();
-                codegen.addTypeParameter(typeParameterDescriptor, StackValue.local(slot, JetTypeMapper.TYPE_TYPEINFO));
-            }
-
-            if (kind instanceof OwnerKind.DelegateKind) {
-                OwnerKind.DelegateKind dk = (OwnerKind.DelegateKind) kind;
-                InstructionAdapter iv = new InstructionAdapter(mv);
-                iv.load(0, JetTypeMapper.TYPE_OBJECT);
-                dk.getDelegate().put(JetTypeMapper.TYPE_OBJECT, iv);
-                for (int i = 0; i < argTypes.length; i++) {
-                    Type argType = argTypes[i];
-                    iv.load(i + 1, argType);
-                }
-                iv.invokeinterface(dk.getOwnerClass(), jvmSignature.getName(), jvmSignature.getDescriptor());
-                iv.areturn(jvmSignature.getReturnType());
-            }
-            else if (!isAbstract) {
-                JetElement last = null;
-                for (JetElement expression : bodyExpressions) {
-                    expression.accept(codegen);
-                    last = expression;
-                }
-                generateReturn(mv, last, codegen, jvmSignature);
-            }
-            mv.visitMaxs(0, 0);
-            mv.visitEnd();
-        }
-    }
-
-    private void generateReturn(MethodVisitor mv, JetElement bodyExpression, ExpressionCodegen codegen, Method jvmSignature) {
-        if (!endsWithReturn(bodyExpression)) {
-            if (jvmSignature.getReturnType() == Type.VOID_TYPE) {
-                mv.visitInsn(Opcodes.RETURN);
-            }
-            else {
-                codegen.returnTopOfStack();
-            }
-        }
-    }
-
-    private static boolean endsWithReturn(JetElement bodyExpression) {
-        if (bodyExpression instanceof JetBlockExpression) {
-            final List<JetElement> statements = ((JetBlockExpression) bodyExpression).getStatements();
-            return statements.size() > 0 && statements.get(statements.size()-1) instanceof JetReturnExpression;
-        }
-
-        return bodyExpression instanceof JetReturnExpression;
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/idea/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
deleted file mode 100644
index e97de80ecdc..00000000000
--- a/idea/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+++ /dev/null
@@ -1,485 +0,0 @@
-package org.jetbrains.jet.codegen;
-
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiElement;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lexer.JetTokens;
-import org.objectweb.asm.ClassVisitor;
-import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.commons.InstructionAdapter;
-import org.objectweb.asm.commons.Method;
-
-import java.util.*;
-
-/**
- * @author max
- * @author yole
- */
-public class ImplementationBodyCodegen extends ClassBodyCodegen {
-    public ImplementationBodyCodegen(JetClassOrObject aClass, ClassContext context, ClassVisitor v, GenerationState state) {
-        super(aClass, context, v, state);
-    }
-
-    @Override
-    protected void generateDeclaration() {
-        String superClass = getSuperClass();
-
-        List<String> interfaces = new ArrayList<String>();
-        interfaces.add("jet/JetObject");
-        if (!(myClass instanceof JetObjectDeclaration)) {
-            interfaces.add(JetTypeMapper.jvmNameForInterface(descriptor));
-        }
-        else {
-            interfaces.addAll(InterfaceBodyCodegen.getSuperInterfaces(myClass, state.getBindingContext()));
-        }
-
-        boolean isAbstract = myClass instanceof JetClass && ((JetClass) myClass).hasModifier(JetTokens.ABSTRACT_KEYWORD);
-
-        v.visit(Opcodes.V1_6,
-                Opcodes.ACC_PUBLIC | (isAbstract ? Opcodes.ACC_ABSTRACT : 0),
-                jvmName(),
-                null,
-                superClass,
-                interfaces.toArray(new String[interfaces.size()])
-        );
-        v.visitSource(myClass.getContainingFile().getName(), null);
-    }
-
-    private String jvmName() {
-        return state.getTypeMapper().jvmName(descriptor, kind);
-    }
-
-    protected String getSuperClass() {
-        List<JetDelegationSpecifier> delegationSpecifiers = myClass.getDelegationSpecifiers();
-
-        if (delegationSpecifiers.isEmpty()) return "java/lang/Object";
-
-        JetDelegationSpecifier first = delegationSpecifiers.get(0);
-        if (first instanceof JetDelegatorToSuperClass || first instanceof JetDelegatorToSuperCall) {
-            JetType superType = state.getBindingContext().get(BindingContext.TYPE, first.getTypeReference());
-            ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
-            final PsiElement declaration = state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, superClassDescriptor);
-            if (declaration instanceof PsiClass && ((PsiClass) declaration).isInterface()) {
-                return "java/lang/Object";
-            }
-            return state.getTypeMapper().jvmName(superClassDescriptor, kind);
-        }
-
-        return "java/lang/Object";
-    }
-
-    @Override
-    protected void generateSyntheticParts() {
-        generateFieldForTypeInfo();
-        generateFieldForObjectInstance();
-        generateFieldForClassObject();
-
-        try {
-            generatePrimaryConstructor();
-        }
-        catch(RuntimeException e) {
-            throw new RuntimeException("Error generating primary constructor of class " + myClass.getName() + " with kind " + kind, e);
-        }
-
-        generateGetTypeInfo();
-    }
-
-    private void generateFieldForTypeInfo() {
-        final boolean typeInfoIsStatic = descriptor.getTypeConstructor().getParameters().size() == 0;
-        v.visitField(Opcodes.ACC_PRIVATE | (typeInfoIsStatic ? Opcodes.ACC_STATIC : 0), "$typeInfo",
-                     "Ljet/typeinfo/TypeInfo;", null, null);
-        if (typeInfoIsStatic) {
-            staticInitializerChunks.add(new CodeChunk() {
-                @Override
-                public void generate(InstructionAdapter v) {
-                    JetTypeMapper typeMapper = state.getTypeMapper();
-                    ClassCodegen.newTypeInfo(v, false, typeMapper.jvmType(descriptor, OwnerKind.INTERFACE));
-                    v.putstatic(typeMapper.jvmName(descriptor, kind), "$typeInfo", "Ljet/typeinfo/TypeInfo;");
-                }
-            });
-        }
-    }
-
-    private void generateFieldForObjectInstance() {
-        if (isNonLiteralObject()) {
-            Type type = JetTypeMapper.jetImplementationType(descriptor);
-            v.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "$instance", type.getDescriptor(), null, null);
-
-            staticInitializerChunks.add(new CodeChunk() {
-                @Override
-                public void generate(InstructionAdapter v) {
-                    String name = jvmName();
-                    v.anew(Type.getObjectType(name));
-                    v.dup();
-                    v.invokespecial(name, "<init>", "()V");
-                    v.putstatic(name, "$instance", JetTypeMapper.jetImplementationType(descriptor).getDescriptor());
-                }
-            });
-
-        }
-    }
-
-    private void generateFieldForClassObject() {
-        final JetClassObject classObject = getClassObject();
-        if (classObject != null) {
-            Type type = Type.getObjectType(state.getTypeMapper().jvmName(classObject));
-            v.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "$classobj", type.getDescriptor(), null, null);
-
-            staticInitializerChunks.add(new CodeChunk() {
-                @Override
-                public void generate(InstructionAdapter v) {
-                    String name = state.getTypeMapper().jvmName(classObject);
-                    final Type classObjectType = Type.getObjectType(name);
-                    v.anew(classObjectType);
-                    v.dup();
-                    v.invokespecial(name, "<init>", "()V");
-                    v.putstatic(state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION), "$classobj",
-                                classObjectType.getDescriptor());
-                }
-            });
-        }
-    }
-
-    protected void generatePrimaryConstructor() {
-        ConstructorDescriptor constructorDescriptor = state.getBindingContext().get(BindingContext.CONSTRUCTOR, (JetElement) myClass);
-        if (constructorDescriptor == null && !(myClass instanceof JetObjectDeclaration) && !isEnum(myClass)) return;
-
-        Method method;
-        CallableMethod callableMethod;
-        if (constructorDescriptor == null) {
-            method = new Method("<init>", Type.VOID_TYPE, new Type[0]);
-            callableMethod = new CallableMethod("", method, Opcodes.INVOKESPECIAL, Collections.<Type>emptyList());
-        }
-        else {
-            callableMethod = state.getTypeMapper().mapToCallableMethod(constructorDescriptor, kind);
-            method = callableMethod.getSignature();
-        }
-        int flags = Opcodes.ACC_PUBLIC; // TODO
-        final MethodVisitor mv = v.visitMethod(flags, "<init>", method.getDescriptor(), null, null);
-        mv.visitCode();
-
-        Type[] argTypes = method.getArgumentTypes();
-        List<ValueParameterDescriptor> paramDescrs = constructorDescriptor != null
-                ? constructorDescriptor.getValueParameters()
-                : Collections.<ValueParameterDescriptor>emptyList();
-
-        ConstructorFrameMap frameMap = new ConstructorFrameMap(callableMethod, constructorDescriptor, kind);
-
-        final InstructionAdapter iv = new InstructionAdapter(mv);
-        ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, context, state);
-
-        String classname = state.getTypeMapper().jvmName(descriptor, kind);
-        final Type classType = Type.getType("L" + classname + ";");
-
-        List<JetDelegationSpecifier> specifiers = myClass.getDelegationSpecifiers();
-
-        if (specifiers.isEmpty() || !(specifiers.get(0) instanceof JetDelegatorToSuperCall)) {
-            // TODO correct calculation of super class
-            String superClass = "java/lang/Object";
-            if (!specifiers.isEmpty()) {
-                final JetType superType = state.getBindingContext().get(BindingContext.TYPE, specifiers.get(0).getTypeReference());
-                ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
-                if (superClassDescriptor.hasConstructors()) {
-                    superClass = getSuperClass();
-                }
-            }
-            iv.load(0, Type.getType("L" + superClass + ";"));
-            iv.invokespecial(superClass, "<init>", /* TODO super constructor descriptor */"()V");
-        }
-
-        final DeclarationDescriptor outerDescriptor = getOuterClassDescriptor();
-        if (outerDescriptor instanceof ClassDescriptor) {
-            final ClassDescriptor outerClassDescriptor = (ClassDescriptor) outerDescriptor;
-            final Type type = JetTypeMapper.jetImplementationType(outerClassDescriptor);
-            String interfaceDesc = type.getDescriptor();
-            final String fieldName = "this$0";
-            v.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, fieldName, interfaceDesc, null, null);
-            iv.load(0, classType);
-            iv.load(frameMap.getOuterThisIndex(), type);
-            iv.putfield(classname, fieldName, interfaceDesc);
-        }
-
-        if (kind == OwnerKind.DELEGATING_IMPLEMENTATION) {
-            String interfaceDesc = JetTypeMapper.jetInterfaceType(descriptor).getDescriptor();
-            v.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, "$this", interfaceDesc, /*TODO*/null, null);
-            iv.load(0, classType);
-            iv.load(frameMap.getDelegateThisIndex(), argTypes[0]);
-            iv.putfield(classname, "$this", interfaceDesc);
-        }
-
-        HashSet<FunctionDescriptor> overridden = new HashSet<FunctionDescriptor>();
-        for (JetDeclaration declaration : myClass.getDeclarations()) {
-            if (declaration instanceof JetFunction) {
-                overridden.addAll(state.getBindingContext().get(BindingContext.FUNCTION, (JetNamedFunction) declaration).getOverriddenFunctions());
-            }
-        }
-
-        int n = 0;
-        for (JetDelegationSpecifier specifier : specifiers) {
-            boolean delegateOnStack = specifier instanceof JetDelegatorToSuperCall && n > 0 ||
-                                      specifier instanceof JetDelegatorByExpressionSpecifier;
-
-            if (delegateOnStack) {
-                iv.load(0, classType);
-            }
-
-            if (specifier instanceof JetDelegatorToSuperCall) {
-                ConstructorDescriptor constructorDescriptor1 = (ConstructorDescriptor) state.getBindingContext().get(BindingContext.REFERENCE_TARGET, ((JetDelegatorToSuperCall) specifier).getCalleeExpression().getConstructorReferenceExpression());
-                generateDelegatorToConstructorCall(iv, codegen, (JetDelegatorToSuperCall) specifier, constructorDescriptor1, n == 0, frameMap);
-            }
-            else if (specifier instanceof JetDelegatorByExpressionSpecifier) {
-                codegen.genToJVMStack(((JetDelegatorByExpressionSpecifier) specifier).getDelegateExpression());
-            }
-
-            if (delegateOnStack) {
-                JetType superType = state.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
-                ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
-                String delegateField = "$delegate_" + n;
-                Type fieldType = JetTypeMapper.jetInterfaceType(superClassDescriptor);
-                String fieldDesc = fieldType.getDescriptor();
-                v.visitField(Opcodes.ACC_PRIVATE, delegateField, fieldDesc, /*TODO*/null, null);
-                iv.putfield(classname, delegateField, fieldDesc);
-
-                JetClass superClass = (JetClass) state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, superClassDescriptor);
-                final ClassContext delegateContext = context.intoClass(superClassDescriptor,
-                        new OwnerKind.DelegateKind(StackValue.field(fieldType, classname, delegateField, false),
-                        JetTypeMapper.jvmNameForInterface(superClassDescriptor)));
-                generateDelegates(superClass, delegateContext, overridden);
-            }
-
-            n++;
-        }
-
-        if (frameMap.getFirstTypeParameter() > 0 && kind == OwnerKind.IMPLEMENTATION) {
-            generateTypeInfoInitializer(frameMap.getFirstTypeParameter(), frameMap.getTypeParameterCount(), iv);
-        }
-
-        generateInitializers(codegen, iv);
-
-        int curParam = 0;
-        List<JetParameter> constructorParameters = getPrimaryConstructorParameters();
-        for (JetParameter parameter : constructorParameters) {
-            if (parameter.getValOrVarNode() != null) {
-                VariableDescriptor descriptor = paramDescrs.get(curParam);
-                Type type = state.getTypeMapper().mapType(descriptor.getOutType());
-                iv.load(0, classType);
-                iv.load(frameMap.getIndex(descriptor), type);
-                iv.putfield(classname, descriptor.getName(), type.getDescriptor());
-            }
-            curParam++;
-        }
-
-        mv.visitInsn(Opcodes.RETURN);
-        mv.visitMaxs(0, 0);
-        mv.visitEnd();
-    }
-
-    static boolean isEnum(JetClassOrObject myClass) {
-        final JetModifierList modifierList = myClass.getModifierList();
-        return modifierList != null && modifierList.hasModifier(JetTokens.ENUM_KEYWORD);
-    }
-
-    @Nullable
-    private ClassDescriptor getOuterClassDescriptor() {
-        if (myClass.getParent() instanceof JetClassObject) {
-            return null;
-        }
-        final DeclarationDescriptor outerDescriptor = descriptor.getContainingDeclaration();
-        return outerDescriptor instanceof ClassDescriptor ? (ClassDescriptor) outerDescriptor : null;
-    }
-
-    private void generateDelegatorToConstructorCall(InstructionAdapter iv, ExpressionCodegen codegen, JetCall constructorCall,
-                                                    ConstructorDescriptor constructorDescriptor, boolean isJavaSuperclass,
-                                                    ConstructorFrameMap frameMap) {
-        ClassDescriptor classDecl = constructorDescriptor.getContainingDeclaration();
-        boolean isDelegating = kind == OwnerKind.DELEGATING_IMPLEMENTATION;
-        PsiElement declaration = state.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, classDecl);
-        Type type;
-        if (declaration instanceof PsiClass) {
-            type = JetTypeMapper.psiClassType((PsiClass) declaration);
-        }
-        else {
-            type = isDelegating
-                    ? JetTypeMapper.jetDelegatingImplementationType(classDecl)
-                    : JetTypeMapper.jetImplementationType(classDecl);
-        }
-
-        if (!isJavaSuperclass) {
-            if (kind == OwnerKind.DELEGATING_IMPLEMENTATION) {
-                codegen.thisToStack();
-            }
-        }
-
-        if (isJavaSuperclass) {
-            iv.load(0, type);
-        }
-        else {
-            iv.anew(type);
-            iv.dup();
-        }
-
-        if (kind == OwnerKind.DELEGATING_IMPLEMENTATION) {
-            iv.load(frameMap.getDelegateThisIndex(), state.getTypeMapper().jvmType(classDecl, OwnerKind.INTERFACE));
-        }
-        if (classDecl.getContainingDeclaration() instanceof ClassDescriptor) {
-            iv.load(frameMap.getOuterThisIndex(), state.getTypeMapper().jvmType((ClassDescriptor) descriptor.getContainingDeclaration(), OwnerKind.IMPLEMENTATION));
-        }
-
-        CallableMethod method = state.getTypeMapper().mapToCallableMethod(constructorDescriptor, kind);
-        codegen.invokeMethodWithArguments(method, constructorCall);
-    }
-
-    @Override
-    protected void generateDeclaration(PropertyCodegen propertyCodegen, JetDeclaration declaration, FunctionCodegen functionCodegen) {
-        if (declaration instanceof JetConstructor) {
-            generateSecondaryConstructor((JetConstructor) declaration);
-        }
-        else if (declaration instanceof JetClassObject) {
-            generateClassObject((JetClassObject) declaration);
-        }
-        else {
-            super.generateDeclaration(propertyCodegen, declaration, functionCodegen);
-        }
-    }
-
-    private void generateSecondaryConstructor(JetConstructor constructor) {
-        ConstructorDescriptor constructorDescriptor = state.getBindingContext().get(BindingContext.CONSTRUCTOR, constructor);
-        if (constructorDescriptor == null) {
-            throw new UnsupportedOperationException("failed to get descriptor for secondary constructor");
-        }
-        CallableMethod method = state.getTypeMapper().mapToCallableMethod(constructorDescriptor, kind);
-        int flags = Opcodes.ACC_PUBLIC; // TODO
-        final MethodVisitor mv = v.visitMethod(flags, "<init>", method.getSignature().getDescriptor(), null, null);
-        mv.visitCode();
-
-        ConstructorFrameMap frameMap = new ConstructorFrameMap(method, constructorDescriptor, kind);
-
-        final InstructionAdapter iv = new InstructionAdapter(mv);
-        ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, context, state);
-
-        for (JetDelegationSpecifier initializer : constructor.getInitializers()) {
-            if (initializer instanceof JetDelegatorToThisCall) {
-                JetDelegatorToThisCall thisCall = (JetDelegatorToThisCall) initializer;
-                DeclarationDescriptor thisDescriptor = state.getBindingContext().get(BindingContext.REFERENCE_TARGET, thisCall.getThisReference());
-                if (!(thisDescriptor instanceof ConstructorDescriptor)) {
-                    throw new UnsupportedOperationException("expected 'this' delegator to resolve to constructor");
-                }
-                generateDelegatorToConstructorCall(iv, codegen, thisCall, (ConstructorDescriptor) thisDescriptor, true, frameMap);
-            }
-            else {
-                throw new UnsupportedOperationException("unknown initializer type");
-            }
-        }
-
-        JetExpression bodyExpression = constructor.getBodyExpression();
-        if (bodyExpression != null) {
-            codegen.gen(bodyExpression, Type.VOID_TYPE);
-        }
-
-        mv.visitInsn(Opcodes.RETURN);
-        mv.visitMaxs(0, 0);
-        mv.visitEnd();
-    }
-
-    protected void generateTypeInfoInitializer(int firstTypeParameter, int typeParamCount, InstructionAdapter iv) {
-        iv.load(0, JetTypeMapper.TYPE_OBJECT);
-        iv.anew(JetTypeMapper.TYPE_TYPEINFO);
-        iv.dup();
-
-        iv.aconst(state.getTypeMapper().jvmType(descriptor, OwnerKind.INTERFACE));
-        iv.aconst(false);
-        iv.iconst(typeParamCount);
-        iv.newarray(JetTypeMapper.TYPE_TYPEINFO);
-
-        for (int i = 0; i < typeParamCount; i++) {
-            iv.dup();
-            iv.iconst(i);
-            iv.load(firstTypeParameter + i, JetTypeMapper.TYPE_OBJECT);
-            iv.astore(JetTypeMapper.TYPE_OBJECT);
-        }
-        iv.invokespecial("jet/typeinfo/TypeInfo", "<init>", "(Ljava/lang/Class;Z[Ljet/typeinfo/TypeInfo;)V");
-        iv.putfield(state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION), "$typeInfo", "Ljet/typeinfo/TypeInfo;");
-    }
-
-    protected void generateInitializers(ExpressionCodegen codegen, InstructionAdapter iv) {
-        for (JetDeclaration declaration : myClass.getDeclarations()) {
-            if (declaration instanceof JetProperty) {
-                final PropertyDescriptor propertyDescriptor = (PropertyDescriptor) state.getBindingContext().get(BindingContext.VARIABLE, (JetProperty) declaration);
-                if ((boolean) state.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
-                    final JetExpression initializer = ((JetProperty) declaration).getInitializer();
-                    if (initializer != null) {
-                        iv.load(0, JetTypeMapper.TYPE_OBJECT);
-                        codegen.genToJVMStack(initializer);
-                        codegen.intermediateValueForProperty(propertyDescriptor, false, false).store(iv);
-                    }
-
-                }
-            }
-            else if (declaration instanceof JetClassInitializer) {
-                codegen.gen(((JetClassInitializer) declaration).getBody(), Type.VOID_TYPE);
-            }
-        }
-    }
-
-    protected void generateDelegates(JetClass toClass, ClassContext delegateContext, Set<FunctionDescriptor> overriden) {
-        final FunctionCodegen functionCodegen = new FunctionCodegen(delegateContext, v, state);
-        final PropertyCodegen propertyCodegen = new PropertyCodegen(delegateContext, v, functionCodegen, state);
-
-        for (JetDeclaration declaration : toClass.getDeclarations()) {
-            if (declaration instanceof JetProperty) {
-                propertyCodegen.gen((JetProperty) declaration);
-            }
-            else if (declaration instanceof JetFunction) {
-                if (!overriden.contains(state.getBindingContext().get(BindingContext.FUNCTION, (JetNamedFunction) declaration))) {
-                    functionCodegen.gen((JetNamedFunction) declaration);
-                }
-            }
-        }
-
-        for (JetParameter p : toClass.getPrimaryConstructorParameters()) {
-            if (p.getValOrVarNode() != null) {
-                PropertyDescriptor propertyDescriptor = state.getBindingContext().get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, p);
-                if (propertyDescriptor != null) {
-                    propertyCodegen.generateDefaultGetter(propertyDescriptor, Opcodes.ACC_PUBLIC);
-                    if (propertyDescriptor.isVar()) {
-                        propertyCodegen.generateDefaultSetter(propertyDescriptor, Opcodes.ACC_PUBLIC);
-                    }
-                }
-            }
-        }
-    }
-
-    @Nullable
-    private JetClassObject getClassObject() {
-        return myClass instanceof JetClass ? ((JetClass) myClass).getClassObject() : null;
-    }
-
-    private boolean isNonLiteralObject() {
-        return myClass instanceof JetObjectDeclaration && !((JetObjectDeclaration) myClass).isObjectLiteral() &&
-                !(myClass.getParent() instanceof JetClassObject);
-    }
-
-    private void generateGetTypeInfo() {
-        final MethodVisitor mv = v.visitMethod(Opcodes.ACC_PUBLIC,
-                "getTypeInfo",
-                "()Ljet/typeinfo/TypeInfo;",
-                null /* TODO */,
-                null);
-        mv.visitCode();
-        InstructionAdapter v = new InstructionAdapter(mv);
-        ExpressionCodegen.loadTypeInfo(state.getTypeMapper(), descriptor, v);
-        v.areturn(JetTypeMapper.TYPE_TYPEINFO);
-        mv.visitMaxs(0, 0);
-        mv.visitEnd();
-    }
-
-    private void generateClassObject(JetClassObject declaration) {
-        state.forClass().generate(context, declaration.getObjectDeclaration());
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/codegen/InterfaceBodyCodegen.java b/idea/src/org/jetbrains/jet/codegen/InterfaceBodyCodegen.java
deleted file mode 100644
index 2e3f4e0578f..00000000000
--- a/idea/src/org/jetbrains/jet/codegen/InterfaceBodyCodegen.java
+++ /dev/null
@@ -1,137 +0,0 @@
-package org.jetbrains.jet.codegen;
-
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiElement;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
-import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.types.JetType;
-import org.objectweb.asm.ClassVisitor;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.commons.InstructionAdapter;
-
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-
-/**
- * @author yole
- */
-public class InterfaceBodyCodegen extends ClassBodyCodegen {
-    private final List<JetEnumEntry> myEnumConstants = new ArrayList<JetEnumEntry>();
-
-    public InterfaceBodyCodegen(JetClassOrObject aClass, ClassContext context, ClassVisitor v, GenerationState state) {
-        super(aClass, context, v, state);
-        assert context.getContextKind() == OwnerKind.INTERFACE;
-    }
-
-    protected void generateDeclaration() {
-        Set<String> superInterfaces = getSuperInterfaces(myClass, state.getBindingContext());
-
-        String fqName = JetTypeMapper.jvmNameForInterface(descriptor);
-        v.visit(Opcodes.V1_6,
-                Opcodes.ACC_PUBLIC | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT,
-                fqName,
-                null,
-                "java/lang/Object",
-                superInterfaces.toArray(new String[superInterfaces.size()])
-        );
-        v.visitSource(myClass.getContainingFile().getName(), null);
-    }
-
-    static Set<String> getSuperInterfaces(JetClassOrObject aClass, final BindingContext bindingContext) {
-        List<JetDelegationSpecifier> delegationSpecifiers = aClass.getDelegationSpecifiers();
-        String superClassName = null;
-        Set<String> superInterfaces = new LinkedHashSet<String>();
-        for (JetDelegationSpecifier specifier : delegationSpecifiers) {
-            JetType superType = bindingContext.get(BindingContext.TYPE, specifier.getTypeReference());
-            ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
-            PsiElement superPsi = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, superClassDescriptor);
-
-            if (superPsi instanceof PsiClass) {
-                PsiClass psiClass = (PsiClass) superPsi;
-                String fqn = psiClass.getQualifiedName();
-                if (psiClass.isInterface()) {
-                    superInterfaces.add(fqn.replace('.', '/'));
-                }
-                else {
-                    if (superClassName == null) {
-                        superClassName = fqn.replace('.', '/');
-
-                        while (psiClass != null) {
-                            for (PsiClass ifs : psiClass.getInterfaces()) {
-                                superInterfaces.add(ifs.getQualifiedName().replace('.', '/'));
-                            }
-                            psiClass = psiClass.getSuperClass();
-                        }
-                    }
-                    else {
-                        throw new RuntimeException("Cannot determine single class to inherit from");
-                    }
-                }
-            }
-            else {
-                superInterfaces.add(JetTypeMapper.jvmNameForInterface(superClassDescriptor));
-            }
-        }
-        return superInterfaces;
-    }
-
-    @Override
-    protected void generateDeclaration(PropertyCodegen propertyCodegen, JetDeclaration declaration, FunctionCodegen functionCodegen) {
-        if (declaration instanceof JetEnumEntry && !((JetEnumEntry) declaration).hasPrimaryConstructor()) {
-            String name = declaration.getName();
-            final String desc = "L" + state.getTypeMapper().jvmName(descriptor, OwnerKind.INTERFACE) + ";";
-            v.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL, name, desc, null, null);
-            if (myEnumConstants.isEmpty()) {
-                staticInitializerChunks.add(new CodeChunk() {
-                    @Override
-                    public void generate(InstructionAdapter v) {
-                        initializeEnumConstants(v);
-                    }
-                });
-            }
-            myEnumConstants.add((JetEnumEntry) declaration);
-        }
-        else {
-            super.generateDeclaration(propertyCodegen, declaration, functionCodegen);
-        }
-    }
-
-    private void initializeEnumConstants(InstructionAdapter v) {
-        ExpressionCodegen codegen = new ExpressionCodegen(v, new FrameMap(), Type.VOID_TYPE, context, state);
-        for (JetEnumEntry enumConstant : myEnumConstants) {
-            // TODO type and constructor parameters
-            String intfClass = state.getTypeMapper().jvmName(descriptor, OwnerKind.INTERFACE);
-            String implClass = state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION);
-
-            final List<JetDelegationSpecifier> delegationSpecifiers = enumConstant.getDelegationSpecifiers();
-            if (delegationSpecifiers.size() > 1) {
-                throw new UnsupportedOperationException("multiple delegation specifiers for enum constant not supported");
-            }
-
-            v.anew(Type.getObjectType(implClass));
-            v.dup();
-
-            if (delegationSpecifiers.size() == 1) {
-                final JetDelegationSpecifier specifier = delegationSpecifiers.get(0);
-                if (specifier instanceof JetDelegatorToSuperCall) {
-                    final JetDelegatorToSuperCall superCall = (JetDelegatorToSuperCall) specifier;
-                    ConstructorDescriptor constructorDescriptor = (ConstructorDescriptor) state.getBindingContext().get(BindingContext.REFERENCE_TARGET, superCall.getCalleeExpression().getConstructorReferenceExpression());
-                    CallableMethod method = state.getTypeMapper().mapToCallableMethod(constructorDescriptor, OwnerKind.IMPLEMENTATION);
-                    codegen.invokeMethodWithArguments(method, superCall);
-                }
-                else {
-                    throw new UnsupportedOperationException("unsupported type of enum constant initializer: " + specifier);
-                }
-            }
-            else {
-                v.invokespecial(implClass, "<init>", "()V");
-            }
-            v.putstatic(intfClass, enumConstant.getName(), "L" + intfClass + ";");
-        }
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/codegen/MethodCodeGen.java b/idea/src/org/jetbrains/jet/codegen/MethodCodeGen.java
deleted file mode 100644
index d9d657ac822..00000000000
--- a/idea/src/org/jetbrains/jet/codegen/MethodCodeGen.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package org.jetbrains.jet.codegen;
-
-/**
- * @author max
- */
-public class MethodCodeGen {
-
-}
diff --git a/idea/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/idea/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
deleted file mode 100644
index 1b8ee6b5429..00000000000
--- a/idea/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
+++ /dev/null
@@ -1,116 +0,0 @@
-package org.jetbrains.jet.codegen;
-
-import com.intellij.psi.PsiFile;
-import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
-import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.objectweb.asm.ClassVisitor;
-import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.objectweb.asm.commons.InstructionAdapter;
-
-/**
- * @author max
- */
-public class NamespaceCodegen {
-    private final ClassVisitor v;
-    private final GenerationState state;
-
-    public NamespaceCodegen(ClassVisitor v, String fqName, GenerationState state, PsiFile sourceFile) {
-        this.v = v;
-        this.state = state;
-
-        v.visit(Opcodes.V1_6,
-                Opcodes.ACC_PUBLIC,
-                getJVMClassName(fqName),
-                null,
-                //"jet/lang/Namespace",
-                "java/lang/Object",
-                new String[0]
-        );
-        // TODO figure something out for a namespace that spans multiple files
-        v.visitSource(sourceFile.getName(), null);
-    }
-
-    public void generate(JetNamespace namespace) {
-        final ClassContext context = ClassContext.STATIC.intoNamespace(state.getBindingContext().get(BindingContext.NAMESPACE, namespace));
-
-        final FunctionCodegen functionCodegen = new FunctionCodegen(context, v, state);
-        final PropertyCodegen propertyCodegen = new PropertyCodegen(context, v, functionCodegen, state);
-        final ClassCodegen classCodegen = state.forClass();
-
-        GenerationState.prepareAnonymousClasses(namespace, state.getTypeMapper());
-
-        if (hasNonConstantPropertyInitializers(namespace)) {
-            generateStaticInitializers(namespace);
-        }
-
-        for (JetDeclaration declaration : namespace.getDeclarations()) {
-            if (declaration instanceof JetProperty) {
-                propertyCodegen.gen((JetProperty) declaration);
-            }
-            else if (declaration instanceof JetNamedFunction) {
-                try {
-                    functionCodegen.gen((JetNamedFunction) declaration);
-                } catch (Exception e) {
-                    throw new RuntimeException("Failed to generate function " + declaration.getName(), e);
-                }
-            }
-            else if (declaration instanceof JetClassOrObject) {
-                classCodegen.generate(context, (JetClassOrObject) declaration);
-            }
-            else if (declaration instanceof JetNamespace) {
-                JetNamespace childNamespace = (JetNamespace) declaration;
-                state.forNamespace(childNamespace).generate(childNamespace);
-            }
-        }
-    }
-
-    private void generateStaticInitializers(JetNamespace namespace) {
-        MethodVisitor mv = v.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC,
-                "<clinit>", "()V", null, null);
-        mv.visitCode();
-
-        FrameMap frameMap = new FrameMap();
-        ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, ClassContext.STATIC, state);
-
-        for (JetDeclaration declaration : namespace.getDeclarations()) {
-            if (declaration instanceof JetProperty) {
-                final JetExpression initializer = ((JetProperty) declaration).getInitializer();
-                if (initializer != null && !(initializer instanceof JetConstantExpression)) {
-                    final PropertyDescriptor descriptor = (PropertyDescriptor) state.getBindingContext().get(BindingContext.VARIABLE, (JetProperty) declaration);
-                    codegen.genToJVMStack(initializer);
-                    codegen.intermediateValueForProperty(descriptor, true, false).store(new InstructionAdapter(mv));
-                }
-            }
-        }
-        mv.visitInsn(Opcodes.RETURN);
-        mv.visitMaxs(0, 0);
-        mv.visitEnd();
-    }
-
-    private static boolean hasNonConstantPropertyInitializers(JetNamespace namespace) {
-        for (JetDeclaration declaration : namespace.getDeclarations()) {
-            if (declaration instanceof JetProperty) {
-                final JetExpression initializer = ((JetProperty) declaration).getInitializer();
-                if (initializer != null && !(initializer instanceof JetConstantExpression)) {
-                    return true;
-                }
-
-            }
-        }
-        return false;
-    }
-
-    public void done() {
-        v.visitEnd();
-    }
-
-    public static String getJVMClassName(String fqName) {
-        if (fqName.length() == 0) {
-            return "namespace";
-        }
-        return fqName.replace('.', '/') + "/namespace";
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/CollectingErrorHandler.java b/idea/src/org/jetbrains/jet/lang/CollectingErrorHandler.java
deleted file mode 100644
index f28dd05c061..00000000000
--- a/idea/src/org/jetbrains/jet/lang/CollectingErrorHandler.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package org.jetbrains.jet.lang;
-
-import com.google.common.collect.Lists;
-import com.intellij.lang.ASTNode;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.psi.JetReferenceExpression;
-import org.jetbrains.jet.lang.types.JetType;
-
-import java.util.List;
-
-/**
- * @author abreslav
- */
-public class CollectingErrorHandler extends ErrorHandler {
-    private final List<JetDiagnostic> diagnostics;
-
-    public CollectingErrorHandler() {
-        this(Lists.<JetDiagnostic>newArrayList());
-    }
-
-    public CollectingErrorHandler(List<JetDiagnostic> diagnostics) {
-        this.diagnostics = diagnostics;
-    }
-
-    public List<JetDiagnostic> getDiagnostics() {
-        return diagnostics;
-    }
-
-    @Override
-    public void unresolvedReference(@NotNull JetReferenceExpression referenceExpression) {
-        diagnostics.add(new JetDiagnostic.UnresolvedReferenceError(referenceExpression));
-    }
-
-    @Override
-    public void typeMismatch(@NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull JetType actualType) {
-        diagnostics.add(new JetDiagnostic.TypeMismatchError(expression, expectedType, actualType));
-    }
-
-    @Override
-    public void redeclaration(@NotNull DeclarationDescriptor existingDescriptor, @NotNull DeclarationDescriptor redeclaredDescriptor) {
-        diagnostics.add(new JetDiagnostic.RedeclarationError(existingDescriptor, redeclaredDescriptor));
-    }
-
-    @Override
-    public void genericError(@NotNull ASTNode node, @NotNull String errorMessage) {
-        diagnostics.add(new JetDiagnostic.GenericError(node, errorMessage));
-    }
-
-    @Override
-    public void genericWarning(@NotNull ASTNode node, @NotNull String message) {
-        diagnostics.add(new JetDiagnostic.GenericWarning(node, message));
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/ErrorHandler.java b/idea/src/org/jetbrains/jet/lang/ErrorHandler.java
deleted file mode 100644
index 6bddbc45a4e..00000000000
--- a/idea/src/org/jetbrains/jet/lang/ErrorHandler.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package org.jetbrains.jet.lang;
-
-import com.intellij.lang.ASTNode;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.psi.JetReferenceExpression;
-import org.jetbrains.jet.lang.types.JetType;
-
-/**
- * @author abreslav
- */
-public class ErrorHandler {
-    public static final ErrorHandler DO_NOTHING = new ErrorHandler();
-    public static final ErrorHandler THROW_EXCEPTION = new ErrorHandler() {
-        @Override
-        public void unresolvedReference(@NotNull JetReferenceExpression referenceExpression) {
-            throw new IllegalStateException("Unresolved reference: " + referenceExpression.getText() +
-                                            " at offset "  + referenceExpression.getTextRange().getStartOffset());
-        }
-
-        @Override
-        public void genericError(@NotNull ASTNode node, @NotNull String errorMessage) {
-            throw new IllegalStateException(errorMessage + " at " + node.getText());
-        }
-
-        @Override
-        public void typeMismatch(@NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull JetType actualType) {
-            throw new IllegalStateException("Type mismatch at " + expression.getTextRange().getStartOffset() + ": inferred type is " + actualType + " but " + expectedType + " was expected");
-        }
-
-        @Override
-        public void redeclaration(@NotNull DeclarationDescriptor existingDescriptor, @NotNull DeclarationDescriptor redeclaredDescriptor) {
-            throw new IllegalStateException("Redeclaration: " + existingDescriptor.getName());
-        }
-    };
-
-    public void unresolvedReference(@NotNull JetReferenceExpression referenceExpression) {
-    }
-
-    public void typeMismatch(@NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull JetType actualType) {
-    }
-
-    public void redeclaration(@NotNull DeclarationDescriptor existingDescriptor, @NotNull DeclarationDescriptor redeclaredDescriptor) {
-    }
-
-    public void genericError(@NotNull ASTNode node, @NotNull String errorMessage) {
-    }
-
-    public void genericWarning(@NotNull ASTNode node, @NotNull String message) {
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/ErrorHandlerAdapter.java b/idea/src/org/jetbrains/jet/lang/ErrorHandlerAdapter.java
deleted file mode 100644
index ba2461c11e6..00000000000
--- a/idea/src/org/jetbrains/jet/lang/ErrorHandlerAdapter.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.jetbrains.jet.lang;
-
-import com.intellij.lang.ASTNode;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.psi.JetReferenceExpression;
-import org.jetbrains.jet.lang.types.JetType;
-
-/**
- * @author abreslav
- */
-public class ErrorHandlerAdapter extends ErrorHandler {
-    protected ErrorHandler worker;
-
-    public ErrorHandlerAdapter(ErrorHandler worker) {
-        this.worker = worker;
-    }
-
-    @Override
-    public void unresolvedReference(@NotNull JetReferenceExpression referenceExpression) {
-        worker.unresolvedReference(referenceExpression);
-    }
-
-    @Override
-    public void typeMismatch(@NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull JetType actualType) {
-        worker.typeMismatch(expression, expectedType, actualType);
-    }
-
-    @Override
-    public void redeclaration(@NotNull DeclarationDescriptor existingDescriptor, @NotNull DeclarationDescriptor redeclaredDescriptor) {
-        worker.redeclaration(existingDescriptor, redeclaredDescriptor);
-    }
-
-    @Override
-    public void genericError(@NotNull ASTNode node, @NotNull String errorMessage) {
-        worker.genericError(node, errorMessage);
-    }
-
-    @Override
-    public void genericWarning(@NotNull ASTNode node, @NotNull String message) {
-        worker.genericWarning(node, message);
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/JetDiagnostic.java b/idea/src/org/jetbrains/jet/lang/JetDiagnostic.java
deleted file mode 100644
index f05a8465266..00000000000
--- a/idea/src/org/jetbrains/jet/lang/JetDiagnostic.java
+++ /dev/null
@@ -1,106 +0,0 @@
-package org.jetbrains.jet.lang;
-
-import com.intellij.lang.ASTNode;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.psi.JetReferenceExpression;
-import org.jetbrains.jet.lang.types.JetType;
-
-/**
- * @author abreslav
- */
-public abstract class JetDiagnostic {
-
-    public static class UnresolvedReferenceError extends JetDiagnostic {
-
-        private final JetReferenceExpression referenceExpression;
-
-        public UnresolvedReferenceError(@NonNls JetReferenceExpression referenceExpression) {
-            this.referenceExpression = referenceExpression;
-        }
-
-        @Override
-        public void acceptHandler(@NonNls ErrorHandler handler) {
-            handler.unresolvedReference(referenceExpression);
-        }
-    }
-
-    public static class GenericError extends JetDiagnostic {
-
-        private final ASTNode node;
-        private final String message;
-
-        public GenericError(@NonNls ASTNode node, @NonNls String message) {
-            this.node = node;
-            this.message = message;
-        }
-
-        @Override
-        public void acceptHandler(@NonNls ErrorHandler handler) {
-            handler.genericError(node, message);
-        }
-    }
-
-    public static class TypeMismatchError extends JetDiagnostic {
-
-        private final JetExpression expression;
-        private final JetType expectedType;
-        private final JetType actualType;
-
-        public TypeMismatchError(@NonNls JetExpression expression, @NonNls JetType expectedType, @NonNls JetType actualType) {
-            this.expression = expression;
-            this.expectedType = expectedType;
-            this.actualType = actualType;
-        }
-
-        @Override
-        public void acceptHandler(@NonNls ErrorHandler handler) {
-            handler.typeMismatch(expression, expectedType, actualType);
-        }
-    }
-
-    public static class RedeclarationError extends JetDiagnostic {
-
-        private final DeclarationDescriptor existingDescriptor;
-        private final DeclarationDescriptor redeclaredDescriptor;
-
-        public RedeclarationError(@NonNls DeclarationDescriptor existingDescriptor, @NonNls DeclarationDescriptor redeclaredDescriptor) {
-            this.existingDescriptor = existingDescriptor;
-            this.redeclaredDescriptor = redeclaredDescriptor;
-        }
-
-        @Override
-        public void acceptHandler(@NonNls ErrorHandler handler) {
-            handler.redeclaration(existingDescriptor, redeclaredDescriptor);
-        }
-    }
-
-    public static class GenericWarning extends JetDiagnostic {
-
-        private final ASTNode node;
-        private final String message;
-
-        public GenericWarning(@NonNls ASTNode node, @NonNls String message) {
-            this.message = message;
-            this.node = node;
-        }
-
-        @Override
-        public void acceptHandler(@NonNls ErrorHandler handler) {
-            handler.genericWarning(node, message);
-        }
-    }
-
-//    private final StackTraceElement[] stackTrace;
-//
-//    protected JetDiagnostic() {
-//        stackTrace = Thread.currentThread().getStackTrace();
-//    }
-//
-//    public StackTraceElement[] getStackTrace() {
-//        return stackTrace;
-//    }
-
-    public abstract void acceptHandler(@NonNls ErrorHandler handler);
-}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/Annotated.java b/idea/src/org/jetbrains/jet/lang/descriptors/Annotated.java
deleted file mode 100644
index c956ec791c5..00000000000
--- a/idea/src/org/jetbrains/jet/lang/descriptors/Annotated.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.jetbrains.jet.lang.descriptors;
-
-import java.util.List;
-
-/**
- * @author abreslav
- */
-public interface Annotated {
-    List<Annotation> getAnnotations();
-}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/AnnotatedImpl.java b/idea/src/org/jetbrains/jet/lang/descriptors/AnnotatedImpl.java
deleted file mode 100644
index 2cbe63b1e0d..00000000000
--- a/idea/src/org/jetbrains/jet/lang/descriptors/AnnotatedImpl.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package org.jetbrains.jet.lang.descriptors;
-
-import java.util.List;
-
-/**
- * @author abreslav
- */
-public abstract class AnnotatedImpl implements Annotated {
-    private final List<Annotation> annotations;
-
-    public AnnotatedImpl(List<Annotation> annotations) {
-        this.annotations = annotations;
-    }
-
-    @Override
-    public List<Annotation> getAnnotations() {
-        return annotations;
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java b/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java
deleted file mode 100644
index bb623b32761..00000000000
--- a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java
+++ /dev/null
@@ -1,237 +0,0 @@
-package org.jetbrains.jet.lang.descriptors;
-
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
-import com.google.common.collect.Maps;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.WritableScope;
-import org.jetbrains.jet.lang.resolve.WritableScopeImpl;
-import org.jetbrains.jet.lang.types.*;
-
-import java.util.*;
-
-/**
- * @author abreslav
- */
-public class FunctionDescriptorUtil {
-    /** @return Minimal number of arguments to be passed */
-    public static int getMinimumArity(@NotNull FunctionDescriptor functionDescriptor) {
-        int result = 0;
-        for (ValueParameterDescriptor valueParameter : functionDescriptor.getValueParameters()) {
-            if (valueParameter.hasDefaultValue()) {
-                break;
-            }
-            result++;
-        }
-        return result;
-    }
-
-    /**
-     * @return Maximum number of arguments that can be passed. -1 if unbound (vararg)
-     */
-    public static int getMaximumArity(@NotNull FunctionDescriptor functionDescriptor) {
-        List<ValueParameterDescriptor> unsubstitutedValueParameters = functionDescriptor.getValueParameters();
-        if (unsubstitutedValueParameters.isEmpty()) {
-            return 0;
-        }
-        // TODO : check somewhere that vararg is only the last one, and that varargs do not have default values
-
-        ValueParameterDescriptor lastParameter = unsubstitutedValueParameters.get(unsubstitutedValueParameters.size() - 1);
-        if (lastParameter.isVararg()) {
-            return -1;
-        }
-        return unsubstitutedValueParameters.size();
-    }
-
-    private static Map<TypeConstructor, TypeProjection> createSubstitutionContext(@NotNull FunctionDescriptor functionDescriptor, List<JetType> typeArguments) {
-        if (functionDescriptor.getTypeParameters().isEmpty()) return Collections.emptyMap();
-
-        Map<TypeConstructor, TypeProjection> result = new HashMap<TypeConstructor, TypeProjection>();
-
-        int typeArgumentsSize = typeArguments.size();
-        List<TypeParameterDescriptor> typeParameters = functionDescriptor.getTypeParameters();
-        assert typeArgumentsSize == typeParameters.size();
-        for (int i = 0; i < typeArgumentsSize; i++) {
-            TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i);
-            JetType typeArgument = typeArguments.get(i);
-            result.put(typeParameterDescriptor.getTypeConstructor(), new TypeProjection(typeArgument));
-        }
-        return result;
-    }
-
-    @Nullable
-    public static List<ValueParameterDescriptor> getSubstitutedValueParameters(FunctionDescriptor substitutedDescriptor, @NotNull FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) {
-        List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>();
-        List<ValueParameterDescriptor> unsubstitutedValueParameters = functionDescriptor.getValueParameters();
-        for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
-            ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i);
-            // TODO : Lazy?
-            JetType substitutedType = substitutor.substitute(unsubstitutedValueParameter.getOutType(), Variance.IN_VARIANCE);
-            if (substitutedType == null) return null;
-            result.add(new ValueParameterDescriptorImpl(
-                    substitutedDescriptor,
-                    i,
-                    unsubstitutedValueParameter.getAnnotations(),
-                    unsubstitutedValueParameter.getName(),
-                    unsubstitutedValueParameter.getInType() == null ? null : substitutedType,
-                    substitutedType,
-                    unsubstitutedValueParameter.hasDefaultValue(),
-                    unsubstitutedValueParameter.isVararg()
-            ));
-        }
-        return result;
-    }
-
-    @Nullable
-    public static JetType getSubstitutedReturnType(@NotNull FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) {
-        return substitutor.substitute(functionDescriptor.getReturnType(), Variance.OUT_VARIANCE);
-    }
-
-    @Nullable
-    public static FunctionDescriptor substituteFunctionDescriptor(@NotNull List<JetType> typeArguments, @NotNull FunctionDescriptor functionDescriptor) {
-        Map<TypeConstructor, TypeProjection> substitutionContext = createSubstitutionContext(functionDescriptor, typeArguments);
-        return functionDescriptor.substitute(TypeSubstitutor.create(substitutionContext));
-    }
-
-    @NotNull
-    public static JetScope getFunctionInnerScope(@NotNull JetScope outerScope, @NotNull FunctionDescriptor descriptor, @NotNull BindingTrace trace) {
-        WritableScope parameterScope = new WritableScopeImpl(outerScope, descriptor, trace.getErrorHandler()).setDebugName("Function inner scope");
-        JetType receiverType = descriptor.getReceiverType();
-        if (receiverType != null) {
-            parameterScope.setThisType(receiverType);
-        }
-        for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) {
-            parameterScope.addTypeParameterDescriptor(typeParameter);
-        }
-        for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getValueParameters()) {
-            parameterScope.addVariableDescriptor(valueParameterDescriptor);
-        }
-        parameterScope.addLabeledDeclaration(descriptor);
-        return parameterScope;
-    }
-
-    public static class OverrideCompatibilityInfo {
-
-        private static final OverrideCompatibilityInfo SUCCESS = new OverrideCompatibilityInfo(false, "SUCCESS");
-
-        @NotNull
-        public static OverrideCompatibilityInfo nameMismatch() {
-            return new OverrideCompatibilityInfo(true, "nameMismatch"); // TODO
-        }
-
-        @NotNull
-        public static OverrideCompatibilityInfo typeParameterNumberMismatch() {
-            return new OverrideCompatibilityInfo(true, "typeParameterNumberMismatch"); // TODO
-        }
-
-        @NotNull
-        public static OverrideCompatibilityInfo valueParameterNumberMismatch() {
-            return new OverrideCompatibilityInfo(true, "valueParameterNumberMismatch"); // TODO
-        }
-
-        @NotNull
-        public static OverrideCompatibilityInfo boundsMismatch(TypeParameterDescriptor superTypeParameter, TypeParameterDescriptor subTypeParameter) {
-            return new OverrideCompatibilityInfo(true, "boundsMismatch"); // TODO
-        }
-
-        @NotNull
-        public static OverrideCompatibilityInfo valueParameterTypeMismatch(ValueParameterDescriptor superValueParameter, ValueParameterDescriptor subValueParameter) {
-            return new OverrideCompatibilityInfo(true, "valueParameterTypeMismatch"); // TODO
-        }
-
-        @NotNull
-        public static OverrideCompatibilityInfo returnTypeMismatch(JetType substitutedSuperReturnType, JetType unsubstitutedSubReturnType) {
-            return new OverrideCompatibilityInfo(true, "returnTypeMismatch: " + unsubstitutedSubReturnType + " >< " + substitutedSuperReturnType); // TODO
-        }
-
-        @NotNull
-        public static OverrideCompatibilityInfo success() {
-            return SUCCESS;
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-        private final boolean isError;
-        private final String message;
-
-        public OverrideCompatibilityInfo(boolean error, String message) {
-            isError = error;
-            this.message = message;
-        }
-
-        public boolean isSuccess() {
-            return !isError;
-        }
-
-        public String getMessage() {
-            return message;
-        }
-    }
-
-    @NotNull
-    public static OverrideCompatibilityInfo isOverridableBy(@NotNull JetTypeChecker typeChecker, @NotNull FunctionDescriptor superFunction, @NotNull FunctionDescriptor subFunction) {
-        if (!superFunction.getName().equals(subFunction.getName())) {
-            return OverrideCompatibilityInfo.nameMismatch();
-        }
-
-        // TODO : Visibility
-
-        if (superFunction.getTypeParameters().size() != subFunction.getTypeParameters().size()) {
-            return OverrideCompatibilityInfo.typeParameterNumberMismatch();
-        }
-
-        if (superFunction.getValueParameters().size() != subFunction.getValueParameters().size()) {
-            return OverrideCompatibilityInfo.valueParameterNumberMismatch();
-        }
-
-        List<TypeParameterDescriptor> superTypeParameters = superFunction.getTypeParameters();
-        List<TypeParameterDescriptor> subTypeParameters = subFunction.getTypeParameters();
-
-        Map<TypeConstructor, TypeProjection> substitutionContext = Maps.newHashMap();
-        BiMap<TypeConstructor, TypeConstructor> axioms = HashBiMap.create();
-        for (int i = 0, typeParametersSize = superTypeParameters.size(); i < typeParametersSize; i++) {
-            TypeParameterDescriptor superTypeParameter = superTypeParameters.get(i);
-            TypeParameterDescriptor subTypeParameter = subTypeParameters.get(i);
-            substitutionContext.put(
-                    superTypeParameter.getTypeConstructor(),
-                    new TypeProjection(subTypeParameter.getDefaultType()));
-            axioms.put(superTypeParameter.getTypeConstructor(), subTypeParameter.getTypeConstructor());
-        }
-
-        for (int i = 0, typeParametersSize = superTypeParameters.size(); i < typeParametersSize; i++) {
-            TypeParameterDescriptor superTypeParameter = superTypeParameters.get(i);
-            TypeParameterDescriptor subTypeParameter = subTypeParameters.get(i);
-
-
-            if (!JetTypeImpl.equalTypes(superTypeParameter.getBoundsAsType(), subTypeParameter.getBoundsAsType(), axioms)) {
-                return OverrideCompatibilityInfo.boundsMismatch(superTypeParameter, subTypeParameter);
-            }
-        }
-
-        List<ValueParameterDescriptor> superValueParameters = superFunction.getValueParameters();
-        List<ValueParameterDescriptor> subValueParameters = subFunction.getValueParameters();
-        for (int i = 0, unsubstitutedValueParametersSize = superValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
-            ValueParameterDescriptor superValueParameter = superValueParameters.get(i);
-            ValueParameterDescriptor subValueParameter = subValueParameters.get(i);
-
-            if (!JetTypeImpl.equalTypes(superValueParameter.getOutType(), subValueParameter.getOutType(), axioms)) {
-                return OverrideCompatibilityInfo.valueParameterTypeMismatch(superValueParameter, subValueParameter);
-            }
-        }
-
-        // TODO : Default values, varargs etc
-
-        TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitutionContext);
-        JetType substitutedSuperReturnType = typeSubstitutor.substitute(superFunction.getReturnType(), Variance.OUT_VARIANCE);
-        assert substitutedSuperReturnType != null;
-        if (!typeChecker.isSubtypeOf(subFunction.getReturnType(), substitutedSuperReturnType)) {
-            return OverrideCompatibilityInfo.returnTypeMismatch(substitutedSuperReturnType, subFunction.getReturnType());
-        }
-
-        return OverrideCompatibilityInfo.success();
-    }
-
-}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionGroup.java b/idea/src/org/jetbrains/jet/lang/descriptors/FunctionGroup.java
deleted file mode 100644
index 05a5ded0fd9..00000000000
--- a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionGroup.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package org.jetbrains.jet.lang.descriptors;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.OverloadResolutionResult;
-import org.jetbrains.jet.lang.types.JetType;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-
-/**
- * @author abreslav
- */
-public interface FunctionGroup extends Named {
-    FunctionGroup EMPTY = new FunctionGroup() {
-        @NotNull
-        @Override
-        public String getName() {
-            return "<empty>";
-        }
-
-        @NotNull
-        @Override
-        public OverloadResolutionResult getPossiblyApplicableFunctions(@NotNull List<JetType> typeArguments, @NotNull List<JetType> positionedValueArgumentTypes) {
-            return OverloadResolutionResult.nameNotFound();
-        }
-
-        @Override
-        public boolean isEmpty() {
-            return true;
-        }
-
-        @NotNull
-        @Override
-        public Set<FunctionDescriptor> getFunctionDescriptors() {
-            return Collections.emptySet();
-        }
-    };
-
-
-    @NotNull
-    @Override
-    String getName();
-
-    @NotNull
-    OverloadResolutionResult getPossiblyApplicableFunctions(@NotNull List<JetType> typeArguments, @NotNull List<JetType> positionedValueArgumentTypes);
-
-    boolean isEmpty();
-
-    @NotNull
-    Set<FunctionDescriptor> getFunctionDescriptors();
-}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingFunctionGroup.java b/idea/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingFunctionGroup.java
deleted file mode 100644
index df79659cb71..00000000000
--- a/idea/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingFunctionGroup.java
+++ /dev/null
@@ -1,74 +0,0 @@
-package org.jetbrains.jet.lang.descriptors;
-
-import com.google.common.collect.Sets;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.OverloadResolutionResult;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.TypeSubstitutor;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-
-/**
- * @author abreslav
- */
-public class LazySubstitutingFunctionGroup implements FunctionGroup {
-    private final TypeSubstitutor substitutor;
-    private final FunctionGroup functionGroup;
-    private Set<FunctionDescriptor> functionDescriptors;
-
-    public LazySubstitutingFunctionGroup(TypeSubstitutor substitutor, FunctionGroup functionGroup) {
-        this.substitutor = substitutor;
-        this.functionGroup = functionGroup;
-    }
-
-    @NotNull
-    @Override
-    public String getName() {
-        return functionGroup.getName();
-    }
-
-    @NotNull
-    @Override
-    public OverloadResolutionResult getPossiblyApplicableFunctions(@NotNull List<JetType> typeArguments, @NotNull List<JetType> positionedValueArgumentTypes) {
-        OverloadResolutionResult resolutionResult = functionGroup.getPossiblyApplicableFunctions(typeArguments, positionedValueArgumentTypes);
-        if (resolutionResult.isNothing()) return resolutionResult;
-
-        Collection<FunctionDescriptor> result = new ArrayList<FunctionDescriptor>();
-        for (FunctionDescriptor function : resolutionResult.getFunctionDescriptors()) {
-            FunctionDescriptor functionDescriptor = substitute(function);
-            if (functionDescriptor != null) {
-                result.add(functionDescriptor);
-            }
-        }
-        return resolutionResult.newContents(result);
-    }
-
-    @Nullable
-    private FunctionDescriptor substitute(
-            @NotNull FunctionDescriptor functionDescriptor) {
-        if (substitutor.isEmpty()) return functionDescriptor;
-
-        return functionDescriptor.substitute(substitutor);
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return functionGroup.isEmpty();
-    }
-
-    @NotNull
-    @Override
-    public Set<FunctionDescriptor> getFunctionDescriptors() {
-        if (functionDescriptors == null) {
-            functionDescriptors = Sets.newHashSet();
-            for (FunctionDescriptor descriptor : functionGroup.getFunctionDescriptors()) {
-                functionDescriptors.add(descriptor.substitute(substitutor));
-            }
-        }
-        return functionDescriptors;
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/MemberModifiers.java b/idea/src/org/jetbrains/jet/lang/descriptors/MemberModifiers.java
deleted file mode 100644
index 506e08ba4db..00000000000
--- a/idea/src/org/jetbrains/jet/lang/descriptors/MemberModifiers.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package org.jetbrains.jet.lang.descriptors;
-
-/**
- * @author abreslav
- */
-public class MemberModifiers {
-
-    private final boolean isAbstract;
-    private final boolean isVirtual;
-    private final boolean isOverride;
-
-    public MemberModifiers(boolean isAbstract, boolean isVirtual, boolean isOverride) {
-        this.isAbstract = isAbstract;
-        this.isVirtual = isVirtual;
-        this.isOverride = isOverride;
-    }
-
-    public boolean isAbstract() {
-        return isAbstract;
-    }
-
-    public boolean isVirtual() {
-        return isVirtual;
-    }
-
-    public boolean isOverride() {
-        return isOverride;
-    }
-
-    public boolean isOverridable() {
-        return isAbstract() || isVirtual() || isOverride();
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/WritableFunctionGroup.java b/idea/src/org/jetbrains/jet/lang/descriptors/WritableFunctionGroup.java
deleted file mode 100644
index f47a5237285..00000000000
--- a/idea/src/org/jetbrains/jet/lang/descriptors/WritableFunctionGroup.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package org.jetbrains.jet.lang.descriptors;
-
-import com.google.common.collect.Sets;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.OverloadResolutionResult;
-import org.jetbrains.jet.lang.types.*;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-/**
- * @author abreslav
- */
-public class WritableFunctionGroup implements FunctionGroup {
-    private final String name;
-    private Set<FunctionDescriptor> functionDescriptors;
-
-    public WritableFunctionGroup(String name) {
-        this.name = name;
-    }
-
-    @NotNull
-    @Override
-    public String getName() {
-        return name;
-    }
-
-    @Override
-    public String toString() {
-        return "FunctionGroup{" +
-                "name='" + name + '\'' +
-                '}';
-    }
-
-    public void addFunction(@NotNull FunctionDescriptor functionDescriptor) {
-        getFunctionDescriptors().add(functionDescriptor);
-    }
-
-    @NotNull
-    public Set<FunctionDescriptor> getFunctionDescriptors() {
-        if (functionDescriptors == null) {
-            functionDescriptors = Sets.newLinkedHashSet();
-        }
-        return functionDescriptors;
-    }
-
-    @NotNull
-    @Override
-    public OverloadResolutionResult getPossiblyApplicableFunctions(@NotNull List<JetType> typeArguments, @NotNull List<JetType> positionedValueArgumentTypes) {
-        Set<FunctionDescriptor> functionDescriptors = getFunctionDescriptors();
-        if (functionDescriptors.isEmpty()) return OverloadResolutionResult.nameNotFound();
-
-        int typeArgCount = typeArguments.size();
-        int valueArgCount = positionedValueArgumentTypes.size();
-        List<FunctionDescriptor> result = new ArrayList<FunctionDescriptor>();
-        for (FunctionDescriptor functionDescriptor : functionDescriptors) {
-            // TODO : type argument inference breaks this logic
-            if (functionDescriptor.getTypeParameters().size() == typeArgCount) {
-                if (FunctionDescriptorUtil.getMinimumArity(functionDescriptor) <= valueArgCount &&
-                        valueArgCount <= FunctionDescriptorUtil.getMaximumArity(functionDescriptor)) {
-                    FunctionDescriptor substitutedFunctionDescriptor = FunctionDescriptorUtil.substituteFunctionDescriptor(typeArguments, functionDescriptor);
-                    assert substitutedFunctionDescriptor != null;
-                    result.add(substitutedFunctionDescriptor);
-                }
-            }
-        }
-        if (result.isEmpty()) {
-            assert !functionDescriptors.isEmpty();
-            if (functionDescriptors.size() == 1) {
-                return OverloadResolutionResult.singleFunctionArgumentMismatch(functionDescriptors.iterator().next());
-            }
-        }
-        if (result.size() == 1) {
-            return OverloadResolutionResult.success(result.get(0));
-        }
-        return OverloadResolutionResult.ambiguity(result);
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return functionDescriptors == null || functionDescriptors.isEmpty();
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java b/idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
deleted file mode 100644
index e62d5096a90..00000000000
--- a/idea/src/org/jetbrains/jet/lang/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package org.jetbrains.jet.lang.parsing;
-
-
-import com.intellij.lang.PsiBuilder;
-import com.intellij.lang.java.parser.JavaParserUtil.PsiBuilderAdapter;
-import com.intellij.psi.TokenType;
-import com.intellij.psi.tree.IElementType;
-import org.jetbrains.jet.lexer.JetTokens;
-
-import java.util.Stack;
-
-/**
- * @author abreslav
- */
-public class SemanticWhitespaceAwarePsiBuilderImpl extends PsiBuilderAdapter implements SemanticWhitespaceAwarePsiBuilder {
-    private final Stack<Boolean> newlinesEnabled = new Stack<Boolean>();
-
-    public SemanticWhitespaceAwarePsiBuilderImpl(final PsiBuilder delegate) {
-        super(delegate);
-        newlinesEnabled.push(true);
-    }
-
-    @Override
-    public boolean newlineBeforeCurrentToken() {
-        if (!newlinesEnabled.peek()) return false;
-        if (eof()) return true;
-        // TODO: maybe, memoize this somehow?
-        for (int i = 1; i <= getCurrentOffset(); i++) {
-            IElementType previousToken = rawLookup(-i);
-            if (previousToken == JetTokens.BLOCK_COMMENT
-                    || previousToken == JetTokens.DOC_COMMENT
-                    || previousToken == JetTokens.EOL_COMMENT) {
-                continue;
-            }
-            if (previousToken != TokenType.WHITE_SPACE) {
-                break;
-            }
-            int previousTokenStart = rawTokenTypeStart(-i);
-            int previousTokenEnd = rawTokenTypeStart(-i + 1);
-            assert previousTokenStart >= 0;
-            assert previousTokenEnd < getOriginalText().length();
-            for (int j = previousTokenStart; j < previousTokenEnd; j++) {
-                if (getOriginalText().charAt(j) == '\n') return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public void disableNewlines() {
-        newlinesEnabled.push(false);
-    }
-
-    @Override
-    public void enableNewlines() {
-        newlinesEnabled.push(true);
-    }
-
-    @Override
-    public void restoreNewlinesState() {
-        assert newlinesEnabled.size() > 1;
-        newlinesEnabled.pop();
-    }
-
-}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetArrayAccessExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetArrayAccessExpression.java
deleted file mode 100644
index 73504018d0b..00000000000
--- a/idea/src/org/jetbrains/jet/lang/psi/JetArrayAccessExpression.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package org.jetbrains.jet.lang.psi;
-
-import com.intellij.lang.ASTNode;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.psi.MultiRangeReference;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiReference;
-import com.intellij.psi.util.PsiTreeUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lexer.JetTokens;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * @author max
- */
-public class JetArrayAccessExpression extends JetReferenceExpression {
-    public JetArrayAccessExpression(@NotNull ASTNode node) {
-        super(node);
-    }
-
-    @Override
-    public PsiReference getReference() {
-        JetContainerNode indicesNode = getIndicesNode();
-        return indicesNode == null ? null : new JetArrayAccessReference();
-    }
-
-    @Override
-    public void accept(@NotNull JetVisitorVoid visitor) {
-        visitor.visitArrayAccessExpression(this);
-    }
-
-    @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
-        return visitor.visitArrayAccessExpression(this, data);
-    }
-
-    @NotNull
-    public JetExpression getArrayExpression() {
-        JetExpression baseExpression = findChildByClass(JetExpression.class);
-        assert baseExpression != null;
-        return baseExpression;
-    }
-
-    @NotNull
-    public List<JetExpression> getIndexExpressions() {
-        PsiElement container = getIndicesNode();
-        if (container == null) return Collections.emptyList();
-        return PsiTreeUtil.getChildrenOfTypeAsList(container, JetExpression.class);
-    }
-
-    public JetContainerNode getIndicesNode() {
-        return (JetContainerNode) findChildByType(JetNodeTypes.INDICES);
-    }
-
-    private class JetArrayAccessReference extends JetPsiReference implements MultiRangeReference {
-
-        @Override
-        public PsiElement getElement() {
-            return JetArrayAccessExpression.this;
-        }
-
-        @Override
-        public TextRange getRangeInElement() {
-            return getElement().getTextRange().shiftRight(-getElement().getTextOffset());
-        }
-
-        @Override
-        public List<TextRange> getRanges() {
-            List<TextRange> list = new ArrayList<TextRange>();
-
-            JetContainerNode indices = getIndicesNode();
-            TextRange textRange = indices.getNode().findChildByType(JetTokens.LBRACKET).getTextRange();
-            TextRange lBracketRange = textRange.shiftRight(-getTextOffset());
-
-            list.add(lBracketRange);
-
-            ASTNode rBracket = indices.getNode().findChildByType(JetTokens.RBRACKET);
-            if (rBracket != null) {
-                textRange = rBracket.getTextRange();
-                TextRange rBracketRange = textRange.shiftRight(-getTextOffset());
-                list.add(rBracketRange);
-            }
-
-            return list;
-        }
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetFunctionLiteralExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetFunctionLiteralExpression.java
deleted file mode 100644
index 8aaefd0e229..00000000000
--- a/idea/src/org/jetbrains/jet/lang/psi/JetFunctionLiteralExpression.java
+++ /dev/null
@@ -1,107 +0,0 @@
-package org.jetbrains.jet.lang.psi;
-
-import com.intellij.lang.ASTNode;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetNodeTypes;
-
-/**
- * @author max
- */
-public class JetFunctionLiteralExpression extends JetExpression implements JetDeclarationWithBody {
-    public JetFunctionLiteralExpression(@NotNull ASTNode node) {
-        super(node);
-    }
-
-    @Override
-    public void accept(@NotNull JetVisitorVoid visitor) {
-        visitor.visitFunctionLiteralExpression(this);
-    }
-
-    @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
-        return visitor.visitFunctionLiteralExpression(this, data);
-    }
-
-    @NotNull
-    public JetFunctionLiteral getFunctionLiteral() {
-        return (JetFunctionLiteral) findChildByType(JetNodeTypes.FUNCTION_LITERAL);
-    }
-
-//    //TODO: Due to the lack of multiple implementation inheritance these getters are copied from JetNamedFunction
-//    @Nullable
-//    public JetParameterList getValueParameterList() {
-//        return (JetParameterList) findChildByType(JetNodeTypes.VALUE_PARAMETER_LIST);
-//    }
-//
-//    @NotNull
-//    public List<JetParameter> getValueParameters() {
-//        JetParameterList list = getValueParameterList();
-//        return list != null ? list.getParameters() : Collections.<JetParameter>emptyList();
-//    }
-//
-//    @NotNull
-//    public ASTNode getBodyNode() {
-//        ASTNode answer = getNode().findChildByType(JetNodeTypes.BODY);
-//        assert answer != null;
-//        return answer;
-//    }
-//
-//    @NotNull
-//    public List<JetElement> getBody() {
-//        return PsiTreeUtil.getChildrenOfTypeAsList(getBodyNode().getPsi(), JetElement.class);
-//    }
-//
-//    @Nullable
-//    public JetTypeReference getReceiverTypeRef() {
-//        PsiElement child = getFirstChild();
-//        while (child != null) {
-//            IElementType tt = child.getNode().getElementType();
-//            if (tt == JetTokens.LPAR || tt == JetTokens.COLON) break;
-//            if (child instanceof JetTypeReference) {
-//                return (JetTypeReference) child;
-//            }
-//            child = child.getNextSibling();
-//        }
-//
-//        return null;
-//    }
-//
-//    @Nullable
-//    public JetTypeReference getReturnTypeRef() {
-//        boolean colonPassed = false;
-//        PsiElement child = getFirstChild();
-//        while (child != null) {
-//            IElementType tt = child.getNode().getElementType();
-//            if (tt == JetTokens.COLON) {
-//                colonPassed = true;
-//            }
-//            if (colonPassed && child instanceof JetTypeReference) {
-//                return (JetTypeReference) child;
-//            }
-//            child = child.getNextSibling();
-//        }
-//
-//        return null;
-//    }
-
-    @Override
-    public JetExpression getBodyExpression() {
-        return getFunctionLiteral().getBodyExpression();
-    }
-
-    @Override
-    public boolean hasBlockBody() {
-        return getFunctionLiteral().hasBlockBody();
-    }
-
-    @Override
-    public boolean hasDeclaredReturnType() {
-        return getFunctionLiteral().getReturnTypeRef() != null;
-    }
-
-    @NotNull
-    @Override
-    public JetElement asElement() {
-        return this;
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java
deleted file mode 100644
index 306bf6e8fb9..00000000000
--- a/idea/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java
+++ /dev/null
@@ -1,71 +0,0 @@
-package org.jetbrains.jet.lang.psi;
-
-import com.intellij.lang.ASTNode;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiReference;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingContextUtils;
-
-/**
- * @author abreslav
- */
-public abstract class JetReferenceExpression extends JetExpression {
-    public JetReferenceExpression(@NotNull ASTNode node) {
-        super(node);
-    }
-
-    protected PsiElement doResolve() {
-        JetFile file = (JetFile) getContainingFile();
-        BindingContext bindingContext = AnalyzingUtils.analyzeFileWithCache(file);
-        PsiElement psiElement = BindingContextUtils.resolveToDeclarationPsiElement(bindingContext, this);
-        return psiElement == null
-                ? file
-                : psiElement;
-    }
-
-    @Override
-    public abstract PsiReference getReference();
-
-    protected abstract class JetPsiReference implements PsiReference {
-
-        @Override
-        public PsiElement resolve() {
-            return doResolve();
-        }
-
-        @NotNull
-        @Override
-        public String getCanonicalText() {
-            return "<TBD>";
-        }
-
-        @Override
-        public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
-            throw new IncorrectOperationException();
-        }
-
-        @Override
-        public PsiElement bindToElement(@NotNull PsiElement element) throws IncorrectOperationException {
-            throw new IncorrectOperationException();
-        }
-
-        @Override
-        public boolean isReferenceTo(PsiElement element) {
-            return resolve() == element;
-        }
-
-        @NotNull
-        @Override
-        public Object[] getVariants() {
-            return EMPTY_ARRAY;
-        }
-
-        @Override
-        public boolean isSoft() {
-            return false;
-        }
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java
deleted file mode 100644
index 68bc5722149..00000000000
--- a/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java
+++ /dev/null
@@ -1,168 +0,0 @@
-package org.jetbrains.jet.lang.psi;
-
-import com.google.common.collect.Lists;
-import com.intellij.codeInsight.lookup.LookupElement;
-import com.intellij.codeInsight.lookup.LookupElementBuilder;
-import com.intellij.lang.ASTNode;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiReference;
-import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.tree.TokenSet;
-import com.intellij.util.Function;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.parsing.JetExpressionParsing;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lexer.JetTokens;
-import org.jetbrains.jet.resolve.DescriptorRenderer;
-
-import java.util.List;
-
-/**
- * @author max
- */
-public class JetSimpleNameExpression extends JetReferenceExpression {
-    public static final TokenSet REFERENCE_TOKENS = TokenSet.orSet(JetTokens.LABELS, TokenSet.create(JetTokens.IDENTIFIER, JetTokens.FIELD_IDENTIFIER, JetTokens.THIS_KEYWORD));
-
-    public JetSimpleNameExpression(@NotNull ASTNode node) {
-        super(node);
-    }
-
-    @Nullable @IfNotParsed
-    public String getReferencedName() {
-        PsiElement referencedNameElement = getReferencedNameElement();
-        if (referencedNameElement == null) {
-            return null;
-        }
-        String text = referencedNameElement.getNode().getText();
-        if (text.startsWith("`") && text.endsWith("`") && text.length() >= 2) {
-            return text.substring(1, text.length()-1);
-        }
-        return text;
-    }
-
-    @Nullable @IfNotParsed
-    public PsiElement getReferencedNameElement() {
-        PsiElement element = findChildByType(REFERENCE_TOKENS);
-        if (element == null) {
-            element = findChildByType(JetExpressionParsing.ALL_OPERATIONS);
-        }
-        return element;
-    }
-
-    @Nullable @IfNotParsed
-    public IElementType getReferencedNameElementType() {
-        PsiElement element = getReferencedNameElement();
-        return element == null ? null : element.getNode().getElementType();
-    }
-
-    @Override
-    public PsiReference findReferenceAt(int offset) {
-        return getReference();
-    }
-
-    @Override
-    public PsiReference getReference() {
-        return new JetPsiReference() {
-
-            @Override
-            public PsiElement getElement() {
-                return getReferencedNameElement();
-            }
-
-            @Override
-            public TextRange getRangeInElement() {
-                return new TextRange(0, getElement().getTextLength());
-            }
-
-            @NotNull
-            @Override
-            public Object[] getVariants() {
-                PsiElement parent = getParent();
-                if (parent instanceof JetQualifiedExpression) {
-                    JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) parent;
-                    JetExpression receiverExpression = qualifiedExpression.getReceiverExpression();
-                    JetFile file = (JetFile) getContainingFile();
-                    BindingContext bindingContext = AnalyzingUtils.analyzeFileWithCache(file);
-                    final JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, receiverExpression);
-                    if (expressionType != null) {
-                        return collectLookupElements(bindingContext, expressionType.getMemberScope());
-                    }
-                }
-                else {
-                    JetFile file = (JetFile) getContainingFile();
-                    BindingContext bindingContext = AnalyzingUtils.analyzeFileWithCache(file);
-                    JetScope resolutionScope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, JetSimpleNameExpression.this);
-                    if (resolutionScope != null) {
-                        return collectLookupElements(bindingContext, resolutionScope);
-                    }
-                }
-
-                return EMPTY_ARRAY;
-            }
-
-            @Override
-            public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
-                PsiElement element = JetChangeUtil.createNameIdentifier(getProject(), newElementName);
-                return getReferencedNameElement().replace(element);
-            }
-        };
-    }
-
-    private Object[] collectLookupElements(BindingContext bindingContext, JetScope scope) {
-        List<LookupElement> result = Lists.newArrayList();
-        for (final DeclarationDescriptor descriptor : scope.getAllDescriptors()) {
-            PsiElement declaration = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, descriptor.getOriginal());
-            LookupElementBuilder element = LookupElementBuilder.create(descriptor.getName());
-            String typeText = "";
-            String tailText = "";
-            boolean tailTextGrayed = false;
-            if (descriptor instanceof FunctionDescriptor) {
-                FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
-                JetType returnType = functionDescriptor.getReturnType();
-                typeText = DescriptorRenderer.TEXT.renderType(returnType);
-                tailText = "(" + StringUtil.join(functionDescriptor.getValueParameters(), new Function<ValueParameterDescriptor, String>() {
-                    @Override
-                    public String fun(ValueParameterDescriptor valueParameterDescriptor) {
-                        return valueParameterDescriptor.getName() + ":" +
-                               DescriptorRenderer.TEXT.renderType(valueParameterDescriptor.getOutType());
-                    }
-                }, ",") + ")";
-            }
-            else if (descriptor instanceof VariableDescriptor) {
-                JetType outType = ((VariableDescriptor) descriptor).getOutType();
-                typeText = DescriptorRenderer.TEXT.renderType(outType);
-            }
-            else if (descriptor instanceof ClassDescriptor) {
-                tailText = " (" + DescriptorRenderer.getFQName(descriptor.getContainingDeclaration()) + ")";
-                tailTextGrayed = true;
-            }
-            else {
-                typeText = DescriptorRenderer.TEXT.render(descriptor);
-            }
-            element = element.setTailText(tailText, tailTextGrayed).setTypeText(typeText);
-            if (declaration != null) {
-                element = element.setIcon(declaration.getIcon(ICON_FLAG_OPEN | ICON_FLAG_VISIBILITY));
-            }
-            result.add(element);
-        }
-        return result.toArray();
-    }
-
-    @Override
-    public void accept(@NotNull JetVisitorVoid visitor) {
-        visitor.visitSimpleNameExpression(this);
-    }
-
-    @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
-        return visitor.visitSimpleNameExpression(this, data);
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetThisReferenceExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetThisReferenceExpression.java
deleted file mode 100644
index 97566a68106..00000000000
--- a/idea/src/org/jetbrains/jet/lang/psi/JetThisReferenceExpression.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package org.jetbrains.jet.lang.psi;
-
-import com.intellij.lang.ASTNode;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiReference;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * @author abreslav
- */
-public class JetThisReferenceExpression extends JetReferenceExpression {
-    public JetThisReferenceExpression(@NotNull ASTNode node) {
-        super(node);
-    }
-
-    @Override
-    public PsiReference getReference() {
-        return new JetPsiReference() {
-
-            @Override
-            public PsiElement getElement() {
-                return JetThisReferenceExpression.this;
-            }
-
-            @Override
-            public TextRange getRangeInElement() {
-                return new TextRange(0, getElement().getTextLength());
-            }
-        };
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/psi/ValueArgumentPsi.java b/idea/src/org/jetbrains/jet/lang/psi/ValueArgumentPsi.java
deleted file mode 100644
index 613431c6b09..00000000000
--- a/idea/src/org/jetbrains/jet/lang/psi/ValueArgumentPsi.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package org.jetbrains.jet.lang.psi;
-
-import com.intellij.psi.PsiElement;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * @author abreslav
- */
-public interface ValueArgumentPsi {
-
-    class ArgumentExpressionWrapper implements ValueArgumentPsi {
-
-        private final JetExpression expression;
-
-        public ArgumentExpressionWrapper(JetExpression expression) {
-            this.expression = expression;
-        }
-
-        @Override
-        public PsiElement asElement() {
-            return expression;
-        }
-
-        @Override
-        public String getArgumentName() {
-            return null;
-        }
-
-        @Override
-        public boolean isNamed() {
-            return false;
-        }
-
-        @Override
-        public JetExpression getArgumentExpression() {
-            return expression;
-        }
-    }
-
-    PsiElement asElement();
-    @Nullable
-    String getArgumentName();
-
-    boolean isNamed();
-
-    @Nullable
-    public JetExpression getArgumentExpression();
-}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java
deleted file mode 100644
index ef21ee997f0..00000000000
--- a/idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java
+++ /dev/null
@@ -1,107 +0,0 @@
-package org.jetbrains.jet.lang.resolve;
-
-import com.intellij.psi.PsiElement;
-import org.jetbrains.jet.lang.JetDiagnostic;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.util.*;
-
-import java.util.Collection;
-
-/**
- * @author abreslav
- */
-public interface BindingContext {
-    WritableSlice<JetAnnotationEntry, AnnotationDescriptor> ANNOTATION = ManyMapSlices.createSimpleSlice("ANNOTATION");
-    WritableSlice<JetExpression, CompileTimeConstant<?>> COMPILE_TIME_VALUE = ManyMapSlices.createSimpleSlice("COMPILE_TIME_VALUE");
-    WritableSlice<JetTypeReference, JetType> TYPE = ManyMapSlices.createSimpleSlice("TYPE");
-    WritableSlice<JetExpression, JetType> EXPRESSION_TYPE = new BasicWritableSlice<JetExpression, JetType>("EXPRESSION_TYPE", RewritePolicy.DO_NOTHING);
-    WritableSlice<JetReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET = new BasicWritableSlice<JetReferenceExpression, DeclarationDescriptor>("REFERENCE_TARGET", RewritePolicy.DO_NOTHING);
-    WritableSlice<JetExpression, JetType> AUTOCAST = ManyMapSlices.createSimpleSlice("AUTOCAST");
-    WritableSlice<JetExpression, JetScope> RESOLUTION_SCOPE = ManyMapSlices.createSimpleSlice("RESOLUTION_SCOPE");
-
-    WritableSlice<JetExpression, Boolean> VARIABLE_REASSIGNMENT = ManyMapSlices.createSimpleSetSlice("VARIABLE_REASSIGNMENT");
-    WritableSlice<JetExpression, Boolean> PROCESSED = ManyMapSlices.createSimpleSetSlice("PROCESSED");
-    WritableSlice<JetElement, Boolean> STATEMENT = ManyMapSlices.createRemovableSetSlice("STATEMENT");
-
-    WritableSlice<PropertyDescriptor, Boolean> BACKING_FIELD_REQUIRED = new ManyMapSlices.SetSlice<PropertyDescriptor>("BACKING_FIELD_REQUIRED", RewritePolicy.DO_NOTHING) {
-        @Override
-        public Boolean computeValue(ManyMap map, PropertyDescriptor propertyDescriptor, Boolean backingFieldRequired, boolean valueNotFound) {
-            backingFieldRequired = valueNotFound ? false : backingFieldRequired;
-            assert backingFieldRequired != null;
-            PsiElement declarationPsiElement = map.get(DESCRIPTOR_TO_DECLARATION, propertyDescriptor);
-            if (declarationPsiElement instanceof JetParameter) {
-                JetParameter jetParameter = (JetParameter) declarationPsiElement;
-                return jetParameter.getValOrVarNode() != null ||
-                       backingFieldRequired;
-            }
-            if (propertyDescriptor.getModifiers().isAbstract()) return false;
-            PropertyGetterDescriptor getter = propertyDescriptor.getGetter();
-            PropertySetterDescriptor setter = propertyDescriptor.getSetter();
-            if (getter == null) {
-                return true;
-            }
-            else if (propertyDescriptor.isVar() && setter == null) {
-                return true;
-            }
-            else if (setter != null && !setter.hasBody() && !setter.getModifiers().isAbstract()) {
-                return true;
-            }
-            else if (!getter.hasBody() && !getter.getModifiers().isAbstract()) {
-                return true;
-            }
-            return backingFieldRequired;
-        }
-    };
-
-    WritableSlice<JetFunctionLiteralExpression, Boolean> BLOCK = new ManyMapSlices.SetSlice<JetFunctionLiteralExpression>("BLOCK", RewritePolicy.DO_NOTHING) {
-        @Override
-        public Boolean computeValue(ManyMap map, JetFunctionLiteralExpression expression, Boolean isBlock, boolean valueNotFound) {
-            isBlock = valueNotFound ? false : isBlock;
-            assert isBlock != null;
-            return isBlock && !expression.getFunctionLiteral().hasParameterSpecification();
-        }
-    };
-
-    ManyMapSlices.KeyNormalizer<DeclarationDescriptor> DECLARATION_DESCRIPTOR_NORMALIZER = new ManyMapSlices.KeyNormalizer<DeclarationDescriptor>() {
-        @Override
-        public DeclarationDescriptor normalize(DeclarationDescriptor declarationDescriptor) {
-            if (declarationDescriptor instanceof VariableAsFunctionDescriptor) {
-                VariableAsFunctionDescriptor descriptor = (VariableAsFunctionDescriptor) declarationDescriptor;
-                return descriptor.getVariableDescriptor().getOriginal();
-            }
-            return declarationDescriptor.getOriginal();
-        }
-    };
-    ReadOnlySlice<DeclarationDescriptor, PsiElement> DESCRIPTOR_TO_DECLARATION = ManyMapSlices.<DeclarationDescriptor, PsiElement>sliceBuilder("DECLARATION_TO_DESCRIPTOR").setKeyNormalizer(DECLARATION_DESCRIPTOR_NORMALIZER).build();
-
-    WritableSlice<PsiElement, NamespaceDescriptor> NAMESPACE = ManyMapSlices.<PsiElement, NamespaceDescriptor>sliceBuilder("DECLARATION").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<PsiElement, ClassDescriptor> CLASS = ManyMapSlices.<PsiElement, ClassDescriptor>sliceBuilder("CLASS").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<JetTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = ManyMapSlices.<JetTypeParameter, TypeParameterDescriptor>sliceBuilder("TYPE_PARAMETER").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<PsiElement, FunctionDescriptor> FUNCTION = ManyMapSlices.<PsiElement, FunctionDescriptor>sliceBuilder("FUNCTION").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<PsiElement, ConstructorDescriptor> CONSTRUCTOR = ManyMapSlices.<PsiElement, ConstructorDescriptor>sliceBuilder("CONSTRUCTOR").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<PsiElement, VariableDescriptor> VARIABLE = ManyMapSlices.<PsiElement, VariableDescriptor>sliceBuilder("VARIABLE").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<JetParameter, VariableDescriptor> VALUE_PARAMETER = ManyMapSlices.<JetParameter, VariableDescriptor>sliceBuilder("VALUE_PARAMETER").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<JetPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR = ManyMapSlices.<JetPropertyAccessor, PropertyAccessorDescriptor>sliceBuilder("PROPERTY_ACCESSOR").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-
-    // normalize value to getOriginal(value)
-    WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER = ManyMapSlices.<PsiElement, PropertyDescriptor>sliceBuilder("PRIMARY_CONSTRUCTOR_PARAMETER").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<JetObjectDeclarationName, PropertyDescriptor> OBJECT_DECLARATION = ManyMapSlices.<JetObjectDeclarationName, PropertyDescriptor>sliceBuilder("OBJECT_DECLARATION").setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-
-    WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] {
-        NAMESPACE, CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PRIMARY_CONSTRUCTOR_PARAMETER, OBJECT_DECLARATION
-    };
-
-    ReadOnlySlice<PsiElement, DeclarationDescriptor> DECLARATION_TO_DESCRIPTOR = ManyMapSlices.<PsiElement, DeclarationDescriptor>sliceBuilder("DECLARATION_TO_DESCRIPTOR")
-            .setFurtherLookupSlices(DECLARATIONS_TO_DESCRIPTORS).build();
-
-    WritableSlice<JetReferenceExpression, PsiElement> LABEL_TARGET = ManyMapSlices.<JetReferenceExpression, PsiElement>sliceBuilder("LABEL_TARGET").build();
-    WritableSlice<JetParameter, PropertyDescriptor> VALUE_PARAMETER_AS_PROPERTY = ManyMapSlices.<JetParameter, PropertyDescriptor>sliceBuilder("VALUE_PARAMETER_AS_PROPERTY").build();
-
-    Collection<JetDiagnostic> getDiagnostics();
-
-    <K, V> V get(ReadOnlySlice<K, V> slice, K key);
-}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/idea/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java
deleted file mode 100644
index 3fdd90e670e..00000000000
--- a/idea/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package org.jetbrains.jet.lang.resolve;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.*;
-
-/**
- * @author abreslav
- */
-public class DescriptorUtils {
-    public static boolean definesItsOwnThis(@NotNull DeclarationDescriptor descriptor) {
-        return descriptor.accept(new DeclarationDescriptorVisitor<Boolean, Void>() {
-            @Override
-            public Boolean visitDeclarationDescriptor(DeclarationDescriptor descriptor, Void data) {
-                return false;
-            }
-
-            @Override
-            public Boolean visitFunctionDescriptor(FunctionDescriptor descriptor, Void data) {
-                return descriptor.getReceiverType() != null;
-            }
-
-            @Override
-            public Boolean visitClassDescriptor(ClassDescriptor descriptor, Void data) {
-                return true;
-            }
-
-            @Override
-            public Boolean visitPropertyDescriptor(PropertyDescriptor descriptor, Void data) {
-                return descriptor.getReceiverType() != null;
-            }
-        }, null);
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/OverloadDomain.java b/idea/src/org/jetbrains/jet/lang/resolve/OverloadDomain.java
deleted file mode 100644
index 5602e47c799..00000000000
--- a/idea/src/org/jetbrains/jet/lang/resolve/OverloadDomain.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package org.jetbrains.jet.lang.resolve;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.types.JetType;
-
-import java.util.List;
-import java.util.Map;
-
-/**
- * @author abreslav
- */
-public interface OverloadDomain {
-
-    OverloadDomain EMPTY = new OverloadDomain() {
-        @NotNull
-        @Override
-        public OverloadResolutionResult getFunctionDescriptorForNamedArguments(@NotNull List<JetType> typeArguments, @NotNull Map<String, JetType> valueArgumentTypes, @Nullable JetType functionLiteralArgumentType) {
-            return OverloadResolutionResult.nameNotFound();
-        }
-
-        @NotNull
-        @Override
-        public OverloadResolutionResult getFunctionDescriptorForPositionedArguments(@NotNull List<JetType> typeArguments, @NotNull List<JetType> positionedValueArgumentTypes) {
-            return OverloadResolutionResult.nameNotFound();
-        }
-
-        @Override
-        public boolean isEmpty() {
-            return true;
-        }
-    };
-
-    /**
-     * @return A function descriptor with NO type parameters (they are already substituted) wrapped together with a result code
-     */
-    @NotNull
-    OverloadResolutionResult getFunctionDescriptorForNamedArguments(
-            @NotNull List<JetType> typeArguments,
-            @NotNull Map<String, JetType> valueArgumentTypes,
-            @Nullable JetType functionLiteralArgumentType);
-
-    /**
-     * @return A function descriptor with NO type parameters (they are already substituted) wrapped together with a result code
-     */
-    @NotNull
-    OverloadResolutionResult getFunctionDescriptorForPositionedArguments(
-            @NotNull List<JetType> typeArguments,
-            @NotNull List<JetType> positionedValueArgumentTypes);
-
-    /**
-     * @return true if the domain is empty
-     */
-    boolean isEmpty();
-}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolutionResult.java b/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolutionResult.java
deleted file mode 100644
index 191f6943a42..00000000000
--- a/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolutionResult.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package org.jetbrains.jet.lang.resolve;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-
-import java.util.Collection;
-import java.util.Collections;
-
-/**
-* @author abreslav
-*/
-public class OverloadResolutionResult {
-    public enum Code {
-        SUCCESS(true),
-        NAME_NOT_FOUND(false),
-        SINGLE_FUNCTION_ARGUMENT_MISMATCH(false),
-        AMBIGUITY(false);
-
-        private final boolean success;
-
-        Code(boolean success) {
-            this.success = success;
-        }
-
-        boolean isSuccess() {
-            return success;
-        }
-
-    }
-
-    public static OverloadResolutionResult success(@NotNull FunctionDescriptor functionDescriptor) {
-        return new OverloadResolutionResult(Code.SUCCESS, Collections.singleton(functionDescriptor));
-    }
-
-    public static OverloadResolutionResult nameNotFound() {
-        return new OverloadResolutionResult(Code.NAME_NOT_FOUND, Collections.<FunctionDescriptor>emptyList());
-    }
-    public static OverloadResolutionResult singleFunctionArgumentMismatch(FunctionDescriptor functionDescriptor) {
-        return new OverloadResolutionResult(Code.SINGLE_FUNCTION_ARGUMENT_MISMATCH, Collections.singleton(functionDescriptor));
-    }
-
-    public static OverloadResolutionResult ambiguity(Collection<FunctionDescriptor> functionDescriptors) {
-        return new OverloadResolutionResult(Code.AMBIGUITY, functionDescriptors);
-    }
-
-    private final Collection<FunctionDescriptor> functionDescriptors;
-
-    private final Code resultCode;
-
-    public OverloadResolutionResult(@NotNull Code resultCode, @NotNull Collection<FunctionDescriptor> functionDescriptors) {
-        this.functionDescriptors = functionDescriptors;
-        this.resultCode = resultCode;
-
-    }
-
-    @NotNull
-    public Collection<FunctionDescriptor> getFunctionDescriptors() {
-        return functionDescriptors;
-    }
-
-    @NotNull
-    public FunctionDescriptor getFunctionDescriptor() {
-        assert singleFunction();
-        return functionDescriptors.iterator().next();
-    }
-
-    @NotNull
-    public Code getResultCode() {
-        return resultCode;
-    }
-
-    public boolean isSuccess() {
-        return resultCode.isSuccess();
-    }
-
-    public boolean singleFunction() {
-        return isSuccess() || resultCode == Code.SINGLE_FUNCTION_ARGUMENT_MISMATCH;
-    }
-
-    public boolean isNothing() {
-        return resultCode == Code.NAME_NOT_FOUND;
-    }
-
-    public boolean isAmbiguity() {
-        return resultCode == Code.AMBIGUITY;
-    }
-
-    public OverloadResolutionResult newContents(@NotNull Collection<FunctionDescriptor> functionDescriptors) {
-        return new OverloadResolutionResult(resultCode, functionDescriptors);
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java
deleted file mode 100644
index 432ec2cc843..00000000000
--- a/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java
+++ /dev/null
@@ -1,173 +0,0 @@
-package org.jetbrains.jet.lang.resolve;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionGroup;
-import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.JetTypeChecker;
-import org.jetbrains.jet.lang.types.TypeUtils;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-/**
- * @author abreslav
- */
-public class OverloadResolver {
-
-    private final JetTypeChecker typeChecker;
-
-    public OverloadResolver(JetTypeChecker typeChecker) {
-        this.typeChecker = typeChecker;
-    }
-
-    @NotNull
-    public OverloadDomain getOverloadDomain(@Nullable JetType receiverType, @NotNull JetScope outerScope, @NotNull String name) {
-        // TODO : extension lookup
-        JetScope scope = receiverType == null ? outerScope : new ScopeWithReceiver(outerScope, receiverType, typeChecker);
-
-        final FunctionGroup functionGroup = scope.getFunctionGroup(name);
-
-        return getOverloadDomain(receiverType, functionGroup);
-    }
-
-    @NotNull
-    public OverloadDomain getOverloadDomain(@Nullable final JetType receiverType, @NotNull final FunctionGroup functionGroup) {
-        if (functionGroup.isEmpty()) {
-            return OverloadDomain.EMPTY;
-        }
-
-        return new OverloadDomain() {
-            @NotNull
-            @Override
-            public OverloadResolutionResult getFunctionDescriptorForPositionedArguments(@NotNull final List<JetType> typeArguments, @NotNull List<JetType> positionedValueArgumentTypes) {
-                OverloadResolutionResult resolutionResult = functionGroup.getPossiblyApplicableFunctions(typeArguments, positionedValueArgumentTypes);
-                if (!resolutionResult.isAmbiguity() && !resolutionResult.isSuccess()) return resolutionResult;
-
-                Collection<FunctionDescriptor> possiblyApplicableFunctions = resolutionResult.getFunctionDescriptors();
-
-                if (possiblyApplicableFunctions.isEmpty()) {
-                    return OverloadResolutionResult.nameNotFound(); // TODO : it may be found, only the number of params did not match
-                }
-
-                List<FunctionDescriptor> applicable = new ArrayList<FunctionDescriptor>();
-
-                descLoop:
-                for (FunctionDescriptor descriptor : possiblyApplicableFunctions) {
-                    // ASSERT: type arguments are figured out and substituted by this time!!!
-                    assert descriptor.getTypeParameters().isEmpty();
-
-                    if (receiverType != null) {
-                        // ASSERT : either the receiver in not present or we are in a scope with no top-level functions
-                        JetType functionReceiverType = descriptor.getReceiverType();
-                        if (functionReceiverType != null) {
-                            functionReceiverType = TypeUtils.makeNullable(functionReceiverType); // Too look things up in T for T?, and later check receiver's nullability
-                            if (!typeChecker.isSubtypeOf(receiverType, functionReceiverType)) {
-                                continue;
-                            }
-                        }
-                    }
-                    else if (descriptor.getReceiverType() != null) {
-                        continue;
-                    }
-
-                    List<ValueParameterDescriptor> parameters = descriptor.getValueParameters();
-                    if (parameters.size() >= positionedValueArgumentTypes.size()) {
-                        // possibly, some default values
-                        // possibly, nothing passed to a vararg
-                        // possibly, a single value passed to a vararg
-                        // possibly an array/list/etc passed as a whole vararg
-                        for (int i = 0, positionedValueArgumentTypesSize = positionedValueArgumentTypes.size(); i < positionedValueArgumentTypesSize; i++) {
-                            JetType argumentType = positionedValueArgumentTypes.get(i);
-                            JetType parameterType = parameters.get(i).getOutType();
-                            // TODO : handle vararg cases here
-                            if (!typeChecker.isConvertibleTo(argumentType, parameterType)) {
-                                continue descLoop;
-                            }
-                        }
-                    } else {
-                        // vararg
-                        int nonVarargs = parameters.size() - 1;
-                        for (int i = 0; i < nonVarargs; i++) {
-                            JetType argumentType = positionedValueArgumentTypes.get(i);
-                            JetType parameterType = parameters.get(i).getOutType();
-                            if (!typeChecker.isConvertibleTo(argumentType, parameterType)) {
-                                continue descLoop;
-                            }
-                        }
-                        JetType varArgType = parameters.get(nonVarargs).getOutType();
-                        for (int i = nonVarargs, args = positionedValueArgumentTypes.size(); i < args; i++) {
-                            JetType argumentType = positionedValueArgumentTypes.get(i);
-                            if (!typeChecker.isConvertibleTo(argumentType, varArgType)) {
-                                continue descLoop;
-                            }
-                        }
-                    }
-                    applicable.add(descriptor);
-                }
-
-                if (applicable.size() == 0) {
-                    if (resolutionResult.singleFunction()) {
-                        return OverloadResolutionResult.singleFunctionArgumentMismatch(resolutionResult.getFunctionDescriptor());
-                    }
-                    return OverloadResolutionResult.nameNotFound();
-                } else if (applicable.size() == 1) {
-                    return OverloadResolutionResult.success(applicable.get(0));
-                } else {
-                    // TODO : varargs
-
-                    List<FunctionDescriptor> maximallySpecific = new ArrayList<FunctionDescriptor>();
-                    meLoop:
-                    for (FunctionDescriptor me : applicable) {
-                        for (FunctionDescriptor other : applicable) {
-                            if (other == me) continue;
-                            if (!moreSpecific(me, other) || moreSpecific(other, me)) continue meLoop;
-                        }
-                        maximallySpecific.add(me);
-                    }
-                    if (maximallySpecific.isEmpty()) {
-                        return OverloadResolutionResult.ambiguity(applicable);
-                    }
-                    if (maximallySpecific.size() == 1) {
-                        return OverloadResolutionResult.success(maximallySpecific.get(0));
-                    }
-                    throw new UnsupportedOperationException();
-                }
-            }
-
-            @Override
-            public boolean isEmpty() {
-                return functionGroup.isEmpty();
-            }
-
-            @NotNull
-            @Override
-            public OverloadResolutionResult getFunctionDescriptorForNamedArguments(@NotNull List<JetType> typeArguments, @NotNull Map<String, JetType> valueArgumentTypes, @Nullable JetType functionLiteralArgumentType) {
-                throw new UnsupportedOperationException(); // TODO
-            }
-        };
-    }
-
-    private boolean moreSpecific(FunctionDescriptor f, FunctionDescriptor g) {
-        List<ValueParameterDescriptor> fParams = f.getValueParameters();
-        List<ValueParameterDescriptor> gParams = g.getValueParameters();
-
-        int fSize = fParams.size();
-        if (fSize != gParams.size()) return false;
-        for (int i = 0; i < fSize; i++) {
-            JetType fParamType = fParams.get(i).getOutType();
-            JetType gParamType = gParams.get(i).getOutType();
-
-            // TODO : maybe isSubtypeOf is sufficient?
-            if (!typeChecker.isConvertibleTo(fParamType, gParamType)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java b/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java
deleted file mode 100644
index 32ef6ae7b1b..00000000000
--- a/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java
+++ /dev/null
@@ -1,87 +0,0 @@
-package org.jetbrains.jet.lang.resolve;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.JetTypeChecker;
-
-/**
- * @author abreslav
- */
-public class ScopeWithReceiver extends JetScopeImpl {
-
-    private final JetType receiverType;
-    private final JetScope outerScope;
-    private final JetTypeChecker typeChecker;
-
-    public ScopeWithReceiver(@NotNull JetScope outerScope, @NotNull JetType receiverType, @NotNull JetTypeChecker typeChecker) {
-        this.outerScope = outerScope;
-        this.receiverType = receiverType;
-        this.typeChecker = typeChecker;
-    }
-
-    @NotNull
-    @Override
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        JetScope memberScope = receiverType.getMemberScope();
-        FunctionGroup functionGroup = memberScope.getFunctionGroup(name);
-        if (functionGroup.isEmpty()) {
-            return outerScope.getFunctionGroup(name);
-//            return FunctionDescriptorUtil.filteredFunctionGroup(outerScope.getFunctionGroup(name),
-//                    new Function<FunctionDescriptor, Boolean>() {
-//                        @Override
-//                        public Boolean apply(@Nullable FunctionDescriptor functionDescriptor) {
-//                            if (functionDescriptor == null) return false;
-//                            JetType functionReceiverType = functionDescriptor.getReceiverType();
-//                            if (functionReceiverType == null) {
-//                                return false;
-//                            }
-//                            // TODO : in case of inferred type arguments, substitute the receiver type first
-//                            return typeChecker.startForPairOfTypes(receiverType, functionReceiverType);
-//                        }
-//                    });
-        }
-        return functionGroup; // TODO
-    }
-
-    @Override
-    public ClassifierDescriptor getClassifier(@NotNull String name) {
-        return receiverType.getMemberScope().getClassifier(name);
-    }
-
-    @Override
-    public VariableDescriptor getVariable(@NotNull String name) {
-        VariableDescriptor variable = receiverType.getMemberScope().getVariable(name);
-        if (variable != null) {
-            return variable;
-        }
-        variable = outerScope.getVariable(name);
-        if (variable instanceof PropertyDescriptor) {
-            PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variable;
-            JetType receiverType = propertyDescriptor.getReceiverType();
-            // TODO : in case of type arguments, substitute the receiver type first
-            if (receiverType != null
-                    && typeChecker.isSubtypeOf(receiverType, receiverType)) {
-                return variable;
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public NamespaceDescriptor getNamespace(@NotNull String name) {
-        return receiverType.getMemberScope().getNamespace(name);
-    }
-
-    @NotNull
-    @Override
-    public JetType getThisType() {
-        return receiverType;
-    }
-
-    @NotNull
-    @Override
-    public DeclarationDescriptor getContainingDeclaration() {
-        return outerScope.getContainingDeclaration();
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java b/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java
deleted file mode 100644
index 8790899191c..00000000000
--- a/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java
+++ /dev/null
@@ -1,102 +0,0 @@
-package org.jetbrains.jet.lang.resolve;
-
-import com.google.common.collect.Sets;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.*;
-
-import java.util.Collection;
-
-/**
- * @author abreslav
- */
-public class SubstitutingScope implements JetScope {
-
-    private final JetScope workerScope;
-//    private final Map<TypeConstructor, TypeProjection> substitutionContext;
-    private final TypeSubstitutor substitutor;
-    private Collection<DeclarationDescriptor> allDescriptors;
-
-    public SubstitutingScope(JetScope workerScope, @NotNull TypeSubstitutor substitutor) {
-        this.workerScope = workerScope;
-        this.substitutor = substitutor;
-    }
-
-    @Override
-    public VariableDescriptor getVariable(@NotNull String name) {
-        VariableDescriptor variable = workerScope.getVariable(name);
-        if (variable == null || substitutor.isEmpty()) {
-            return variable;
-        }
-
-        return variable.substitute(substitutor);
-    }
-
-    @Override
-    public ClassifierDescriptor getClassifier(@NotNull String name) {
-        ClassifierDescriptor descriptor = workerScope.getClassifier(name);
-        if (descriptor == null) {
-            return null;
-        }
-        if (descriptor instanceof ClassDescriptor) {
-            return new LazySubstitutingClassDescriptor((ClassDescriptor) descriptor, substitutor);
-        }
-        throw new UnsupportedOperationException(); // TODO
-    }
-
-    @Override
-    public NamespaceDescriptor getNamespace(@NotNull String name) {
-        return workerScope.getNamespace(name); // TODO
-    }
-
-    @NotNull
-    @Override
-    public JetType getThisType() {
-        throw new UnsupportedOperationException(); // TODO
-    }
-
-    @NotNull
-    @Override
-    public FunctionGroup getFunctionGroup(@NotNull String name) {
-        FunctionGroup functionGroup = workerScope.getFunctionGroup(name);
-        if (substitutor.isEmpty()) {
-            return functionGroup;
-        }
-        return new LazySubstitutingFunctionGroup(substitutor, functionGroup);
-    }
-
-    @NotNull
-    @Override
-    public DeclarationDescriptor getContainingDeclaration() {
-        return workerScope.getContainingDeclaration();
-    }
-
-    @NotNull
-    @Override
-    public Collection<DeclarationDescriptor> getDeclarationsByLabel(String labelName) {
-        throw new UnsupportedOperationException(); // TODO
-    }
-
-    @Override
-    public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) {
-        throw new UnsupportedOperationException(); // TODO
-    }
-
-    @Override
-    @Nullable
-    public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() {
-        return workerScope.getDeclarationDescriptorForUnqualifiedThis();
-    }
-
-    @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
-        if (allDescriptors == null) {
-            allDescriptors = Sets.newHashSet();
-            for (DeclarationDescriptor descriptor : workerScope.getAllDescriptors()) {
-                allDescriptors.add(descriptor.substitute(substitutor));
-            }
-        }
-        return allDescriptors;
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
deleted file mode 100644
index 182d8731119..00000000000
--- a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
+++ /dev/null
@@ -1,914 +0,0 @@
-package org.jetbrains.jet.lang.resolve;
-
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.util.PsiTreeUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.JetSemanticServices;
-import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.types.ErrorUtils;
-import org.jetbrains.jet.lang.types.JetStandardClasses;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.JetTypeInferrer;
-import org.jetbrains.jet.lexer.JetTokens;
-import org.jetbrains.jet.util.WritableSlice;
-
-import java.util.*;
-
-/**
- * @author abreslav
- */
-public class TopDownAnalyzer {
-
-    private final Map<JetClass, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
-    private final Map<JetObjectDeclaration, MutableClassDescriptor> objects = Maps.newLinkedHashMap();
-    private final Map<JetNamespace, WritableScope> namespaceScopes = Maps.newHashMap();
-    private final Map<JetNamespace, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
-
-    private final Map<JetNamedFunction, FunctionDescriptorImpl> functions = Maps.newLinkedHashMap();
-    private final Map<JetDeclaration, ConstructorDescriptor> constructors = Maps.newLinkedHashMap();
-    private final Map<JetProperty, PropertyDescriptor> properties = Maps.newLinkedHashMap();
-    private final Map<JetDeclaration, JetScope> declaringScopes = Maps.newHashMap();
-    private final Set<PropertyDescriptor> primaryConstructorParameterProperties = Sets.newHashSet();
-
-    private final JetSemanticServices semanticServices;
-    private final ClassDescriptorResolver classDescriptorResolver;
-    private final BindingTrace trace;
-    private final BindingTraceAdapter traceForConstructors;
-    private final BindingTraceAdapter traceForMembers;
-
-    public TopDownAnalyzer(JetSemanticServices semanticServices, @NotNull BindingTrace bindingTrace) {
-        this.semanticServices = semanticServices;
-        this.classDescriptorResolver = semanticServices.getClassDescriptorResolver(bindingTrace);
-        this.trace = bindingTrace;
-
-        // This allows access to backing fields
-        this.traceForConstructors = new BindingTraceAdapter(bindingTrace).addHandler(BindingContext.REFERENCE_TARGET, new BindingTraceAdapter.RecordHandler<JetReferenceExpression, DeclarationDescriptor>() {
-            @Override
-            public void handleRecord(WritableSlice<JetReferenceExpression, DeclarationDescriptor> slice, JetReferenceExpression expression, DeclarationDescriptor descriptor) {
-                if (expression instanceof JetSimpleNameExpression) {
-                    JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression;
-                    if (simpleNameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
-                        if (!trace.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, (PropertyDescriptor) descriptor)) {
-                            TopDownAnalyzer.this.trace.getErrorHandler().genericError(expression.getNode(), "This property does not have a backing field");
-                        }
-                    }
-                }
-            }
-        });
-
-        // This tracks access to properties in order to register primary constructor parameters that yield real fields (JET-9)
-        this.traceForMembers = new BindingTraceAdapter(bindingTrace).addHandler(BindingContext.REFERENCE_TARGET, new BindingTraceAdapter.RecordHandler<JetReferenceExpression, DeclarationDescriptor>() {
-            @Override
-            public void handleRecord(WritableSlice<JetReferenceExpression, DeclarationDescriptor> slice, JetReferenceExpression expression, DeclarationDescriptor descriptor) {
-                if (descriptor instanceof PropertyDescriptor) {
-                    PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
-                    if (primaryConstructorParameterProperties.contains(propertyDescriptor)) {
-                        traceForMembers.record(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor);
-                    }
-                }
-            }
-        });
-    }
-
-    @Deprecated // For JetStandardLibraryOnly
-    public void processStandardLibraryNamespace(@NotNull WritableScope outerScope, @NotNull NamespaceDescriptorImpl standardLibraryNamespace, @NotNull JetNamespace namespace) {
-        namespaceScopes.put(namespace, standardLibraryNamespace.getMemberScope());
-        namespaceDescriptors.put(namespace, standardLibraryNamespace);
-        process(outerScope, standardLibraryNamespace, namespace.getDeclarations());
-    }
-
-    public void processObject(@NotNull JetScope outerScope, @NotNull DeclarationDescriptor containingDeclaration, @NotNull JetObjectDeclaration object) {
-        process(outerScope, new NamespaceLike.Adapter(containingDeclaration) {
-
-                    @Override
-                    public NamespaceDescriptorImpl getNamespace(String name) {
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) {
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
-
-                    }
-
-                    @Override
-                    public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
-                        throw new UnsupportedOperationException();
-                    }
-
-                    @Override
-                    public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
-
-                    }
-
-                    @Override
-                    public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
-                        return ClassObjectStatus.NOT_ALLOWED;
-                    }
-                }, Collections.<JetDeclaration>singletonList(object));
-    }
-
-    public void process(@NotNull JetScope outerScope, NamespaceLike owner, @NotNull List<JetDeclaration> declarations) {
-        collectNamespacesAndClassifiers(outerScope, owner, declarations); // namespaceScopes, classes
-
-        createTypeConstructors(); // create type constructors for classes and generic parameters
-        resolveTypesInClassHeaders(); // Generic bounds and types in supertype lists (no expressions or constructor resolution)
-        checkGenericBoundsInClassHeaders(); // For the types resolved so far
-
-        resolveFunctionAndPropertyHeaders(); // Constructor headers are resolved as well
-
-        resolveBehaviorDeclarationBodies();
-    }
-
-    private void collectNamespacesAndClassifiers(
-            @NotNull final JetScope outerScope,
-            @NotNull final NamespaceLike owner,
-            @NotNull Collection<JetDeclaration> declarations) {
-        for (JetDeclaration declaration : declarations) {
-            declaration.accept(new JetVisitorVoid() {
-                @Override
-                public void visitNamespace(JetNamespace namespace) {
-
-                    String name = namespace.getName();
-                    if (name == null) {
-                        name = "<no name provided>";
-                    }
-                    NamespaceDescriptorImpl namespaceDescriptor = owner.getNamespace(name);
-                    if (namespaceDescriptor == null) {
-                        namespaceDescriptor = new NamespaceDescriptorImpl(
-                                owner.getOriginal(),
-                                Collections.<AnnotationDescriptor>emptyList(), // TODO
-                                name
-                        );
-                        namespaceDescriptor.initialize(new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, trace.getErrorHandler()).setDebugName("Namespace member scope"));
-                        owner.addNamespace(namespaceDescriptor);
-                        trace.record(BindingContext.NAMESPACE, namespace, namespaceDescriptor);
-                    }
-                    namespaceDescriptors.put(namespace, namespaceDescriptor);
-
-                    WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), trace.getErrorHandler());
-                    namespaceScopes.put(namespace, namespaceScope);
-
-                    processImports(namespace, namespaceScope, outerScope);
-
-                    collectNamespacesAndClassifiers(namespaceScope, namespaceDescriptor, namespace.getDeclarations());
-                }
-
-                @Override
-                public void visitClass(JetClass klass) {
-                    MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(trace, owner, outerScope);
-
-                    if (klass.hasModifier(JetTokens.ENUM_KEYWORD)) {
-                        MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor(trace, mutableClassDescriptor, outerScope, true);
-                        classObjectDescriptor.setName("class-object-for-" + klass.getName());
-                        classObjectDescriptor.createTypeConstructor();
-                        createPrimaryConstructor(classObjectDescriptor);
-                        mutableClassDescriptor.setClassObjectDescriptor(classObjectDescriptor);
-                    }
-                    visitClassOrObject(
-                            klass,
-                            (Map) classes,
-                            owner,
-                            outerScope,
-                            mutableClassDescriptor);
-                    owner.addClassifierDescriptor(mutableClassDescriptor);
-                }
-
-                @Override
-                public void visitObjectDeclaration(JetObjectDeclaration declaration) {
-                    createClassDescriptorForObject(declaration, owner);
-                }
-
-                @Override
-                public void visitEnumEntry(JetEnumEntry enumEntry) {
-                    MutableClassDescriptor classObjectDescriptor = ((MutableClassDescriptor) owner).getClassObjectDescriptor();
-                    assert classObjectDescriptor != null : enumEntry.getParent().getText();
-                    if (enumEntry.getPrimaryConstructorParameterList() == null) {
-                        MutableClassDescriptor classDescriptor = createClassDescriptorForObject(enumEntry, classObjectDescriptor);
-                        objects.remove(enumEntry);
-                        classes.put(enumEntry, classDescriptor);
-                    }
-                    else {
-                        MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(trace, classObjectDescriptor, outerScope);
-                        visitClassOrObject(
-                                enumEntry,
-                                (Map) classes,
-                                classObjectDescriptor,
-                                outerScope,
-                                mutableClassDescriptor);
-                        classObjectDescriptor.addClassifierDescriptor(mutableClassDescriptor);
-                    }
-                }
-
-                private MutableClassDescriptor createClassDescriptorForObject(@NotNull JetClassOrObject declaration, @NotNull NamespaceLike owner) {
-                    MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(trace, owner, outerScope, true) {
-                        @Override
-                        public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
-                            return ClassObjectStatus.NOT_ALLOWED;
-                        }
-                    };
-                    visitClassOrObject(declaration, (Map) objects, owner, outerScope, mutableClassDescriptor);
-                    createPrimaryConstructor(mutableClassDescriptor);
-                    trace.record(BindingContext.CLASS, declaration, mutableClassDescriptor);
-                    return mutableClassDescriptor;
-                }
-
-                private void createPrimaryConstructor(MutableClassDescriptor mutableClassDescriptor) {
-                    ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(mutableClassDescriptor, Collections.<AnnotationDescriptor>emptyList(), true);
-                    constructorDescriptor.initialize(Collections.<TypeParameterDescriptor>emptyList(), Collections.<ValueParameterDescriptor>emptyList());
-                    // TODO : make the constructor private?
-                    mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor);
-                }
-
-                private void visitClassOrObject(@NotNull JetClassOrObject declaration, Map<JetClassOrObject, MutableClassDescriptor> map, NamespaceLike owner, JetScope outerScope, MutableClassDescriptor mutableClassDescriptor) {
-                    mutableClassDescriptor.setName(JetPsiUtil.safeName(declaration.getName()));
-
-                    map.put(declaration, mutableClassDescriptor);
-                    declaringScopes.put((JetDeclaration) declaration, outerScope);
-
-                    JetScope classScope = mutableClassDescriptor.getScopeForMemberResolution();
-                    collectNamespacesAndClassifiers(classScope, mutableClassDescriptor, declaration.getDeclarations());
-                }
-
-                @Override
-                public void visitTypedef(JetTypedef typedef) {
-                    trace.getErrorHandler().genericError(typedef.getNode(), "Unsupported [TopDownAnalyzer]");
-                }
-
-                @Override
-                public void visitClassObject(JetClassObject classObject) {
-                    JetObjectDeclaration objectDeclaration = classObject.getObjectDeclaration();
-                    if (objectDeclaration != null) {
-                        NamespaceLike.ClassObjectStatus status = owner.setClassObjectDescriptor(createClassDescriptorForObject(objectDeclaration, owner));
-                        switch (status) {
-                            case DUPLICATE:
-                                trace.getErrorHandler().genericError(classObject.getNode(), "Only one class object is allowed per class");
-                                break;
-                            case NOT_ALLOWED:
-                                trace.getErrorHandler().genericError(classObject.getNode(), "A class object is not allowed here");
-                                break;
-                        }
-                    }
-                }
-            });
-        }
-    }
-
-    private void processImports(@NotNull JetNamespace namespace, @NotNull WriteThroughScope namespaceScope, @NotNull JetScope outerScope) {
-        List<JetImportDirective> importDirectives = namespace.getImportDirectives();
-        for (JetImportDirective importDirective : importDirectives) {
-            if (importDirective.isAbsoluteInRootNamespace()) {
-                trace.getErrorHandler().genericError(namespace.getNode(), "Unsupported by TDA"); // TODO
-                continue;
-            }
-            if (importDirective.isAllUnder()) {
-                JetExpression importedReference = importDirective.getImportedReference();
-                if (importedReference != null) {
-                    JetTypeInferrer.Services typeInferrerServices = semanticServices.getTypeInferrerServices(trace, JetFlowInformationProvider.THROW_EXCEPTION);
-                    JetType type = typeInferrerServices.getTypeWithNamespaces(namespaceScope, importedReference, false);
-                    if (type != null) {
-                        namespaceScope.importScope(type.getMemberScope());
-                    }
-                }
-            }
-            else {
-                ClassifierDescriptor classifierDescriptor = null;
-                JetSimpleNameExpression referenceExpression = null;
-
-                JetExpression importedReference = importDirective.getImportedReference();
-                if (importedReference instanceof JetDotQualifiedExpression) {
-                    JetDotQualifiedExpression reference = (JetDotQualifiedExpression) importedReference;
-                    JetType type = semanticServices.getTypeInferrerServices(trace, JetFlowInformationProvider.THROW_EXCEPTION).getTypeWithNamespaces(namespaceScope, reference.getReceiverExpression(), false);
-                    JetExpression selectorExpression = reference.getSelectorExpression();
-                    if (selectorExpression != null) {
-                        referenceExpression = (JetSimpleNameExpression) selectorExpression;
-                        String referencedName = referenceExpression.getReferencedName();
-                        if (type != null && referencedName != null) {
-                            classifierDescriptor = type.getMemberScope().getClassifier(referencedName);
-                        }
-                    }
-                }
-                else {
-                    assert importedReference instanceof JetSimpleNameExpression;
-                    referenceExpression = (JetSimpleNameExpression) importedReference;
-
-                    String referencedName = referenceExpression.getReferencedName();
-                    if (referencedName != null) {
-                        classifierDescriptor = outerScope.getClassifier(referencedName);
-                    }
-                }
-
-                if (classifierDescriptor != null) {
-                    trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor);
-
-                    String aliasName = importDirective.getAliasName();
-                    String importedClassifierName = aliasName != null ? aliasName : classifierDescriptor.getName();
-                    namespaceScope.importClassifierAlias(importedClassifierName, classifierDescriptor);
-                }
-            }
-        }
-    }
-
-    private void createTypeConstructors() {
-        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
-            JetClass jetClass = entry.getKey();
-            MutableClassDescriptor descriptor = entry.getValue();
-            classDescriptorResolver.resolveMutableClassDescriptor(jetClass, descriptor);
-            descriptor.createTypeConstructor();
-        }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : objects.entrySet()) {
-            MutableClassDescriptor descriptor = entry.getValue();
-            descriptor.createTypeConstructor();
-        }
-    }
-
-    private void resolveTypesInClassHeaders() {
-        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
-            JetClass jetClass = entry.getKey();
-            MutableClassDescriptor descriptor = entry.getValue();
-            classDescriptorResolver.resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters());
-            classDescriptorResolver.resolveSupertypes(jetClass, descriptor);
-        }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : objects.entrySet()) {
-            JetClassOrObject jetClass = entry.getKey();
-            MutableClassDescriptor descriptor = entry.getValue();
-            classDescriptorResolver.resolveSupertypes(jetClass, descriptor);
-        }
-    }
-
-    private void checkGenericBoundsInClassHeaders() {
-        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
-            JetClass jetClass = entry.getKey();
-
-            for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) {
-                JetTypeReference typeReference = delegationSpecifier.getTypeReference();
-                if (typeReference != null) {
-                    JetType type = trace.getBindingContext().get(BindingContext.TYPE, typeReference);
-                    classDescriptorResolver.checkBounds(typeReference, type);
-                }
-            }
-
-            for (JetTypeParameter jetTypeParameter : jetClass.getTypeParameters()) {
-                JetTypeReference extendsBound = jetTypeParameter.getExtendsBound();
-                if (extendsBound != null) {
-                    JetType type = trace.getBindingContext().get(BindingContext.TYPE, extendsBound);
-                    if (type != null) {
-                        classDescriptorResolver.checkBounds(extendsBound, type);
-                    }
-                }
-            }
-
-            for (JetTypeConstraint constraint : jetClass.getTypeConstaints()) {
-                JetTypeReference extendsBound = constraint.getBoundTypeReference();
-                if (extendsBound != null) {
-                    JetType type = trace.getBindingContext().get(BindingContext.TYPE, extendsBound);
-                    if (type != null) {
-                        classDescriptorResolver.checkBounds(extendsBound, type);
-                    }
-                }
-            }
-        }
-    }
-
-    private void resolveFunctionAndPropertyHeaders() {
-        for (Map.Entry<JetNamespace, WritableScope> entry : namespaceScopes.entrySet()) {
-            JetNamespace namespace = entry.getKey();
-            WritableScope namespaceScope = entry.getValue();
-            NamespaceLike namespaceDescriptor = namespaceDescriptors.get(namespace);
-
-            resolveFunctionAndPropertyHeaders(namespace.getDeclarations(), namespaceScope, namespaceDescriptor);
-        }
-        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
-            JetClass jetClass = entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
-
-            resolveFunctionAndPropertyHeaders(jetClass.getDeclarations(), classDescriptor.getScopeForMemberResolution(), classDescriptor);
-            processPrimaryConstructor(classDescriptor, jetClass);
-            for (JetConstructor jetConstructor : jetClass.getSecondaryConstructors()) {
-                processSecondaryConstructor(classDescriptor, jetConstructor);
-            }
-        }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : objects.entrySet()) {
-            JetObjectDeclaration object = entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
-
-            resolveFunctionAndPropertyHeaders(object.getDeclarations(), classDescriptor.getScopeForMemberResolution(), classDescriptor);
-        }
-
-        // TODO : Extensions
-    }
-
-    private void resolveFunctionAndPropertyHeaders(@NotNull List<JetDeclaration> declarations, final @NotNull JetScope scope, final @NotNull NamespaceLike namespaceLike) {
-        for (JetDeclaration declaration : declarations) {
-            declaration.accept(new JetVisitorVoid() {
-                @Override
-                public void visitNamedFunction(JetNamedFunction function) {
-                    FunctionDescriptorImpl functionDescriptor = classDescriptorResolver.resolveFunctionDescriptor(namespaceLike, scope, function);
-                    namespaceLike.addFunctionDescriptor(functionDescriptor);
-                    functions.put(function, functionDescriptor);
-                    declaringScopes.put(function, scope);
-                }
-
-                @Override
-                public void visitProperty(JetProperty property) {
-                    PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolvePropertyDescriptor(namespaceLike, scope, property);
-                    namespaceLike.addPropertyDescriptor(propertyDescriptor);
-                    properties.put(property, propertyDescriptor);
-                    declaringScopes.put(property, scope);
-                }
-
-                @Override
-                public void visitObjectDeclaration(JetObjectDeclaration declaration) {
-                    PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(namespaceLike, declaration, objects.get(declaration));
-                    namespaceLike.addPropertyDescriptor(propertyDescriptor);
-                }
-
-                @Override
-                public void visitEnumEntry(JetEnumEntry enumEntry) {
-                    if (enumEntry.getPrimaryConstructorParameterList() == null) {
-                        PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(namespaceLike, enumEntry, classes.get(enumEntry));
-                        MutableClassDescriptor classObjectDescriptor = ((MutableClassDescriptor) namespaceLike).getClassObjectDescriptor();
-                        assert classObjectDescriptor != null;
-                        classObjectDescriptor.addPropertyDescriptor(propertyDescriptor);
-                    }
-                }
-            });
-        }
-    }
-
-    private void processPrimaryConstructor(MutableClassDescriptor classDescriptor, JetClass klass) {
-        if (!klass.hasPrimaryConstructor()) return;
-
-        // TODO : not all the parameters are real properties
-        JetScope memberScope = classDescriptor.getScopeForMemberResolution(); // TODO : this is REALLY questionable
-        ConstructorDescriptor constructorDescriptor = classDescriptorResolver.resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass);
-        for (JetParameter parameter : klass.getPrimaryConstructorParameters()) {
-            PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolvePrimaryConstructorParameterToAProperty(
-                    classDescriptor,
-                    memberScope,
-                    parameter
-            );
-            classDescriptor.addPropertyDescriptor(propertyDescriptor);
-            primaryConstructorParameterProperties.add(propertyDescriptor);
-        }
-        if (constructorDescriptor != null) {
-            classDescriptor.setPrimaryConstructor(constructorDescriptor);
-        }
-    }
-
-    private void processSecondaryConstructor(MutableClassDescriptor classDescriptor, JetConstructor constructor) {
-        ConstructorDescriptor constructorDescriptor = classDescriptorResolver.resolveSecondaryConstructorDescriptor(
-                classDescriptor.getScopeForMemberResolution(),
-                classDescriptor,
-                constructor);
-        classDescriptor.addConstructor(constructorDescriptor);
-        constructors.put(constructor, constructorDescriptor);
-        declaringScopes.put(constructor, classDescriptor.getScopeForMemberLookup());
-    }
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    private void resolveBehaviorDeclarationBodies() {
-        resolveDelegationSpecifierLists();
-        resolveClassAnnotations();
-
-        resolveAnonymousInitializers();
-        resolvePropertyDeclarationBodies();
-
-        resolveSecondaryConstructorBodies();
-        resolveFunctionBodies();
-
-        checkIfPrimaryConstructorIsNecessary();
-
-        bindOverrides();
-    }
-
-    private void bindOverrides() {
-        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
-            bindOverridesInAClass(entry.getValue());
-        }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : objects.entrySet()) {
-            bindOverridesInAClass(entry.getValue());
-        }
-    }
-
-    private void bindOverridesInAClass(MutableClassDescriptor classDescriptor) {
-
-        for (FunctionDescriptor declaredFunction : classDescriptor.getFunctions()) {
-            for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
-                FunctionDescriptor overridden = findFunctionOverridableBy(declaredFunction, supertype);
-                if (overridden != null) {
-                    ((FunctionDescriptorImpl) declaredFunction).addOverriddenFunction(overridden);
-                }
-            }
-        }
-    }
-
-    @Nullable
-    private FunctionDescriptor findFunctionOverridableBy(@NotNull FunctionDescriptor declaredFunction, @NotNull JetType supertype) {
-        FunctionGroup functionGroup = supertype.getMemberScope().getFunctionGroup(declaredFunction.getName());
-        for (FunctionDescriptor functionDescriptor : functionGroup.getFunctionDescriptors()) {
-            if (FunctionDescriptorUtil.isOverridableBy(semanticServices.getTypeChecker(), functionDescriptor, declaredFunction).isSuccess()) {
-                return functionDescriptor;
-            }
-        }
-        return null;
-    }
-
-    private void checkIfPrimaryConstructorIsNecessary() {
-        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
-            MutableClassDescriptor classDescriptor = entry.getValue();
-            JetClass jetClass = entry.getKey();
-            if (classDescriptor.getUnsubstitutedPrimaryConstructor() == null) {
-                for (PropertyDescriptor propertyDescriptor : classDescriptor.getProperties()) {
-                    if ((boolean) trace.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
-                        PsiElement nameIdentifier = jetClass.getNameIdentifier();
-                        if (nameIdentifier != null) {
-                            trace.getErrorHandler().genericError(nameIdentifier.getNode(),
-                                    "This class must have a primary constructor, because property " + propertyDescriptor.getName() + " has a backing field");
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    private void resolveDelegationSpecifierLists() {
-        // TODO : Make sure the same thing is not initialized twice
-        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
-            resolveDelegationSpecifierList(entry.getKey(), entry.getValue());
-        }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : objects.entrySet()) {
-            resolveDelegationSpecifierList(entry.getKey(), entry.getValue());
-        }
-    }
-
-    private void resolveDelegationSpecifierList(final JetClassOrObject jetClass, final MutableClassDescriptor descriptor) {
-        final ConstructorDescriptor primaryConstructor = descriptor.getUnsubstitutedPrimaryConstructor();
-        final JetScope scopeForConstructor = primaryConstructor == null
-                ? null
-                : getInnerScopeForConstructor(primaryConstructor, descriptor.getScopeForMemberResolution(), true);
-        final JetTypeInferrer.Services typeInferrer = semanticServices.getTypeInferrerServices(traceForConstructors, JetFlowInformationProvider.NONE); // TODO : flow
-
-        for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) {
-            delegationSpecifier.accept(new JetVisitorVoid() {
-                @Override
-                public void visitDelegationByExpressionSpecifier(JetDelegatorByExpressionSpecifier specifier) {
-                    JetExpression delegateExpression = specifier.getDelegateExpression();
-                    if (delegateExpression != null) {
-                        JetScope scope = scopeForConstructor == null ? descriptor.getScopeForMemberResolution() : scopeForConstructor;
-                        JetType type = typeInferrer.getType(scope, delegateExpression, false, JetTypeInferrer.NO_EXPECTED_TYPE);
-                        JetType supertype = trace.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
-                        if (type != null && !semanticServices.getTypeChecker().isSubtypeOf(type, supertype)) { // TODO : Convertible?
-                            trace.getErrorHandler().typeMismatch(delegateExpression, supertype, type);
-                        }
-                    }
-                }
-
-                @Override
-                public void visitDelegationToSuperCallSpecifier(JetDelegatorToSuperCall call) {
-                    JetTypeReference typeReference = call.getTypeReference();
-                    if (typeReference != null) {
-                        if (descriptor.getUnsubstitutedPrimaryConstructor() != null) {
-                            typeInferrer.checkTypeInitializerCall(scopeForConstructor, typeReference, call);
-                        }
-                        else {
-                            JetValueArgumentList valueArgumentList = call.getValueArgumentList();
-                            assert valueArgumentList != null;
-                            trace.getErrorHandler().genericError(valueArgumentList.getNode(),
-                                    "Class " + JetPsiUtil.safeName(jetClass.getName()) + " must have a constructor in order to be able to initialize supertypes");
-                        }
-                    }
-                }
-
-                @Override
-                public void visitDelegationToSuperClassSpecifier(JetDelegatorToSuperClass specifier) {
-                    JetType supertype = trace.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
-                    if (supertype != null) {
-                        DeclarationDescriptor declarationDescriptor = supertype.getConstructor().getDeclarationDescriptor();
-                        if (declarationDescriptor instanceof ClassDescriptor) {
-                            ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor;
-                            if (classDescriptor.hasConstructors() && !ErrorUtils.isError(classDescriptor.getTypeConstructor())) {
-                                trace.getErrorHandler().genericError(specifier.getNode(), "This type has a constructor, and thus must be initialized here");
-                            }
-                        }
-                        else {
-                            trace.getErrorHandler().genericError(specifier.getNode(), "Only classes may serve as supertypes");
-                        }
-
-                    }
-                }
-
-                @Override
-                public void visitDelegationToThisCall(JetDelegatorToThisCall thisCall) {
-                    throw new IllegalStateException("This-calls should be prohibited by the parser");
-                }
-
-                @Override
-                public void visitJetElement(JetElement element) {
-                    throw new UnsupportedOperationException(element.getText() + " : " + element);
-                }
-            });
-        }
-    }
-
-    private void resolveClassAnnotations() {
-
-    }
-
-    private void resolveAnonymousInitializers() {
-        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
-            resolveAnonymousInitializers(entry.getKey(), entry.getValue());
-        }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : objects.entrySet()) {
-            resolveAnonymousInitializers(entry.getKey(), entry.getValue());
-        }
-    }
-
-    private void resolveAnonymousInitializers(JetClassOrObject jetClassOrObject, MutableClassDescriptor classDescriptor) {
-        List<JetClassInitializer> anonymousInitializers = jetClassOrObject.getAnonymousInitializers();
-        if (jetClassOrObject.hasPrimaryConstructor()) {
-            ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
-            assert primaryConstructor != null;
-            final JetScope scopeForConstructor = getInnerScopeForConstructor(primaryConstructor, classDescriptor.getScopeForMemberResolution(), true);
-            JetTypeInferrer.Services typeInferrer = semanticServices.getTypeInferrerServices(traceForConstructors, JetFlowInformationProvider.NONE); // TODO : flow
-            for (JetClassInitializer anonymousInitializer : anonymousInitializers) {
-                typeInferrer.getType(scopeForConstructor, anonymousInitializer.getBody(), true, JetTypeInferrer.NO_EXPECTED_TYPE);
-            }
-        }
-        else {
-            for (JetClassInitializer anonymousInitializer : anonymousInitializers) {
-                trace.getErrorHandler().genericError(anonymousInitializer.getNode(), "Anonymous initializers are only allowed in the presence of a primary constructor");
-            }
-        }
-    }
-
-    private void resolveSecondaryConstructorBodies() {
-        for (Map.Entry<JetDeclaration, ConstructorDescriptor> entry : constructors.entrySet()) {
-            JetDeclaration declaration = entry.getKey();
-            ConstructorDescriptor descriptor = entry.getValue();
-
-            resolveSecondaryConstructorBody((JetConstructor) declaration, descriptor, ((MutableClassDescriptor) descriptor.getContainingDeclaration()).getScopeForMemberResolution());
-
-            assert descriptor.getReturnType() != null;
-        }
-    }
-
-    private void resolveSecondaryConstructorBody(JetConstructor declaration, final ConstructorDescriptor descriptor, final JetScope declaringScope) {
-        final JetScope functionInnerScope = getInnerScopeForConstructor(descriptor, declaringScope, false);
-
-        final JetTypeInferrer.Services typeInferrerForInitializers = semanticServices.getTypeInferrerServices(traceForConstructors, JetFlowInformationProvider.NONE);
-
-        JetClass containingClass = PsiTreeUtil.getParentOfType(declaration, JetClass.class);
-        assert containingClass != null : "This must be guaranteed by the parser";
-        if (!containingClass.hasPrimaryConstructor()) {
-            trace.getErrorHandler().genericError(declaration.getNameNode(), "A secondary constructor may appear only in a class that has a primary constructor");
-        }
-        else {
-            List<JetDelegationSpecifier> initializers = declaration.getInitializers();
-            if (initializers.isEmpty()) {
-                trace.getErrorHandler().genericError(declaration.getNameNode(), "Secondary constructors must have an initializer list");
-            }
-            else {
-                initializers.get(0).accept(new JetVisitorVoid() {
-                    @Override
-                    public void visitDelegationToSuperCallSpecifier(JetDelegatorToSuperCall call) {
-                        JetTypeReference typeReference = call.getTypeReference();
-                        if (typeReference != null) {
-                            typeInferrerForInitializers.checkTypeInitializerCall(functionInnerScope, typeReference, call);
-                        }
-                    }
-
-                    @Override
-                    public void visitDelegationToThisCall(JetDelegatorToThisCall call) {
-                        // TODO : check that there's no recursion in this() calls
-                        // TODO : check: if a this() call is present, no other initializers are allowed
-                        ClassDescriptor classDescriptor = descriptor.getContainingDeclaration();
-                        typeInferrerForInitializers.checkClassConstructorCall(
-                                functionInnerScope,
-                                call.getThisReference(),
-                                classDescriptor,
-                                classDescriptor.getDefaultType(),
-                                call);
-                    }
-
-                    @Override
-                    public void visitDelegationByExpressionSpecifier(JetDelegatorByExpressionSpecifier specifier) {
-                        trace.getErrorHandler().genericError(specifier.getNode(), "'by'-clause is only supported for primary constructors");
-                    }
-
-                    @Override
-                    public void visitDelegationToSuperClassSpecifier(JetDelegatorToSuperClass specifier) {
-                        trace.getErrorHandler().genericError(specifier.getNode(), "Constructor parameters required");
-                    }
-
-                    @Override
-                    public void visitDelegationSpecifier(JetDelegationSpecifier specifier) {
-                        throw new IllegalStateException();
-                    }
-                });
-                for (int i = 1, initializersSize = initializers.size(); i < initializersSize; i++) {
-                    JetDelegationSpecifier initializer = initializers.get(i);
-                    trace.getErrorHandler().genericError(initializer.getNode(), "Only one call to 'this(...)' is allowed");
-                }
-            }
-        }
-        JetExpression bodyExpression = declaration.getBodyExpression();
-        if (bodyExpression != null) {
-            classDescriptorResolver.computeFlowData(declaration, bodyExpression);
-            JetFlowInformationProvider flowInformationProvider = classDescriptorResolver.computeFlowData(declaration, bodyExpression);
-            JetTypeInferrer.Services typeInferrer = semanticServices.getTypeInferrerServices(traceForConstructors, flowInformationProvider);
-
-            typeInferrer.checkFunctionReturnType(functionInnerScope, declaration, JetStandardClasses.getUnitType());
-        }
-    }
-
-    @NotNull
-    private JetScope getInnerScopeForConstructor(@NotNull ConstructorDescriptor descriptor, @NotNull JetScope declaringScope, boolean primary) {
-        WritableScope constructorScope = new WritableScopeImpl(declaringScope, declaringScope.getContainingDeclaration(), trace.getErrorHandler()).setDebugName("Inner scope for constructor");
-        for (PropertyDescriptor propertyDescriptor : ((MutableClassDescriptor) descriptor.getContainingDeclaration()).getProperties()) {
-            constructorScope.addPropertyDescriptorByFieldName("$" + propertyDescriptor.getName(), propertyDescriptor);
-        }
-
-        constructorScope.setThisType(descriptor.getContainingDeclaration().getDefaultType());
-
-        for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getValueParameters()) {
-            JetParameter parameter = (JetParameter) trace.getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, valueParameterDescriptor);
-            if (parameter.getValOrVarNode() == null || !primary) {
-                constructorScope.addVariableDescriptor(valueParameterDescriptor);
-            }
-        }
-
-        constructorScope.addLabeledDeclaration(descriptor); // TODO : Labels for constructors?!
-
-        return constructorScope;
-    }
-
-    private void resolvePropertyDeclarationBodies() {
-
-        // Member properties
-        Set<JetProperty> processed = Sets.newHashSet();
-        for (Map.Entry<JetClass, MutableClassDescriptor> entry : classes.entrySet()) {
-            JetClass jetClass = entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
-
-            for (JetProperty property : jetClass.getProperties()) {
-                final PropertyDescriptor propertyDescriptor = properties.get(property);
-                assert propertyDescriptor != null;
-
-                JetScope declaringScope = declaringScopes.get(property);
-
-                JetExpression initializer = property.getInitializer();
-                if (initializer != null) {
-                    ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
-                    if (primaryConstructor == null) {
-                        trace.getErrorHandler().genericError(initializer.getNode(), "Property initializers are not allowed when no primary constructor is present");
-                    }
-                    else {
-                        JetScope scope = getInnerScopeForConstructor(primaryConstructor, classDescriptor.getScopeForMemberResolution(), true);
-                        resolvePropertyInitializer(property, propertyDescriptor, initializer, scope);
-                    }
-                }
-
-                resolvePropertyAccessors(property, propertyDescriptor, declaringScope);
-                processed.add(property);
-            }
-        }
-
-        // Top-level properties & properties of objects
-        for (Map.Entry<JetProperty, PropertyDescriptor> entry : properties.entrySet()) {
-            JetProperty property = entry.getKey();
-            if (processed.contains(property)) continue;
-
-            final PropertyDescriptor propertyDescriptor = entry.getValue();
-            JetScope declaringScope = declaringScopes.get(property);
-
-            JetExpression initializer = property.getInitializer();
-            if (initializer != null) {
-                resolvePropertyInitializer(property, propertyDescriptor, initializer, declaringScope);
-            }
-
-            resolvePropertyAccessors(property, propertyDescriptor, declaringScope);
-        }
-    }
-
-    private JetScope getPropertyDeclarationInnerScope(@NotNull JetScope outerScope, @NotNull PropertyDescriptor propertyDescriptor) {
-        WritableScopeImpl result = new WritableScopeImpl(outerScope, propertyDescriptor, trace.getErrorHandler()).setDebugName("Property declaration inner scope");
-        for (TypeParameterDescriptor typeParameterDescriptor : propertyDescriptor.getTypeParemeters()) {
-            result.addTypeParameterDescriptor(typeParameterDescriptor);
-        }
-        JetType receiverType = propertyDescriptor.getReceiverType();
-        if (receiverType != null) {
-            result.setThisType(receiverType);
-        }
-        return result;
-    }
-
-    private void resolvePropertyAccessors(JetProperty property, PropertyDescriptor propertyDescriptor, JetScope declaringScope) {
-        BindingTraceAdapter fieldAccessTrackingTrace = createFieldTrackingTrace(propertyDescriptor);
-
-        WritableScope accessorScope = new WritableScopeImpl(getPropertyDeclarationInnerScope(declaringScope, propertyDescriptor), declaringScope.getContainingDeclaration(), trace.getErrorHandler()).setDebugName("Accessor scope");
-        accessorScope.addPropertyDescriptorByFieldName("$" + propertyDescriptor.getName(), propertyDescriptor);
-
-        JetPropertyAccessor getter = property.getGetter();
-        PropertyGetterDescriptor getterDescriptor = propertyDescriptor.getGetter();
-        if (getter != null && getterDescriptor != null) {
-            resolveFunctionBody(fieldAccessTrackingTrace, getter, getterDescriptor, accessorScope);
-        }
-
-        JetPropertyAccessor setter = property.getSetter();
-        PropertySetterDescriptor setterDescriptor = propertyDescriptor.getSetter();
-        if (setter != null && setterDescriptor != null) {
-            resolveFunctionBody(fieldAccessTrackingTrace, setter, setterDescriptor, accessorScope);
-        }
-
-        JetExpression initializer = property.getInitializer();
-        if (!property.isVar() && initializer != null && !trace.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
-            trace.getErrorHandler().genericError(initializer.getNode(), "Initializer is not allowed here because this property has no setter and no backing field either");
-        }
-    }
-
-    private BindingTraceAdapter createFieldTrackingTrace(final PropertyDescriptor propertyDescriptor) {
-        return new BindingTraceAdapter(traceForMembers).addHandler(BindingContext.REFERENCE_TARGET, new BindingTraceAdapter.RecordHandler<JetReferenceExpression, DeclarationDescriptor>() {
-            @Override
-            public void handleRecord(WritableSlice<JetReferenceExpression, DeclarationDescriptor> slice, JetReferenceExpression expression, DeclarationDescriptor descriptor) {
-                if (expression instanceof JetSimpleNameExpression) {
-                    JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression;
-                    if (simpleNameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
-                        // This check may be considered redundant as long as $x is only accessible from accessors to $x
-                        if (descriptor == propertyDescriptor) { // TODO : original?
-                            traceForMembers.record(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor); // TODO: this trace?
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    private void resolvePropertyInitializer(JetProperty property, PropertyDescriptor propertyDescriptor, JetExpression initializer, JetScope scope) {
-        JetFlowInformationProvider flowInformationProvider = classDescriptorResolver.computeFlowData(property, initializer); // TODO : flow JET-15
-        JetTypeInferrer.Services typeInferrer = semanticServices.getTypeInferrerServices(traceForConstructors, flowInformationProvider);
-        JetType type = typeInferrer.getType(getPropertyDeclarationInnerScope(scope, propertyDescriptor), initializer, false, JetTypeInferrer.NO_EXPECTED_TYPE);
-
-        JetType expectedType;
-        PropertySetterDescriptor setter = propertyDescriptor.getSetter();
-        if (setter != null) {
-            expectedType = setter.getReturnType();
-        }
-        else {
-            expectedType = propertyDescriptor.getInType();
-            if (expectedType == null) {
-                expectedType = propertyDescriptor.getOutType();
-            }
-        }
-        if (type != null && expectedType != null
-            && !semanticServices.getTypeChecker().isConvertibleTo(type, expectedType)) {
-            trace.getErrorHandler().typeMismatch(initializer, expectedType, type);
-        }
-    }
-
-    private void resolveFunctionBodies() {
-        for (Map.Entry<JetNamedFunction, FunctionDescriptorImpl> entry : functions.entrySet()) {
-            JetDeclaration declaration = entry.getKey();
-            FunctionDescriptor descriptor = entry.getValue();
-
-            JetScope declaringScope = declaringScopes.get(declaration);
-            assert declaringScope != null;
-
-            resolveFunctionBody(traceForMembers, (JetNamedFunction) declaration, (FunctionDescriptorImpl) descriptor, declaringScope);
-
-            assert descriptor.getReturnType() != null;
-        }
-    }
-
-    private void resolveFunctionBody(
-            @NotNull BindingTrace trace,
-            @NotNull JetDeclarationWithBody function,
-            @NotNull FunctionDescriptor functionDescriptor,
-            @NotNull JetScope declaringScope) {
-        JetExpression bodyExpression = function.getBodyExpression();
-
-        if (bodyExpression != null) {
-            JetFlowInformationProvider flowInformationProvider = classDescriptorResolver.computeFlowData(function.asElement(), bodyExpression);
-            JetTypeInferrer.Services typeInferrer = semanticServices.getTypeInferrerServices(trace, flowInformationProvider);
-
-            typeInferrer.checkFunctionReturnType(declaringScope, function, functionDescriptor);
-        }
-
-        assert functionDescriptor.getReturnType() != null;
-    }
-
-
-
-}
diff --git a/idea/src/org/jetbrains/jet/lang/types/ReenteringLazyValueComputationException.java b/idea/src/org/jetbrains/jet/lang/types/ReenteringLazyValueComputationException.java
deleted file mode 100644
index 36847c3ea4c..00000000000
--- a/idea/src/org/jetbrains/jet/lang/types/ReenteringLazyValueComputationException.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package org.jetbrains.jet.lang.types;
-
-/**
- * @author abreslav
- */
-public class ReenteringLazyValueComputationException extends RuntimeException {
-    public ReenteringLazyValueComputationException() {
-    }
-
-    public ReenteringLazyValueComputationException(String message) {
-        super(message);
-    }
-
-    public ReenteringLazyValueComputationException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public ReenteringLazyValueComputationException(Throwable cause) {
-        super(cause);
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/plugin/AnalyzerFacade.java b/idea/src/org/jetbrains/jet/plugin/AnalyzerFacade.java
new file mode 100644
index 00000000000..ec376a187b8
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/AnalyzerFacade.java
@@ -0,0 +1,24 @@
+package org.jetbrains.jet.plugin;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.java.JavaDefaultImports;
+
+/**
+ * @author abreslav
+ */
+public class AnalyzerFacade {
+    public static BindingContext analyzeNamespace(@NotNull JetNamespace namespace, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) {
+        return AnalyzingUtils.getInstance(JavaDefaultImports.JAVA_DEFAULT_IMPORTS).analyzeNamespace(namespace, flowDataTraceFactory);
+    }
+
+    public static BindingContext analyzeFileWithCache(@NotNull JetFile file) {
+        return AnalyzingUtils.getInstance(JavaDefaultImports.JAVA_DEFAULT_IMPORTS).analyzeFileWithCache(file);
+    }
+
+
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/JetHighlighter.java b/idea/src/org/jetbrains/jet/plugin/JetHighlighter.java
index dd5ab7174bc..79903d2774b 100644
--- a/idea/src/org/jetbrains/jet/plugin/JetHighlighter.java
+++ b/idea/src/org/jetbrains/jet/plugin/JetHighlighter.java
@@ -7,6 +7,7 @@ import com.intellij.lexer.Lexer;
 import com.intellij.openapi.editor.HighlighterColors;
 import com.intellij.openapi.editor.SyntaxHighlighterColors;
 import com.intellij.openapi.editor.colors.TextAttributesKey;
+import com.intellij.openapi.editor.markup.EffectType;
 import com.intellij.openapi.editor.markup.TextAttributes;
 import com.intellij.openapi.fileTypes.SyntaxHighlighterBase;
 import com.intellij.psi.TokenType;
@@ -96,6 +97,42 @@ public class JetHighlighter extends SyntaxHighlighterBase {
         JET_AUTO_CAST_EXPRESSION = TextAttributesKey.createTextAttributesKey("JET.AUTO.CAST.EXPRESSION", clone);
     }
 
+    public static final TextAttributesKey JET_AUTOCREATED_IT;
+
+    static {
+        TextAttributes attributes = new TextAttributes();
+        attributes.setFontType(Font.BOLD);
+// TODO: proper attributes
+        JET_AUTOCREATED_IT = TextAttributesKey.createTextAttributesKey("JET.AUTO.CREATED.IT", attributes);
+    }
+
+    public static final TextAttributesKey JET_FUNCTION_LITERAL_DELIMITER;
+
+    static {
+        TextAttributes attributes = new TextAttributes();
+        attributes.setFontType(Font.BOLD);
+// TODO: proper attributes
+        JET_FUNCTION_LITERAL_DELIMITER = TextAttributesKey.createTextAttributesKey("JET.AUTO.CREATED.IT", attributes);
+    }
+
+    public static final TextAttributesKey JET_DEBUG_INFO;
+
+    static {
+        TextAttributes textAttributes = new TextAttributes();
+        textAttributes.setEffectType(EffectType.ROUNDED_BOX);
+        textAttributes.setEffectColor(Color.BLACK);
+        JET_DEBUG_INFO = TextAttributesKey.createTextAttributesKey("JET.DEBUG.INFO", textAttributes);
+    }
+
+    public static final TextAttributesKey JET_RESOLVED_TO_ERROR;
+
+    static {
+        TextAttributes textAttributes = new TextAttributes();
+        textAttributes.setEffectType(EffectType.ROUNDED_BOX);
+        textAttributes.setEffectColor(Color.RED);
+        JET_RESOLVED_TO_ERROR = TextAttributesKey.createTextAttributesKey("JET.RESOLVED.TO.ERROR", textAttributes);
+    }
+
     @NotNull
     public Lexer getHighlightingLexer() {
         return new JetLexer();
diff --git a/idea/src/org/jetbrains/jet/plugin/JetLanguage.java b/idea/src/org/jetbrains/jet/plugin/JetLanguage.java
deleted file mode 100644
index cf8802b6fc0..00000000000
--- a/idea/src/org/jetbrains/jet/plugin/JetLanguage.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * @author max
- */
-package org.jetbrains.jet.plugin;
-
-import com.intellij.lang.Language;
-import com.intellij.openapi.fileTypes.SingleLazyInstanceSyntaxHighlighterFactory;
-import com.intellij.openapi.fileTypes.SyntaxHighlighter;
-import com.intellij.openapi.fileTypes.SyntaxHighlighterFactory;
-import org.jetbrains.annotations.NotNull;
-
-public class JetLanguage extends Language {
-    public static JetLanguage INSTANCE = new JetLanguage();
-
-    private JetLanguage() {
-        super("jet");
-
-        SyntaxHighlighterFactory.LANGUAGE_FACTORY.addExplicitExtension(this, new SingleLazyInstanceSyntaxHighlighterFactory() {
-          @NotNull
-          protected SyntaxHighlighter createHighlighter() {
-            return new JetHighlighter();
-          }
-        });
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java b/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java
new file mode 100644
index 00000000000..37cc3071f59
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java
@@ -0,0 +1,74 @@
+package org.jetbrains.jet.plugin;
+
+import com.google.common.collect.Lists;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.java.JavaClassDescriptor;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.types.DeferredType;
+import org.jetbrains.jet.lang.types.ErrorUtils;
+import org.jetbrains.jet.lang.types.JetStandardLibrary;
+import org.jetbrains.jet.lang.types.JetType;
+
+import java.util.LinkedList;
+
+/**
+ * @author svtk
+ */
+public class JetPluginUtil {
+    @NotNull
+    public static String computeTypeFullName(JetType type) {
+        LinkedList<String> fullName = computeTypeFullNameList(type);
+        String last = fullName.getLast();
+        StringBuilder sb = new StringBuilder();
+        for (String s : fullName) {
+            sb.append(s);
+            if (s != last) {
+                sb.append('.');
+            }
+        }
+        return sb.toString();
+    }
+
+    @NotNull
+    private static LinkedList<String> computeTypeFullNameList(JetType type) {
+        if (type instanceof DeferredType) {
+            type = ((DeferredType)type).getActualType();
+        }
+        DeclarationDescriptor declarationDescriptor = type.getConstructor().getDeclarationDescriptor();
+
+        LinkedList<String> fullName = Lists.newLinkedList();
+        while (declarationDescriptor != null) {
+            fullName.addFirst(declarationDescriptor.getName());
+            declarationDescriptor = declarationDescriptor.getContainingDeclaration();
+        }
+        assert fullName.size() > 0;
+        if (JavaDescriptorResolver.JAVA_ROOT.equals(fullName.getFirst())) {
+            fullName.removeFirst();
+        }
+        return fullName;
+    }
+
+    public static boolean checkTypeIsStandard(JetType type, Project project) {
+        LinkedList<String> fullName = computeTypeFullNameList(type);
+        if (fullName.size() == 3 && fullName.getFirst().equals("java") && fullName.get(1).equals("lang")) {
+            return true;
+        }
+
+        JetStandardLibrary standardLibrary = JetStandardLibrary.getJetStandardLibrary(project);
+        JetScope libraryScope = standardLibrary.getLibraryScope();
+
+        DeclarationDescriptor declaration = type.getMemberScope().getContainingDeclaration();
+        if (declaration instanceof JavaClassDescriptor || ErrorUtils.isError(declaration)) {
+            return false;
+        }
+        while (!(declaration instanceof NamespaceDescriptor)) {
+            declaration = declaration.getContainingDeclaration();
+            assert declaration != null;
+        }
+        return libraryScope == ((NamespaceDescriptor) declaration).getMemberScope();
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/JetQuickDocumentationProvider.java b/idea/src/org/jetbrains/jet/plugin/JetQuickDocumentationProvider.java
index 2b1cc65b9bf..68ff66afb3d 100644
--- a/idea/src/org/jetbrains/jet/plugin/JetQuickDocumentationProvider.java
+++ b/idea/src/org/jetbrains/jet/plugin/JetQuickDocumentationProvider.java
@@ -6,7 +6,6 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetReferenceExpression;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
@@ -26,7 +25,7 @@ public class JetQuickDocumentationProvider extends AbstractDocumentationProvider
             ref = PsiTreeUtil.getParentOfType(originalElement, JetReferenceExpression.class);
         }
         if (ref != null) {
-            BindingContext bindingContext = AnalyzingUtils.analyzeFileWithCache((JetFile) element.getContainingFile());
+            BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache((JetFile) element.getContainingFile());
             DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, ref);
             if (declarationDescriptor != null) {
                 return render(declarationDescriptor);
diff --git a/idea/src/org/jetbrains/jet/plugin/JetSyntaxHighlighterFactory.java b/idea/src/org/jetbrains/jet/plugin/JetSyntaxHighlighterFactory.java
new file mode 100644
index 00000000000..ff932b6ae03
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/JetSyntaxHighlighterFactory.java
@@ -0,0 +1,12 @@
+package org.jetbrains.jet.plugin;
+
+import com.intellij.openapi.fileTypes.SingleLazyInstanceSyntaxHighlighterFactory;
+import com.intellij.openapi.fileTypes.SyntaxHighlighter;
+import org.jetbrains.annotations.NotNull;
+
+public class JetSyntaxHighlighterFactory extends SingleLazyInstanceSyntaxHighlighterFactory {
+    @NotNull
+    protected SyntaxHighlighter createHighlighter() {
+      return new JetHighlighter();
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/actions/CopyAsDiagnosticTestAction.java b/idea/src/org/jetbrains/jet/plugin/actions/CopyAsDiagnosticTestAction.java
new file mode 100644
index 00000000000..b9c35a7986d
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/actions/CopyAsDiagnosticTestAction.java
@@ -0,0 +1,50 @@
+package org.jetbrains.jet.plugin.actions;
+
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.LangDataKeys;
+import com.intellij.openapi.actionSystem.PlatformDataKeys;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.jet.checkers.CheckerTestUtil;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
+
+import java.awt.*;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.ClipboardOwner;
+import java.awt.datatransfer.StringSelection;
+import java.awt.datatransfer.Transferable;
+
+/**
+ * @author abreslav
+ */
+public class CopyAsDiagnosticTestAction extends AnAction {
+    @Override
+    public void actionPerformed(AnActionEvent e) {
+        Editor editor = e.getData(PlatformDataKeys.EDITOR);
+        PsiFile psiFile = e.getData(LangDataKeys.PSI_FILE);
+        assert editor != null && psiFile != null;
+
+        BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache((JetFile) psiFile);
+
+        String result = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, bindingContext).toString();
+
+        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+        clipboard.setContents(new StringSelection(result), new ClipboardOwner() {
+            @Override
+            public void lostOwnership(Clipboard clipboard, Transferable contents) {}
+        });
+    }
+
+
+    @Override
+    public void update(AnActionEvent e) {
+        Editor editor = e.getData(PlatformDataKeys.EDITOR);
+        PsiFile psiFile = e.getData(LangDataKeys.PSI_FILE);
+        e.getPresentation().setEnabled(editor != null && psiFile instanceof JetFile && ApplicationManager.getApplication().isInternal());
+    }
+
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/actions/ShowExpressionTypeAction.java b/idea/src/org/jetbrains/jet/plugin/actions/ShowExpressionTypeAction.java
index 7b13fb6aebd..26f778b3fe1 100644
--- a/idea/src/org/jetbrains/jet/plugin/actions/ShowExpressionTypeAction.java
+++ b/idea/src/org/jetbrains/jet/plugin/actions/ShowExpressionTypeAction.java
@@ -11,9 +11,9 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
 import org.jetbrains.jet.plugin.JetLanguage;
 
 /**
@@ -26,7 +26,7 @@ public class ShowExpressionTypeAction extends AnAction {
         PsiFile psiFile = e.getData(LangDataKeys.PSI_FILE);
         assert editor != null && psiFile != null;
         JetExpression expression;
-        BindingContext bindingContext = AnalyzingUtils.analyzeFileWithCache((JetFile) psiFile);
+        BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache((JetFile) psiFile);
         if (editor.getSelectionModel().hasSelection()) {
             int startOffset = editor.getSelectionModel().getSelectionStart();
             int endOffset = editor.getSelectionModel().getSelectionEnd();
diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java b/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java
new file mode 100644
index 00000000000..3b82898afe8
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java
@@ -0,0 +1,130 @@
+package org.jetbrains.jet.plugin.annotations;
+
+import com.google.common.collect.Sets;
+import com.intellij.lang.annotation.AnnotationHolder;
+import com.intellij.lang.annotation.Annotator;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.progress.ProcessCanceledException;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetNodeTypes;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.types.ErrorUtils;
+import org.jetbrains.jet.lexer.JetTokens;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
+import org.jetbrains.jet.plugin.JetHighlighter;
+
+import java.util.Collection;
+import java.util.Set;
+
+import static org.jetbrains.jet.lang.resolve.BindingContext.*;
+import static org.jetbrains.jet.lexer.JetTokens.*;
+
+/**
+ * @author abreslav
+ */
+public class DebugInfoAnnotator implements Annotator {
+
+    public static final TokenSet EXCLUDED = TokenSet.create(COLON, AS_KEYWORD, AS_SAFE, IS_KEYWORD, NOT_IS, OROR, ANDAND, EQ, EQEQEQ, EXCLEQEQEQ, ELVIS);
+
+    private static volatile boolean debugInfoEnabled = true;
+
+    public static void setDebugInfoEnabled(boolean value) {
+        debugInfoEnabled = value;
+    }
+
+    public static boolean isDebugInfoEnabled() {
+        return debugInfoEnabled;
+    }
+
+    @Override
+    public void annotate(@NotNull PsiElement element, @NotNull final AnnotationHolder holder) {
+        if (!debugInfoEnabled) {
+            return;
+        }
+        
+        if (element instanceof JetFile) {
+            JetFile file = (JetFile) element;
+            try {
+                final BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
+
+                final Set<JetReferenceExpression> unresolvedReferences = Sets.newHashSet();
+                for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
+                    if (diagnostic instanceof UnresolvedReferenceDiagnostic) {
+                        unresolvedReferences.add(((UnresolvedReferenceDiagnostic) diagnostic).getPsiElement());
+                    }
+                }
+
+                file.acceptChildren(new JetVisitorVoid() {
+
+                    @Override
+                    public void visitReferenceExpression(JetReferenceExpression expression) {
+                        if (expression instanceof JetSimpleNameExpression) {
+                            JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) expression;
+                            IElementType elementType = expression.getNode().getElementType();
+                            if (elementType == JetNodeTypes.OPERATION_REFERENCE) {
+                                IElementType referencedNameElementType = nameExpression.getReferencedNameElementType();
+                                if (EXCLUDED.contains(referencedNameElementType)) {
+                                    return;
+                                }
+                                if (JetTokens.LABELS.contains(referencedNameElementType)) return;
+                            }
+                            else if (nameExpression.getReferencedNameElementType() == JetTokens.THIS_KEYWORD) {
+                                return;
+                            }
+                        }
+
+                        String target = null;
+                        DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, expression);
+                        if (declarationDescriptor != null) {
+                            target = declarationDescriptor.toString();
+                        }
+                        else {
+                            PsiElement labelTarget = bindingContext.get(LABEL_TARGET, expression);
+                            if (labelTarget != null) {
+                                target = labelTarget.getText();
+                            }
+                            else {
+                                Collection<? extends DeclarationDescriptor> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, expression);
+                                if (declarationDescriptors != null) {
+                                    target = "[" + declarationDescriptors.size() + " descriptors]";
+                                }
+                            }
+                        }
+                        boolean resolved = target != null;
+                        boolean unresolved = unresolvedReferences.contains(expression);
+                        if (declarationDescriptor != null && !ApplicationManager.getApplication().isUnitTestMode() && ErrorUtils.isError(declarationDescriptor)) {
+                            holder.createErrorAnnotation(expression, "[DEBUG] Resolved to error element").setTextAttributes(JetHighlighter.JET_RESOLVED_TO_ERROR);
+                        }
+                        if (resolved && unresolved) {
+                            holder.createErrorAnnotation(expression, "[DEBUG] Reference marked as unresolved is actually resolved to " + target).setTextAttributes(JetHighlighter.JET_DEBUG_INFO);
+                        }
+                        else if (!resolved && !unresolved) {
+                            holder.createErrorAnnotation(expression, "[DEBUG] Reference is not resolved to anything, but is not marked unresolved").setTextAttributes(JetHighlighter.JET_DEBUG_INFO);
+                        }
+                    }
+
+                    @Override
+                    public void visitJetElement(JetElement element) {
+                        element.acceptChildren(this);
+                    }
+                });
+            }
+            catch (ProcessCanceledException e) {
+                throw e;
+            }
+            catch (Throwable e) {
+                // TODO
+                holder.createErrorAnnotation(element, e.getClass().getCanonicalName() + ": " + e.getMessage());
+                e.printStackTrace();
+            }
+        }
+    }
+
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java
index aafe04c8cdb..e53c0587f4e 100644
--- a/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java
+++ b/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java
@@ -16,12 +16,15 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.util.PsiUtilBase;
 import com.intellij.ui.awt.RelativePoint;
-import com.intellij.util.*;
+import com.intellij.util.Function;
+import com.intellij.util.PlatformIcons;
+import com.intellij.util.PsiIconUtil;
+import com.intellij.util.PsiNavigateUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 
 import javax.swing.*;
@@ -42,7 +45,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
         JetFile file = PsiTreeUtil.getParentOfType(element, JetFile.class);
 
         if (file == null) return null;
-        final BindingContext bindingContext = AnalyzingUtils.analyzeFileWithCache(file);
+        final BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
 
         if (element instanceof JetClass) {
             JetClass jetClass = (JetClass) element;
@@ -64,7 +67,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
 
             final FunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, jetFunction);
             if (functionDescriptor == null) return null;
-            final Set<? extends FunctionDescriptor> overriddenFunctions = functionDescriptor.getOverriddenFunctions();
+            final Set<? extends FunctionDescriptor> overriddenFunctions = functionDescriptor.getOverriddenDescriptors();
             Icon icon = isMember(functionDescriptor) ? (overriddenFunctions.isEmpty() ? PlatformIcons.METHOD_ICON : OVERRIDING_FUNCTION) : PlatformIcons.FUNCTION_ICON;
             return new LineMarkerInfo<JetNamedFunction>(
                     jetFunction, jetFunction.getTextOffset(), icon, Pass.UPDATE_ALL,
@@ -130,8 +133,11 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
         }
 
         if (element instanceof JetNamespace) {
-            return createLineMarkerInfo((JetNamespace) element,
-                    DescriptorRenderer.HTML.render(bindingContext.get(BindingContext.NAMESPACE, element)));
+            JetNamespace namespace = (JetNamespace) element;
+            if (namespace.getNameIdentifier() != null) {
+                return createLineMarkerInfo(namespace,
+                        DescriptorRenderer.HTML.render(bindingContext.get(BindingContext.NAMESPACE, element)));
+            }
         }
 
         if (element instanceof JetObjectDeclaration && !(element.getParent() instanceof JetExpression)) {
diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java b/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java
index c8d61556144..a845fd21838 100644
--- a/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java
+++ b/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java
@@ -1,28 +1,37 @@
 package org.jetbrains.jet.plugin.annotations;
 
+import com.google.common.collect.Sets;
+import com.intellij.codeInsight.intention.IntentionAction;
 import com.intellij.codeInspection.ProblemHighlightType;
-import com.intellij.lang.ASTNode;
+import com.intellij.lang.annotation.Annotation;
 import com.intellij.lang.annotation.AnnotationHolder;
 import com.intellij.lang.annotation.Annotator;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.progress.ProcessCanceledException;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.MultiRangeReference;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiReference;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ErrorHandler;
-import org.jetbrains.jet.plugin.JetHighlighter;
-import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
-import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
+import org.jetbrains.jet.lang.diagnostics.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
+import org.jetbrains.jet.plugin.JetHighlighter;
+import org.jetbrains.jet.plugin.quickfix.JetIntentionActionFactory;
+import org.jetbrains.jet.plugin.quickfix.QuickFixes;
 
-import java.util.HashSet;
+import java.util.Collection;
 import java.util.Set;
 
+import static org.jetbrains.jet.lang.resolve.BindingContext.*;
+
 /**
  * @author abreslav
  */
@@ -42,71 +51,78 @@ public class JetPsiChecker implements Annotator {
     public void annotate(@NotNull PsiElement element, @NotNull final AnnotationHolder holder) {
         if (element instanceof JetFile) {
             JetFile file = (JetFile) element;
+            Project project = element.getProject();
             try {
-                final BindingContext bindingContext = AnalyzingUtils.analyzeFileWithCache(file);
-
-                ErrorHandler errorHandler = new ErrorHandler() {
-                    private final Set<DeclarationDescriptor> redeclarations = new HashSet<DeclarationDescriptor>();
-
-                    @Override
-                    public void unresolvedReference(@NotNull JetReferenceExpression referenceExpression) {
-                        PsiReference reference = referenceExpression.getReference();
-                        if (reference instanceof MultiRangeReference) {
-                            MultiRangeReference mrr = (MultiRangeReference) reference;
-                            for (TextRange range : mrr.getRanges()) {
-                                holder.createErrorAnnotation(range.shiftRight(referenceExpression.getTextOffset()), "Unresolved").setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);
-                            }
-                        }
-                        else {
-                            holder.createErrorAnnotation(referenceExpression, "Unresolved").setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);
-                        }
-                    }
-
-                    @Override
-                    public void typeMismatch(@NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull JetType actualType) {
-                        holder.createErrorAnnotation(expression, "Type mismatch: inferred type is " + actualType + " but " + expectedType + " was expected");
-                    }
-
-                    @Override
-                    public void redeclaration(@NotNull DeclarationDescriptor existingDescriptor, @NotNull DeclarationDescriptor redeclaredDescriptor) {
-                        markRedeclaration(existingDescriptor);
-                        markRedeclaration(redeclaredDescriptor);
-                    }
-
-                    private void markRedeclaration(DeclarationDescriptor redeclaration) {
-                        if (!redeclarations.add(redeclaration)) return;
-                        PsiElement declarationPsiElement = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, redeclaration);
-                        if (declarationPsiElement instanceof JetNamedDeclaration) {
-                            PsiElement nameIdentifier = ((JetNamedDeclaration) declarationPsiElement).getNameIdentifier();
-                            assert nameIdentifier != null : declarationPsiElement.getText() + " has nameIdentifier 'null'";
-                            holder.createErrorAnnotation(nameIdentifier, "Redeclaration");
-                        }
-                        else if (declarationPsiElement != null) {
-                            holder.createErrorAnnotation(declarationPsiElement, "Redeclaration");
-                        }
-                    }
-
-                    @Override
-                    public void genericError(@NotNull ASTNode node, @NotNull String errorMessage) {
-                        holder.createErrorAnnotation(node, errorMessage);
-                    }
-
-                    @Override
-                    public void genericWarning(@NotNull ASTNode node, @NotNull String message) {
-                        holder.createWarningAnnotation(node, message);
-                    }
-                };
+                final BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
 
                 if (errorReportingEnabled) {
-                    AnalyzingUtils.applyHandler(errorHandler, bindingContext);
+                    Collection<Diagnostic> diagnostics = Sets.newLinkedHashSet(bindingContext.getDiagnostics());
+                    Set<PsiElement> redeclarations = Sets.newHashSet();
+                    for (Diagnostic diagnostic : diagnostics) {
+                        Annotation annotation = null;
+                        if (diagnostic.getSeverity() == Severity.ERROR) {
+                            if (diagnostic instanceof UnresolvedReferenceDiagnostic) {
+                                UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic = (UnresolvedReferenceDiagnostic) diagnostic;
+                                JetReferenceExpression referenceExpression = unresolvedReferenceDiagnostic.getPsiElement();
+                                PsiReference reference = referenceExpression.getReference();
+                                if (reference instanceof MultiRangeReference) {
+                                    MultiRangeReference mrr = (MultiRangeReference) reference;
+                                    for (TextRange range : mrr.getRanges()) {
+                                        holder.createErrorAnnotation(range.shiftRight(referenceExpression.getTextOffset()), diagnostic.getMessage()).setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);
+                                    }
+                                }
+                                else {
+                                    holder.createErrorAnnotation(referenceExpression, diagnostic.getMessage()).setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);
+                                }
+                            }
+                            else if (diagnostic instanceof RedeclarationDiagnostic) {
+                                RedeclarationDiagnostic redeclarationDiagnostic = (RedeclarationDiagnostic) diagnostic;
+                                annotation = markRedeclaration(redeclarations, redeclarationDiagnostic, holder);
+                            }
+                            else {
+                                annotation = holder.createErrorAnnotation(diagnostic.getFactory().getTextRange(diagnostic), getMessage(diagnostic));
+                            }
+                        }
+                        else if (diagnostic.getSeverity() == Severity.WARNING) {
+                            annotation = holder.createWarningAnnotation(diagnostic.getFactory().getTextRange(diagnostic), getMessage(diagnostic));
+                        }
+                        if (annotation != null && diagnostic instanceof DiagnosticWithPsiElementImpl) {
+                            DiagnosticWithPsiElement diagnosticWithPsiElement = (DiagnosticWithPsiElement) diagnostic;
+                            if (diagnostic.getFactory() instanceof PsiElementOnlyDiagnosticFactory) {
+                                PsiElementOnlyDiagnosticFactory factory = (PsiElementOnlyDiagnosticFactory) diagnostic.getFactory();
+                                Collection<JetIntentionActionFactory> intentionActionFactories = QuickFixes.get(factory);
+                                for (JetIntentionActionFactory intentionActionFactory : intentionActionFactories) {
+                                    IntentionAction action = null;
+                                    if (intentionActionFactory != null) {
+                                        action = intentionActionFactory.createAction(diagnosticWithPsiElement);
+                                    }
+                                    if (action != null) {
+                                        annotation.registerFix(action);
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
 
                 highlightBackingFields(holder, file, bindingContext);
 
                 file.acceptChildren(new JetVisitorVoid() {
+                    @Override
+                    public void visitSimpleNameExpression(JetSimpleNameExpression expression) {
+                        DeclarationDescriptor target = bindingContext.get(REFERENCE_TARGET, expression);
+                        if (target instanceof ValueParameterDescriptor) {
+                            ValueParameterDescriptor parameterDescriptor = (ValueParameterDescriptor) target;
+                            if (bindingContext.get(AUTO_CREATED_IT, parameterDescriptor)) {
+                                holder.createInfoAnnotation(expression, "Automatically declared based on the expected type").setTextAttributes(JetHighlighter.JET_AUTOCREATED_IT);
+                            }
+                        }
+                        super.visitSimpleNameExpression(expression);
+                    }
+
                     @Override
                     public void visitExpression(JetExpression expression) {
-                        JetType autoCast = bindingContext.get(BindingContext.AUTOCAST, expression);
+                        JetType autoCast = bindingContext.get(AUTOCAST, expression);
                         if (autoCast != null) {
                             holder.createInfoAnnotation(expression, "Automatically cast to " + autoCast).setTextAttributes(JetHighlighter.JET_AUTO_CAST_EXPRESSION);
                         }
@@ -130,6 +146,18 @@ public class JetPsiChecker implements Annotator {
         }
     }
 
+    private String getMessage(Diagnostic diagnostic) {
+        if (ApplicationManager.getApplication().isInternal() || ApplicationManager.getApplication().isUnitTestMode()) {
+            return "[" + diagnostic.getFactory().getName() + "] " + diagnostic.getMessage();
+        }
+        return diagnostic.getMessage();
+    }
+
+    private Annotation markRedeclaration(Set<PsiElement> redeclarations, RedeclarationDiagnostic diagnostic, AnnotationHolder holder) {
+        if (!redeclarations.add(diagnostic.getPsiElement())) return null;
+        return holder.createErrorAnnotation(diagnostic.getFactory().getTextRange(diagnostic), getMessage(diagnostic));
+    }
+
 
     private void highlightBackingFields(final AnnotationHolder holder, JetFile file, final BindingContext bindingContext) {
         file.acceptChildren(new JetVisitorVoid() {
@@ -137,7 +165,7 @@ public class JetPsiChecker implements Annotator {
             public void visitProperty(JetProperty property) {
                 VariableDescriptor propertyDescriptor = bindingContext.get(BindingContext.VARIABLE, property);
                 if (propertyDescriptor instanceof PropertyDescriptor) {
-                    if ((boolean) bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, (PropertyDescriptor) propertyDescriptor)) {
+                    if (bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, (PropertyDescriptor) propertyDescriptor)) {
                         putBackingfieldAnnotation(holder, property);
                     }
                 }
diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/SoftKeywordsAnnotator.java b/idea/src/org/jetbrains/jet/plugin/annotations/SoftKeywordsAnnotator.java
index 77aa4d0eac4..194d06ab932 100644
--- a/idea/src/org/jetbrains/jet/plugin/annotations/SoftKeywordsAnnotator.java
+++ b/idea/src/org/jetbrains/jet/plugin/annotations/SoftKeywordsAnnotator.java
@@ -3,8 +3,10 @@
  */
 package org.jetbrains.jet.plugin.annotations;
 
+import com.intellij.lang.ASTNode;
 import com.intellij.lang.annotation.AnnotationHolder;
 import com.intellij.lang.annotation.Annotator;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.impl.source.tree.LeafPsiElement;
 import org.jetbrains.annotations.NotNull;
@@ -13,20 +15,41 @@ import org.jetbrains.jet.plugin.JetHighlighter;
 import org.jetbrains.jet.lexer.JetTokens;
 
 public class SoftKeywordsAnnotator implements Annotator {
-    public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) {
-        if (element instanceof LeafPsiElement) {
-            if (JetTokens.SOFT_KEYWORDS.contains(((LeafPsiElement) element).getElementType())) {
-                holder.createInfoAnnotation(element, null).setTextAttributes(JetHighlighter.JET_SOFT_KEYWORD);
+    public void annotate(@NotNull PsiElement element, @NotNull final AnnotationHolder holder) {
+        element.accept(new JetVisitorVoid() {
+            @Override
+            public void visitElement(PsiElement element) {
+                if (element instanceof LeafPsiElement) {
+                    if (JetTokens.SOFT_KEYWORDS.contains(((LeafPsiElement) element).getElementType())) {
+                        holder.createInfoAnnotation(element, null).setTextAttributes(JetHighlighter.JET_SOFT_KEYWORD);
+                    }
+                }
             }
-        }
-        else if (element instanceof JetAnnotationEntry) {
-            JetAnnotationEntry entry = (JetAnnotationEntry) element;
-            JetTypeReference typeReference = entry.getTypeReference();
-            if (typeReference != null) {
-                JetTypeElement typeElement = typeReference.getTypeElement();
-                markAnnotationIdentifiers(typeElement, holder);
+
+            @Override
+            public void visitAnnotationEntry(JetAnnotationEntry annotationEntry) {
+                JetTypeReference typeReference = annotationEntry.getTypeReference();
+                if (typeReference != null) {
+                    JetTypeElement typeElement = typeReference.getTypeElement();
+                    markAnnotationIdentifiers(typeElement, holder);
+                }
             }
-        }
+
+            @Override
+            public void visitFunctionLiteralExpression(JetFunctionLiteralExpression expression) {
+                if (ApplicationManager.getApplication().isUnitTestMode()) return;
+                JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
+                holder.createInfoAnnotation(functionLiteral.getOpenBraceNode(), null).setTextAttributes(JetHighlighter.JET_FUNCTION_LITERAL_DELIMITER);
+                ASTNode closingBraceNode = functionLiteral.getClosingBraceNode();
+                if (closingBraceNode != null) {
+                    holder.createInfoAnnotation(closingBraceNode, null).setTextAttributes(JetHighlighter.JET_FUNCTION_LITERAL_DELIMITER);
+                }
+                ASTNode arrowNode = functionLiteral.getArrowNode();
+                if (arrowNode != null) {
+                    holder.createInfoAnnotation(arrowNode, null).setTextAttributes(JetHighlighter.JET_FUNCTION_LITERAL_DELIMITER);
+                }
+            }
+        });
     }
 
     private void markAnnotationIdentifiers(JetTypeElement typeElement, @NotNull AnnotationHolder holder) {
diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java b/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java
index 9c12a4b27d3..c29a35c2ea3 100644
--- a/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java
+++ b/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java
@@ -1,12 +1,14 @@
 package org.jetbrains.jet.plugin.compiler;
 
+import com.google.common.collect.Lists;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.compiler.CompileContext;
 import com.intellij.openapi.compiler.CompileScope;
 import com.intellij.openapi.compiler.CompilerMessageCategory;
 import com.intellij.openapi.compiler.TranslatingCompiler;
+import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.module.Module;
-import com.intellij.openapi.util.Computable;
+import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiFile;
@@ -15,14 +17,20 @@ import com.intellij.util.Chunk;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.java.JavaDefaultImports;
 import org.jetbrains.jet.plugin.JetFileType;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
+
+import static com.intellij.openapi.compiler.CompilerMessageCategory.ERROR;
 
 /**
  * @author yole
@@ -45,67 +53,148 @@ public class JetCompiler implements TranslatingCompiler {
     }
 
     @Override
-    public void compile(CompileContext compileContext, Chunk<Module> moduleChunk, VirtualFile[] virtualFiles, OutputSink outputSink) {
-        Map<Module, ModuleCompileState> moduleMap = new HashMap<Module, ModuleCompileState>();
+    public void compile(final CompileContext compileContext, Chunk<Module> moduleChunk, final VirtualFile[] virtualFiles, OutputSink outputSink) {
+        if (virtualFiles.length == 0) return;
 
-        for (VirtualFile virtualFile : virtualFiles) {
-            Module module = compileContext.getModuleByFile(virtualFile);
-            ModuleCompileState state = moduleMap.get(module);
-            if (state == null) {
-                state = new ModuleCompileState(compileContext, module, outputSink);
-                moduleMap.put(module, state);
-            }
-            state.compile(virtualFile);
+        Module module = compileContext.getModuleByFile(virtualFiles[0]);
+        final VirtualFile outputDir = compileContext.getModuleOutputDirectory(module);
+        if (outputDir == null) {
+            compileContext.addMessage(ERROR, "[Internal Error] No output directory", "", -1, -1);
+            return;
         }
 
-        for (ModuleCompileState state : moduleMap.values()) {
-            state.done();
-        }
-
-    }
-
-    private static class ModuleCompileState {
-        private final GenerationState state;
-        private final CompileContext compileContext;
-        private final Module module;
-        private final OutputSink outputSink;
-
-        public ModuleCompileState(final CompileContext compileContext, Module module, OutputSink outputSink) {
-            this.compileContext = compileContext;
-            this.module = module;
-            this.outputSink = outputSink;
-            state = ApplicationManager.getApplication().runReadAction(new Computable<GenerationState>() {
-                @Override
-                public GenerationState compute() {
-                    return new GenerationState(compileContext.getProject(), false);
-                }
-            });
-        }
-
-        public void compile(final VirtualFile virtualFile) {
-            ApplicationManager.getApplication().runReadAction(new Runnable() {
-                @Override
-                public void run() {
-                    PsiFile psiFile = PsiManager.getInstance(module.getProject()).findFile(virtualFile);
+        ApplicationManager.getApplication().runReadAction(new Runnable() {
+            @Override
+            public void run() {
+                GenerationState generationState = new GenerationState(compileContext.getProject(), false);
+                List<JetNamespace> namespaces = Lists.newArrayList();
+                for (VirtualFile virtualFile : virtualFiles) {
+                    PsiFile psiFile = PsiManager.getInstance(compileContext.getProject()).findFile(virtualFile);
                     if (psiFile instanceof JetFile) {
-                        state.compile((JetFile) psiFile);
+                        namespaces.add(((JetFile) psiFile).getRootNamespace());
                     }
                 }
-            });
-        }
 
-        public void done() {
-            VirtualFile outputDir = compileContext.getModuleOutputDirectory(module);
-            final ClassFileFactory factory = state.getFactory();
-            List<String> files = factory.files();
-            for (String file : files) {
-                File target = new File(outputDir.getPath(), file);
-                try {
-                    FileUtil.writeToFile(target, factory.asBytes(file));
-                } catch (IOException e) {
-                    compileContext.addMessage(CompilerMessageCategory.ERROR, e.getMessage(), null, 0, 0);
+                BindingContext bindingContext = AnalyzingUtils.getInstance(JavaDefaultImports.JAVA_DEFAULT_IMPORTS).analyzeNamespaces(compileContext.getProject(), namespaces, JetControlFlowDataTraceFactory.EMPTY);
+
+                boolean errors = false;
+                for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
+                    switch (diagnostic.getSeverity()) {
+                        case ERROR:
+                            errors = true;
+                            report(diagnostic, CompilerMessageCategory.ERROR, compileContext);
+                            break;
+                        case INFO:
+                            report(diagnostic, CompilerMessageCategory.INFORMATION, compileContext);                            
+                            break;
+                        case WARNING:
+                            report(diagnostic, CompilerMessageCategory.WARNING, compileContext);                            
+                            break;
+                    }
+                }
+                
+                if (!errors) {
+                    generationState.compileCorrectNamespaces(bindingContext, namespaces);
+
+                    final ClassFileFactory factory = generationState.getFactory();
+                    List<String> files = factory.files();
+                    for (String file : files) {
+                        File target = new File(outputDir.getPath(), file);
+                        try {
+                            FileUtil.writeToFile(target, factory.asBytes(file));
+                        } catch (IOException e) {
+                            compileContext.addMessage(ERROR, e.getMessage(), null, 0, 0);
+                        }
+                    }
                 }
             }
+        });
+        
+//        Map<Module, ModuleCompileState> moduleMap = new HashMap<Module, ModuleCompileState>();
+//
+//        for (VirtualFile virtualFile : virtualFiles) {
+//            Module module = compileContext.getModuleByFile(virtualFile);
+//            ModuleCompileState state = moduleMap.get(module);
+//            if (state == null) {
+//                state = new ModuleCompileState(compileContext, module, outputSink);
+//                moduleMap.put(module, state);
+//            }
+//            state.compile(virtualFile);
+//        }
+//
+//        for (ModuleCompileState state : moduleMap.values()) {
+//            state.done();
+//        }
+
+    }
+
+    private void report(Diagnostic diagnostic, CompilerMessageCategory severity, CompileContext compileContext) {
+        PsiFile psiFile = diagnostic.getFactory().getPsiFile(diagnostic);
+        TextRange textRange = diagnostic.getFactory().getTextRange(diagnostic);
+        Document document = psiFile.getViewProvider().getDocument();
+        int line;
+        int col;
+        if (document != null) {
+            line = document.getLineNumber(textRange.getStartOffset());
+            col = textRange.getStartOffset() - document.getLineStartOffset(line) + 1;
+        }
+        else {
+            line = -1;
+            col = -1;
+        }
+        VirtualFile virtualFile = psiFile.getVirtualFile();
+        if (virtualFile == null) {
+            compileContext.addMessage(ERROR, "[Internal Error] No virtual file for PsiFile. Diagnostic: " + diagnostic.getMessage(), "", -1, -1);
+        }
+        else {
+            compileContext.addMessage(severity, diagnostic.getMessage(), virtualFile.getUrl(), line + 1, col);
         }
     }
+
+//    private static class ModuleCompileState {
+//        private final GenerationState state;
+//        private final CompileContext compileContext;
+//        private final Module module;
+//        private final OutputSink outputSink;
+//
+//        public ModuleCompileState(final CompileContext compileContext, Module module, OutputSink outputSink) {
+//            this.compileContext = compileContext;
+//            this.module = module;
+//            this.outputSink = outputSink;
+//            state = ApplicationManager.getApplication().runReadAction(new Computable<GenerationState>() {
+//                @Override
+//                public GenerationState compute() {
+//                    return new GenerationState(compileContext.getProject(), false);
+//                }
+//            });
+//        }
+//
+//
+//
+//        public void compile(final VirtualFile virtualFile) {
+//            ApplicationManager.getApplication().runReadAction(new Runnable() {
+//                @Override
+//                public void run() {
+//                    PsiFile psiFile = PsiManager.getInstance(module.getProject()).findFile(virtualFile);
+//                    if (psiFile instanceof JetFile) {
+//                        state.compile((JetFile) psiFile);
+//                    }
+//                }
+//            });
+//        }
+//
+//        public void done() {
+//            VirtualFile outputDir = compileContext.getModuleOutputDirectory(module);
+//            final ClassFileFactory factory = state.getFactory();
+//            List<String> files = factory.files();
+//            for (String file : files) {
+//                File target = new File(outputDir.getPath(), file);
+//                try {
+//                    FileUtil.writeToFile(target, factory.asBytes(file));
+//                } catch (IOException e) {
+//                    compileContext.addMessage(ERROR, e.getMessage(), null, 0, 0);
+//                }
+//            }
+//        }
+//    }
 }
diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java
index d8fcb6558ef..073d4d9ba61 100644
--- a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java
+++ b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java
@@ -20,9 +20,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.codegen.JetTypeMapper;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
 
 import java.util.*;
 
@@ -125,7 +125,7 @@ public class JetPositionManager implements PositionManager {
         if (mapper != null) {
             return mapper;
         }
-        final BindingContext bindingContext = AnalyzingUtils.analyzeFileWithCache(file);
+        final BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
         final JetStandardLibrary standardLibrary = JetStandardLibrary.getJetStandardLibrary(myDebugProcess.getProject());
         final JetTypeMapper typeMapper = new JetTypeMapper(standardLibrary, bindingContext);
         file.acceptChildren(new JetVisitorVoid() {
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java
new file mode 100644
index 00000000000..7131d3b0e02
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java
@@ -0,0 +1,60 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiWhiteSpace;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.*;
+
+/**
+ * @author svtk
+ */
+public class AddFunctionBodyFix extends JetIntentionAction<JetFunctionOrPropertyAccessor> {
+    public AddFunctionBodyFix(@NotNull JetFunctionOrPropertyAccessor element) {
+        super(element);
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        return "Add function body";
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Add function body";
+    }
+
+    @Override
+    public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+        return super.isAvailable(project, editor, file) &&
+                element.getBodyExpression() == null;
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        JetFunctionOrPropertyAccessor newElement = (JetFunctionOrPropertyAccessor) element.copy();
+        JetExpression bodyExpression = newElement.getBodyExpression();
+        if (!(newElement.getLastChild() instanceof PsiWhiteSpace)) {
+            newElement.add(JetPsiFactory.createWhiteSpace(project));
+        }
+        if (bodyExpression == null) {
+            newElement.add(JetPsiFactory.createEmptyBody(project));
+        }
+        element.replace(newElement);
+    }
+    
+    public static JetIntentionActionFactory<JetFunctionOrPropertyAccessor> createFactory() {
+        return new JetIntentionActionFactory<JetFunctionOrPropertyAccessor>() {
+            @Override
+            public JetIntentionAction<JetFunctionOrPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetFunctionOrPropertyAccessor;
+                return new AddFunctionBodyFix((JetFunctionOrPropertyAccessor) diagnostic.getPsiElement());
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java
new file mode 100644
index 00000000000..de64087a558
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java
@@ -0,0 +1,97 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.JetModifierList;
+import org.jetbrains.jet.lang.psi.JetModifierListOwner;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
+import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetTokens;
+
+/**
+ * @author svtk
+ */
+public class AddModifierFix extends ModifierFix {
+    private final JetToken[] modifiersThanCanBeReplaced;
+
+    private AddModifierFix(@NotNull JetModifierListOwner element, JetKeywordToken modifier, JetToken[] modifiersThanCanBeReplaced) {
+        super(element, modifier);
+        this.modifiersThanCanBeReplaced = modifiersThanCanBeReplaced;
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        if (modifier == JetTokens.ABSTRACT_KEYWORD || modifier == JetTokens.OPEN_KEYWORD) {
+            return "Make " + getElementName() + " " + modifier.getValue();
+        }
+        return "Add '" + modifier.getValue() + "' modifier";
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Add modifier";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        element.replace(addModifier(element, modifier, modifiersThanCanBeReplaced, project));
+    }
+
+    @NotNull
+    private static JetModifierListOwner addModifier(@NotNull PsiElement element, @NotNull JetKeywordToken modifier, JetToken[] modifiersThanCanBeReplaced, @NotNull Project project) {
+        JetModifierListOwner newElement = (JetModifierListOwner) (element.copy());
+
+        JetModifierList modifierList = newElement.getModifierList();
+        JetModifierList listWithModifier = JetPsiFactory.createModifier(project, modifier);
+        PsiElement whiteSpace = JetPsiFactory.createWhiteSpace(project);
+        if (modifierList == null) {
+            PsiElement firstChild = newElement.getFirstChild();
+            newElement.addBefore(listWithModifier, firstChild);
+            newElement.addBefore(whiteSpace, firstChild);
+        }
+        else {
+            boolean replaced = false;
+            for (JetToken modifierThanCanBeReplaced : modifiersThanCanBeReplaced) {
+                if (modifierList.hasModifier(modifierThanCanBeReplaced)) {
+                    PsiElement openModifierPsi = modifierList.getModifierNode(modifierThanCanBeReplaced).getPsi();
+                    assert openModifierPsi != null;
+                    openModifierPsi.replace(listWithModifier.getFirstChild());
+                    replaced = true;
+                }
+            }
+            if (!replaced) {
+                PsiElement lastChild = modifierList.getLastChild();
+                modifierList.addAfter(listWithModifier.getFirstChild(), lastChild);
+                modifierList.addAfter(whiteSpace, lastChild);
+            }
+        }
+        return newElement;
+    }
+
+    @Override
+    public boolean startInWriteAction() {
+        return true;
+    }
+
+    public static JetIntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier, final JetToken[] modifiersThatCanBeReplaced) {
+        return new JetIntentionActionFactory<JetModifierListOwner>() {
+            @Override
+            public JetIntentionAction<JetModifierListOwner> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetModifierListOwner;
+                return new AddModifierFix((JetModifierListOwner) diagnostic.getPsiElement(), modifier, modifiersThatCanBeReplaced);
+            }
+        };
+    }
+    
+    public static JetIntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier) {
+        return createFactory(modifier, new JetToken[0]);
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFix.java
new file mode 100644
index 00000000000..ec8e3ee1a50
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFix.java
@@ -0,0 +1,52 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.JetClass;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
+
+/**
+ * @author svtk
+ */
+public class AddPrimaryConstructorFix extends JetIntentionAction<JetClass> {
+
+    public AddPrimaryConstructorFix(@NotNull JetClass element) {
+        super(element);
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        return "Add primary constructor to " + element.getName();
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Add primary constructor";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        JetClass newClass = (JetClass) element.copy();
+        assert !newClass.hasPrimaryConstructor();
+        PsiElement primaryConstructor = JetPsiFactory.createPrimaryConstructor(project);
+        newClass.addAfter(primaryConstructor, newClass.getNameIdentifier());
+        element.replace(newClass);
+    }
+
+    public static JetIntentionActionFactory<JetClass> createFactory() {
+        return new JetIntentionActionFactory<JetClass>() {
+            @Override
+            public JetIntentionAction<JetClass> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetClass;
+                return new AddPrimaryConstructorFix((JetClass) diagnostic.getPsiElement());
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java
new file mode 100644
index 00000000000..17590360691
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java
@@ -0,0 +1,73 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticParameters;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.JetParameter;
+import org.jetbrains.jet.lang.psi.JetPropertyAccessor;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
+import org.jetbrains.jet.lang.psi.JetTypeReference;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * @author svtk
+ */
+public class ChangeAccessorTypeFix extends JetIntentionAction<JetPropertyAccessor> {
+    private final JetType type;
+
+    public ChangeAccessorTypeFix(@NotNull JetPropertyAccessor element, JetType type) {
+        super(element);
+        this.type = type;
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        return (element.isGetter() ? "Change getter " : "Change setter parameter ") + "type to " + type;
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Change accessor type";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        JetPropertyAccessor newElement = (JetPropertyAccessor) element.copy();
+        JetTypeReference newTypeReference = JetPsiFactory.createType(project, type.toString());
+
+        if (element.isGetter()) {
+            JetTypeReference returnTypeReference = newElement.getReturnTypeReference();
+            assert returnTypeReference != null;
+            CodeEditUtil.replaceChild(newElement.getNode(), returnTypeReference.getNode(), newTypeReference.getNode());
+        }
+        else {
+            JetParameter parameter = newElement.getParameter();
+            assert parameter != null;
+            JetTypeReference typeReference = parameter.getTypeReference();
+            assert typeReference != null;
+            CodeEditUtil.replaceChild(parameter.getNode(), typeReference.getNode(), newTypeReference.getNode());
+        }
+        ImportClassHelper.perform(type, element, newElement);
+    }
+    
+    public static JetIntentionActionFactory<JetPropertyAccessor> createFactory() {
+        return new JetIntentionActionFactory<JetPropertyAccessor>() {
+            @Override
+            public JetIntentionAction<JetPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetPropertyAccessor;
+                DiagnosticWithParameters<PsiElement> diagnosticWithParameters = assertAndCastToDiagnosticWithParameters(diagnostic, DiagnosticParameters.TYPE);
+                JetType type = diagnosticWithParameters.getParameter(DiagnosticParameters.TYPE);
+                return new ChangeAccessorTypeFix((JetPropertyAccessor) diagnostic.getPsiElement(), type);
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java
new file mode 100644
index 00000000000..a55b23da7c8
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java
@@ -0,0 +1,64 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.JetProperty;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
+import org.jetbrains.jet.lexer.JetTokens;
+
+/**
+ * @author svtk
+ */
+public class ChangeVariableMutabilityFix extends JetIntentionAction<JetProperty> {
+    public ChangeVariableMutabilityFix(@NotNull JetProperty element) {
+        super(element);
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        return "Make variable " + (element.isVar() ? "immutable" : "mutable");
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Change variable mutability";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        JetProperty newElement = (JetProperty) element.copy();
+        if (newElement.isVar()) {
+            PsiElement varElement = newElement.getNode().findChildByType(JetTokens.VAR_KEYWORD).getPsi();
+
+            JetProperty valProperty = JetPsiFactory.createProperty(project, "x", "Any", false);
+            PsiElement valElement = valProperty.getNode().findChildByType(JetTokens.VAL_KEYWORD).getPsi();
+            CodeEditUtil.replaceChild(newElement.getNode(), varElement.getNode(), valElement.getNode());
+        }
+        else {
+            PsiElement valElement = newElement.getNode().findChildByType(JetTokens.VAL_KEYWORD).getPsi();
+
+            JetProperty varProperty = JetPsiFactory.createProperty(project, "x", "Any", true);
+            PsiElement varElement = varProperty.getNode().findChildByType(JetTokens.VAR_KEYWORD).getPsi();
+            CodeEditUtil.replaceChild(newElement.getNode(), valElement.getNode(), varElement.getNode());
+        }
+        element.replace(newElement);
+    }
+
+    public static JetIntentionActionFactory<JetProperty> createFactory() {
+        return new JetIntentionActionFactory<JetProperty>() {
+            @Override
+            public JetIntentionAction<JetProperty> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetProperty;
+                return new ChangeVariableMutabilityFix((JetProperty) diagnostic.getPsiElement());
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassHelper.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassHelper.java
new file mode 100644
index 00000000000..a8471ab2e96
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassHelper.java
@@ -0,0 +1,58 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.types.ErrorUtils;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.plugin.JetPluginUtil;
+
+import java.util.List;
+
+/**
+ * @author svtk
+ */
+public class ImportClassHelper {
+    public static void perform(@NotNull JetType type, @NotNull PsiElement element, @NotNull PsiElement newElement) {
+        PsiElement parent = element;
+        while (!(parent instanceof JetNamespace)) {
+            parent = parent.getParent();
+            assert parent != null;
+        }
+        JetNamespace namespace = (JetNamespace) parent;
+        List<JetImportDirective> importDirectives = namespace.getImportDirectives();
+
+        if (JetPluginUtil.checkTypeIsStandard(type, element.getProject()) || ErrorUtils.isError(type.getMemberScope().getContainingDeclaration())) {
+            element.replace(newElement);
+            return;
+        }
+
+        String typeFullName = JetPluginUtil.computeTypeFullName(type);
+
+        JetImportDirective newDirective = JetPsiFactory.createImportDirective(element.getProject(), typeFullName);
+
+        if (!importDirectives.isEmpty()) {
+            boolean isPresent = false;
+            for (JetImportDirective directive : importDirectives) {
+                if (directive.getText().endsWith(typeFullName) ||
+                    directive.getText().endsWith(typeFullName + ";")) {
+                    isPresent = true;
+                }
+            }
+            if (!isPresent) {
+                JetImportDirective lastDirective = importDirectives.get(importDirectives.size() - 1);
+                lastDirective.getParent().addAfter(newDirective, lastDirective);
+                lastDirective.getParent().addAfter(JetPsiFactory.createWhiteSpace(element.getProject(), "\n"), lastDirective);
+            }
+        }
+        else {
+            List<JetDeclaration> declarations = namespace.getDeclarations();
+            assert !declarations.isEmpty();
+            JetDeclaration firstDeclaration = declarations.iterator().next();
+            firstDeclaration.getParent().addBefore(newDirective, firstDeclaration);
+            firstDeclaration.getParent().addBefore(JetPsiFactory.createWhiteSpace(element.getProject(), "\n\n"), firstDeclaration);
+        }
+        element.replace(newElement);
+        parent.replace(namespace);
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionAction.java b/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionAction.java
new file mode 100644
index 00000000000..df6670a19c9
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionAction.java
@@ -0,0 +1,46 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.codeInsight.intention.IntentionAction;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticParameter;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
+
+import java.util.Arrays;
+
+/**
+* @author svtk
+*/
+public abstract class JetIntentionAction<T extends PsiElement> implements IntentionAction {
+    protected @NotNull T element;
+
+    public JetIntentionAction(@NotNull T element) {
+        this.element = element;
+    }
+
+    @Override
+    public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+        return element.isValid();
+    }
+
+    @Override
+    public boolean startInWriteAction() {
+        return true;
+    }
+
+    public static DiagnosticWithParameters<PsiElement> assertAndCastToDiagnosticWithParameters(Diagnostic diagnostic, DiagnosticParameter... parameters) {
+        assert diagnostic instanceof DiagnosticWithParameters :
+                "For this type of quick fix diagnostic with additional " +
+                (parameters.length == 1 ? "parameter '" + parameters[0] + "'" : "parameters " + Arrays.asList(parameters)) + " is expected";
+
+        for (DiagnosticParameter parameter : parameters) {
+            assert ((DiagnosticWithParameters) diagnostic).hasParameter(parameter) :
+                    "For this type of quick fix diagnostic with additional parameter '" + parameter + "' is expected";
+        }
+        return (DiagnosticWithParameters<PsiElement>) diagnostic;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionFactory.java b/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionFactory.java
new file mode 100644
index 00000000000..58e7296750d
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionFactory.java
@@ -0,0 +1,13 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+
+/**
+* @author svtk
+*/
+public interface JetIntentionActionFactory<T extends PsiElement> {
+
+    JetIntentionAction<T> createAction(DiagnosticWithPsiElement diagnostic);
+
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ModifierFix.java
new file mode 100644
index 00000000000..fa1c38e7a6c
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ModifierFix.java
@@ -0,0 +1,38 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiNameIdentifierOwner;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetModifierListOwner;
+import org.jetbrains.jet.lang.psi.JetPropertyAccessor;
+import org.jetbrains.jet.lexer.JetKeywordToken;
+
+/**
+ * @author svtk
+ */
+public abstract class ModifierFix extends JetIntentionAction<JetModifierListOwner> {
+    protected final JetKeywordToken modifier;
+
+    protected ModifierFix(@NotNull JetModifierListOwner element, JetKeywordToken modifier) {
+        super(element);
+        this.modifier = modifier;
+    }
+
+    @NotNull
+    protected String getElementName() {
+        String name = null;
+        if (element instanceof PsiNameIdentifierOwner) {
+            PsiElement nameIdentifier = ((PsiNameIdentifierOwner) element).getNameIdentifier();
+            if (nameIdentifier != null) {
+                name = nameIdentifier.getText();
+            }
+        }
+        else if (element instanceof JetPropertyAccessor) {
+            name = ((JetPropertyAccessor) element).getNamePlaceholder().getText();
+        }
+        if (name == null) {
+            name = element.getText();
+        }
+        return "'" + name + "'";
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java
new file mode 100644
index 00000000000..02ffaa2b339
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java
@@ -0,0 +1,72 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticParameter;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElementImpl;
+
+/**
+ * @author svtk
+ */
+public class QuickFixUtil {
+    private QuickFixUtil() {
+    }
+
+    public static <T extends PsiElement, P extends T> JetIntentionActionFactory<PsiElement> createFactoryRedirectingAdditionalInfoToAnotherFactory(final JetIntentionActionFactory<T> factory, final DiagnosticParameter<P> parameter) {
+        return new JetIntentionActionFactory<PsiElement>() {
+            @Override
+            public JetIntentionAction<PsiElement> createAction(DiagnosticWithPsiElement diagnostic) {
+
+                DiagnosticWithParameters<PsiElement> diagnosticWithParameters = JetIntentionAction.assertAndCastToDiagnosticWithParameters(diagnostic, parameter);
+                P element = diagnosticWithParameters.getParameter(parameter);
+                return (JetIntentionAction<PsiElement>) factory.createAction(new DiagnosticWithPsiElementImpl<T>(diagnostic.getFactory(), diagnostic.getSeverity(), diagnostic.getMessage(), element));
+            }
+        };
+    }
+
+    public static <T extends PsiElement, P extends T> JetIntentionActionFactory<PsiElement> createFactoryRedirectingAdditionalInfoIfAnyToAnotherFactory(final JetIntentionActionFactory<T> factory, final DiagnosticParameter<P> parameter) {
+        return new JetIntentionActionFactory<PsiElement>() {
+            @Override
+            public JetIntentionAction<PsiElement> createAction(DiagnosticWithPsiElement diagnostic) {
+
+                if (diagnostic instanceof DiagnosticWithParameters && ((DiagnosticWithParameters<PsiElement>) diagnostic).hasParameter(parameter)) {
+                    P element = ((DiagnosticWithParameters<PsiElement>) diagnostic).getParameter(parameter);
+                    return (JetIntentionAction<PsiElement>) factory.createAction(new DiagnosticWithPsiElementImpl<T>(diagnostic.getFactory(), diagnostic.getSeverity(), diagnostic.getMessage(), element));
+                }
+                return createDoNothingAction(diagnostic);
+            }
+        };
+    }
+
+    public static JetIntentionAction<PsiElement> createDoNothingAction(DiagnosticWithPsiElement diagnostic) {
+        return new JetIntentionAction<PsiElement>(diagnostic.getPsiElement()) {
+            @Override
+            public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+                return false;
+            }
+
+            @NotNull
+            @Override
+            public String getText() {
+                throw new UnsupportedOperationException();
+            }
+
+            @NotNull
+            @Override
+            public String getFamilyName() {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java
new file mode 100644
index 00000000000..a2f4fb48753
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java
@@ -0,0 +1,109 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticParameters;
+import org.jetbrains.jet.lang.diagnostics.Errors;
+import org.jetbrains.jet.lang.diagnostics.PsiElementOnlyDiagnosticFactory;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetTokens;
+
+import java.util.Collection;
+
+/**
+* @author svtk
+*/
+public class QuickFixes {
+    private static final Multimap<PsiElementOnlyDiagnosticFactory, JetIntentionActionFactory> actionMap = HashMultimap.create();
+
+    public static Collection<JetIntentionActionFactory> get(PsiElementOnlyDiagnosticFactory diagnosticFactory) {
+        return actionMap.get(diagnosticFactory);
+    }
+
+    private QuickFixes() {}
+
+    private static <T extends PsiElement> void add(PsiElementOnlyDiagnosticFactory<? extends T> diagnosticFactory, JetIntentionActionFactory<T> actionFactory) {
+        actionMap.put(diagnosticFactory, actionFactory);
+    }
+
+    static {
+        JetIntentionActionFactory<JetModifierListOwner> removeAbstractModifierFactory = RemoveModifierFix.createFactory(JetTokens.ABSTRACT_KEYWORD);
+        JetIntentionActionFactory<JetModifierListOwner> addAbstractModifierFactory = AddModifierFix.createFactory(JetTokens.ABSTRACT_KEYWORD, new JetToken[]{JetTokens.OPEN_KEYWORD, JetTokens.FINAL_KEYWORD});
+
+        add(Errors.ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS, removeAbstractModifierFactory);
+        add(Errors.ABSTRACT_PROPERTY_NOT_IN_CLASS, removeAbstractModifierFactory);
+
+        JetIntentionActionFactory<JetProperty> removePartsFromPropertyFactory = RemovePartsFromPropertyFix.createFactory();
+        add(Errors.ABSTRACT_PROPERTY_WITH_INITIALIZER, removeAbstractModifierFactory);
+        add(Errors.ABSTRACT_PROPERTY_WITH_INITIALIZER, removePartsFromPropertyFactory);
+
+        add(Errors.ABSTRACT_PROPERTY_WITH_GETTER, removeAbstractModifierFactory);
+        add(Errors.ABSTRACT_PROPERTY_WITH_GETTER, removePartsFromPropertyFactory);
+
+        add(Errors.ABSTRACT_PROPERTY_WITH_SETTER, removeAbstractModifierFactory);
+        add(Errors.ABSTRACT_PROPERTY_WITH_SETTER, removePartsFromPropertyFactory);
+
+        add(Errors.PROPERTY_INITIALIZER_IN_TRAIT, removePartsFromPropertyFactory);
+
+        add(Errors.MUST_BE_INITIALIZED_OR_BE_ABSTRACT, addAbstractModifierFactory);
+
+        JetIntentionActionFactory<PsiElement> addAbstractToClassFactory = QuickFixUtil.createFactoryRedirectingAdditionalInfoToAnotherFactory(addAbstractModifierFactory, DiagnosticParameters.CLASS);
+        add(Errors.ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory);
+        add(Errors.ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory);
+
+        JetIntentionActionFactory<JetFunctionOrPropertyAccessor> removeFunctionBodyFactory = RemoveFunctionBodyFix.createFactory();
+        add(Errors.ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory);
+        add(Errors.ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory);
+
+        add(Errors.ABSTRACT_FUNCTION_WITH_BODY, removeAbstractModifierFactory);
+        add(Errors.ABSTRACT_FUNCTION_WITH_BODY, removeFunctionBodyFactory);
+
+        JetIntentionActionFactory<JetFunctionOrPropertyAccessor> addFunctionBodyFactory = AddFunctionBodyFix.createFactory();
+        add(Errors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addAbstractModifierFactory);
+        add(Errors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addFunctionBodyFactory);
+
+        add(Errors.NON_MEMBER_ABSTRACT_FUNCTION, removeAbstractModifierFactory);
+        add(Errors.NON_MEMBER_ABSTRACT_ACCESSOR, removeAbstractModifierFactory);
+        add(Errors.NON_MEMBER_FUNCTION_NO_BODY, addFunctionBodyFactory);
+
+        add(Errors.NOTHING_TO_OVERRIDE, RemoveModifierFix.createFactory(JetTokens.OVERRIDE_KEYWORD));
+        add(Errors.VIRTUAL_MEMBER_HIDDEN, AddModifierFix.createFactory(JetTokens.OVERRIDE_KEYWORD, new JetToken[] {JetTokens.OPEN_KEYWORD}));
+
+        add(Errors.VAL_WITH_SETTER, ChangeVariableMutabilityFix.createFactory());
+
+        add(Errors.USELESS_CAST_STATIC_ASSERT_IS_FINE, ReplaceOperationInBinaryExpressionFix.createChangeCastToStaticAssertFactory());
+        add(Errors.USELESS_CAST, RemoveRightPartOfBinaryExpressionFix.createRemoveCastFactory());
+
+        JetIntentionActionFactory<JetPropertyAccessor> changeAccessorTypeFactory = ChangeAccessorTypeFix.createFactory();
+        add(Errors.WRONG_SETTER_PARAMETER_TYPE, changeAccessorTypeFactory);
+        add(Errors.WRONG_GETTER_RETURN_TYPE, changeAccessorTypeFactory);
+
+        add(Errors.USELESS_ELVIS, RemoveRightPartOfBinaryExpressionFix.createRemoveElvisOperatorFactory());
+
+        add(Errors.UNNECESSARY_SAFE_CALL, ReplaceSafeCallToDotCall.createFactory());
+
+        JetIntentionActionFactory<JetModifierList> removeRedundantModifierFactory = RemoveRedundantModifierFix.createFactory();
+        add(Errors.REDUNDANT_MODIFIER, removeRedundantModifierFactory);
+        add(Errors.REDUNDANT_MODIFIER_IN_TRAIT, removeRedundantModifierFactory);
+        add(Errors.TRAIT_CAN_NOT_BE_FINAL, RemoveModifierFix.createFactory(JetTokens.FINAL_KEYWORD));
+
+        add(Errors.PROPERTY_INITIALIZER_NO_PRIMARY_CONSTRUCTOR, RemovePartsFromPropertyFix.createRemoveInitializerFactory());
+
+        JetIntentionActionFactory<JetClass> addPrimaryConstructorFactory = AddPrimaryConstructorFix.createFactory();
+        add(Errors.PROPERTY_INITIALIZER_NO_PRIMARY_CONSTRUCTOR, QuickFixUtil.createFactoryRedirectingAdditionalInfoToAnotherFactory(addPrimaryConstructorFactory, DiagnosticParameters.CLASS));
+        add(Errors.PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY, addPrimaryConstructorFactory);
+
+        JetIntentionActionFactory<JetModifierListOwner> addOpenModifierFactory = AddModifierFix.createFactory(JetTokens.OPEN_KEYWORD, new JetToken[]{JetTokens.FINAL_KEYWORD});
+        JetIntentionActionFactory<JetModifierListOwner> removeOpenModifierFactory = RemoveModifierFix.createFactory(JetTokens.OPEN_KEYWORD);
+        add(Errors.NON_FINAL_MEMBER_IN_FINAL_CLASS, QuickFixUtil.createFactoryRedirectingAdditionalInfoToAnotherFactory(addOpenModifierFactory, DiagnosticParameters.CLASS));
+        add(Errors.NON_FINAL_MEMBER_IN_FINAL_CLASS, removeOpenModifierFactory);
+        add(Errors.NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY, QuickFixUtil.createFactoryRedirectingAdditionalInfoToAnotherFactory(addOpenModifierFactory, DiagnosticParameters.PROPERTY));
+        add(Errors.NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY, removeOpenModifierFactory);
+
+        add(Errors.ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY, QuickFixUtil.createFactoryRedirectingAdditionalInfoToAnotherFactory(addAbstractModifierFactory, DiagnosticParameters.PROPERTY));
+        add(Errors.ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY, removeAbstractModifierFactory);
+    }
+}
+
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionBodyFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionBodyFix.java
new file mode 100644
index 00000000000..4b7bb7fd187
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionBodyFix.java
@@ -0,0 +1,63 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiWhiteSpace;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.*;
+
+/**
+ * @author svtk
+ */
+public class RemoveFunctionBodyFix extends JetIntentionAction<JetFunctionOrPropertyAccessor> {
+
+    public RemoveFunctionBodyFix(@NotNull JetFunctionOrPropertyAccessor element) {
+        super(element);
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        return "Remove function body";
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Remove function body";
+    }
+
+    @Override
+    public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+        return super.isAvailable(project, editor, file) &&
+                element.getBodyExpression() != null;
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        JetFunctionOrPropertyAccessor newElement = (JetFunctionOrPropertyAccessor) element.copy();
+        JetExpression bodyExpression = newElement.getBodyExpression();
+        if (bodyExpression != null) {
+            PsiElement prevSibling = bodyExpression.getPrevSibling();
+            if (prevSibling instanceof PsiWhiteSpace) {
+                ((JetElement)newElement).deleteChildInternal(prevSibling.getNode());
+            }
+            ((JetElement)newElement).deleteChildInternal(bodyExpression.getNode());
+        }
+        element.replace(newElement);
+    }
+
+    public static JetIntentionActionFactory<JetFunctionOrPropertyAccessor> createFactory() {
+        return new JetIntentionActionFactory<JetFunctionOrPropertyAccessor>() {
+            @Override
+            public JetIntentionAction<JetFunctionOrPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetFunctionOrPropertyAccessor;
+                return new RemoveFunctionBodyFix((JetFunctionOrPropertyAccessor) diagnostic.getPsiElement());
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java
new file mode 100644
index 00000000000..ac68ec8c38c
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java
@@ -0,0 +1,93 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.extapi.psi.ASTDelegatePsiElement;
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiWhiteSpace;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.JetElement;
+import org.jetbrains.jet.lang.psi.JetModifierList;
+import org.jetbrains.jet.lang.psi.JetModifierListOwner;
+import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetTokens;
+
+/**
+* @author svtk
+*/
+public class RemoveModifierFix extends ModifierFix {
+
+    public RemoveModifierFix(@NotNull JetModifierListOwner element, JetKeywordToken modifier) {
+        super(element, modifier);
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        if (modifier == JetTokens.ABSTRACT_KEYWORD || modifier == JetTokens.OPEN_KEYWORD) {
+            return "Make " + getElementName() + " not " + modifier.getValue();
+        }
+        return "Remove '" + modifier.getValue() + "' modifier";
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Remove modifier";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        JetModifierListOwner newElement = (JetModifierListOwner) element.copy();
+        element.replace(removeModifier(newElement, modifier));
+    }
+
+    @NotNull
+    /*package*/ static <T extends JetModifierListOwner> T removeModifier(T element, JetToken modifier) {
+        JetModifierList modifierList = element.getModifierList();
+        assert modifierList != null;
+        removeModifierFromList(modifierList, modifier);
+        if (modifierList.getFirstChild() == null) {
+            PsiElement whiteSpace = modifierList.getNextSibling();
+            assert element instanceof JetElement;
+            ((JetElement) element).deleteChildInternal(modifierList.getNode());
+            removeWhiteSpace((JetElement) element, whiteSpace);
+        }
+        return element;
+    }
+
+    /*package*/ static JetModifierList removeModifierFromList(@NotNull JetModifierList modifierList, JetToken modifier) {
+        assert modifierList.hasModifier(modifier);
+        ASTNode modifierNode = modifierList.getModifierNode(modifier);
+        PsiElement whiteSpace = modifierNode.getPsi().getNextSibling();
+        boolean wsRemoved = removeWhiteSpace(modifierList, whiteSpace);
+        modifierList.deleteChildInternal(modifierNode);
+        if (!wsRemoved) {
+            removeWhiteSpace(modifierList, modifierList.getLastChild());
+        }
+        return modifierList;
+    }
+
+    private static boolean removeWhiteSpace(ASTDelegatePsiElement element, PsiElement subElement) {
+        if (subElement instanceof PsiWhiteSpace) {
+            element.deleteChildInternal(subElement.getNode());
+            return true;
+        }
+        return false;
+    }
+
+    public static JetIntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier) {
+        return new JetIntentionActionFactory<JetModifierListOwner>() {
+            @Override
+            public JetIntentionAction<JetModifierListOwner> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetModifierListOwner;
+                return new RemoveModifierFix((JetModifierListOwner) diagnostic.getPsiElement(), modifier);
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java
new file mode 100644
index 00000000000..34c99ff3155
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java
@@ -0,0 +1,143 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Pair;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticParameters;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * @author svtk
+ */
+public class RemovePartsFromPropertyFix extends JetIntentionAction<JetProperty> {
+    private final JetType type;
+    private final boolean removeInitializer;
+    private final boolean removeGetter;
+    private final boolean removeSetter;
+    
+    private RemovePartsFromPropertyFix(@NotNull JetProperty element, @Nullable JetType type, boolean removeInitializer, boolean removeGetter, boolean removeSetter) {
+        super(element);
+        this.type = type;
+        this.removeInitializer = removeInitializer;
+        this.removeGetter = removeGetter;
+        this.removeSetter = removeSetter;
+    }
+    
+    private RemovePartsFromPropertyFix(@NotNull JetProperty element, @Nullable JetType type) {
+        this(element, type, element.getInitializer() != null,
+             element.getGetter() != null && element.getGetter().getBodyExpression() != null,
+             element.getSetter() != null && element.getSetter().getBodyExpression() != null);
+    }
+
+    private RemovePartsFromPropertyFix(@NotNull JetProperty element, boolean removeInitializer, boolean removeGetter, boolean removeSetter) {
+        this(element, null, removeInitializer, removeGetter, removeSetter);
+    }
+
+    private static String partsToRemove(boolean getter, boolean setter, boolean initializer) {
+        StringBuilder sb = new StringBuilder();
+        if (getter) {
+            sb.append("getter");
+            if (setter && initializer) {
+                sb.append(", ");
+            }
+            else if (setter || initializer) {
+                sb.append(" and ");
+            }
+        }
+        if (setter) {
+            sb.append("setter");
+            if (initializer) {
+                sb.append(" and ");
+            }
+        }
+        if (initializer) {
+            sb.append("initializer");
+        }
+        return sb.toString();
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        return "Remove " + partsToRemove(removeGetter, removeSetter, removeInitializer) + " from property";
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Remove parts from property to make it abstract";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        JetProperty newElement = (JetProperty) element.copy();
+        JetPropertyAccessor getter = newElement.getGetter();
+        if (removeGetter && getter != null) {
+            newElement.deleteChildInternal(getter.getNode());
+        }
+        JetPropertyAccessor setter = newElement.getSetter();
+        if (removeSetter && setter != null) {
+            newElement.deleteChildInternal(setter.getNode());
+        }
+        JetExpression initializer = newElement.getInitializer();
+        boolean needImport = false;
+        if (removeInitializer && initializer != null) {
+            PsiElement nameIdentifier = newElement.getNameIdentifier();
+            assert nameIdentifier != null;
+            PsiElement nextSibling = nameIdentifier.getNextSibling();
+            assert nextSibling != null;
+            newElement.deleteChildRange(nextSibling, initializer);
+
+            if (newElement.getPropertyTypeRef() == null && type != null) {
+                newElement = addPropertyType(project, newElement, type);
+                needImport = true;
+            }
+        }
+        if (needImport) {
+            ImportClassHelper.perform(type, element, newElement);
+        } else {
+            element.replace(newElement);
+        }
+    }
+
+    public static JetProperty addPropertyType(Project project, JetProperty property, JetType type) {
+        JetProperty newProperty = (JetProperty) property.copy();
+        JetTypeReference typeReference = JetPsiFactory.createType(project, type.toString());
+        Pair<PsiElement, PsiElement> colon = JetPsiFactory.createColon(project);
+        PsiElement nameIdentifier = newProperty.getNameIdentifier();
+        assert nameIdentifier != null;
+        newProperty.addAfter(typeReference, nameIdentifier);
+        newProperty.addRangeAfter(colon.getFirst(), colon.getSecond(), nameIdentifier);
+        return newProperty;
+    }
+
+    public static JetIntentionActionFactory<JetProperty> createFactory() {
+        return new JetIntentionActionFactory<JetProperty>() {
+            @Override
+            public JetIntentionAction<JetProperty> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetProperty;
+                DiagnosticWithParameters<PsiElement> diagnosticWithParameters = assertAndCastToDiagnosticWithParameters(diagnostic, DiagnosticParameters.TYPE);
+                JetType type = diagnosticWithParameters.getParameter(DiagnosticParameters.TYPE);
+                return new RemovePartsFromPropertyFix((JetProperty) diagnostic.getPsiElement(), type);
+            }
+        };
+    }
+
+    public static JetIntentionActionFactory<JetProperty> createRemoveInitializerFactory() {
+        return new JetIntentionActionFactory<JetProperty>() {
+            @Override
+            public JetIntentionAction<JetProperty> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetProperty;
+                return new RemovePartsFromPropertyFix((JetProperty) diagnostic.getPsiElement(), true, false, false);
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRedundantModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRedundantModifierFix.java
new file mode 100644
index 00000000000..4c895b3ebcf
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRedundantModifierFix.java
@@ -0,0 +1,54 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticParameters;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.JetModifierList;
+import org.jetbrains.jet.lexer.JetKeywordToken;
+
+/**
+ * @author svtk
+ */
+public class RemoveRedundantModifierFix extends JetIntentionAction<JetModifierList> {
+    private JetKeywordToken redundantModifier;
+    public RemoveRedundantModifierFix(@NotNull JetModifierList element, @NotNull JetKeywordToken redundantModifier) {
+        super(element);
+        this.redundantModifier = redundantModifier;
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        return "Remove redundant '" + redundantModifier + "' modifier";
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Remove redundant modifier";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        JetModifierList newElement = (JetModifierList) element.copy();
+        element.replace(RemoveModifierFix.removeModifierFromList(newElement, redundantModifier));
+    }
+
+    public static JetIntentionActionFactory<JetModifierList> createFactory() {
+        return new JetIntentionActionFactory<JetModifierList>() {
+            @Override
+            public JetIntentionAction<JetModifierList> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetModifierList;
+                DiagnosticWithParameters<PsiElement> diagnosticWithParameters = assertAndCastToDiagnosticWithParameters(diagnostic, DiagnosticParameters.MODIFIER);
+                JetKeywordToken modifier = diagnosticWithParameters.getParameter(DiagnosticParameters.MODIFIER);
+                return new RemoveRedundantModifierFix((JetModifierList) diagnostic.getPsiElement(), modifier);
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRightPartOfBinaryExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRightPartOfBinaryExpressionFix.java
new file mode 100644
index 00000000000..61b72d624c9
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRightPartOfBinaryExpressionFix.java
@@ -0,0 +1,71 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiFile;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.JetBinaryExpression;
+import org.jetbrains.jet.lang.psi.JetBinaryExpressionWithTypeRHS;
+import org.jetbrains.jet.lang.psi.JetExpression;
+
+/**
+ * @author svtk
+ */
+public abstract class RemoveRightPartOfBinaryExpressionFix<T extends JetExpression> extends JetIntentionAction<T> {
+    public RemoveRightPartOfBinaryExpressionFix(@NotNull T element) {
+        super(element);
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Remove right part of a binary expression";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        if (element instanceof JetBinaryExpression) {
+            JetBinaryExpression newElement = (JetBinaryExpression) element.copy();
+            element.replace(newElement.getLeft());
+        }
+        else if (element instanceof JetBinaryExpressionWithTypeRHS) {
+            JetBinaryExpressionWithTypeRHS newElement = (JetBinaryExpressionWithTypeRHS) element.copy();
+            element.replace(newElement.getLeft());
+        }
+    }
+
+    public static JetIntentionActionFactory<JetBinaryExpressionWithTypeRHS> createRemoveCastFactory() {
+        return new JetIntentionActionFactory<JetBinaryExpressionWithTypeRHS>() {
+            @Override
+            public JetIntentionAction<JetBinaryExpressionWithTypeRHS> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetBinaryExpressionWithTypeRHS;
+                return new RemoveRightPartOfBinaryExpressionFix<JetBinaryExpressionWithTypeRHS>((JetBinaryExpressionWithTypeRHS) diagnostic.getPsiElement()) {
+                    @NotNull
+                    @Override
+                    public String getText() {
+                        return "Remove cast";
+                    }
+                };
+            }
+        };
+    }
+
+    public static JetIntentionActionFactory<JetBinaryExpression> createRemoveElvisOperatorFactory() {
+        return new JetIntentionActionFactory<JetBinaryExpression>() {
+            @Override
+            public JetIntentionAction<JetBinaryExpression> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetBinaryExpression;
+                return new RemoveRightPartOfBinaryExpressionFix<JetBinaryExpression>((JetBinaryExpression) diagnostic.getPsiElement()) {
+                    @NotNull
+                    @Override
+                    public String getText() {
+                        return "Remove elvis operator";
+                    }
+                };
+            }
+        };
+    }
+}
+
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java
new file mode 100644
index 00000000000..14231b22689
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java
@@ -0,0 +1,57 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.JetBinaryExpressionWithTypeRHS;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
+
+/**
+ * @author svtk
+ */
+public abstract class ReplaceOperationInBinaryExpressionFix<T extends JetExpression> extends JetIntentionAction<T> {
+    private final String expressionWithNecessaryOperation;
+    public ReplaceOperationInBinaryExpressionFix(@NotNull T element, String expressionWithNecessaryOperation) {
+        super(element);
+        this.expressionWithNecessaryOperation = expressionWithNecessaryOperation;
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Replace operation in a binary expression";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        if (element instanceof JetBinaryExpressionWithTypeRHS) {
+            JetBinaryExpressionWithTypeRHS expression = (JetBinaryExpressionWithTypeRHS) JetPsiFactory.createExpression(project, expressionWithNecessaryOperation);
+
+            JetBinaryExpressionWithTypeRHS newElement = (JetBinaryExpressionWithTypeRHS) element.copy();
+            CodeEditUtil.replaceChild(newElement.getNode(), newElement.getOperationSign().getNode(), expression.getOperationSign().getNode());
+
+            element.replace(newElement);
+        }
+    }
+
+    public static JetIntentionActionFactory<JetBinaryExpressionWithTypeRHS> createChangeCastToStaticAssertFactory() {
+        return new JetIntentionActionFactory<JetBinaryExpressionWithTypeRHS>() {
+            @Override
+            public JetIntentionAction<JetBinaryExpressionWithTypeRHS> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetBinaryExpressionWithTypeRHS;
+                return new ReplaceOperationInBinaryExpressionFix<JetBinaryExpressionWithTypeRHS>((JetBinaryExpressionWithTypeRHS) diagnostic.getPsiElement(), "2 : Int") {
+                    @NotNull
+                    @Override
+                    public String getText() {
+                        return "Replace a cast with a static assert";
+                    }
+                };
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallToDotCall.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallToDotCall.java
new file mode 100644
index 00000000000..61a8cc6e0ad
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallToDotCall.java
@@ -0,0 +1,62 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
+import org.jetbrains.jet.lang.psi.*;
+
+/**
+ * @author svtk
+ */
+public class ReplaceSafeCallToDotCall extends JetIntentionAction<JetElement> {
+
+    public ReplaceSafeCallToDotCall(@NotNull JetElement element) {
+        super(element);
+    }
+
+    @NotNull
+    @Override
+    public String getText() {
+        return "Replace to dot call";
+    }
+
+    @NotNull
+    @Override
+    public String getFamilyName() {
+        return "Replace safe call to dot call";
+    }
+
+    @Override
+    public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+        if (element instanceof JetSafeQualifiedExpression) {
+            JetSafeQualifiedExpression safeQualifiedExpression = (JetSafeQualifiedExpression) element;
+            JetDotQualifiedExpression newElement = (JetDotQualifiedExpression) JetPsiFactory.createExpression(project, "x.foo");
+
+            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);
+        }
+    }
+
+    public static JetIntentionActionFactory<JetElement> createFactory() {
+        return new JetIntentionActionFactory<JetElement>() {
+            @Override
+            public JetIntentionAction<JetElement> createAction(DiagnosticWithPsiElement diagnostic) {
+                assert diagnostic.getPsiElement() instanceof JetElement;
+                return new ReplaceSafeCallToDotCall((JetElement) diagnostic.getPsiElement());
+            }
+        };
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetArrayAccessReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetArrayAccessReference.java
new file mode 100644
index 00000000000..f59c7c7b02b
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/references/JetArrayAccessReference.java
@@ -0,0 +1,54 @@
+package org.jetbrains.jet.plugin.references;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.MultiRangeReference;
+import com.intellij.psi.PsiReference;
+import org.jetbrains.jet.lang.psi.JetArrayAccessExpression;
+import org.jetbrains.jet.lang.psi.JetContainerNode;
+import org.jetbrains.jet.lexer.JetTokens;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+* @author yole
+*/
+class JetArrayAccessReference extends JetPsiReference implements MultiRangeReference {
+    private JetArrayAccessExpression expression;
+
+    public static PsiReference[] create(JetArrayAccessExpression expression) {
+        JetContainerNode indicesNode = expression.getIndicesNode();
+        return indicesNode == null ? PsiReference.EMPTY_ARRAY : new PsiReference[] { new JetArrayAccessReference(expression) };
+    }
+
+    public JetArrayAccessReference(JetArrayAccessExpression expression) {
+        super(expression);
+        this.expression = expression;
+    }
+
+    @Override
+    public TextRange getRangeInElement() {
+        return getElement().getTextRange().shiftRight(-getElement().getTextOffset());
+    }
+
+    @Override
+    public List<TextRange> getRanges() {
+        List<TextRange> list = new ArrayList<TextRange>();
+
+        JetContainerNode indices = expression.getIndicesNode();
+        TextRange textRange = indices.getNode().findChildByType(JetTokens.LBRACKET).getTextRange();
+        TextRange lBracketRange = textRange.shiftRight(-expression.getTextOffset());
+
+        list.add(lBracketRange);
+
+        ASTNode rBracket = indices.getNode().findChildByType(JetTokens.RBRACKET);
+        if (rBracket != null) {
+            textRange = rBracket.getTextRange();
+            TextRange rBracketRange = textRange.shiftRight(-expression.getTextOffset());
+            list.add(rBracketRange);
+        }
+
+        return list;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java
new file mode 100644
index 00000000000..a771388c338
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java
@@ -0,0 +1,104 @@
+package org.jetbrains.jet.plugin.references;
+
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementResolveResult;
+import com.intellij.psi.PsiPolyVariantReference;
+import com.intellij.psi.ResolveResult;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.JetReferenceExpression;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingContextUtils;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
+
+import java.util.Collection;
+
+import static org.jetbrains.jet.lang.resolve.BindingContext.AMBIGUOUS_REFERENCE_TARGET;
+import static org.jetbrains.jet.lang.resolve.BindingContext.DESCRIPTOR_TO_DECLARATION;
+
+public abstract class JetPsiReference implements PsiPolyVariantReference {
+    protected final JetReferenceExpression myExpression;
+
+    protected JetPsiReference(JetReferenceExpression expression) {
+        this.myExpression = expression;
+    }
+
+    @Override
+    public PsiElement getElement() {
+        return myExpression;
+    }
+
+    @NotNull
+    @Override
+    public ResolveResult[] multiResolve(boolean incompleteCode) {
+        return doMultiResolve();
+    }
+
+    @Override
+    public PsiElement resolve() {
+        return doResolve();
+    }
+
+    @NotNull
+    @Override
+    public String getCanonicalText() {
+        return "<TBD>";
+    }
+
+    @Override
+    public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
+        throw new IncorrectOperationException();
+    }
+
+    @Override
+    public PsiElement bindToElement(@NotNull PsiElement element) throws IncorrectOperationException {
+        throw new IncorrectOperationException();
+    }
+
+    @Override
+    public boolean isReferenceTo(PsiElement element) {
+        return resolve() == element;
+    }
+
+    @NotNull
+    @Override
+    public Object[] getVariants() {
+        return EMPTY_ARRAY;
+    }
+
+    @Override
+    public boolean isSoft() {
+        return false;
+    }
+
+    protected PsiElement doResolve() {
+        JetFile file = (JetFile) getElement().getContainingFile();
+        BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
+        PsiElement psiElement = BindingContextUtils.resolveToDeclarationPsiElement(bindingContext, myExpression);
+        if (psiElement != null) {
+            return psiElement;
+        }
+        Collection<? extends DeclarationDescriptor> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression);
+        if (declarationDescriptors != null) return null;
+        return file;
+    }
+
+    protected ResolveResult[] doMultiResolve() {
+        JetFile file = (JetFile) getElement().getContainingFile();
+        BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
+        Collection<? extends DeclarationDescriptor> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression);
+        if (declarationDescriptors == null) return ResolveResult.EMPTY_ARRAY;
+        ResolveResult[] results = new ResolveResult[declarationDescriptors.size()];
+        int i = 0;
+        for (DeclarationDescriptor descriptor : declarationDescriptors) {
+            PsiElement element = bindingContext.get(DESCRIPTOR_TO_DECLARATION, descriptor);
+            if (element != null) {
+                results[i] = new PsiElementResolveResult(element, true);
+                i++;
+            }
+        }
+        return results;
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.java b/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.java
new file mode 100644
index 00000000000..b47fc0edccb
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.java
@@ -0,0 +1,45 @@
+package org.jetbrains.jet.plugin.references;
+
+import com.intellij.psi.*;
+import com.intellij.util.ProcessingContext;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetArrayAccessExpression;
+import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
+import org.jetbrains.jet.lang.psi.JetThisReferenceExpression;
+
+import static com.intellij.patterns.PlatformPatterns.psiElement;
+
+/**
+ * @author yole
+ */
+public class JetReferenceContributor extends PsiReferenceContributor {
+    @Override
+    public void registerReferenceProviders(PsiReferenceRegistrar registrar) {
+        registrar.registerReferenceProvider(psiElement(JetSimpleNameExpression.class),
+                                            new PsiReferenceProvider() {
+                                                @NotNull
+                                                @Override
+                                                public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext processingContext) {
+                                                    return new PsiReference[] { new JetSimpleNameReference((JetSimpleNameExpression) element) };
+                                                }
+                                            });
+
+        registrar.registerReferenceProvider(psiElement(JetThisReferenceExpression.class),
+                                            new PsiReferenceProvider() {
+                                                @NotNull
+                                                @Override
+                                                public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext processingContext) {
+                                                    return new PsiReference[] { new JetThisReference((JetThisReferenceExpression) element) };
+                                                }
+                                            });
+
+        registrar.registerReferenceProvider(psiElement(JetArrayAccessExpression.class),
+                                            new PsiReferenceProvider() {
+                                                @NotNull
+                                                @Override
+                                                public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext processingContext) {
+                                                    return JetArrayAccessReference.create((JetArrayAccessExpression) element);
+                                                }
+                                            });
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java
new file mode 100644
index 00000000000..b90af3696ef
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java
@@ -0,0 +1,115 @@
+package org.jetbrains.jet.plugin.references;
+
+import com.google.common.collect.Lists;
+import com.intellij.codeInsight.lookup.LookupElement;
+import com.intellij.codeInsight.lookup.LookupElementBuilder;
+import com.intellij.openapi.util.Iconable;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.PsiElement;
+import com.intellij.util.Function;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
+import org.jetbrains.jet.resolve.DescriptorRenderer;
+
+import java.util.List;
+
+/**
+* @author yole
+*/
+class JetSimpleNameReference extends JetPsiReference {
+    private final JetSimpleNameExpression myExpression;
+
+    public JetSimpleNameReference(JetSimpleNameExpression jetSimpleNameExpression) {
+        super(jetSimpleNameExpression);
+        myExpression = jetSimpleNameExpression;
+    }
+
+    @Override
+    public PsiElement getElement() {
+        return myExpression.getReferencedNameElement();
+    }
+
+    @Override
+    public TextRange getRangeInElement() {
+        return new TextRange(0, getElement().getTextLength());
+    }
+
+    @NotNull
+    @Override
+    public Object[] getVariants() {
+        PsiElement parent = myExpression.getParent();
+        if (parent instanceof JetQualifiedExpression) {
+            JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) parent;
+            JetExpression receiverExpression = qualifiedExpression.getReceiverExpression();
+            JetFile file = (JetFile) myExpression.getContainingFile();
+            BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
+            final JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, receiverExpression);
+            if (expressionType != null) {
+                return collectLookupElements(bindingContext, expressionType.getMemberScope());
+            }
+        }
+        else {
+            JetFile file = (JetFile) myExpression.getContainingFile();
+            BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
+            JetScope resolutionScope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, myExpression);
+            if (resolutionScope != null) {
+                return collectLookupElements(bindingContext, resolutionScope);
+            }
+        }
+
+        return EMPTY_ARRAY;
+    }
+
+    @Override
+    public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
+        PsiElement element = JetPsiFactory.createNameIdentifier(myExpression.getProject(), newElementName);
+        return myExpression.getReferencedNameElement().replace(element);
+    }
+
+    private Object[] collectLookupElements(BindingContext bindingContext, JetScope scope) {
+        List<LookupElement> result = Lists.newArrayList();
+        for (final DeclarationDescriptor descriptor : scope.getAllDescriptors()) {
+            PsiElement declaration = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, descriptor.getOriginal());
+            LookupElementBuilder element = LookupElementBuilder.create(descriptor.getName());
+            String typeText = "";
+            String tailText = "";
+            boolean tailTextGrayed = false;
+            if (descriptor instanceof FunctionDescriptor) {
+                FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
+                JetType returnType = functionDescriptor.getReturnType();
+                typeText = DescriptorRenderer.TEXT.renderType(returnType);
+                tailText = "(" + StringUtil.join(functionDescriptor.getValueParameters(), new Function<ValueParameterDescriptor, String>() {
+                    @Override
+                    public String fun(ValueParameterDescriptor valueParameterDescriptor) {
+                        return valueParameterDescriptor.getName() + ":" +
+                               DescriptorRenderer.TEXT.renderType(valueParameterDescriptor.getOutType());
+                    }
+                }, ",") + ")";
+            }
+            else if (descriptor instanceof VariableDescriptor) {
+                JetType outType = ((VariableDescriptor) descriptor).getOutType();
+                typeText = DescriptorRenderer.TEXT.renderType(outType);
+            }
+            else if (descriptor instanceof ClassDescriptor) {
+                tailText = " (" + DescriptorRenderer.getFQName(descriptor.getContainingDeclaration()) + ")";
+                tailTextGrayed = true;
+            }
+            else {
+                typeText = DescriptorRenderer.TEXT.render(descriptor);
+            }
+            element = element.setTailText(tailText, tailTextGrayed).setTypeText(typeText);
+            if (declaration != null) {
+                element = element.setIcon(declaration.getIcon(Iconable.ICON_FLAG_OPEN | Iconable.ICON_FLAG_VISIBILITY));
+            }
+            result.add(element);
+        }
+        return result.toArray();
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetThisReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetThisReference.java
new file mode 100644
index 00000000000..9f5f28ca023
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/references/JetThisReference.java
@@ -0,0 +1,18 @@
+package org.jetbrains.jet.plugin.references;
+
+import com.intellij.openapi.util.TextRange;
+import org.jetbrains.jet.lang.psi.JetThisReferenceExpression;
+
+/**
+* @author yole
+*/
+public class JetThisReference extends JetPsiReference {
+    public JetThisReference(JetThisReferenceExpression expression) {
+        super(expression);
+    }
+
+    @Override
+    public TextRange getRangeInElement() {
+        return new TextRange(0, getElement().getTextLength());
+    }
+}
diff --git a/idea/src/org/jetbrains/jet/plugin/structureView/JetStructureViewElement.java b/idea/src/org/jetbrains/jet/plugin/structureView/JetStructureViewElement.java
index 2f0c86f7e1e..ae8d861a16e 100644
--- a/idea/src/org/jetbrains/jet/plugin/structureView/JetStructureViewElement.java
+++ b/idea/src/org/jetbrains/jet/plugin/structureView/JetStructureViewElement.java
@@ -69,11 +69,6 @@ public class JetStructureViewElement implements StructureViewTreeElement {
                         ? PsiIconUtil.getProvidersIcon(myElement, open ? Iconable.ICON_FLAG_OPEN : Iconable.ICON_FLAG_CLOSED)
                         : null;
             }
-
-            @Override
-            public TextAttributesKey getTextAttributesKey() {
-                return null;
-            }
         };
     }
 
diff --git a/idea/src/org/jetbrains/jet/util/ManyMapImpl.java b/idea/src/org/jetbrains/jet/util/ManyMapImpl.java
deleted file mode 100644
index f4df65f2384..00000000000
--- a/idea/src/org/jetbrains/jet/util/ManyMapImpl.java
+++ /dev/null
@@ -1,73 +0,0 @@
-package org.jetbrains.jet.util;
-
-import com.google.common.collect.Maps;
-
-import java.util.Iterator;
-import java.util.Map;
-
-/**
-* @author abreslav
-*/
-public class ManyMapImpl implements MutableManyMap {
-
-    public static ManyMapImpl create() {
-        return new ManyMapImpl(Maps.<ManyMapKey<?, ?>, Object>newLinkedHashMap());
-    }
-
-    public static ManyMapImpl create(Map<ManyMapKey<?, ?>, Object> map) {
-        return new ManyMapImpl(map);
-    }
-
-    public static ManyMapImpl create(MapSupplier mapSupplier) {
-        return new ManyMapImpl(mapSupplier.<ManyMapKey<?, ?>, Object>get());
-    }
-    
-    private final Map<ManyMapKey<?, ?>, Object> map;
-
-    private ManyMapImpl(Map<ManyMapKey<?, ?>, Object> map) {
-        this.map = map;
-    }
-
-    @Override
-    public <K, V> void put(WritableSlice<K, V> slice, K key, V value) {
-        if (!slice.check(key, value)) {
-            return;
-        }
-        ManyMapKey<K, V> manyMapKey = slice.makeKey(key);
-        if (slice.getRewritePolicy().rewriteProcessingNeeded(key)) {
-            if (map.containsKey(manyMapKey)) {
-                //noinspection unchecked
-                if (!slice.getRewritePolicy().processRewrite(slice, key, (V) map.get(manyMapKey), value)) {
-                    return;
-                }
-            }
-        }
-        map.put(manyMapKey, value);
-        slice.afterPut(this, key, value);
-    }
-
-    @Override
-    public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
-        ManyMapKey<K, V> manyMapKey = slice.makeKey(key);
-        //noinspection unchecked
-        V value = (V) map.get(manyMapKey);
-        return slice.computeValue(this, key, value, value == null && !map.containsKey(manyMapKey));
-    }
-
-    @Override
-    public <K, V> boolean containsKey(ReadOnlySlice<K, V> slice, K key) {
-        return map.containsKey(slice.makeKey(key));
-    }
-
-    @Override
-    public <K, V> V remove(RemovableSlice<K, V> slice, K key) {
-        //noinspection unchecked
-        return (V) map.remove(slice.makeKey(key));
-    }
-
-    @Override
-    public Iterator<Map.Entry<ManyMapKey<?, ?>, ?>> iterator() {
-        //noinspection unchecked
-        return (Iterator) map.entrySet().iterator();
-    }
-}
diff --git a/idea/src/org/jetbrains/jet/util/ReadOnlySlice.java b/idea/src/org/jetbrains/jet/util/ReadOnlySlice.java
deleted file mode 100644
index 55ea30e59fb..00000000000
--- a/idea/src/org/jetbrains/jet/util/ReadOnlySlice.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package org.jetbrains.jet.util;
-
-/**
- * @author abreslav
- */
-public interface ReadOnlySlice<K, V> {
-    ManyMapKey<K, V> makeKey(K key);
-
-    V computeValue(ManyMap map, K key, V value, boolean valueNotFound);
-
-}
diff --git a/idea/testData/cfg/Basic.instructions b/idea/testData/cfg/Basic.instructions
index b5c79c02c71..43e9c080245 100644
--- a/idea/testData/cfg/Basic.instructions
+++ b/idea/testData/cfg/Basic.instructions
@@ -84,6 +84,7 @@ fun foo(a : Boolean, b : Int) : Unit {}
 ---------------------
 l0:
     <START>
+    read (Unit)
 l1:
     <END>
 error:
@@ -94,6 +95,7 @@ fun genfun<T>() : Unit {}
 ---------------------
 l0:
     <START>
+    read (Unit)
 l1:
     <END>
 error:
@@ -104,6 +106,7 @@ fun flfun(f : fun () : Any) : Unit {}
 ---------------------
 l0:
     <START>
+    read (Unit)
 l1:
     <END>
 error:
diff --git a/idea/testData/cfg/EmptyFunction.instructions b/idea/testData/cfg/EmptyFunction.instructions
index 78e2b0a1173..04fbe42e40a 100644
--- a/idea/testData/cfg/EmptyFunction.instructions
+++ b/idea/testData/cfg/EmptyFunction.instructions
@@ -3,6 +3,7 @@ fun empty() {}
 ---------------------
 l0:
     <START>
+    read (Unit)
 l1:
     <END>
 error:
diff --git a/idea/testData/checker/Abstract.jet b/idea/testData/checker/Abstract.jet
new file mode 100644
index 00000000000..ca35e2bac53
--- /dev/null
+++ b/idea/testData/checker/Abstract.jet
@@ -0,0 +1,166 @@
+namespace abstract
+
+class MyClass() {
+    //properties
+    val <error>a</error>: Int
+    val a1: Int = 1
+    <error>abstract</error> val a2: Int
+    <error>abstract</error> val a3: Int = 1
+
+    var <error>b</error>: Int                private set
+    var b1: Int = 0;                         private set
+    <error>abstract</error> var b2: Int      private set
+    <error>abstract</error> var b3: Int = 0; private set
+
+    var <error>c</error>: Int                set(v: Int) { $c = v }
+    var c1: Int = 0;                         set(v: Int) { $c1 = v }
+    <error>abstract</error> var c2: Int      set(v: Int) { $c2 = v }
+    <error>abstract</error> var c3: Int = 0; set(v: Int) { $c3 = v }
+
+    val e: Int                               get() = a
+    val e1: Int = <error>0</error>;          get() = a
+    <error>abstract</error> val e2: Int      get() = a
+    <error>abstract</error> val e3: Int = 0; get() = a
+
+    //methods
+    fun <error>f</error>()
+    fun g() {}
+    <error>abstract</error> fun h()
+    <error><error>abstract</error></error> fun j() {}
+}
+
+abstract class MyAbstractClass() {
+    //properties
+    val <error>a</error>: Int
+    val a1: Int = 1
+    abstract val a2: Int
+    abstract val a3: Int = <error>1</error>
+
+    var <error>b</error>: Int                private set
+    var b1: Int = 0;                         private set
+    abstract var b2: Int      private set
+    abstract var b3: Int = <error>0</error>; private set
+
+    var <error>c</error>: Int                set(v: Int) { $c = v }
+    var c1: Int = 0;                         set(v: Int) { $c1 = v }
+    abstract var c2: Int                     <error>set(v: Int) { $c2 = v }</error>
+    abstract var c3: Int = <error>0</error>; <error>set(v: Int) { $c3 = v }</error>
+
+    val e: Int                               get() = a
+    val e1: Int = <error>0</error>;          get() = a
+    abstract val e2: Int                     <error>get() = a</error>
+    abstract val e3: Int = <error>0</error>; <error>get() = a</error>
+
+    //methods
+    fun <error>f</error>()
+    fun g() {}
+    abstract fun h()
+    <error>abstract</error> fun j() {}
+}
+
+trait MyTrait {
+    //properties
+    val a: Int
+    val a1: Int = <error>1</error>
+    <warning>abstract</warning> val a2: Int
+    <warning>abstract</warning> val a3: Int = <error>1</error>
+
+    var b: Int                                                  private set
+    var b1: Int = <error>0</error>;                             private set
+    <warning>abstract</warning> var b2: Int                     private set
+    <warning>abstract</warning> var b3: Int = <error>0</error>; private set
+
+    var <error>c</error>: Int                                   set(v: Int) { $c = v }
+    var <error>c1</error>: Int = <error>0</error>;              set(v: Int) { $c1 = v }
+    <warning>abstract</warning> var c2: Int                     <error>set(v: Int) { $c2 = v }</error>
+    <warning>abstract</warning> var c3: Int = <error>0</error>; <error>set(v: Int) { $c3 = v }</error>
+
+    val e: Int                                                  get() = a
+    val e1: Int = <error>0</error>;                             get() = a
+    <warning>abstract</warning> val e2: Int                     <error>get() = a</error>
+    <warning>abstract</warning> val e3: Int = <error>0</error>; <error>get() = a</error>
+
+    //methods
+    fun f()
+    fun g() {}
+    <warning>abstract</warning> fun h()
+    <error>abstract</error> fun j() {}
+}
+
+enum class MyEnum() {
+    //properties
+    val <error>a</error>: Int
+    val a1: Int = 1
+    abstract val a2: Int
+    abstract val a3: Int = <error>1</error>
+
+    var <error>b</error>: Int                private set
+    var b1: Int = 0;                         private set
+    abstract var b2: Int      private set
+    abstract var b3: Int = <error>0</error>; private set
+
+    var <error>c</error>: Int                set(v: Int) { $c = v }
+    var c1: Int = 0;                         set(v: Int) { $c1 = v }
+    abstract var c2: Int                     <error>set(v: Int) { $c2 = v }</error>
+    abstract var c3: Int = <error>0</error>; <error>set(v: Int) { $c3 = v }</error>
+
+    val e: Int                               get() = a
+    val e1: Int = <error>0</error>;          get() = a
+    abstract val e2: Int                     <error>get() = a</error>
+    abstract val e3: Int = <error>0</error>; <error>get() = a</error>
+
+    //methods
+    fun <error>f</error>()
+    fun g() {}
+    abstract fun h()
+    <error>abstract</error> fun j() {}
+}
+
+abstract enum class MyAbstractEnum() {}
+
+namespace MyNamespace {
+    //properties
+    val <error>a</error>: Int
+    val a1: Int = 1
+    <error>abstract</error> val a2: Int
+    <error>abstract</error> val a3: Int = 1
+
+    var <error>b</error>: Int                private set
+    var b1: Int = 0;                         private set
+    <error>abstract</error> var b2: Int      private set
+    <error>abstract</error> var b3: Int = 0; private set
+
+    var <error>c</error>: Int                set(v: Int) { $c = v }
+    var c1: Int = 0;                         set(v: Int) { $c1 = v }
+    <error>abstract</error> var c2: Int      set(v: Int) { $c2 = v }
+    <error>abstract</error> var c3: Int = 0; set(v: Int) { $c3 = v }
+
+    val e: Int                               get() = a
+    val e1: Int = <error>0</error>;          get() = a
+    <error>abstract</error> val e2: Int      get() = a
+    <error>abstract</error> val e3: Int = 0; get() = a
+
+    //methods
+    fun <error>f</error>()
+    fun g() {}
+    <error>abstract</error> fun h()
+    <error>abstract</error> fun j() {}
+}
+
+//creating an instance
+abstract class B1(
+    val i: Int,
+    val s: String
+) {
+}
+
+class B2() : B1(1, "r") {}
+
+abstract class B3(i: Int) {
+    this(): this(1)
+}
+
+fun foo(a: B3) {
+    val a = <error>B3()</error>
+    val b = <error>B1(2, "s")</error>
+}
\ No newline at end of file
diff --git a/idea/testData/checker/BinaryCallsOnNullableValues.jet b/idea/testData/checker/BinaryCallsOnNullableValues.jet
index b05563cd548..285605c2a42 100644
--- a/idea/testData/checker/BinaryCallsOnNullableValues.jet
+++ b/idea/testData/checker/BinaryCallsOnNullableValues.jet
@@ -1,13 +1,13 @@
 class A() {
-  fun equals(a : Any?) : Boolean
+  fun equals(a : Any?) : Boolean = false
 }
 
 class B() {
-  fun equals(a : Any?) : Boolean?
+  fun equals(a : Any?) : Boolean? = false
 }
 
 class C() {
-  fun equals(a : Any?) : Int
+  fun equals(a : Any?) : Int = 0
 }
 
 fun f(): Unit {
@@ -32,7 +32,7 @@ fun f(): Unit {
   x !== 1
 
   x<error>..</error>2
-  x <error>in</error> 1..2
+  <error>x</error> in 1..2
 
   val y : Boolean? = true
   false || <error>y</error>
diff --git a/idea/testData/checker/Bounds.jet b/idea/testData/checker/Bounds.jet
index 3b3f6a41ed2..87d5cfa1579 100644
--- a/idea/testData/checker/Bounds.jet
+++ b/idea/testData/checker/Bounds.jet
@@ -18,10 +18,10 @@ namespace boundsWithSubstitutors {
   open class A {}
   open class B<T : A>()
 
-  class C<T : B<<error>Int</error>>, X : fun (B<<error>Char</error>>) : (B<<error>Any</error>>, B<A>)>() : B<<error>Any</error>>() { // 2 errors
+  abstract class C<T : B<<error>Int</error>>, X : fun (B<<error>Char</error>>) : (B<<error>Any</error>>, B<A>)>() : B<<error>Any</error>>() { // 2 errors
     val a = B<<error>Char</error>>() // error
 
-    val x : fun (B<<error>Char</error>>) : B<<error>Any</error>>
+    abstract val x : fun (B<<error>Char</error>>) : B<<error>Any</error>>
   }
 
 
diff --git a/idea/testData/checker/Builders.jet b/idea/testData/checker/Builders.jet
new file mode 100644
index 00000000000..1d26cbbc8b2
--- /dev/null
+++ b/idea/testData/checker/Builders.jet
@@ -0,0 +1,121 @@
+import java.util.*
+
+namespace html {
+
+  abstract class Factory<T> {
+    abstract fun create() : T
+  }
+
+  abstract class Element
+
+  class TextElement(val text : String) : Element
+
+  abstract class Tag(val name : String) : Element {
+    val children = ArrayList<Element>()
+    val attributes = HashMap<String, String>()
+
+    protected fun initTag<T : Element>(init : fun T.() : Unit) : T
+      where class object T : Factory<T>{
+      val tag = T.create()
+      tag.init()
+      children.add(tag)
+      return tag
+    }
+  }
+
+  abstract class TagWithText(name : String) : Tag(name) {
+    fun String.plus() {
+      children.add(TextElement(this))
+    }
+  }
+
+  class HTML() : TagWithText("html") {
+    class object : Factory<HTML> {
+      override fun create() = HTML()
+    }
+
+    fun head(init : fun Head.() : Unit) = initTag<Head>(init)
+
+    fun body(init : fun Body.() : Unit) = initTag<Body>(init)
+  }
+
+  class Head() : TagWithText("head") {
+    class object : Factory<Head> {
+      override fun create() = Head()
+    }
+
+    fun title(init : fun Title.() : Unit) = initTag<Title>(init)
+  }
+
+  class Title() : TagWithText("title")
+
+  abstract class BodyTag(name : String) : TagWithText(name) {
+  }
+
+  class Body() : BodyTag("body") {
+    class object : Factory<Body> {
+      override fun create() = Body()
+    }
+
+    fun b(init : fun B.() : Unit) = initTag<B>(init)
+    fun p(init : fun P.() : Unit) = initTag<P>(init)
+    fun h1(init : fun H1.() : Unit) = initTag<H1>(init)
+    fun a(href : String, init : fun A.() : Unit) {
+      val a = initTag<A>(init)
+      a.href = href
+    }
+  }
+
+  class B() : BodyTag("b")
+  class P() : BodyTag("p")
+  class H1() : BodyTag("h1")
+  class A() : BodyTag("a") {
+    var href : String
+      get() = attributes["href"]
+      set(value) { attributes["href"] = value }
+  }
+
+  fun Map<String, String>.set(key : String, value : String) = this.put(key, value)
+
+  fun html(init : fun HTML.() : Unit) : HTML {
+    val html = HTML()
+    html.init()
+    return html
+  }
+
+}
+
+namespace foo {
+
+import html.*
+
+fun result(args : Array<String>) =
+  html {
+    head {
+      title {+"XML encoding with Groovy"}
+    }
+    body {
+      h1 {+"XML encoding with Groovy"}
+      p {+"this format can be used as an alternative markup to XML"}
+
+      // an element with attributes and text content
+      a(href = "http://groovy.codehaus.org") {+"Groovy"}
+
+      // mixed content
+      p {
+        +"This is some"
+        b {+"mixed"}
+        +"text. For more see the"
+        a(href = "http://groovy.codehaus.org") {+"Groovy"}
+        +"project"
+      }
+      p {+"some text"}
+
+      // content generated by
+      p {
+        for (arg in args)
+          +arg
+      }
+    }
+  }
+}
diff --git a/idea/testData/checker/Constants.jet b/idea/testData/checker/Constants.jet
new file mode 100644
index 00000000000..2ff80a0c1bb
--- /dev/null
+++ b/idea/testData/checker/Constants.jet
@@ -0,0 +1,8 @@
+fun test() {
+  1 : Byte
+  1 : Int
+  <error>1</error> : Double
+  1 <warning>as</warning> Byte
+  1 <warning>as</warning> Int
+  <error>1</error> <warning>as</warning> Double
+}
\ No newline at end of file
diff --git a/idea/testData/checker/Constructors.jet b/idea/testData/checker/Constructors.jet
index 13a787da063..7c6e8582a56 100644
--- a/idea/testData/checker/Constructors.jet
+++ b/idea/testData/checker/Constructors.jet
@@ -1,9 +1,9 @@
 
-class NoC
+open class NoC
 class NoC1 : NoC
 
 class WithC0() : NoC<error>()</error>
-class WithC1() : NoC
+open class WithC1() : NoC
 class NoC2 : <error>WithC1</error>
 class NoC3 : WithC1<error>()</error>
 class WithC2() : <error>WithC1</error>
@@ -23,7 +23,7 @@ class WithPC1(a : Int) {
 
   this(s : String) : this(1) {}
 
-  this(b : Char) : this<error>("", 2)</error> {}
+  this(b : Char) : <error>this("", 2)</error> {}
 
   this(b : Byte) : this(""), <error>this(1)</error> {}
 }
@@ -33,7 +33,7 @@ class Foo() : <error>WithPC0</error>, <error>this</error>() {
 
 }
 
-class WithCPI_Dup(<error>x</error> : Int) {
+class WithCPI_Dup(x : Int) {
   var <error>x</error> : Int
 }
 
diff --git a/idea/testData/checker/CyclicHierarchy.jet b/idea/testData/checker/CyclicHierarchy.jet
new file mode 100644
index 00000000000..f63abefd2be
--- /dev/null
+++ b/idea/testData/checker/CyclicHierarchy.jet
@@ -0,0 +1,30 @@
+trait A {
+    fun foo() {}
+}
+trait B : A, <error>E</error> {}
+trait C : B {}
+trait D : <error>B</error> {}
+trait E : <error>F</error> {}
+trait F : <error>D</error>, C {}
+trait G : F {}
+trait H : F {}
+
+val a : A? = null
+val b : B? = null
+val c : C? = null
+val d : D? = null
+val e : E? = null
+val f : F? = null
+val g : G? = null
+val h : H? = null
+
+fun test() {
+    a?.foo()
+    b?.foo()
+    c?.foo()
+    d?.foo()
+    e?.<error>foo</error>()
+    f?.foo()
+    g?.foo()
+    h?.foo()
+}
\ No newline at end of file
diff --git a/idea/testData/checker/ExtensionFunctions.jet b/idea/testData/checker/ExtensionFunctions.jet
index 669b51c0cbe..0464054f743 100644
--- a/idea/testData/checker/ExtensionFunctions.jet
+++ b/idea/testData/checker/ExtensionFunctions.jet
@@ -1,5 +1,5 @@
-fun Int?.optint() : Unit
-val Int?.optval : Unit
+fun Int?.optint() : Unit {}
+val Int?.optval : Unit = ()
 
 fun <T, E> T.foo(x : E, y : A) : T   {
   y.plus(1)
@@ -16,7 +16,7 @@ class A
 fun A.plus(a : Any) {
 
   1.foo()
-  true.foo<error>()</error>
+  true.<error>foo()</error>
 
   1
 }
@@ -33,7 +33,7 @@ fun test() {
 val Int.abs : Int
   get() = if (this > 0) this else -this;
 
-val <T> T.foo : T
+val <T> T.<error>foo</error> : T
 
 fun Int.foo() = this
 
@@ -42,11 +42,12 @@ namespace null_safety {
         fun parse(cmd: String): Command? { return null  }
         class Command() {
         //  fun equals(other : Any?) : Boolean
-          val foo : Int
+          val foo : Int = 0
         }
 
-        fun Any.equals(other : Any?) : Boolean
-        fun Any?.equals1(other : Any?) : Boolean
+        fun Any.equals(other : Any?) : Boolean = true
+        fun Any?.equals1(other : Any?) : Boolean = true
+        fun Any.equals2(other : Any?) : Boolean = true
 
         fun main(args: Array<String>) {
 
@@ -56,13 +57,13 @@ namespace null_safety {
 
             command<error>.</error>foo
 
-            command<error>.</error>equals(null)
-            command?.equals(null)
+            command.equals(null)
+            command<warning>?.</warning>equals(null)
             command.equals1(null)
             command<warning>?.</warning>equals1(null)
 
             val c = Command()
-            c<warning>?.</warning>equals(null)
+            c<warning>?.</warning>equals2(null)
 
             if (command == null) 1
         }
diff --git a/idea/testData/checker/ForRangeConventions.jet b/idea/testData/checker/ForRangeConventions.jet
index ebc71d5e462..da56cf2232e 100644
--- a/idea/testData/checker/ForRangeConventions.jet
+++ b/idea/testData/checker/ForRangeConventions.jet
@@ -4,77 +4,77 @@ class NotRange1() {
 
 }
 
-class NotRange2() {
-  fun iterator() : Unit
+abstract class NotRange2() {
+  abstract fun iterator() : Unit
 }
 
-class ImproperIterator1 {
-  fun hasNext() : Boolean
+abstract class ImproperIterator1 {
+  abstract fun hasNext() : Boolean
 }
 
-class NotRange3() {
-  fun iterator() : ImproperIterator1
+abstract class NotRange3() {
+  abstract fun iterator() : ImproperIterator1
 }
 
-class ImproperIterator2 {
-  fun next() : Boolean
+abstract class ImproperIterator2 {
+  abstract fun next() : Boolean
 }
 
-class NotRange4() {
-  fun iterator() : ImproperIterator2
+abstract class NotRange4() {
+  abstract fun iterator() : ImproperIterator2
 }
 
-class ImproperIterator3 {
-  fun hasNext() : Int
-  fun next() : Int
+abstract class ImproperIterator3 {
+  abstract fun hasNext() : Int
+  abstract fun next() : Int
 }
 
-class NotRange5() {
-  fun iterator() : ImproperIterator3
+abstract class NotRange5() {
+  abstract fun iterator() : ImproperIterator3
 }
 
-class AmbiguousHasNextIterator {
-  fun hasNext() : Boolean
+abstract class AmbiguousHasNextIterator {
+  abstract fun hasNext() : Boolean
   val hasNext : Boolean get() = false
-  fun next() : Int
+  abstract fun next() : Int
 }
 
-class NotRange6() {
-  fun iterator() : AmbiguousHasNextIterator
+abstract class NotRange6() {
+  abstract fun iterator() : AmbiguousHasNextIterator
 }
 
-class ImproperIterator4 {
+abstract class ImproperIterator4 {
   val hasNext : Int get() = 1
-  fun next() : Int
+  abstract fun next() : Int
 }
 
-class NotRange7() {
-  fun iterator() : ImproperIterator3
+abstract class NotRange7() {
+  abstract fun iterator() : ImproperIterator3
 }
 
-class GoodIterator {
-  fun hasNext() : Boolean
-  fun next() : Int
+abstract class GoodIterator {
+  abstract fun hasNext() : Boolean
+  abstract fun next() : Int
 }
 
-class Range0() {
-  fun iterator() : GoodIterator
+abstract class Range0() {
+  abstract fun iterator() : GoodIterator
 }
 
-class Range1() {
-  fun iterator() : Iterator<Int>
+abstract class Range1() {
+  abstract fun iterator() : Iterator<Int>
 }
 
-fun test() {
-  for (i in <error>NotRange1()</error>);
-  for (i in <error>NotRange2()</error>);
-  for (i in <error>NotRange3()</error>);
-  for (i in <error>NotRange4()</error>);
-  for (i in <error>NotRange5()</error>);
-  for (i in <error>NotRange6()</error>);
-  for (i in <error>NotRange7()</error>);
-  for (i in Range0());
-  for (i in Range1());
+fun test(notRange1: NotRange1, notRange2: NotRange2, notRange3: NotRange3, notRange4: NotRange4, notRange5: NotRange5, notRange6: NotRange6, notRange7: NotRange7, range0: Range0, range1: Range1) {
+  for (i in <error>notRange1</error>);
+  for (i in <error>notRange2</error>);
+  for (i in <error>notRange3</error>);
+  for (i in <error>notRange4</error>);
+  for (i in <error>notRange5</error>);
+  for (i in <error>notRange6</error>);
+  for (i in <error>notRange7</error>);
+  for (i in range0);
+  for (i in range1);
 
   for (i in (ArrayList<Int>() : List<Int>));
 }
diff --git a/idea/testData/checker/FunctionReturnTypes.jet b/idea/testData/checker/FunctionReturnTypes.jet
index a541589263a..43a607f9714 100644
--- a/idea/testData/checker/FunctionReturnTypes.jet
+++ b/idea/testData/checker/FunctionReturnTypes.jet
@@ -1,4 +1,4 @@
-fun none()
+fun none() {}
 
 fun unitEmptyInfer() {}
 fun unitEmpty() : Unit {}
@@ -128,6 +128,8 @@ fun blockNoReturnIfUnitInOneBranch(): Int {
     }
   }
 }
+fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) <error>{}</error> else <error>{}</error>
+fun nonBlockNoReturnIfUnitInOneBranch(): Int = if (1 < 2) <error>{}</error> else 2
 
 val a = <error>return 1</error>
 
diff --git a/idea/testData/checker/GenericArgumentConsistency.jet b/idea/testData/checker/GenericArgumentConsistency.jet
new file mode 100644
index 00000000000..658b84dc9d4
--- /dev/null
+++ b/idea/testData/checker/GenericArgumentConsistency.jet
@@ -0,0 +1,42 @@
+trait A<in T> {}
+trait B<T> : A<Int> {}
+trait C<T> : <error>B<T>, A<T></error> {}
+trait C1<T> : B<T>, A<Any> {}
+trait D : <error>C<Boolean>, B<Double></error>{}
+
+trait A1<out T> {}
+trait B1 : A1<Int> {}
+trait B2 : A1<Any>, B1 {}
+
+trait BA1<T> {}
+trait BB1 : BA1<Int> {}
+trait BB2 : <error>BA1<Any>, BB1</error> {}
+
+
+namespace x {
+    trait AA1<out T> {}
+    trait AB1 : AA1<Int> {}
+    trait AB3 : AA1<Comparable<Int>> {}
+    trait AB2 : AA1<Number>, AB1, AB3 {}
+}
+
+namespace x2 {
+    trait AA1<out T> {}
+    trait AB1 : AA1<Any> {}
+    trait AB3 : AA1<Comparable<Int>> {}
+    trait AB2 : <error>AA1<Number>, AB1, AB3</error> {}
+}
+
+namespace x3 {
+    trait AA1<in T> {}
+    trait AB1 : AA1<Any> {}
+    trait AB3 : AA1<Comparable<Int>> {}
+    trait AB2 : AA1<Number>, AB1, AB3 {}
+}
+
+namespace sx2 {
+    trait AA1<in T> {}
+    trait AB1 : AA1<Int> {}
+    trait AB3 : AA1<Comparable<Int>> {}
+    trait AB2 : <error>AA1<Number>, AB1, AB3</error> {}
+}
\ No newline at end of file
diff --git a/idea/testData/checker/MultipleBounds.jet b/idea/testData/checker/MultipleBounds.jet
index 126864510c1..2ecb95b9e6e 100644
--- a/idea/testData/checker/MultipleBounds.jet
+++ b/idea/testData/checker/MultipleBounds.jet
@@ -1,17 +1,17 @@
 namespace Jet87
 
 open class A() {
-  fun foo() : Int
+  fun foo() : Int = 1
 }
 
-open class B() {
-  fun bar() : Double;
+trait B {
+  fun bar() : Double = 1.0;
 }
 
-class C() : A(), B()
+class C() : A(), B
 
 class D() {
-  class object : A(), B () {}
+  class object : A(), B {}
 }
 
 class Test1<T : A>()
@@ -60,13 +60,13 @@ fun <T : A> test2(t : T)
   t.bar()
 }
 
-val test1 = test2<<error>A</error>>(A())
-val test2 = test2<<error>B</error>>(B())
-val test3 = test2<C>(C())
+val t1 = test2<<error>A</error>>(A())
+val t2 = test2<<error>B</error>>(C())
+val t3 = test2<C>(C())
 
 class Test<<error>T</error>>
   where
     class object T : <error>Foo</error>,
     class object T : A {}
 
-val <T, B : T> x : Int
\ No newline at end of file
+val <T, B : T> x : Int = 0
diff --git a/idea/testData/checker/NamespaceQualified.jet b/idea/testData/checker/NamespaceQualified.jet
index 2b8832aef89..120b3b73d34 100644
--- a/idea/testData/checker/NamespaceQualified.jet
+++ b/idea/testData/checker/NamespaceQualified.jet
@@ -8,6 +8,10 @@ namespace a {
 
 }
 
+abstract class Foo<T>() {
+    abstract val x : T<Int>
+}
+
 namespace a {
     import java.util.*
 
@@ -22,25 +26,32 @@ val y1 = a.b
 
 /////////////////////////////////////////////////////////////////////////
 
-fun done<O>(result : O) : Iteratee<Any?, O>
+fun done<O>(result : O) : Iteratee<Any?, O> = StrangeIterateeImpl<Any?, O>(result)
 
-class Iteratee<in I, out O> {
+abstract class Iteratee<in I, out O> {
   abstract fun process(item : I) : Iteratee<I, O>
   abstract val isDone : Boolean
   abstract val result : O
   abstract fun done() : O
 }
 
-class Sum() : Iteratee<Int, Int> {
+class StrangeIterateeImpl<in I, out O>(val obj: O) : Iteratee<I, O> {
+    override fun process(item: I): Iteratee<I, O> = StrangeIterateeImpl<I, O>(obj)
+    override val isDone = true
+    override val result = obj
+    override fun done() = obj
+}
+
+abstract class Sum() : Iteratee<Int, Int> {
   override fun process(item : Int) : Iteratee<Int, Int> {
     return foobar.done<Int>(item);
   }
-  override val isDone : Boolean
-  override val result : Int
-  override fun done() : Int
+  abstract override val isDone : Boolean
+  abstract override val result : Int
+  abstract override fun done() : Int
 }
 
-class Collection<E> : Iterable<E> {
+abstract class Collection<E> : Iterable<E> {
   fun iterate<O>(iteratee : Iteratee<E, O>) : O {
       for (x in this) {
         val it = iteratee.process(x)
diff --git a/idea/testData/checker/Objects.jet b/idea/testData/checker/Objects.jet
index 66f21030719..a619e1c22d6 100644
--- a/idea/testData/checker/Objects.jet
+++ b/idea/testData/checker/Objects.jet
@@ -1,6 +1,6 @@
 namespace toplevelObjectDeclarations {
-  class Foo(y : Int) {
-    virtual fun foo() : Int = 1
+  open class Foo(y : Int) {
+    open fun foo() : Int = 1
   }
 
   class T : <error>Foo</error> {}
@@ -60,11 +60,11 @@ namespace nestedObejcts {
 
 namespace localObjects {
   object A {
-    val x : Int
+    val x : Int = 0
   }
 
-  class Foo {
-    fun foo() : Int
+  open class Foo {
+    fun foo() : Int = 1
   }
 
   fun test() {
diff --git a/idea/testData/checker/Override.jet b/idea/testData/checker/Override.jet
new file mode 100644
index 00000000000..0ba1406e651
--- /dev/null
+++ b/idea/testData/checker/Override.jet
@@ -0,0 +1,76 @@
+namespace override
+
+namespace normal {
+    trait MyTrait {
+        fun foo()
+    }
+
+    abstract class MyAbstractClass {
+        abstract fun bar()
+    }
+
+    open class MyClass : MyTrait, MyAbstractClass {
+        override fun foo() {}
+        override fun bar() {}
+    }
+
+    class MyChildClass : MyClass {}
+
+    class <error>MyIllegalClass</error> : MyTrait, MyAbstractClass {}
+
+    class <error>MyIllegalClass2</error> : MyTrait, MyAbstractClass {
+        override fun foo() {}
+    }
+
+    class <error>MyIllegalClass3</error> : MyTrait, MyAbstractClass {
+        override fun bar() {}
+    }
+
+    class <error>MyIllegalClass4</error> : MyTrait, MyAbstractClass {
+        fun <error>foo</error>() {}
+        <error>override</error> fun other() {}
+    }
+
+    class MyChildClass1 : MyClass {
+        fun <error>foo</error>() {}
+        override fun bar() {}
+    }
+}
+
+namespace generics {
+    trait MyTrait<T> {
+        fun foo(t: T) : T
+    }
+
+    abstract class MyAbstractClass<T> {
+        abstract fun bar(t: T) : T
+    }
+
+    open class MyGenericClass<T> : MyTrait<T>, MyAbstractClass<T> {
+        override fun foo(t: T) = t
+        override fun bar(t: T) = t
+    }
+
+    class MyChildClass : MyGenericClass<Int> {}
+    class MyChildClass1<T> : MyGenericClass<T> {}
+    class MyChildClass2<T> : MyGenericClass<T> {
+        fun <error>foo</error>(t: T) = t
+        override fun bar(t: T) = t
+    }
+
+    open class MyClass : MyTrait<Int>, MyAbstractClass<String> {
+        override fun foo(i: Int) = i
+        override fun bar(s: String) = s
+    }
+
+    class <error>MyIllegalGenericClass1</error><T> : MyTrait<T>, MyAbstractClass<T> {}
+    class <error>MyIllegalGenericClass2</error><T, R> : MyTrait<T>, MyAbstractClass<R> {
+        <error>override</error> fun foo(r: R) = r
+    }
+    class <error>MyIllegalClass1</error> : MyTrait<Int>, MyAbstractClass<String> {}
+
+    class <error>MyIllegalClass2</error><T> : MyTrait<Int>, MyAbstractClass<Int> {
+        fun foo(t: T) = t
+        fun bar(t: T) = t
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/checker/PrimaryConstructors.jet b/idea/testData/checker/PrimaryConstructors.jet
index d453dad9602..2ea2ef34ab9 100644
--- a/idea/testData/checker/PrimaryConstructors.jet
+++ b/idea/testData/checker/PrimaryConstructors.jet
@@ -1,9 +1,9 @@
 class <error>X</error> {
-  val x : Int
+  val <error>x</error> : Int
 }
 
-class Y() {
-  val x : Int
+open class Y() {
+  val x : Int = 2
 }
 
 class Y1 {
diff --git a/idea/testData/checker/ProjectionsInSupertypes.jet b/idea/testData/checker/ProjectionsInSupertypes.jet
new file mode 100644
index 00000000000..efddb978e07
--- /dev/null
+++ b/idea/testData/checker/ProjectionsInSupertypes.jet
@@ -0,0 +1,6 @@
+trait A<T> {}
+trait B<T> {}
+trait C<T> {}
+trait D<T> {}
+
+trait Test : A<<error>in</error> Int>, B<<error>out</error> Int>, C<<error>*</error>><error>?</error><error>?</error><error>?</error>, D<Int> {}
\ No newline at end of file
diff --git a/idea/testData/checker/Properties.jet b/idea/testData/checker/Properties.jet
index 61330844bc4..8f9ae255576 100644
--- a/idea/testData/checker/Properties.jet
+++ b/idea/testData/checker/Properties.jet
@@ -7,13 +7,13 @@
 
  val xx : Int = <error>1 + x</error>
    get() : Int = 1
-   <error>set(ref value : Long) {$x = value}</error>
+   <error>set(value : Long) {}</error>
 
   val p : Int = <error>1</error>
     get() = 1
 
 class Test() {
-    var a : Int
+    var a : Int = 111
     var b : Int get() = <error>$a</error>; set(x) {a = x; <error>$a</error> = x}
 
    this(i : Int) : this() {
diff --git a/idea/testData/checker/QualifiedThis.jet b/idea/testData/checker/QualifiedThis.jet
index 21113c22f0d..37a1f0d90d3 100644
--- a/idea/testData/checker/QualifiedThis.jet
+++ b/idea/testData/checker/QualifiedThis.jet
@@ -16,7 +16,7 @@ class A() {
   val z = foo()
 }
 
-fun foo() : Unit {
+fun foo1() : Unit {
   <error>this</error>
   this<error>@a</error>
 }
diff --git a/idea/testData/checker/RecursiveTypeInference.jet b/idea/testData/checker/RecursiveTypeInference.jet
index cb32ac6cefc..a73cf01cc0e 100644
--- a/idea/testData/checker/RecursiveTypeInference.jet
+++ b/idea/testData/checker/RecursiveTypeInference.jet
@@ -1,7 +1,7 @@
 namespace a {
-    val foo = bar()
+    val foo = <error>bar()</error>
 
-    fun bar() = <error>foo</error>
+    fun bar() = foo
 }
 
 namespace b {
diff --git a/idea/testData/checker/Redeclarations.jet b/idea/testData/checker/Redeclarations.jet
index 4201582c728..6998ada29eb 100644
--- a/idea/testData/checker/Redeclarations.jet
+++ b/idea/testData/checker/Redeclarations.jet
@@ -1,6 +1,6 @@
 namespace redeclarations {
   object <error>A</error> {
-    val x : Int
+    val x : Int = 0
 
     val A = 1
   }
diff --git a/idea/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet
index c308dd86974..215e9561ffe 100644
--- a/idea/testData/checker/ResolveToJava.jet
+++ b/idea/testData/checker/ResolveToJava.jet
@@ -19,10 +19,10 @@ fun test(l : java.util.List<Int>) {
   Collections.<error>emptyList</error>
   Collections.emptyList<Int>
   Collections.emptyList<Int>()
-  Collections.emptyList<error>()</error>
+  Collections.emptyList()
 
   Collections.singleton<Int>(1) : Set<Int>?
-  Collections.singleton<Int><error>(1.0)</error>
+  Collections.singleton<Int>(<error>1.0</error>)
 
   <error>List</error><Int>
 
@@ -43,7 +43,7 @@ fun test(l : java.util.List<Int>) {
   c : java.lang.Comparable<Int>?
 
 //  Collections.sort<Integer>(ArrayList<Integer>())
-  xxx.Class<error>()</error>
+  xxx.<error>Class</error>()
 }
 
 
diff --git a/idea/testData/checker/SupertypeListChecks.jet b/idea/testData/checker/SupertypeListChecks.jet
new file mode 100644
index 00000000000..b040428ec85
--- /dev/null
+++ b/idea/testData/checker/SupertypeListChecks.jet
@@ -0,0 +1,51 @@
+// KT-286 Check supertype lists
+
+/*
+In a supertype list:
+ Same type should not be mentioned twice
+ Same type should not be indirectly mentioned with incoherent type arguments
+ Every trait's required dependencies should be satisfied
+ No final types should appear
+ Only one class is allowed
+*/
+
+class C1()
+
+open class OC1()
+
+open class C2 {}
+
+open class C3 {}
+
+trait T1 {}
+
+trait T2<T> {}
+
+trait Test<error>()</error> {
+    <error>this</error>(x : Int) {}
+}
+
+trait Test1 : C2<error>()</error> {}
+
+trait Test2 : C2 {}
+
+trait Test3 : C2, <error>C3</error> {}
+
+trait Test4 : T1 {}
+
+trait Test5 : T1, <error>T1</error> {}
+
+trait Test6 : <error>C1</error> {}
+
+class CTest1() : OC1() {}
+
+class CTest2 : C2 {}
+
+class CTest3 : C2, <error>C3</error> {}
+
+class CTest4 : T1 {}
+
+class CTest5 : T1, <error>T1</error> {}
+
+class CTest6 : <error>C1</error> {}
+
diff --git a/idea/testData/checker/TraitSupertypeList.jet b/idea/testData/checker/TraitSupertypeList.jet
new file mode 100644
index 00000000000..37e17339fec
--- /dev/null
+++ b/idea/testData/checker/TraitSupertypeList.jet
@@ -0,0 +1,11 @@
+open class bar()
+
+trait Foo<error>()</error> : bar<error>()</error>, <error>bar</error>, <error>bar</error> {
+    <error>this</error>(x : Int) {}
+}
+
+trait Foo2 : bar, Foo {
+}
+
+open class Foo1() : bar(), <error>bar</error>, Foo, <error>Foo</error><error>()</error> {}
+open class Foo12 : bar<error>()</error>, <error>bar</error> {}
\ No newline at end of file
diff --git a/idea/testData/checker/Variance.jet b/idea/testData/checker/Variance.jet
new file mode 100644
index 00000000000..0f27cbc73ff
--- /dev/null
+++ b/idea/testData/checker/Variance.jet
@@ -0,0 +1,40 @@
+namespace variance
+
+abstract class Consumer<in T> {}
+
+abstract class Producer<out T> {}
+
+abstract class Usual<T> {}
+
+fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
+    val c1: Consumer<Any> = <error>c</error>
+    val c2: Consumer<Int> = c1
+
+    val p1: Producer<Any> = p
+    val p2: Producer<Int> = <error>p1</error>
+
+    val u1: Usual<Any> = <error>u</error>
+    val u2: Usual<Int> = <error>u1</error>
+}
+
+//Arrays copy example
+class Array<T>(val length : Int) {
+    fun get(index : Int) : T { return null }
+    fun set(index : Int, value : T) { /* ... */ }
+}
+
+fun copy1(from : Array<Any>, to : Array<Any>) {}
+
+fun copy2(from : Array<out Any>, to : Array<in Any>) {}
+
+fun <T> copy3(from : Array<out T>, to : Array<in T>) {}
+
+fun copy4(from : Array<out Number>, to : Array<in Int>) {}
+
+fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
+    copy1(<error>ints</error>, any)
+    copy2(ints, any) //ok
+    copy2(ints, <error>numbers</error>)
+    copy3<Int>(ints, numbers)
+    copy4(ints, numbers) //ok
+}
diff --git a/idea/testData/checker/infos/Autocasts.jet b/idea/testData/checker/infos/Autocasts.jet
index 48ef4191b47..7cf18aadd48 100644
--- a/idea/testData/checker/infos/Autocasts.jet
+++ b/idea/testData/checker/infos/Autocasts.jet
@@ -1,4 +1,4 @@
-class A() {
+<info>open</info> class A() {
   fun foo() {}
 }
 
@@ -215,4 +215,41 @@ fun returnFunctionLiteral(a: Any?): Function0<Int> =
 
 fun illegalTupleReturnType(a: Any): (Any, String) = (a, <error>a</error>)
 
-fun declarationInsidePattern(x: (Any, Any)): String = when(x) { is (val a is String, *) => <info descr="Automatically cast to String">a</info>; else => "something" }
\ No newline at end of file
+fun declarationInsidePattern(x: (Any, Any)): String = when(x) { is (val a is String, *) => <info descr="Automatically cast to String">a</info>; else => "something" }
+
+fun mergeAutocasts(a: Any?) {
+  if (a is String || a is Int) {
+    a.<error>compareTo</error>("")
+    a.toString()
+  }
+  if (a is Int || a is String) {
+    a.<error>compareTo</error>("")
+  }
+  when (a) {
+    is String, is Any => a.<error>compareTo</error>("")
+  }
+  if (a is String && a is Any) {
+    val i: Int = <info descr="Automatically cast to String">a</info>.compareTo("")
+  }
+  if (a is String && <info descr="Automatically cast to String">a</info>.compareTo("") == 0) {}
+  if (a is String || a.<error>compareTo</error>("") == 0) {}
+}
+
+//mutability
+fun f(): String {
+    var a: Any = 11
+    if (a is String) {
+        val i: String = <error>a</error>
+        <error>a</error>.compareTo("f")
+        val f: Function0<String> = { <error>a</error> }
+        return <error>a</error>
+    }
+    return ""
+}
+
+fun foo(var a: Any): Int {
+    if (a is Int) {
+        return <error>a</error>
+    }
+    return 1
+}
\ No newline at end of file
diff --git a/idea/testData/checker/infos/PropertiesWithBackingFields.jet b/idea/testData/checker/infos/PropertiesWithBackingFields.jet
index 942763a1ee9..294ea276524 100644
--- a/idea/testData/checker/infos/PropertiesWithBackingFields.jet
+++ b/idea/testData/checker/infos/PropertiesWithBackingFields.jet
@@ -1,10 +1,10 @@
-class Test() {
+<info>abstract</info> class Test() {
     <info>abstract</info> val x : Int
     <info>abstract</info> val x1 : Int <info>get</info>
-    <info>abstract</info> val x2 : Int <info>get</info>() = 1
+    <info>abstract</info> val x2 : Int <error><info>get</info>() = 1</error>
 
-    val <info>a</info> : Int
-    val <info>b</info> : Int <info>get</info>
+    val <error>a</error> : Int
+    val <error>b</error> : Int <info>get</info>
     val <info>c</info> = 1
 
     val <info>c1</info> = 1
@@ -15,35 +15,36 @@ class Test() {
         <info>get</info>() { return 1 }
     val c4 : Int
         <info>get</info>() = 1
-    val <info>c5</info> : Int
+    val <error>c5</error> : Int
         <info>get</info>() = $c5 + 1
 
     <info>abstract</info> var y : Int
     <info>abstract</info> var y1 : Int <info>get</info>
     <info>abstract</info> var y2 : Int <info>set</info>
     <info>abstract</info> var y3 : Int <info>set</info> <info>get</info>
-    <info>abstract</info> var y4 : Int <info>set</info> <info>get</info>() = 1
-    <info>abstract</info> var y5 : Int <info>set</info>(x) {} <info>get</info>() = 1
+    <info>abstract</info> var y4 : Int <info>set</info> <error><info>get</info>() = 1</error>
+    <info>abstract</info> var y5 : Int <error><info>set</info>(x) {}</error> <error><info>get</info>() = 1</error>
+    <info>abstract</info> var y6 : Int <error><info>set</info>(x) {}</error>
 
-    var <info>v</info> : Int
-    var <info>v1</info> : Int <info>get</info>
-    var <info>v2</info> : Int <info>get</info> <info>set</info>
-    var <info>v3</info> : Int <info>get</info>() = 1; <info>set</info>
+    var <error>v</error> : Int
+    var <error>v1</error> : Int <info>get</info>
+    var <error>v2</error> : Int <info>get</info> <info>set</info>
+    var <error>v3</error> : Int <info>get</info>() = 1; <info>set</info>
     var v4 : Int <info>get</info>() = 1; <info>set</info>(x){}
 
-    var <info>v5</info> : Int <info>get</info>() = 1; <info>set</info>(x){$v5 = x}
-    var <info>v6</info> : Int <info>get</info>() = $v6 + 1; <info>set</info>(x){}
+    var <error>v5</error> : Int <info>get</info>() = 1; <info>set</info>(x){$v5 = x}
+    var <error>v6</error> : Int <info>get</info>() = $v6 + 1; <info>set</info>(x){}
 
-  val v7 : Int <info>abstract</info> <info>get</info>
-  var v8 : Int <info>abstract</info> <info>get</info> <info>abstract</info> <info>set</info>
-  var <info>v9</info> : Int <info>abstract</info> <info>set</info>
-  var <info>v10</info> : Int <info>abstract</info> <info>get</info>
+  <info>abstract</info> val v7 : Int <info>abstract</info> <info>get</info>
+  <info>abstract</info> var v8 : Int <info>abstract</info> <info>get</info> <info>abstract</info> <info>set</info>
+  var <error>v9</error> : Int <info>set</info>
+  var <error>v10</error> : Int <info>get</info>
 
 }
 
 <info>open</info> class Super(i : Int)
 
-class TestPCParameters(w : Int, <info>x</info> : Int, val <info>y</info> : Int, var <info>z</info> : Int) : Super(w) {
+class TestPCParameters(w : Int, x : Int, val <info>y</info> : Int, var <info>z</info> : Int) : Super(w) {
 
   val <info>xx</info> = w
 
@@ -51,6 +52,6 @@ class TestPCParameters(w : Int, <info>x</info> : Int, val <info>y</info> : Int,
     w + 1
   }
 
-  fun foo() = x
+  fun foo() = <error>x</error>
 
 }
\ No newline at end of file
diff --git a/idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet b/idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet
new file mode 100644
index 00000000000..779ee4c4d97
--- /dev/null
+++ b/idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet
@@ -0,0 +1,12 @@
+// One of the two passes is making a scope and turning vals into functions
+// See KT-76
+
+namespace x
+
+val b : Foo = Foo()
+val a1 = b.compareTo(2)
+
+class Foo() {
+  fun compareTo(other : Byte)   : Int = 0
+  fun compareTo(other : Char)   : Int = 0
+}
diff --git a/idea/testData/checker/regression/CoercionToUnit.jet b/idea/testData/checker/regression/CoercionToUnit.jet
new file mode 100644
index 00000000000..5d814eadc9e
--- /dev/null
+++ b/idea/testData/checker/regression/CoercionToUnit.jet
@@ -0,0 +1,9 @@
+fun foo(u : Unit) : Int = 1
+
+fun test() : Int {
+    foo(<error>1</error>)
+    val a : fun() : Unit = {
+        foo(<error>1</error>)
+    }
+    return 1
+}
\ No newline at end of file
diff --git a/idea/testData/checker/regression/DoubleDefine.jet b/idea/testData/checker/regression/DoubleDefine.jet
index 3aa5205ccf1..ebbda575d07 100644
--- a/idea/testData/checker/regression/DoubleDefine.jet
+++ b/idea/testData/checker/regression/DoubleDefine.jet
@@ -11,8 +11,8 @@ fun takeFirst(expr: StringBuilder): Char {
 
 fun evaluateArg(expr: AbstractStringBuilder, numbers: ArrayList<Int>): Int {
   if (expr.length() == 0) throw Exception("Syntax error: Character expected");
-  val c = takeFirst<error>(expr)</error>
-  if (c <error>>=</error> '0' && c <error><=</error> '9') {
+  val c = takeFirst(<error>expr</error>)
+  if (c >= '0' && c <= '9') {
     val n = c - '0'
     if (!numbers.contains(n)) throw Exception("You used incorrect number: " + n)
     numbers.remove(n)
diff --git a/idea/testData/checker/regression/Jet11.jet b/idea/testData/checker/regression/Jet11.jet
index d78aa91a35d..e2e2a110a52 100644
--- a/idea/testData/checker/regression/Jet11.jet
+++ b/idea/testData/checker/regression/Jet11.jet
@@ -1,4 +1,4 @@
 // JET-11 Redeclaration & Forward reference for classes cause an exception
-class <error>NoC</error>
+open class <error>NoC</error>
 class NoC1 : NoC
-class <error>NoC</error>
+open class <error>NoC</error>
diff --git a/idea/testData/checker/regression/Jet124.jet b/idea/testData/checker/regression/Jet124.jet
index 79392a018f1..317b1438f41 100644
--- a/idea/testData/checker/regression/Jet124.jet
+++ b/idea/testData/checker/regression/Jet124.jet
@@ -1,4 +1,4 @@
-fun foo1() : fun (Int) : Int
+fun foo1() : fun (Int) : Int = { (x: Int) => x }
 
 fun foo() {
   val h : fun (Int) : Int = foo1();
diff --git a/idea/testData/checker/regression/Jet183-1.jet b/idea/testData/checker/regression/Jet183-1.jet
index 599560ac69f..37c72d83ef6 100644
--- a/idea/testData/checker/regression/Jet183-1.jet
+++ b/idea/testData/checker/regression/Jet183-1.jet
@@ -1,4 +1,4 @@
-enum class ProtocolState {
+abstract enum class ProtocolState {
   WAITING {
     override fun signal() = ProtocolState.TALKING
   }
diff --git a/idea/testData/checker/regression/Jet183.jet b/idea/testData/checker/regression/Jet183.jet
index 92c5cca572b..58712e5db73 100644
--- a/idea/testData/checker/regression/Jet183.jet
+++ b/idea/testData/checker/regression/Jet183.jet
@@ -1,4 +1,4 @@
-enum class ProtocolState {
+abstract enum class ProtocolState {
   WAITING {
     override fun signal() = ProtocolState.TALKING
   }
diff --git a/idea/testData/checker/regression/Jet67.jet b/idea/testData/checker/regression/Jet67.jet
index 13b000754e4..7c2248a5f6a 100644
--- a/idea/testData/checker/regression/Jet67.jet
+++ b/idea/testData/checker/regression/Jet67.jet
@@ -1,4 +1,4 @@
-class XXX {
-  val a : Int abstract get
+abstract class XXX {
+  abstract val a : Int abstract get
 
 }
diff --git a/idea/testData/checker/regression/Jet72.jet b/idea/testData/checker/regression/Jet72.jet
index bcee3560ccc..d3d3272c8e3 100644
--- a/idea/testData/checker/regression/Jet72.jet
+++ b/idea/testData/checker/regression/Jet72.jet
@@ -2,8 +2,8 @@
 
 import java.util.ArrayList
 
-class Item(val room: Object) {
-   val name : String
+abstract class Item(val room: Object) {
+   abstract val name : String
 }
 
 val items: ArrayList<Item> = ArrayList<Item>
diff --git a/idea/testData/checker/regression/Jet81.jet b/idea/testData/checker/regression/Jet81.jet
index cafc4840db7..f6b382d86da 100644
--- a/idea/testData/checker/regression/Jet81.jet
+++ b/idea/testData/checker/regression/Jet81.jet
@@ -14,9 +14,9 @@ val a = object {
   {
     b + 1
   }
-  val x = <error>b</error>
+  val x = b
   val y = 1
 }
 
-val b = a.x
+val b = <error>a</error>.x
 val c = a.y
diff --git a/idea/testData/checker/regression/OverrideResolution.jet b/idea/testData/checker/regression/OverrideResolution.jet
new file mode 100644
index 00000000000..b58ac616160
--- /dev/null
+++ b/idea/testData/checker/regression/OverrideResolution.jet
@@ -0,0 +1,16 @@
+fun box() {
+    val a : C
+    a.foo()
+}
+
+open class A {
+    open fun foo() {}
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+open class C : B {
+    override fun foo() {}
+}
diff --git a/idea/testData/checker/regression/SpecififcityByReceiver.jet b/idea/testData/checker/regression/SpecififcityByReceiver.jet
new file mode 100644
index 00000000000..b25f919e597
--- /dev/null
+++ b/idea/testData/checker/regression/SpecififcityByReceiver.jet
@@ -0,0 +1,9 @@
+fun Any.equals(other : Any?) : Boolean = true
+
+fun main(args: Array<String>) {
+
+    val command : Any = 1
+
+    command<warning>?.</warning>equals(null)
+    command.equals(null)
+}
\ No newline at end of file
diff --git a/idea/testData/checker/regression/WrongTraceInCallResolver.jet b/idea/testData/checker/regression/WrongTraceInCallResolver.jet
new file mode 100644
index 00000000000..2c88d2450dd
--- /dev/null
+++ b/idea/testData/checker/regression/WrongTraceInCallResolver.jet
@@ -0,0 +1,9 @@
+open class Foo {}
+open class Bar {}
+
+fun <T : Bar, T1> foo(x : Int) {}
+fun <T1, T : Foo> foo(x : Long) {}
+
+fun f(): Unit {
+    foo<<error>Int</error>, Int>(1)
+}
\ No newline at end of file
diff --git a/idea/testData/checker/regression/kt251.jet b/idea/testData/checker/regression/kt251.jet
new file mode 100644
index 00000000000..5a7e562057c
--- /dev/null
+++ b/idea/testData/checker/regression/kt251.jet
@@ -0,0 +1,33 @@
+class A() {
+    var x: Int = 0
+        get() = <error>"s"</error>
+        set(value: <error>String</error>) {
+            $x = <error>value</error>
+        }
+    val y: Int
+        get(): <error>String</error> = "s"
+    val z: Int
+        get() {
+            return <error>"s"</error>
+        }
+
+    var a: Any = 1
+        set(v: <error>String</error>) {
+            $a = v
+        }
+    val b: Int
+        get(): <error>Any</error> = "s"
+    val c: Int
+        get() {
+            return 1
+        }
+    val d = 1
+        get() {
+            return $d
+        }
+    val e = 1
+        get(): <error>String</error> {
+            return <error>$e</error>
+        }
+
+}
\ No newline at end of file
diff --git a/idea/testData/checker/regression/kt303.jet b/idea/testData/checker/regression/kt303.jet
new file mode 100644
index 00000000000..e7b10295990
--- /dev/null
+++ b/idea/testData/checker/regression/kt303.jet
@@ -0,0 +1,11 @@
+// KT-303 Stack overflow on a cyclic class hierarchy
+
+open class Foo() : <error>Bar</error>() {
+  val a : Int = 1
+}
+
+open class Bar() : <error>Foo</error>() {
+
+}
+
+val x : Int = <error>Foo()</error>
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/checkerTestUtil/test.jet b/idea/testData/checkerWithErrorTypes/checkerTestUtil/test.jet
new file mode 100644
index 00000000000..e78606b8885
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/checkerTestUtil/test.jet
@@ -0,0 +1,15 @@
+fun foo(u : Unit) : Int = 1
+
+fun test() : Int {
+    foo(1)
+    val a : fun() : Unit = {
+        foo(1)
+    }
+    return 1 - "1"
+}
+
+class A() {
+    val x : Int = foo1(xx)
+}
+
+fun foo1() {}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Abstract.jet b/idea/testData/checkerWithErrorTypes/full/Abstract.jet
new file mode 100644
index 00000000000..a1c73c553d7
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Abstract.jet
@@ -0,0 +1,241 @@
+namespace abstract
+
+class MyClass() {
+    //properties
+    val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!>: Int
+    val a1: Int = 1
+    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a2: Int
+    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a3: Int = 1
+
+    var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!>: Int                private set
+    var b1: Int = 0;                         private set
+    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b2: Int      private set
+    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b3: Int = 0; private set
+
+    var <!MUST_BE_INITIALIZED!>c<!>: Int                set(v: Int) { $c = v }
+    var c1: Int = 0;                         set(v: Int) { $c1 = v }
+    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c2: Int      set(v: Int) { $c2 = v }
+    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c3: Int = 0; set(v: Int) { $c3 = v }
+
+    val e: Int                               get() = a
+    val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;          get() = a
+    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e2: Int      get() = a
+    <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e3: Int = 0; get() = a
+
+    //methods
+    fun <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>f<!>()
+    fun g() {}
+    <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS!>abstract<!> fun h()
+    <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
+
+    //property accessors
+    var i: Int                       <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var j: Int                       get() = i;    <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  get() = i;    <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>k<!>: Int        <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var k1: Int = 0;                 <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var l: Int                       <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var n: Int                       <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_FUNCTION_WITH_BODY, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
+}
+
+abstract class MyAbstractClass() {
+    //properties
+    val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!>: Int
+    val a1: Int = 1
+    abstract val a2: Int
+    abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
+
+    var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!>: Int                private set
+    var b1: Int = 0;                         private set
+    abstract var b2: Int      private set
+    abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
+
+    var <!MUST_BE_INITIALIZED!>c<!>: Int                set(v: Int) { $c = v }
+    var c1: Int = 0;                         set(v: Int) { $c1 = v }
+    abstract var c2: Int                     <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
+    abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
+
+    val e: Int                               get() = a
+    val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;          get() = a
+    abstract val e2: Int                     <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
+    abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
+
+    //methods
+    fun <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>f<!>()
+    fun g() {}
+    abstract fun h()
+    <!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
+
+    //property accessors
+    var i: Int                       <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var j: Int                       get() = i;    <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var j1: Int                      get() = i;    <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>k<!>: Int        <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var k1: Int = 0;                 <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var l: Int                       <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var n: Int                       <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_WITH_BODY, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
+}
+
+trait MyTrait {
+    //properties
+    val a: Int
+    val a1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>1<!>
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val a2: Int
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
+
+    var b: Int                                                  private set
+    var b1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;                             private set
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var b2: Int                     private set
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
+
+    var <!BACKING_FIELD_IN_TRAIT!>c<!>: Int                                   set(v: Int) { $c = v }
+    var <!BACKING_FIELD_IN_TRAIT!>c1<!>: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;              set(v: Int) { $c1 = v }
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var c2: Int                     <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
+
+    val e: Int                                                  get() = a
+    val e1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;                             get() = a
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val e2: Int                     <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
+
+    //methods
+    fun f()
+    fun g() {}
+    <!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> fun h()
+    <!REDUNDANT_MODIFIER_IN_TRAIT, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
+
+    //property accessors
+    var i: Int                       abstract get  abstract set
+    var i1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var j: Int                       get() = i;    <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var j1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;  get() = i;    <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var k: Int                       abstract set
+    var k1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var l: Int                       abstract get  abstract set
+    var l1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>;  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var n: Int                       <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_WITH_BODY, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
+}
+
+enum class MyEnum() {
+    //properties
+    val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!>: Int
+    val a1: Int = 1
+    abstract val a2: Int
+    abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
+
+    var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!>: Int                private set
+    var b1: Int = 0;                         private set
+    abstract var b2: Int      private set
+    abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
+
+    var <!MUST_BE_INITIALIZED!>c<!>: Int                set(v: Int) { $c = v }
+    var c1: Int = 0;                         set(v: Int) { $c1 = v }
+    abstract var c2: Int                     <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
+    abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
+
+    val e: Int                               get() = a
+    val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;          get() = a
+    abstract val e2: Int                     <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
+    abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
+
+    //methods
+    fun <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>f<!>()
+    fun g() {}
+    abstract fun h()
+    <!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
+
+    //property accessors
+    var i: Int                       <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var j: Int                       get() = i;    <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  get() = i;    <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>k<!>: Int        <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var k1: Int = 0;                 <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var l: Int                       <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;   <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var n: Int                       <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_WITH_BODY, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
+}
+
+abstract enum class MyAbstractEnum() {}
+
+namespace MyNamespace {
+    //properties
+    val <!MUST_BE_INITIALIZED!>a<!>: Int
+    val a1: Int = 1
+    <!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val a2: Int
+    <!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val a3: Int = 1
+
+    var <!MUST_BE_INITIALIZED!>b<!>: Int                private set
+    var b1: Int = 0;                         private set
+    <!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var b2: Int      private set
+    <!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var b3: Int = 0; private set
+
+    var <!MUST_BE_INITIALIZED!>c<!>: Int                set(v: Int) { $c = v }
+    var c1: Int = 0;                         set(v: Int) { $c1 = v }
+    <!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var c2: Int      set(v: Int) { $c2 = v }
+    <!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var c3: Int = 0; set(v: Int) { $c3 = v }
+
+    val e: Int                               get() = a
+    val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;          get() = a
+    <!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val e2: Int      get() = a
+    <!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val e3: Int = 0; get() = a
+
+    //methods
+    fun <!NON_MEMBER_FUNCTION_NO_BODY!>f<!>()
+    fun g() {}
+    <!NON_MEMBER_ABSTRACT_FUNCTION!>abstract<!> fun h()
+    <!NON_MEMBER_ABSTRACT_FUNCTION!>abstract<!> fun j() {}
+
+    //property accessors
+    var i: Int                       <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var j: Int                       get() = i;    <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  get() = i;    <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var <!MUST_BE_INITIALIZED!>k<!>: Int        <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var k1: Int = 0;                 <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var l: Int                       <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+    var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;  <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get  <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+
+    var n: Int                       <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
+}
+
+//creating an instance
+abstract class B1(
+    val i: Int,
+    val s: String
+) {
+}
+
+class B2() : B1(1, "r") {}
+
+abstract class B3(i: Int) {
+    this(): this(1)
+}
+
+fun foo(a: B3) {
+    val a = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B3()<!>
+    val b = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B1(2, "s")<!>
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/AnonymousInitializers.jet b/idea/testData/checkerWithErrorTypes/full/AnonymousInitializers.jet
new file mode 100644
index 00000000000..955798a7a9c
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/AnonymousInitializers.jet
@@ -0,0 +1,34 @@
+class NoC {
+  <!ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR!>{
+
+  }<!>
+
+  val a : Int get() = 1
+
+  <!ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR!>{
+
+  }<!>
+}
+
+class WithC() {
+  val x : Int
+  {
+    $x = 1
+    <!UNRESOLVED_REFERENCE!>$y<!> = 2
+    val b = x
+
+  }
+
+  val a : Int get() = 1
+
+  {
+    val z = <!UNRESOLVED_REFERENCE!>b<!>
+    val zz = x
+    val zzz = <!NO_BACKING_FIELD!>$a<!>
+  }
+
+  this(a : Int) : this() {
+    val b = x
+  }
+
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/BinaryCallsOnNullableValues.jet b/idea/testData/checkerWithErrorTypes/full/BinaryCallsOnNullableValues.jet
new file mode 100644
index 00000000000..86d34c881be
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/BinaryCallsOnNullableValues.jet
@@ -0,0 +1,41 @@
+class A() {
+  fun equals(a : Any?) : Boolean = false
+}
+
+class B() {
+  fun equals(a : Any?) : Boolean? = false
+}
+
+class C() {
+  fun equals(a : Any?) : Int = 0
+}
+
+fun f(): Unit {
+  var x: Int? = 1
+  x = 1
+  x <!UNSAFE_INFIX_CALL!>+<!> 1
+  x <!UNSAFE_INFIX_CALL!>plus<!> 1
+  x <!UNSAFE_INFIX_CALL!><<!> 1
+  x <!UNSAFE_INFIX_CALL!>+=<!> 1
+
+  x == 1
+  x != 1
+
+  <!EQUALITY_NOT_APPLICABLE!>A() == 1<!>
+  B() <!RESULT_TYPE_MISMATCH!>==<!> 1
+  C() <!RESULT_TYPE_MISMATCH!>==<!> 1
+
+  <!EQUALITY_NOT_APPLICABLE!>x === "1"<!>
+  <!EQUALITY_NOT_APPLICABLE!>x !== "1"<!>
+
+  x === 1
+  x !== 1
+
+  x<!UNSAFE_INFIX_CALL!>..<!>2
+  <!TYPE_MISMATCH!>x<!> in 1..2
+
+  val y : Boolean? = true
+  false || <!TYPE_MISMATCH!>y<!>
+  <!TYPE_MISMATCH!>y<!> && true
+  <!TYPE_MISMATCH!>y<!> && <!TYPE_MISMATCH!>1<!>
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Bounds.jet b/idea/testData/checkerWithErrorTypes/full/Bounds.jet
new file mode 100644
index 00000000000..37066cb74ab
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Bounds.jet
@@ -0,0 +1,40 @@
+namespace boundsWithSubstitutors {
+    open class A<T>
+    class B<X : A<X>>()
+
+    class C : A<C>
+
+    val a = B<C>()
+    val a1 = B<<!UPPER_BOUND_VIOLATED!>Int<!>>()
+
+    class X<A, B : A>()
+
+    val b = X<Any, X<A<C>, C>>
+    val b0 = X<Any, <!UPPER_BOUND_VIOLATED!>Any?<!>>
+    val b1 = X<Any, X<A<C>, <!UPPER_BOUND_VIOLATED!>String<!>>>
+
+}
+
+  open class A {}
+  open class B<T : A>()
+
+  abstract class C<T : B<<!UPPER_BOUND_VIOLATED!>Int<!>>, X : fun (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) : (B<<!UPPER_BOUND_VIOLATED!>Any<!>>, B<A>)>() : B<<!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any<!>>() { // 2 errors
+    val a = B<<!UPPER_BOUND_VIOLATED!>Char<!>>() // error
+
+    abstract val x : fun (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) : B<<!UPPER_BOUND_VIOLATED!>Any<!>>
+  }
+
+
+fun test() {
+    foo<<!UPPER_BOUND_VIOLATED!>Int?<!>>()
+    foo<Int>()
+    bar<Int?>()
+    bar<Int>()
+    bar<<!UPPER_BOUND_VIOLATED!>Double?<!>>()
+    bar<<!UPPER_BOUND_VIOLATED!>Double<!>>()
+    1.buzz<<!UPPER_BOUND_VIOLATED!>Double<!>>()
+}
+
+fun foo<T : Any>() {}
+fun bar<T : Int?>() {}
+fun <T : <!FINAL_UPPER_BOUND!>Int<!>> Int.buzz() : Unit {}
diff --git a/idea/testData/checkerWithErrorTypes/full/BreakContinue.jet b/idea/testData/checkerWithErrorTypes/full/BreakContinue.jet
new file mode 100644
index 00000000000..2bf691799e0
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/BreakContinue.jet
@@ -0,0 +1,28 @@
+class C {
+
+    fun f (a : Boolean, b : Boolean) {
+        @b (while (true)
+          @a {
+            <!NOT_A_LOOP_LABEL!>break@f<!>
+            break
+            break@b
+            <!NOT_A_LOOP_LABEL!>break@a<!>
+          })
+
+        <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue<!>
+
+        @b (while (true)
+          @a {
+            <!NOT_A_LOOP_LABEL!>continue@f<!>
+            continue
+            continue@b
+            <!NOT_A_LOOP_LABEL!>continue@a<!>
+          })
+
+        <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>break<!>
+
+        <!NOT_A_LOOP_LABEL!>continue@f<!>
+        <!NOT_A_LOOP_LABEL!>break@f<!>
+    }
+
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Builders.jet b/idea/testData/checkerWithErrorTypes/full/Builders.jet
new file mode 100644
index 00000000000..1d26cbbc8b2
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Builders.jet
@@ -0,0 +1,121 @@
+import java.util.*
+
+namespace html {
+
+  abstract class Factory<T> {
+    abstract fun create() : T
+  }
+
+  abstract class Element
+
+  class TextElement(val text : String) : Element
+
+  abstract class Tag(val name : String) : Element {
+    val children = ArrayList<Element>()
+    val attributes = HashMap<String, String>()
+
+    protected fun initTag<T : Element>(init : fun T.() : Unit) : T
+      where class object T : Factory<T>{
+      val tag = T.create()
+      tag.init()
+      children.add(tag)
+      return tag
+    }
+  }
+
+  abstract class TagWithText(name : String) : Tag(name) {
+    fun String.plus() {
+      children.add(TextElement(this))
+    }
+  }
+
+  class HTML() : TagWithText("html") {
+    class object : Factory<HTML> {
+      override fun create() = HTML()
+    }
+
+    fun head(init : fun Head.() : Unit) = initTag<Head>(init)
+
+    fun body(init : fun Body.() : Unit) = initTag<Body>(init)
+  }
+
+  class Head() : TagWithText("head") {
+    class object : Factory<Head> {
+      override fun create() = Head()
+    }
+
+    fun title(init : fun Title.() : Unit) = initTag<Title>(init)
+  }
+
+  class Title() : TagWithText("title")
+
+  abstract class BodyTag(name : String) : TagWithText(name) {
+  }
+
+  class Body() : BodyTag("body") {
+    class object : Factory<Body> {
+      override fun create() = Body()
+    }
+
+    fun b(init : fun B.() : Unit) = initTag<B>(init)
+    fun p(init : fun P.() : Unit) = initTag<P>(init)
+    fun h1(init : fun H1.() : Unit) = initTag<H1>(init)
+    fun a(href : String, init : fun A.() : Unit) {
+      val a = initTag<A>(init)
+      a.href = href
+    }
+  }
+
+  class B() : BodyTag("b")
+  class P() : BodyTag("p")
+  class H1() : BodyTag("h1")
+  class A() : BodyTag("a") {
+    var href : String
+      get() = attributes["href"]
+      set(value) { attributes["href"] = value }
+  }
+
+  fun Map<String, String>.set(key : String, value : String) = this.put(key, value)
+
+  fun html(init : fun HTML.() : Unit) : HTML {
+    val html = HTML()
+    html.init()
+    return html
+  }
+
+}
+
+namespace foo {
+
+import html.*
+
+fun result(args : Array<String>) =
+  html {
+    head {
+      title {+"XML encoding with Groovy"}
+    }
+    body {
+      h1 {+"XML encoding with Groovy"}
+      p {+"this format can be used as an alternative markup to XML"}
+
+      // an element with attributes and text content
+      a(href = "http://groovy.codehaus.org") {+"Groovy"}
+
+      // mixed content
+      p {
+        +"This is some"
+        b {+"mixed"}
+        +"text. For more see the"
+        a(href = "http://groovy.codehaus.org") {+"Groovy"}
+        +"project"
+      }
+      p {+"some text"}
+
+      // content generated by
+      p {
+        for (arg in args)
+          +arg
+      }
+    }
+  }
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/Casts.jet b/idea/testData/checkerWithErrorTypes/full/Casts.jet
new file mode 100644
index 00000000000..163619fd4d0
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Casts.jet
@@ -0,0 +1,16 @@
+fun test() : Unit {
+  var x : Int? = 0
+  var y : Int = 0
+
+  x : Int?
+  y : Int
+  x as Int : Int
+  y <!USELESS_CAST!>as<!> Int : Int
+  x <!USELESS_CAST!>as<!> Int? : Int?
+  y <!USELESS_CAST_STATIC_ASSERT_IS_FINE!>as<!> Int? : Int?
+  x as? Int : Int?
+  y <!USELESS_CAST!>as?<!> Int : Int?
+  x <!USELESS_CAST!>as?<!> Int? : Int?
+  y <!USELESS_CAST_STATIC_ASSERT_IS_FINE!>as?<!> Int? : Int?
+  ()
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/ClassObjects.jet b/idea/testData/checkerWithErrorTypes/full/ClassObjects.jet
new file mode 100644
index 00000000000..5be76d57e39
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/ClassObjects.jet
@@ -0,0 +1,30 @@
+namespace Jet86
+
+class A {
+  class object {
+    val x = 1
+  }
+  <!MANY_CLASS_OBJECTS!>class object { // error
+    val x = 1
+  }<!>
+}
+
+class B() {
+  val x = 12
+}
+
+object b {
+  <!CLASS_OBJECT_NOT_ALLOWED!>class object {
+    val x = 1
+  }<!> // error
+}
+
+val a = A.x
+val c = <!NO_CLASS_OBJECT!>B<!>.x
+val d = b.<!UNRESOLVED_REFERENCE!>x<!>
+
+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/idea/testData/checkerWithErrorTypes/full/Constants.jet b/idea/testData/checkerWithErrorTypes/full/Constants.jet
new file mode 100644
index 00000000000..cc908e189f0
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Constants.jet
@@ -0,0 +1,8 @@
+fun test() {
+  1 : Byte
+  1 : Int
+  <!TYPE_MISMATCH, TYPE_MISMATCH!>1<!> : Double
+  1 <!USELESS_CAST!>as<!> Byte
+  1 <!USELESS_CAST!>as<!> Int
+  <!ERROR_COMPILE_TIME_VALUE!>1<!> <!CAST_NEVER_SUCCEEDS!>as<!> Double
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Constructors.jet b/idea/testData/checkerWithErrorTypes/full/Constructors.jet
new file mode 100644
index 00000000000..370fa759a3e
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Constructors.jet
@@ -0,0 +1,50 @@
+open class NoC
+class NoC1 : NoC
+
+class WithC0() : NoC<!NO_CONSTRUCTOR!>()<!>
+open class WithC1() : NoC
+class NoC2 : <!SUPERTYPE_NOT_INITIALIZED!>WithC1<!>
+class NoC3 : WithC1<!PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL!>()<!>
+class WithC2() : <!SUPERTYPE_NOT_INITIALIZED!>WithC1<!>
+
+class NoPC {
+  <!SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY!>this<!>() {}
+}
+
+class WithPC0() {
+  this(a : Int) : this() {}
+}
+
+class WithPC1(a : Int) {
+  <!SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST!>this<!>() {}
+
+  this(b : Long) : this("") {}
+
+  this(s : String) : this(1) {}
+
+  this(b : Char) : <!NONE_APPLICABLE!>this("", 2)<!> {}
+
+  this(b : Byte) : this(""), <!MANY_CALLS_TO_THIS!>this(1)<!> {}
+}
+
+
+class Foo() : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>WithPC0<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST!>this<!>() {
+
+}
+
+class WithCPI_Dup(x : Int) {
+  var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>x<!> : Int
+}
+
+class WithCPI(x : Int) {
+  val a = 1
+  val b : Int = $a
+  val xy : Int = x
+}
+
+class <!PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY!>NoCPI<!> {
+  val a = <!PROPERTY_INITIALIZER_NO_PRIMARY_CONSTRUCTOR!>1<!>
+  var ab = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>1<!>
+    get() = 1
+    set(v) {}
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet b/idea/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet
new file mode 100644
index 00000000000..a32e3d0ca40
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet
@@ -0,0 +1,26 @@
+trait A {
+    fun foo() : Int = 1
+    fun foo1() : Int = 1
+    val a : Int
+    val a1 : Int
+    val <T> g : Iterator<T>
+
+    fun <T> g() : T
+    fun <T> g1() : T
+}
+
+abstract class B() : A {
+    override fun <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>foo<!>() {
+    }
+    override fun foo() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Unit<!> {
+    }
+
+    override val a : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Double<!> = 1.dbl
+    override val <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>a1<!> = 1.dbl
+
+    abstract override fun <X> g() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Int<!>
+    abstract override fun <X> g1() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>java.util.List<X><!>
+
+    abstract override val <X> g : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Iterator<Int><!>
+}
+
diff --git a/idea/testData/checkerWithErrorTypes/full/CyclicHierarchy.jet b/idea/testData/checkerWithErrorTypes/full/CyclicHierarchy.jet
new file mode 100644
index 00000000000..e0857d24e0f
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/CyclicHierarchy.jet
@@ -0,0 +1,30 @@
+trait A {
+    fun foo() {}
+}
+trait B : A, <!CYCLIC_INHERITANCE_HIERARCHY!>E<!> {}
+trait C : B {}
+trait D : <!CYCLIC_INHERITANCE_HIERARCHY!>B<!> {}
+trait E : <!CYCLIC_INHERITANCE_HIERARCHY!>F<!> {}
+trait F : <!CYCLIC_INHERITANCE_HIERARCHY!>D<!>, C {}
+trait G : F {}
+trait H : F {}
+
+val a : A? = null
+val b : B? = null
+val c : C? = null
+val d : D? = null
+val e : E? = null
+val f : F? = null
+val g : G? = null
+val h : H? = null
+
+fun test() {
+    a?.foo()
+    b?.foo()
+    c?.foo()
+    d?.foo()
+    e?.<!UNRESOLVED_REFERENCE!>foo<!>()
+    f?.foo()
+    g?.foo()
+    h?.foo()
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Enums.jet b/idea/testData/checkerWithErrorTypes/full/Enums.jet
new file mode 100644
index 00000000000..0ef400fda22
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Enums.jet
@@ -0,0 +1,10 @@
+enum class List<out T>(val size : Int) {
+  Nil : List<Nothing>(0) {
+    val a = 1
+  }
+  Cons<out T>(val head : T, val tail : List<T>) : List<T>(tail.size + 1)
+
+}
+
+val foo = List.Nil
+val foo1 = foo.a
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet b/idea/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet
new file mode 100644
index 00000000000..54edfbaa527
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet
@@ -0,0 +1,71 @@
+fun Int?.optint() : Unit {}
+val Int?.optval : Unit = ()
+
+fun <T, E> T.foo(x : E, y : A) : T   {
+  y.plus(1)
+  y plus 1
+  y + 1.0
+
+  this<!UNNECESSARY_SAFE_CALL!>?.<!>minus<T>(this)
+
+  return this
+}
+
+class A
+
+fun A.plus(a : Any) {
+
+  1.foo()
+  true.<!NONE_APPLICABLE!>foo()<!>
+
+  1
+}
+
+fun A.plus(a : Int) {
+  1
+}
+
+fun <T> T.minus(t : T) : Int = 1
+
+fun test() {
+  val y = 1.abs
+}
+val Int.abs : Int
+  get() = if (this > 0) this else -this;
+
+val <T> T.<!MUST_BE_INITIALIZED!>foo<!> : T
+
+fun Int.foo() = this
+
+namespace null_safety {
+
+        fun parse(cmd: String): Command? { return null  }
+        class Command() {
+        //  fun equals(other : Any?) : Boolean
+          val foo : Int = 0
+        }
+
+        fun Any.equals(other : Any?) : Boolean = true
+        fun Any?.equals1(other : Any?) : Boolean = true
+        fun Any.equals2(other : Any?) : Boolean = true
+
+        fun main(args: Array<String>) {
+
+            System.out?.print(1)
+
+            val command = parse("")
+
+            command<!UNSAFE_CALL!>.<!>foo
+
+            command.equals(null)
+            command<!UNNECESSARY_SAFE_CALL!>?.<!>equals(null)
+            command.equals1(null)
+            command<!UNNECESSARY_SAFE_CALL!>?.<!>equals1(null)
+
+            val c = Command()
+            c<!UNNECESSARY_SAFE_CALL!>?.<!>equals2(null)
+
+            if (command == null) 1
+        }
+
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/ForRangeConventions.jet b/idea/testData/checkerWithErrorTypes/full/ForRangeConventions.jet
new file mode 100644
index 00000000000..1f14e587fcd
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/ForRangeConventions.jet
@@ -0,0 +1,81 @@
+import java.util.*;
+
+class NotRange1() {
+
+}
+
+abstract class NotRange2() {
+  abstract fun iterator() : Unit
+}
+
+abstract class ImproperIterator1 {
+  abstract fun hasNext() : Boolean
+}
+
+abstract class NotRange3() {
+  abstract fun iterator() : ImproperIterator1
+}
+
+abstract class ImproperIterator2 {
+  abstract fun next() : Boolean
+}
+
+abstract class NotRange4() {
+  abstract fun iterator() : ImproperIterator2
+}
+
+abstract class ImproperIterator3 {
+  abstract fun hasNext() : Int
+  abstract fun next() : Int
+}
+
+abstract class NotRange5() {
+  abstract fun iterator() : ImproperIterator3
+}
+
+abstract class AmbiguousHasNextIterator {
+  abstract fun hasNext() : Boolean
+  val hasNext : Boolean get() = false
+  abstract fun next() : Int
+}
+
+abstract class NotRange6() {
+  abstract fun iterator() : AmbiguousHasNextIterator
+}
+
+abstract class ImproperIterator4 {
+  val hasNext : Int get() = 1
+  abstract fun next() : Int
+}
+
+abstract class NotRange7() {
+  abstract fun iterator() : ImproperIterator3
+}
+
+abstract class GoodIterator {
+  abstract fun hasNext() : Boolean
+  abstract fun next() : Int
+}
+
+abstract class Range0() {
+  abstract fun iterator() : GoodIterator
+}
+
+abstract class Range1() {
+  abstract fun iterator() : Iterator<Int>
+}
+
+fun test(notRange1: NotRange1, notRange2: NotRange2, notRange3: NotRange3, notRange4: NotRange4, notRange5: NotRange5, notRange6: NotRange6, notRange7: NotRange7, range0: Range0, range1: Range1) {
+  for (i in <!ITERATOR_MISSING!>notRange1<!>);
+  for (i in <!HAS_NEXT_MISSING, NEXT_MISSING!>notRange2<!>);
+  for (i in <!NEXT_MISSING!>notRange3<!>);
+  for (i in <!HAS_NEXT_MISSING!>notRange4<!>);
+  for (i in <!HAS_NEXT_FUNCTION_TYPE_MISMATCH!>notRange5<!>);
+  for (i in <!HAS_NEXT_PROPERTY_AND_FUNCTION_AMBIGUITY!>notRange6<!>);
+  for (i in <!HAS_NEXT_FUNCTION_TYPE_MISMATCH!>notRange7<!>);
+  for (i in range0);
+  for (i in range1);
+
+  for (i in (ArrayList<Int>() : List<Int>));
+}
+
diff --git a/idea/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet b/idea/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet
new file mode 100644
index 00000000000..64012287566
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet
@@ -0,0 +1,166 @@
+fun none() {}
+
+fun unitEmptyInfer() {}
+fun unitEmpty() : Unit {}
+fun unitEmptyReturn() : Unit {return}
+fun unitIntReturn() : Unit {return <!TYPE_MISMATCH!>1<!>}
+fun unitUnitReturn() : Unit {return ()}
+fun test1() : Any = {<!RETURN_NOT_ALLOWED, RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY!>return<!>}
+fun test2() : Any = @a {return@a 1}
+fun test3() : Any { <!RETURN_TYPE_MISMATCH!>return<!> }
+
+fun bbb() {
+  return <!TYPE_MISMATCH!>1<!>
+}
+
+fun foo(expr: StringBuilder): Int {
+  val c = 'a'
+  when(c) {
+    0.chr => throw Exception("zero")
+    else => throw Exception("nonzero" + c)
+  }
+}
+
+
+fun unitShort() : Unit = ()
+fun unitShortConv() : Unit = <!TYPE_MISMATCH!>1<!>
+fun unitShortNull() : Unit = <!TYPE_MISMATCH!>null<!>
+
+fun intEmpty() : Int <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
+fun intShortInfer() = 1
+fun intShort() : Int = 1
+//fun intBlockInfer()  {1}
+fun intBlock() : Int {return 1}
+fun intBlock() : Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>1<!>}
+
+fun intString(): Int = <!TYPE_MISMATCH!>"s"<!>
+fun intFunctionLiteral(): Int = <!TYPE_MISMATCH!>{ 10 }<!>
+
+fun blockReturnUnitMismatch() : Int {<!RETURN_TYPE_MISMATCH!>return<!>}
+fun blockReturnValueTypeMismatch() : Int {return <!ERROR_COMPILE_TIME_VALUE!>3.4<!>}
+fun blockReturnValueTypeMatch() : Int {return 1}
+fun blockReturnValueTypeMismatchUnit() : Int {return <!TYPE_MISMATCH!>()<!>}
+
+fun blockAndAndMismatch() : Int {
+  <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>true && false<!>
+}
+fun blockAndAndMismatch() : Int {
+  return <!TYPE_MISMATCH!>true && false<!>
+}
+fun blockAndAndMismatch() : Int {
+  <!UNREACHABLE_CODE!>(return <!ERROR_COMPILE_TIME_VALUE!>true<!>) && (return <!ERROR_COMPILE_TIME_VALUE!>false<!>)<!>
+}
+
+fun blockAndAndMismatch() : Int {
+  <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>true || false<!>
+}
+fun blockAndAndMismatch() : Int {
+  return <!TYPE_MISMATCH!>true || false<!>
+}
+fun blockAndAndMismatch() : Int {
+  <!UNREACHABLE_CODE!>(return <!ERROR_COMPILE_TIME_VALUE!>true<!>) || (return <!ERROR_COMPILE_TIME_VALUE!>false<!>)<!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  return if (1 > 2) <!ERROR_COMPILE_TIME_VALUE!>1.0<!> else <!ERROR_COMPILE_TIME_VALUE!>2.0<!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  return <!TYPE_MISMATCH!>if (1 > 2) 1<!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  return <!TYPE_MISMATCH!>if (1 > 2) else 1<!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  if (1 > 2)
+    return <!ERROR_COMPILE_TIME_VALUE!>1.0<!>
+  else return <!ERROR_COMPILE_TIME_VALUE!>2.0<!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  if (1 > 2)
+    return <!ERROR_COMPILE_TIME_VALUE!>1.0<!>
+  return <!ERROR_COMPILE_TIME_VALUE!>2.0<!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  if (1 > 2)
+    else return <!ERROR_COMPILE_TIME_VALUE!>1.0<!>
+  return <!ERROR_COMPILE_TIME_VALUE!>2.0<!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  if (1 > 2)
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>1.0<!>
+  else <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>2.0<!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  if (1 > 2)
+    1.0
+  else 2.0
+  return 1
+}
+fun blockReturnValueTypeMatch() : Int {
+  <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>if (1 > 2)
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>1.0<!><!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  return <!TYPE_MISMATCH!>if (1 > 2)
+    1<!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>if (1 > 2)
+  else <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>1.0<!><!>
+}
+fun blockReturnValueTypeMatch() : Int {
+  if (1 > 2)
+    return 1
+  else return <!ERROR_COMPILE_TIME_VALUE!>1.0<!>
+}
+fun blockNoReturnIfValDeclaration(): Int {
+  <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>val x = 1<!>
+}
+fun blockNoReturnIfEmptyIf(): Int {
+  if (1 < 2) <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!> else <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
+}
+fun blockNoReturnIfUnitInOneBranch(): Int {
+  if (1 < 2) {
+    return 1
+  } else {
+    if (3 < 4) <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{
+    }<!> else {
+      return 2
+    }
+  }
+}
+fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else <!TYPE_MISMATCH!>{}<!>
+fun nonBlockNoReturnIfUnitInOneBranch(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else 2
+
+val a = <!RETURN_NOT_ALLOWED!>return 1<!>
+
+class A() {
+  this(a : Int) : this() {
+    if (a == 1)
+      return
+    return <!TYPE_MISMATCH!>1<!>
+  }
+
+}
+fun illegalConstantBody(): Int = <!TYPE_MISMATCH!>"s"<!>
+fun illegalConstantBlock(): String {
+    return <!ERROR_COMPILE_TIME_VALUE!>1<!>
+}
+fun illegalIfBody(): Int =
+    if (1 < 2) <!ERROR_COMPILE_TIME_VALUE!>'a'<!> else { <!ERROR_COMPILE_TIME_VALUE!>1.0<!> }
+fun illegalIfBlock(): Boolean {
+    if (1 < 2)
+        return false
+    else { return <!ERROR_COMPILE_TIME_VALUE!>1<!> }
+}
+fun illegalReturnIf(): Char {
+    return if (1 < 2) 'a' else { <!ERROR_COMPILE_TIME_VALUE!>1<!> }
+}
+
+fun returnNothing(): Nothing {
+    throw 1
+}
+fun f(): Int {
+    if (1 < 2) { return 1 } else returnNothing()
+}
+
+fun f(): Int = if (1 < 2) 1 else returnNothing()
diff --git a/idea/testData/checkerWithErrorTypes/full/GenericArgumentConsistency.jet b/idea/testData/checkerWithErrorTypes/full/GenericArgumentConsistency.jet
new file mode 100644
index 00000000000..fafd2cf98c8
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/GenericArgumentConsistency.jet
@@ -0,0 +1,42 @@
+trait A<in T> {}
+trait B<T> : A<Int> {}
+trait C<T> : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>B<T>, A<T><!> {}
+trait C1<T> : B<T>, A<Any> {}
+trait D : <!INCONSISTENT_TYPE_PARAMETER_VALUES, INCONSISTENT_TYPE_PARAMETER_VALUES!>C<Boolean>, B<Double><!>{}
+
+trait A1<out T> {}
+trait B1 : A1<Int> {}
+trait B2 : A1<Any>, B1 {}
+
+trait BA1<T> {}
+trait BB1 : BA1<Int> {}
+trait BB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>BA1<Any>, BB1<!> {}
+
+
+namespace x {
+    trait AA1<out T> {}
+    trait AB1 : AA1<Int> {}
+    trait AB3 : AA1<Comparable<Int>> {}
+    trait AB2 : AA1<Number>, AB1, AB3 {}
+}
+
+namespace x2 {
+    trait AA1<out T> {}
+    trait AB1 : AA1<Any> {}
+    trait AB3 : AA1<Comparable<Int>> {}
+    trait AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}
+}
+
+namespace x3 {
+    trait AA1<in T> {}
+    trait AB1 : AA1<Any> {}
+    trait AB3 : AA1<Comparable<Int>> {}
+    trait AB2 : AA1<Number>, AB1, AB3 {}
+}
+
+namespace sx2 {
+    trait AA1<in T> {}
+    trait AB1 : AA1<Int> {}
+    trait AB3 : AA1<Comparable<Int>> {}
+    trait AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/IllegalModifiers.jet b/idea/testData/checkerWithErrorTypes/full/IllegalModifiers.jet
new file mode 100644
index 00000000000..9feae3696e1
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/IllegalModifiers.jet
@@ -0,0 +1,21 @@
+namespace illegal_modifiers
+
+abstract class A() {
+    <!INCOMPATIBLE_MODIFIERS!>abstract<!> <!INCOMPATIBLE_MODIFIERS!>final<!> fun f()
+    abstract <!REDUNDANT_MODIFIER!>open<!> fun g()
+    <!INCOMPATIBLE_MODIFIERS!>final<!> <!INCOMPATIBLE_MODIFIERS!>open<!> fun h() {}
+
+    open var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>r<!>: String
+    get
+    <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> protected set
+}
+
+<!TRAIT_CAN_NOT_BE_FINAL!>final<!> trait T {}
+
+class FinalClass() {
+    <!NON_FINAL_MEMBER_IN_FINAL_CLASS!>open<!> fun foo() {}
+    val i: Int = 1
+        <!NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY!>open<!> get(): Int = $i
+    var j: Int = 1
+        <!NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY!>open<!> set(v: Int) {}
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/IncDec.jet b/idea/testData/checkerWithErrorTypes/full/IncDec.jet
new file mode 100644
index 00000000000..5b7143f3eef
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/IncDec.jet
@@ -0,0 +1,46 @@
+class IncDec() {
+  fun inc() : IncDec = this
+  fun dec() : IncDec = this
+}
+
+fun testIncDec() {
+  var x = IncDec()
+  x++
+  ++x
+  x--
+  --x
+  x = x++
+  x = x--
+  x = ++x
+  x = --x
+}
+
+class WrongIncDec() {
+  fun inc() : Int = 1
+  fun dec() : Int = 1
+}
+
+fun testWrongIncDec() {
+  var x = WrongIncDec()
+  x<!RESULT_TYPE_MISMATCH!>++<!>
+  <!RESULT_TYPE_MISMATCH!>++<!>x
+  x<!RESULT_TYPE_MISMATCH!>--<!>
+  <!RESULT_TYPE_MISMATCH!>--<!>x
+}
+
+class UnitIncDec() {
+  fun inc() : Unit {}
+  fun dec() : Unit {}
+}
+
+fun testUnitIncDec() {
+  var x = UnitIncDec()
+  x++
+  ++x
+  x--
+  --x
+  x = <!TYPE_MISMATCH!>x++<!>
+  x = <!TYPE_MISMATCH!>x--<!>
+  x = <!TYPE_MISMATCH!>++x<!>
+  x = <!TYPE_MISMATCH!>--x<!>
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/IsExpressions.jet b/idea/testData/checkerWithErrorTypes/full/IsExpressions.jet
new file mode 100644
index 00000000000..960f3711e37
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/IsExpressions.jet
@@ -0,0 +1,7 @@
+fun test() {
+   if (1 is Int) {
+     if (1 is <!INCOMPATIBLE_TYPES!>Boolean<!>) {
+
+     }
+   }
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/MultipleBounds.jet b/idea/testData/checkerWithErrorTypes/full/MultipleBounds.jet
new file mode 100644
index 00000000000..773ebaea33f
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/MultipleBounds.jet
@@ -0,0 +1,72 @@
+namespace Jet87
+
+open class A() {
+  fun foo() : Int = 1
+}
+
+trait B {
+  fun bar() : Double = 1.0;
+}
+
+class C() : A(), B
+
+class D() {
+  class object : A(), B {}
+}
+
+class Test1<T : A>()
+  where
+    T : B,
+    <!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T, // error
+    class object T : A,
+    class object T : B,
+    class object <!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T
+  {
+
+  fun test(t : T) {
+    T.foo()
+    T.bar()
+    t.foo()
+    t.bar()
+  }
+}
+
+fun test() {
+  Test1<<!UPPER_BOUND_VIOLATED!>B<!>>()
+  Test1<<!UPPER_BOUND_VIOLATED!>A<!>>()
+  Test1<C>()
+}
+
+class Foo() {}
+
+class Bar<T : <!FINAL_UPPER_BOUND!>Foo<!>>
+
+class Buzz<T> where T : <!FINAL_UPPER_BOUND!>Bar<<!UPPER_BOUND_VIOLATED!>Int<!>><!>, T : <!UNRESOLVED_REFERENCE!>nioho<!>
+
+class X<T : <!FINAL_UPPER_BOUND!>Foo<!>>
+class Y<<!CONFLICTING_UPPER_BOUNDS!>T<!> : <!FINAL_UPPER_BOUND!>Foo<!>> where T : <!FINAL_UPPER_BOUND!>Bar<Foo><!>
+
+fun <T : A> test2(t : T)
+  where
+    T : B,
+    <!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T,
+    class object <!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T,
+    class object T : B,
+    class object T : A
+{
+  T.foo()
+  T.bar()
+  t.foo()
+  t.bar()
+}
+
+val t1 = test2<<!UPPER_BOUND_VIOLATED!>A<!>>(A())
+val t2 = test2<<!UPPER_BOUND_VIOLATED!>B<!>>(C())
+val t3 = test2<C>(C())
+
+class Test<<!CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS!>T<!>>
+  where
+    class object T : <!FINAL_CLASS_OBJECT_UPPER_BOUND!>Foo<!>,
+    class object T : A {}
+
+val <T, B : T> x : Int = 0
diff --git a/idea/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet b/idea/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet
new file mode 100644
index 00000000000..a7e2a3a78a7
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet
@@ -0,0 +1,8 @@
+namespace root
+
+namespace a {
+
+}
+
+val x = <!EXPRESSION_EXPECTED_NAMESPACE_FOUND, UNRESOLVED_REFERENCE!>a<!>
+val y2 = <!NAMESPACE_IS_NOT_AN_EXPRESSION!>namespace<!>
diff --git a/idea/testData/checkerWithErrorTypes/full/NamespaceQualified.jet b/idea/testData/checkerWithErrorTypes/full/NamespaceQualified.jet
new file mode 100644
index 00000000000..a298efcacfe
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/NamespaceQualified.jet
@@ -0,0 +1,63 @@
+namespace foobar
+
+namespace a {
+    import java.*
+
+    val a : util.List<Int>? = null
+    val a1 : <!UNRESOLVED_REFERENCE!>List<!><Int>? = null
+
+}
+
+abstract class Foo<T>() {
+    abstract val x : T<Int>
+}
+
+namespace a {
+    import java.util.*
+
+    val b : List<Int>? = a
+    val b1 : <!UNRESOLVED_REFERENCE!>util<!>.List<Int>? = a
+}
+
+val x1 = a.a
+
+val y1 = a.b
+
+
+/////////////////////////////////////////////////////////////////////////
+
+fun done<O>(result : O) : Iteratee<Any?, O> = StrangeIterateeImpl<Any?, O>(result)
+
+abstract class Iteratee<in I, out O> {
+  abstract fun process(item : I) : Iteratee<I, O>
+  abstract val isDone : Boolean
+  abstract val result : O
+  abstract fun done() : O
+}
+
+class StrangeIterateeImpl<in I, out O>(val obj: O) : Iteratee<I, O> {
+    override fun process(item: I): Iteratee<I, O> = StrangeIterateeImpl<I, O>(obj)
+    override val isDone = true
+    override val result = obj
+    override fun done() = obj
+}
+
+abstract class Sum() : Iteratee<Int, Int> {
+  override fun process(item : Int) : Iteratee<Int, Int> {
+    return foobar.done<Int>(item);
+  }
+  abstract override val isDone : Boolean
+  abstract override val result : Int
+  abstract override fun done() : Int
+}
+
+abstract class Collection<E> : Iterable<E> {
+  fun iterate<O>(iteratee : Iteratee<E, O>) : O {
+      for (x in this) {
+        val it = iteratee.process(x)
+        if (it.isDone) return it.result
+        iteratee = it
+      }
+      return iteratee.done()
+  }
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Nullability.jet b/idea/testData/checkerWithErrorTypes/full/Nullability.jet
new file mode 100644
index 00000000000..8479b364cd8
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Nullability.jet
@@ -0,0 +1,280 @@
+fun test() {
+  val a : Int? = 0
+  if (a != null) {
+    a.plus(1)
+  }
+  else {
+    a?.plus(1)
+  }
+
+  val out : java.io.PrintStream? = null//= System.out
+  val ins = System.`in`
+
+  out?.println()
+  ins?.read()
+
+  if (ins != null) {
+    ins.read()
+    out?.println()
+    if (out != null) {
+      ins.read();
+      out.println();
+    }
+  }
+
+  if (out != null && ins != null) {
+    ins.read();
+    out.println();
+  }
+
+  if (out == null) {
+    out?.println()
+  } else {
+    out.println()
+  }
+
+  if (out != null && ins != null || out != null) {
+    ins?.read();
+    out.println();
+  }
+
+  if (out == null || out.println(0) == ()) {
+    out?.println(1)
+  }
+  else {
+    out.println(2)
+  }
+
+  if (out != null && out.println() == ()) {
+    out.println();
+  }
+  else {
+    out?.println();
+  }
+
+  if (out == null || out != null && out.println() == ()) {
+    out?.println();
+  }
+  else {
+    out.println();
+  }
+
+  if (1 == 2 || out != null && out.println(1) == ()) {
+    out?.println(2);
+  }
+  else {
+    out?.println(3)
+  }
+
+  out?.println()
+  ins?.read()
+
+  if (ins != null) {
+    ins.read()
+    out?.println()
+    if (out != null) {
+      ins.read();
+      out.println();
+    }
+  }
+
+  if (out != null && ins != null) {
+    ins.read();
+    out.println();
+  }
+
+  if (out == null) {
+    out?.println()
+  } else {
+    out.println()
+  }
+
+  if (out != null && ins != null || out != null) {
+    ins?.read();
+    out.println();
+  }
+
+  if (out == null || out.println(0) == ()) {
+    out?.println(1)
+  }
+  else {
+    out.println(2)
+  }
+
+  if (out != null && out.println() == ()) {
+    out.println();
+  }
+  else {
+    out?.println();
+  }
+
+  if (out == null || out != null && out.println() == ()) {
+    out?.println();
+  }
+  else {
+    out.println();
+  }
+
+  if (1 == 2 || out != null && out.println(1) == ()) {
+    out?.println(2);
+  }
+  else {
+    out?.println(3)
+  }
+
+  if (1 > 2) {
+    if (out == null) return;
+    out.println();
+  }
+  out?.println();
+
+  while (out != null) {
+    out.println();
+  }
+  out?.println();
+
+  while (out == null) {
+    out?.println();
+  }
+  out.println()
+
+}
+
+
+fun f(out : String?) {
+  out?.get(0)
+  if (out != null) else return;
+  out.get(0)
+}
+
+fun f1(out : String?) {
+  out?.get(0)
+  if (out != null) else {
+    1 + 2
+    return;
+  }
+  out.get(0)
+}
+
+fun f2(out : String?) {
+  out?.get(0)
+  if (out == null) {
+    1 + 2
+    return;
+  }
+  out.get(0)
+}
+
+fun f3(out : String?) {
+  out?.get(0)
+  if (out == null) {
+    1 + 2
+    return;
+  }
+  else {
+    1 + 2
+  }
+  out.get(0)
+}
+
+fun f4(s : String?) {
+  s?.get(0)
+  while (1 < 2 && s != null) {
+    s.get(0)
+  }
+  s?.get(0)
+  while (s == null || 1 < 2) {
+     s?.get(0)
+  }
+  s.get(0)
+}
+
+fun f5(s : String?) {
+  s?.get(0)
+  while (1 < 2 && s != null) {
+    s.get(0)
+  }
+  s?.get(0)
+  while (s == null || 1 < 2) {
+    if (1 > 2) break
+     s?.get(0)
+  }
+  s?.get(0);
+}
+
+fun f6(s : String?) {
+  s?.get(0)
+  do {
+    s?.get(0)
+    if (1 < 2) break;
+  } while (s == null)
+  s?.get(0)
+  do {
+    s?.get(0)
+  } while (s == null)
+  s.get(0)
+}
+
+fun f7(s : String?, t : String?) {
+  s?.get(0)
+  if (!(s == null)) {
+    s.get(0)
+  }
+  s?.get(0)
+  if (!(s != null)) {
+    s?.get(0)
+  }
+  else {
+    s.get(0)
+  }
+  s?.get(0)
+  if (!!(s != null)) {
+    s.get(0)
+  }
+  else {
+    s?.get(0)
+  }
+  s?.get(0)
+  t?.get(0)
+  if (!(s == null || t == null)) {
+    s.get(0)
+    t.get(0)
+  }
+  else {
+    s?.get(0)
+    t?.get(0)
+  }
+  s?.get(0)
+  t?.get(0)
+  if (!(s == null && s == null)) {
+    s.get(0)
+    t?.get(0)
+  }
+  else {
+    s?.get(0)
+    t?.get(0)
+  }
+}
+
+fun f8(b : String?, a : String) {
+  b?.get(0)
+  if (b == a) {
+    b.get(0);
+  }
+  b?.get(0)
+  if (a == b) {
+    b.get(0)
+  }
+  if (a != b) {
+    b?.get(0)
+  }
+  else {
+    b.get(0)
+  }
+}
+
+fun f9(a : Int?) : Int {
+  if (a != null)
+    return a
+  return 1
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Objects.jet b/idea/testData/checkerWithErrorTypes/full/Objects.jet
new file mode 100644
index 00000000000..79ed4e42644
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Objects.jet
@@ -0,0 +1,83 @@
+namespace toplevelObjectDeclarations {
+  open class Foo(y : Int) {
+    open fun foo() : Int = 1
+  }
+
+  class T : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {}
+
+  object A : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {
+    val x : Int = 2
+
+    fun test() : Int {
+      return x + foo()
+    }
+  }
+
+  object B : <!UNRESOLVED_REFERENCE!>A<!> {}
+
+  val x = A.foo()
+
+  val y = object : Foo(x) {
+    {
+      x + 12
+    }
+
+    override fun foo() : Int = 1
+  }
+
+  val z = y.foo()
+}
+
+namespace nestedObejcts {
+  object A {
+    val b = B
+    val d = A.B.A
+
+    object B {
+      val a = A
+      val e = B.A
+
+      object A {
+        val a = A
+        val b = B
+        val x = nestedObejcts.A.B.A
+        val y = this<!AMBIGUOUS_LABEL!>@A<!>
+      }
+    }
+
+  }
+  object B {
+    val b = B
+    val c = A.B
+  }
+
+  val a = A
+  val b = B
+  val c = A.B
+  val d = A.B.A
+  val e = B.<!UNRESOLVED_REFERENCE!>A<!>.B
+}
+
+namespace localObjects {
+  object A {
+    val x : Int = 0
+  }
+
+  open class Foo {
+    fun foo() : Int = 1
+  }
+
+  fun test() {
+    A.x
+    val b = object : Foo {
+    }
+    b.foo()
+
+    object B {
+      fun foo() {}
+    }
+    B.foo()
+  }
+
+  val bb = <!UNRESOLVED_REFERENCE!>B<!>.foo()
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/PrimaryConstructors.jet b/idea/testData/checkerWithErrorTypes/full/PrimaryConstructors.jet
new file mode 100644
index 00000000000..8756860955f
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/PrimaryConstructors.jet
@@ -0,0 +1,14 @@
+class <!PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY!>X<!> {
+  val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>x<!> : Int
+}
+
+open class Y() {
+  val x : Int = 2
+}
+
+class Y1 {
+  val x : Int get() = 1
+}
+
+class Z : Y<!PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL!>()<!> {
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/ProjectionsInSupertypes.jet b/idea/testData/checkerWithErrorTypes/full/ProjectionsInSupertypes.jet
new file mode 100644
index 00000000000..c02bb72b6a2
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/ProjectionsInSupertypes.jet
@@ -0,0 +1,6 @@
+trait A<T> {}
+trait B<T> {}
+trait C<T> {}
+trait D<T> {}
+
+trait Test : A<<!PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE!>in<!> Int>, B<<!PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE!>out<!> Int>, C<<!PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE!>*<!>><!NULLABLE_SUPERTYPE!>?<!><!NULLABLE_SUPERTYPE!>?<!><!NULLABLE_SUPERTYPE!>?<!>, D<Int> {}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Properties.jet b/idea/testData/checkerWithErrorTypes/full/Properties.jet
new file mode 100644
index 00000000000..999ebc5173e
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Properties.jet
@@ -0,0 +1,28 @@
+ var x : Int = 1 + x
+   get() : Int = 1
+   set(<!REF_SETTER_PARAMETER!>ref<!> value : <!WRONG_SETTER_PARAMETER_TYPE!>Long<!>) {
+      $x = value.int
+      $x = <!TYPE_MISMATCH!>1.lng<!>
+    }
+
+ val xx : Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>1 + x<!>
+   get() : Int = 1
+   <!VAL_WITH_SETTER!>set(value : Long) {}<!>
+
+  val p : Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>1<!>
+    get() = 1
+
+class Test() {
+    var a : Int = 111
+    var b : Int get() = <!UNRESOLVED_REFERENCE!>$a<!>; set(x) {a = x; <!UNRESOLVED_REFERENCE!>$a<!> = x}
+
+   this(i : Int) : this() {
+    <!NO_BACKING_FIELD!>$b<!> = $a
+    $a = <!NO_BACKING_FIELD!>$b<!>
+    a = <!NO_BACKING_FIELD!>$b<!>
+   }
+   fun f() {
+    <!UNRESOLVED_REFERENCE!>$b<!> = <!UNRESOLVED_REFERENCE!>$a<!>
+    a = <!UNRESOLVED_REFERENCE!>$b<!>
+   }
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/QualifiedExpressions.jet b/idea/testData/checkerWithErrorTypes/full/QualifiedExpressions.jet
new file mode 100644
index 00000000000..67233fd840f
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/QualifiedExpressions.jet
@@ -0,0 +1,11 @@
+namespace qualified_expressions
+
+fun test(s: String?) {
+   val a: Int = <!TYPE_MISMATCH!>s?.length<!>
+   val b: Int? = s?.length
+   val c: Int = s?.length ?: -11
+   val d: Int = s?.length ?: <!TYPE_MISMATCH!>"empty"<!>
+   val e: String = <!TYPE_MISMATCH!>s?.length<!> ?: "empty"
+   val f: Int = s?.length ?: b ?: 1
+   val g: Int? = e? startsWith("s")?.length
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/QualifiedThis.jet b/idea/testData/checkerWithErrorTypes/full/QualifiedThis.jet
new file mode 100644
index 00000000000..f23c01cfd20
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/QualifiedThis.jet
@@ -0,0 +1,41 @@
+class Dup {
+  fun Dup() : Unit {
+    this<!AMBIGUOUS_LABEL!>@Dup<!>
+  }
+}
+
+class A() {
+  fun foo() : Unit {
+    this@A
+    this<!UNRESOLVED_REFERENCE!>@a<!>
+    this
+  }
+
+  val x = this@A.foo()
+  val y = this.foo()
+  val z = foo()
+}
+
+fun foo1() : Unit {
+  <!NO_THIS!>this<!>
+  this<!UNRESOLVED_REFERENCE!>@a<!>
+}
+
+namespace closures {
+    class A(val a:Int) {
+
+      class B() {
+        val x = this@B : B
+        val y = this@A : A
+        val z = this : B
+        val Int.xx = this : Int
+        fun Char.xx() : Any {
+          this : Char
+          val a = {Double.() => this : Double + this@xx : Char}
+          val b = @a{Double.() => this@a : Double + this@xx : Char}
+          val c = @a{() => <!NO_THIS!>this@a<!> + this@xx : Char}
+          return (@a{Double.() => this@a : Double + this@xx : Char})
+        }
+      }
+    }
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/RecursiveTypeInference.jet b/idea/testData/checkerWithErrorTypes/full/RecursiveTypeInference.jet
new file mode 100644
index 00000000000..11eb880a193
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/RecursiveTypeInference.jet
@@ -0,0 +1,42 @@
+namespace a {
+    val foo = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>
+
+    fun bar() = foo
+}
+
+namespace b {
+    fun foo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>
+
+    fun bar() = foo()
+}
+
+namespace c {
+    fun bazz() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>
+
+    fun foo() = bazz()
+
+    fun bar() = foo()
+}
+
+namespace ok {
+
+    namespace a {
+        val foo = bar()
+
+        fun bar() : Int = foo
+    }
+
+    namespace b {
+        fun foo() : Int = bar()
+
+        fun bar() = foo()
+    }
+
+    namespace c {
+        fun bazz() = bar()
+
+        fun foo() : Int = bazz()
+
+        fun bar() = foo()
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Redeclarations.jet b/idea/testData/checkerWithErrorTypes/full/Redeclarations.jet
new file mode 100644
index 00000000000..3068a16b54d
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Redeclarations.jet
@@ -0,0 +1,16 @@
+namespace redeclarations {
+  object <!REDECLARATION, REDECLARATION!>A<!> {
+    val x : Int = 0
+
+    val A = 1
+  }
+
+  namespace <!REDECLARATION!>A<!> {
+    class A {}
+  }
+
+  class <!REDECLARATION, REDECLARATION!>A<!> {}
+
+  val <!REDECLARATION!>A<!> = 1
+
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/ResolveToJava.jet b/idea/testData/checkerWithErrorTypes/full/ResolveToJava.jet
new file mode 100644
index 00000000000..e2385007530
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/ResolveToJava.jet
@@ -0,0 +1,52 @@
+import java.*
+import util.*
+import <!UNRESOLVED_REFERENCE!>utils<!>.*
+
+import java.io.PrintStream
+import java.lang.Comparable as Com
+
+val l : List<in Int> = ArrayList<Int>()
+
+fun test(l : java.util.List<Int>) {
+  val x : java.<!UNRESOLVED_REFERENCE!>List<!>
+  val y : java.util.List<Int>
+  val b : java.lang.Object
+  val a : util.List<Int>
+  val z : java.<!UNRESOLVED_REFERENCE!>utils<!>.List<Int>
+
+  val f : java.io.File? = null
+
+  Collections.<!UNRESOLVED_REFERENCE!>emptyList<!>
+  Collections.emptyList<Int>
+  Collections.emptyList<Int>()
+  Collections.emptyList()
+
+  Collections.singleton<Int>(1) : Set<Int>?
+  Collections.singleton<Int>(<!ERROR_COMPILE_TIME_VALUE!>1.0<!>)
+
+  <!UNRESOLVED_REFERENCE!>List<!><Int>
+
+
+  val o = "sdf" <!CAST_NEVER_SUCCEEDS!>as<!> Object
+
+  try {
+    // ...
+  }
+  catch(e: Exception) {
+    System.out?.println(e.getMessage())
+  }
+
+  PrintStream("sdf")
+
+  val c : Com<Int>? = null
+
+  c : java.lang.Comparable<Int>?
+
+//  Collections.sort<Integer>(ArrayList<Integer>())
+  xxx.<!UNRESOLVED_REFERENCE!>Class<!>()
+}
+
+
+namespace xxx {
+  import java.lang.Class;
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/StringTemplates.jet b/idea/testData/checkerWithErrorTypes/full/StringTemplates.jet
new file mode 100644
index 00000000000..108ffe1d7dd
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/StringTemplates.jet
@@ -0,0 +1,21 @@
+fun demo() {
+  val abc = 1
+  val a = ""
+  val asd = 1
+  val bar = 5
+  fun map(f : fun () : Any?) : Int  = 1
+  fun buzz(f : fun () : Any?) : Int  = 1
+  val sdf = 1
+  val foo = 3;
+    "$abc"
+    "$"
+    "$.$.asdf$\t"
+    "asd\$"
+    "asd$a<!ILLEGAL_ESCAPE_SEQUENCE!>\x<!>"
+    "asd$a$asd$ $<!UNRESOLVED_REFERENCE!>xxx<!>"
+    "fosdfasdo${1 + bar + 100}}sdsdfgdsfsdf"
+    "foo${bar + map {foo}}sdfsdf"
+    "foo${bar + map { "foo" }}sdfsdf"
+    "foo${bar + map {
+      "foo$sdf${ buzz{}}" }}sdfsdf"
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/SupertypeListChecks.jet b/idea/testData/checkerWithErrorTypes/full/SupertypeListChecks.jet
new file mode 100644
index 00000000000..b63a4d3af5d
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/SupertypeListChecks.jet
@@ -0,0 +1,51 @@
+// KT-286 Check supertype lists
+
+/*
+In a supertype list:
+ Same type should not be mentioned twice
+ Same type should not be indirectly mentioned with incoherent type arguments
+ Every trait's required dependencies should be satisfied
+ No final types should appear
+ Only one class is allowed
+*/
+
+class C1()
+
+open class OC1()
+
+open class C2 {}
+
+open class C3 {}
+
+trait T1 {}
+
+trait T2<T> {}
+
+trait Test<!CONSTRUCTOR_IN_TRAIT!>()<!> {
+    <!CONSTRUCTOR_IN_TRAIT, SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST!>this<!>(x : Int) {}
+}
+
+trait Test1 : C2<!SUPERTYPE_INITIALIZED_IN_TRAIT!>()<!> {}
+
+trait Test2 : C2 {}
+
+trait Test3 : C2, <!MANY_CLASSES_IN_SUPERTYPE_LIST!>C3<!> {}
+
+trait Test4 : T1 {}
+
+trait Test5 : T1, <!SUPERTYPE_APPEARS_TWICE!>T1<!> {}
+
+trait Test6 : <!FINAL_SUPERTYPE!>C1<!> {}
+
+class CTest1() : OC1() {}
+
+class CTest2 : C2 {}
+
+class CTest3 : C2, <!MANY_CLASSES_IN_SUPERTYPE_LIST!>C3<!> {}
+
+class CTest4 : T1 {}
+
+class CTest5 : T1, <!SUPERTYPE_APPEARS_TWICE!>T1<!> {}
+
+class CTest6 : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>C1<!> {}
+
diff --git a/idea/testData/checkerWithErrorTypes/full/TraitSupertypeList.jet b/idea/testData/checkerWithErrorTypes/full/TraitSupertypeList.jet
new file mode 100644
index 00000000000..7f109773457
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/TraitSupertypeList.jet
@@ -0,0 +1,11 @@
+open class bar()
+
+trait Foo<!CONSTRUCTOR_IN_TRAIT!>()<!> : bar<!SUPERTYPE_INITIALIZED_IN_TRAIT!>()<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!> {
+    <!CONSTRUCTOR_IN_TRAIT, SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST!>this<!>(x : Int) {}
+}
+
+trait Foo2 : bar, Foo {
+}
+
+open class Foo1() : bar(), <!SUPERTYPE_NOT_INITIALIZED, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!>, Foo, <!SUPERTYPE_APPEARS_TWICE!>Foo<!><!CONSTRUCTOR_IN_TRAIT!>()<!> {}
+open class Foo12 : bar<!PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL!>()<!>, <!SUPERTYPE_NOT_INITIALIZED, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!> {}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/UnreachableCode.jet b/idea/testData/checkerWithErrorTypes/full/UnreachableCode.jet
new file mode 100644
index 00000000000..2a72a04117d
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/UnreachableCode.jet
@@ -0,0 +1,161 @@
+fun t1() : Int{
+  return 0
+  <!UNREACHABLE_CODE!>1<!>
+}
+
+fun t1a() : Int {
+  <!RETURN_TYPE_MISMATCH!>return<!>
+  <!UNREACHABLE_CODE!>return 1<!>
+  <!UNREACHABLE_CODE!>1<!>
+}
+
+fun t1b() : Int {
+  return 1
+  <!UNREACHABLE_CODE!>return 1<!>
+  <!UNREACHABLE_CODE!>1<!>
+}
+
+fun t1c() : Int {
+  return 1
+  <!RETURN_TYPE_MISMATCH, UNREACHABLE_CODE!>return<!>
+  <!UNREACHABLE_CODE!>1<!>
+}
+
+fun t2() : Int {
+  if (1 > 2)
+    return 1
+  else return 1
+  <!UNREACHABLE_CODE!>1<!>
+}
+
+fun t2a() : Int {
+  if (1 > 2) {
+    return 1
+    <!UNREACHABLE_CODE!>1<!>
+  } else { return 1
+    <!UNREACHABLE_CODE!>2<!>
+  }
+  <!UNREACHABLE_CODE!>1<!>
+}
+
+fun t3() : Any {
+  if (1 > 2)
+    return 2
+  else return ""
+  <!UNREACHABLE_CODE!>1<!>
+}
+
+fun t4(a : Boolean) : Int {
+  do {
+    return 1
+  }
+  while (<!UNREACHABLE_CODE!>a<!>)
+  <!UNREACHABLE_CODE!>1<!>
+}
+
+fun t4break(a : Boolean) : Int {
+  do {
+    break
+  }
+  while (<!UNREACHABLE_CODE!>a<!>)
+  return 1
+}
+
+fun t5() : Int {
+  do {
+    return 1
+    <!UNREACHABLE_CODE!>2<!>
+  }
+  while (<!UNREACHABLE_CODE!>1 > 2<!>)
+  <!UNREACHABLE_CODE!>return 1<!>
+}
+
+fun t6() : Int {
+  while (1 > 2) {
+    return 1
+    <!UNREACHABLE_CODE!>2<!>
+  }
+  return 1
+}
+
+fun t6break() : Int {
+  while (1 > 2) {
+    break
+    <!UNREACHABLE_CODE!>2<!>
+  }
+  return 1
+}
+
+fun t7(b : Int) : Int {
+  for (i in 1..b) {
+    return 1
+    <!UNREACHABLE_CODE!>2<!>
+  }
+  return 1
+}
+
+fun t7break(b : Int) : Int {
+  for (i in 1..b) {
+    return 1
+    <!UNREACHABLE_CODE!>2<!>
+  }
+  return 1
+}
+
+fun t7() : Int {
+  try {
+    return 1
+    <!UNREACHABLE_CODE!>2<!>
+  }
+  catch (e : Any) {
+    2
+  }
+  return 1 // this is OK, like in Java
+}
+
+fun t8() : Int {
+  try {
+    return 1
+    <!UNREACHABLE_CODE!>2<!>
+  }
+  catch (e : Any) {
+    return 1
+    <!UNREACHABLE_CODE!>2<!>
+  }
+  <!UNREACHABLE_CODE!>return 1<!>
+}
+
+fun blockAndAndMismatch() : Boolean {
+  <!UNREACHABLE_CODE!>(return true) || (return false)<!>
+  <!UNREACHABLE_CODE!>return true<!>
+}
+
+fun tf() : Int {
+  try {<!UNREACHABLE_CODE!>return 1<!>} finally{return 1}
+  <!UNREACHABLE_CODE!>return 1<!>
+}
+
+fun failtest(a : Int) : Int {
+  <!UNREACHABLE_BECAUSE_OF_NOTHING!>if (fail() || true) {
+
+  }<!>
+  <!UNREACHABLE_BECAUSE_OF_NOTHING!>return 1<!>
+}
+
+fun foo(a : Nothing) : Unit {
+  1
+  a
+  <!UNREACHABLE_BECAUSE_OF_NOTHING!>2<!>
+}
+
+fun fail() : Nothing {
+  throw java.lang.RuntimeException()
+}
+
+fun nullIsNotNothing() : Unit {
+    val x : Int? = 1
+    if (x != null) {
+         return
+    }
+    fail()
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/Unresolved.jet b/idea/testData/checkerWithErrorTypes/full/Unresolved.jet
new file mode 100644
index 00000000000..48ea2a58e4d
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Unresolved.jet
@@ -0,0 +1,30 @@
+namespace unresolved
+
+fun testGenericArgumentsCount() {
+    val p1: Tuple2<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> = (2, 2)
+    val p2: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Tuple2<!> = (2, 2)
+}
+
+fun testUnresolved() {
+    if (<!UNRESOLVED_REFERENCE!>a<!> is String) {
+        val s = <!UNRESOLVED_REFERENCE!>a<!>
+    }
+    <!UNRESOLVED_REFERENCE!>foo<!>(<!UNRESOLVED_REFERENCE!>a<!>)
+    val s = "s"
+    <!UNRESOLVED_REFERENCE!>foo<!>(s)
+    foo1(<!UNRESOLVED_REFERENCE!>i<!>)
+    s.<!UNRESOLVED_REFERENCE!>foo<!>()
+
+    when(<!UNRESOLVED_REFERENCE!>a<!>) {
+        is Int => <!UNRESOLVED_REFERENCE!>a<!>
+        is String => <!UNRESOLVED_REFERENCE!>a<!>
+    }
+
+    //TODO
+    for (j in <!UNRESOLVED_REFERENCE!>collection<!>) {
+       val i: Int = j
+       j += 1
+    }
+}
+
+fun foo1(i: Int) {}
diff --git a/idea/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet b/idea/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet
new file mode 100644
index 00000000000..f18974bb51f
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/ValAndFunOverrideCompatibilityClash.jet
@@ -0,0 +1,8 @@
+class Foo1() : java.util.ArrayList<Int>()
+
+open class Bar() {
+    fun v() : Int  = 1
+    val v : Int = 1
+}
+
+class Barr() : Bar() {}
diff --git a/idea/testData/checkerWithErrorTypes/full/Variance.jet b/idea/testData/checkerWithErrorTypes/full/Variance.jet
new file mode 100644
index 00000000000..9b6531ffd02
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/Variance.jet
@@ -0,0 +1,40 @@
+namespace variance
+
+abstract class Consumer<in T> {}
+
+abstract class Producer<out T> {}
+
+abstract class Usual<T> {}
+
+fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
+    val c1: Consumer<Any> = <!TYPE_MISMATCH!>c<!>
+    val c2: Consumer<Int> = c1
+
+    val p1: Producer<Any> = p
+    val p2: Producer<Int> = <!TYPE_MISMATCH!>p1<!>
+
+    val u1: Usual<Any> = <!TYPE_MISMATCH!>u<!>
+    val u2: Usual<Int> = <!TYPE_MISMATCH!>u1<!>
+}
+
+//Arrays copy example
+class Array<T>(val length : Int) {
+    fun get(index : Int) : T { return null }
+    fun set(index : Int, value : T) { /* ... */ }
+}
+
+fun copy1(from : Array<Any>, to : Array<Any>) {}
+
+fun copy2(from : Array<out Any>, to : Array<in Any>) {}
+
+fun <T> copy3(from : Array<out T>, to : Array<in T>) {}
+
+fun copy4(from : Array<out Number>, to : Array<in Int>) {}
+
+fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
+    copy1(<!TYPE_MISMATCH!>ints<!>, any)
+    copy2(ints, any) //ok
+    copy2(ints, <!TYPE_MISMATCH!>numbers<!>)
+    copy3<Int>(ints, numbers)
+    copy4(ints, numbers) //ok
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/When.jet b/idea/testData/checkerWithErrorTypes/full/When.jet
new file mode 100644
index 00000000000..f8612546d1c
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/When.jet
@@ -0,0 +1,61 @@
+fun foo() : Int {
+    val s = ""
+    val x = 1
+    when (x) {
+      is * => 1
+      is <!INCOMPATIBLE_TYPES!>String<!> => 1
+      !is Int => 1
+      is Any? => 1
+      <!INCOMPATIBLE_TYPES!>s<!> => 1
+      1 => 1
+      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
+      else => 1
+    }
+    return when (<!USELESS_ELVIS!>x<!>?:null) {
+      <!UNSAFE_CALL!>.<!>equals(1) => 1
+      ?.equals(1).equals(2) => 1
+    }
+}
+
+val _type_test : Int = foo() // this is needed to ensure the inferred return type of foo()
+
+fun test() {
+  val x = 1;
+  val s = "";
+
+  when (x) {
+    <!INCOMPATIBLE_TYPES!>s<!> => 1
+    is <!INCOMPATIBLE_TYPES!>""<!> => 1
+    x => 1
+    is 1 => 1
+    is <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>(1, 1)<!> => 1
+  }
+
+  val z = (1, 1)
+
+  when (z) {
+    is (*, *) => 1
+    is (*, 1) => 1
+    is (1, 1) => 1
+    is (1, <!INCOMPATIBLE_TYPES!>"1"<!>) => 1
+    is <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>(1, "1", *)<!> => 1
+    is boo @ (1, <!INCOMPATIBLE_TYPES!>"a"<!>, *) => 1
+    is boo @ <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>(1, *)<!> => 1
+  }
+
+  when (z) {
+    <!ELSE_MISPLACED_IN_WHEN!>else => 1<!>
+    (1, 1) => 2
+  }
+
+  when (z) {
+    else => 1
+  }
+}
+
+val (Int, Int).boo : (Int, Int, Int) = (1, 1, 1)
diff --git a/idea/testData/checkerWithErrorTypes/full/infos/Autocasts.jet b/idea/testData/checkerWithErrorTypes/full/infos/Autocasts.jet
new file mode 100644
index 00000000000..ff7066a34f5
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/infos/Autocasts.jet
@@ -0,0 +1,255 @@
+open class A() {
+  fun foo() {}
+}
+
+class B() : A() {
+  fun bar() {}
+}
+
+fun f9() {
+  val a : A?
+  a?.foo()
+  a?.<!UNRESOLVED_REFERENCE!>bar<!>()
+  if (a is B) {
+    a.bar()
+    a.foo()
+  }
+  a?.foo()
+  a?.<!UNRESOLVED_REFERENCE!>bar<!>()
+  if (!(a is B)) {
+    a?.<!UNRESOLVED_REFERENCE!>bar<!>()
+    a?.foo()
+  }
+  if (!(a is B) || a.bar() == ()) {
+      a?.<!UNRESOLVED_REFERENCE!>bar<!>()
+  }
+  if (!(a is B)) {
+    return;
+  }
+  a.bar()
+  a.foo()
+}
+
+fun f10() {
+  val a : A?
+  if (!(a is B)) {
+    return;
+  }
+  if (!(a is B)) {
+    return;
+  }
+}
+
+class C() : A() {
+  fun bar() {
+
+  }
+}
+
+fun f10(a : A?) {
+  if (a is B) {
+    if (a is C) {
+      a.bar();
+    }
+  }
+}
+
+fun f11(a : A?) {
+  when (a) {
+    is B => a.bar()
+    is A => a.foo()
+    is Any => a.foo()
+    is Any? => a.<!UNRESOLVED_REFERENCE!>bar<!>()
+    else => a?.foo()
+  }
+}
+
+fun f12(a : A?) {
+  when (a) {
+    is B => a.bar()
+    is A => a.foo()
+    is Any => a.foo();
+    is Any? => a.<!UNRESOLVED_REFERENCE!>bar<!>()
+    is val c : <!TYPE_MISMATCH_IN_BINDING_PATTERN!>B<!> => c.foo()
+    is val c is C => c.bar()
+    is val c is C => a.bar()
+    else => a?.foo()
+  }
+
+  if (a is val b) {
+    a?.<!UNRESOLVED_REFERENCE!>bar<!>()
+    b?.foo()
+  }
+  if (a is val b is B) {
+    b.foo()
+    a.bar()
+    b.bar()
+  }
+}
+
+fun f13(a : A?) {
+  if (a is val c is B) {
+    c.foo()
+    c.bar()
+  }
+  else {
+    a?.foo()
+    <!UNRESOLVED_REFERENCE!>c<!>.bar()
+  }
+
+  a?.foo()
+  if (!(a is val c is B)) {
+    a?.foo()
+    <!UNRESOLVED_REFERENCE!>c<!>.bar()
+  }
+  else {
+    a.foo()
+    <!UNRESOLVED_REFERENCE!>c<!>.bar()
+  }
+
+  a?.foo()
+  if (a is val c is B && a.foo() == () && c.bar() == ()) {
+    c.foo()
+    c.bar()
+  }
+  else {
+    a?.foo()
+    <!UNRESOLVED_REFERENCE!>c<!>.bar()
+  }
+
+  if (!(a is val c is B) || !(a is val x is C)) {
+    <!UNRESOLVED_REFERENCE!>x<!>
+    <!UNRESOLVED_REFERENCE!>c<!>
+  }
+  else {
+    <!UNRESOLVED_REFERENCE!>x<!>
+    <!UNRESOLVED_REFERENCE!>c<!>
+  }
+
+  if (!(a is val c is B) || !(a is val c is C)) {
+  }
+
+  if (!(a is val c is B)) return
+  a.bar()
+  <!UNRESOLVED_REFERENCE!>c<!>.foo()
+  <!UNRESOLVED_REFERENCE!>c<!>.bar()
+}
+
+fun f14(a : A?) {
+  while (!(a is val c is B)) {
+  }
+  a.bar()
+  <!UNRESOLVED_REFERENCE!>c<!>.bar()
+}
+fun f15(a : A?) {
+  do {
+  } while (!(a is val c is B))
+  a.bar()
+  <!UNRESOLVED_REFERENCE!>c<!>.bar()
+}
+
+fun getStringLength(obj : Any) : Char? {
+  if (obj !is String)
+    return null
+  return obj.get(0) // no cast to String is needed
+}
+
+fun toInt(i: Int?): Int = if (i != null) i else 0
+fun illegalWhenBody(a: Any): Int = when(a) {
+    is Int => a
+    is String => <!TYPE_MISMATCH!>a<!>
+}
+fun illegalWhenBlock(a: Any): Int {
+    when(a) {
+        is Int => return a
+        is String => return <!TYPE_MISMATCH!>a<!>
+    }
+}
+fun declarations(a: Any?) {
+    if (a is String) {
+       val p4: (Int, String) = (2, a)
+    }
+    if (a is String?) {
+        if (a != null) {
+            val s: String = a
+        }
+    }
+    if (a != null) {
+        if (a is String?) {
+            val s: String = a
+        }
+    }
+}
+fun vars(a: Any?) {
+    var b: Int = 0
+    if (a is Int) {
+        b = a
+    }
+}
+fun tuples(a: Any?) {
+    if (a != null) {
+        val s: (Any, String) = (a, <!TYPE_MISMATCH!>a<!>)
+    }
+    if (a is String) {
+        val s: (Any, String) = (a, a)
+    }
+    fun illegalTupleReturnType(): (Any, String) = (<!TYPE_MISMATCH!>a<!>, <!TYPE_MISMATCH!>a<!>)
+    if (a is String) {
+        fun legalTupleReturnType(): (Any, String) = (a, a)
+    }
+    val illegalFunctionLiteral: Function0<Int> = <!TYPE_MISMATCH!>{ <!TYPE_MISMATCH!>a<!> }<!>
+    val illegalReturnValueInFunctionLiteral: Function0<Int> = { (): Int => <!TYPE_MISMATCH!>a<!> }
+
+    if (a is Int) {
+        val legalFunctionLiteral: Function0<Int> = { a }
+        val alsoLegalFunctionLiteral: Function0<Int> = { (): Int => a }
+    }
+}
+fun returnFunctionLiteralBlock(a: Any?): Function0<Int> {
+    if (a is Int) return { a }
+    else return { 1 }
+}
+fun returnFunctionLiteral(a: Any?): Function0<Int> =
+    if (a is Int) { (): Int => a }
+    else { () => 1 }
+
+fun illegalTupleReturnType(a: Any): (Any, String) = (a, <!TYPE_MISMATCH!>a<!>)
+
+fun declarationInsidePattern(x: (Any, Any)): String = when(x) { is (val a is String, *) => a; else => "something" }
+
+fun mergeAutocasts(a: Any?) {
+  if (a is String || a is Int) {
+    a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
+    a.toString()
+  }
+  if (a is Int || a is String) {
+    a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
+  }
+  when (a) {
+    is String, is Any => a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
+  }
+  if (a is String && a is Any) {
+    val i: Int = a.compareTo("")
+  }
+  if (a is String && a.compareTo("") == 0) {}
+  if (a is String || a.<!UNRESOLVED_REFERENCE!>compareTo<!>("") == 0) {}
+}
+
+//mutability
+fun f(): String {
+    var a: Any = 11
+    if (a is String) {
+        val i: String = <!AUTOCAST_IMPOSSIBLE!>a<!>
+        <!AUTOCAST_IMPOSSIBLE!>a<!>.compareTo("f")
+        val f: Function0<String> = { <!AUTOCAST_IMPOSSIBLE!>a<!> }
+        return <!AUTOCAST_IMPOSSIBLE!>a<!>
+    }
+    return ""
+}
+
+fun foo(var a: Any): Int {
+    if (a is Int) {
+        return <!AUTOCAST_IMPOSSIBLE!>a<!>
+    }
+    return 1
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet b/idea/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet
new file mode 100644
index 00000000000..3f417b56418
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet
@@ -0,0 +1,57 @@
+abstract class Test() {
+    abstract val x : Int
+    abstract val x1 : Int get
+    abstract val x2 : Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
+
+    val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!> : Int
+    val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!> : Int get
+    val c = 1
+
+    val c1 = 1
+      get
+    val c2 : Int
+        get() = 1
+    val c3 : Int
+        get() { return 1 }
+    val c4 : Int
+        get() = 1
+    val <!MUST_BE_INITIALIZED!>c5<!> : Int
+        get() = $c5 + 1
+
+    abstract var y : Int
+    abstract var y1 : Int get
+    abstract var y2 : Int set
+    abstract var y3 : Int set get
+    abstract var y4 : Int set <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
+    abstract var y5 : Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(x) {}<!> <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
+    abstract var y6 : Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(x) {}<!>
+
+    var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v<!> : Int
+    var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v1<!> : Int get
+    var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v2<!> : Int get set
+    var <!MUST_BE_INITIALIZED!>v3<!> : Int get() = 1; set
+    var v4 : Int get() = 1; set(x){}
+
+    var <!MUST_BE_INITIALIZED!>v5<!> : Int get() = 1; set(x){$v5 = x}
+    var <!MUST_BE_INITIALIZED!>v6<!> : Int get() = $v6 + 1; set(x){}
+
+  abstract val v7 : Int abstract get
+  abstract var v8 : Int abstract get abstract set
+  var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v9<!> : Int <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
+  var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v10<!> : Int <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get
+
+}
+
+open class Super(i : Int)
+
+class TestPCParameters(w : Int, x : Int, val y : Int, var z : Int) : Super(w) {
+
+  val xx = w
+
+  {
+    w + 1
+  }
+
+  fun foo() = <!UNRESOLVED_REFERENCE!>x<!>
+
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/AmbiguityOnLazyTypeComputation.jet b/idea/testData/checkerWithErrorTypes/full/regression/AmbiguityOnLazyTypeComputation.jet
new file mode 100644
index 00000000000..779ee4c4d97
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/AmbiguityOnLazyTypeComputation.jet
@@ -0,0 +1,12 @@
+// One of the two passes is making a scope and turning vals into functions
+// See KT-76
+
+namespace x
+
+val b : Foo = Foo()
+val a1 = b.compareTo(2)
+
+class Foo() {
+  fun compareTo(other : Byte)   : Int = 0
+  fun compareTo(other : Char)   : Int = 0
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/AssignmentsUnderOperators.jet b/idea/testData/checkerWithErrorTypes/full/regression/AssignmentsUnderOperators.jet
new file mode 100644
index 00000000000..5a7c24b7fd0
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/AssignmentsUnderOperators.jet
@@ -0,0 +1,6 @@
+fun test() {
+  val a : Any? = null
+  if (a is Any) else a = null;
+  while (a is Any) a = null
+  while (true) a = null
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/CoercionToUnit.jet b/idea/testData/checkerWithErrorTypes/full/regression/CoercionToUnit.jet
new file mode 100644
index 00000000000..6733ab3a31e
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/CoercionToUnit.jet
@@ -0,0 +1,9 @@
+fun foo(u : Unit) : Int = 1
+
+fun test() : Int {
+    foo(<!TYPE_MISMATCH!>1<!>)
+    val a : fun() : Unit = {
+        foo(<!TYPE_MISMATCH!>1<!>)
+    }
+    return 1
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet b/idea/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet
new file mode 100644
index 00000000000..fbca6a41c99
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/DoubleDefine.jet
@@ -0,0 +1,66 @@
+import java.*
+import util.*
+
+import java.io.*
+
+fun takeFirst(expr: StringBuilder): Char {
+  val c = expr.charAt(0)
+  expr.deleteCharAt(0)
+  return c
+}
+
+fun evaluateArg(expr: AbstractStringBuilder, numbers: ArrayList<Int>): Int {
+  if (expr.length() == 0) throw Exception("Syntax error: Character expected");
+  val c = takeFirst(<!TYPE_MISMATCH!>expr<!>)
+  if (c >= '0' && c <= '9') {
+    val n = c - '0'
+    if (!numbers.contains(n)) throw Exception("You used incorrect number: " + n)
+    numbers.remove(n)
+    return n
+  }
+  throw Exception("Syntax error: Unrecognized character " + c)
+}
+
+fun evaluateAdd(expr: StringBuilder, numbers: ArrayList<Int>): Int {
+  val lhs = evaluateArg(expr, numbers)
+  if (expr.length() > 0) {
+
+  }
+  return lhs
+}
+
+fun evaluate(expr: StringBuilder, numbers: ArrayList<Int>): Int {
+  val lhs = evaluateAdd(expr, numbers)
+  if (expr.length() > 0) {
+    val c = expr.charAt(0)
+    expr.deleteCharAt(0)
+  }
+  return lhs
+}
+
+fun main(args: Array<String>) {
+  System.out?.println("24 game")
+  val numbers = ArrayList<Int>(4)
+  val rnd = Random();
+  val prompt = StringBuilder()
+  for(val i in 0..3) {
+    val n = rnd.nextInt(9) + 1
+    numbers.add(n)
+    if (i > 0) prompt.append(" ");
+    prompt.append(n)
+  }
+  System.out?.println("Your numbers: " + prompt)
+  System.out?.println("Enter your expression:")
+  val reader = BufferedReader(InputStreamReader(System.`in`))
+  val expr = StringBuilder(reader.readLine())
+  try {
+    val result = evaluate(expr, numbers)
+    if (result != 24)
+      System.out?.println("Sorry, that's " + result)
+    else
+      System.out?.println("You won!");
+  }
+  catch(e: Throwable) {
+    System.out?.println(e.getMessage())
+  }
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet11.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet11.jet
new file mode 100644
index 00000000000..eb42b6f2427
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet11.jet
@@ -0,0 +1,4 @@
+// JET-11 Redeclaration & Forward reference for classes cause an exception
+open class <!REDECLARATION!>NoC<!>
+class NoC1 : NoC
+open class <!REDECLARATION!>NoC<!>
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet121.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet121.jet
new file mode 100644
index 00000000000..fc29dfe5293
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet121.jet
@@ -0,0 +1,14 @@
+namespace jet121 {
+  fun box() : String {
+    val answer = apply("OK") { String.() : Int =>
+      get(0)
+      length
+    }
+
+    return if (answer == 2) "OK" else "FAIL"
+  }
+
+  fun apply(arg:String, f : fun String.() : Int) : Int {
+      return arg.f()
+  }
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet124.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet124.jet
new file mode 100644
index 00000000000..317b1438f41
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet124.jet
@@ -0,0 +1,8 @@
+fun foo1() : fun (Int) : Int = { (x: Int) => x }
+
+fun foo() {
+  val h : fun (Int) : Int = foo1();
+  h(1)
+  val m : fun (Int) : Int = {(a : Int) => 1}//foo1()
+  m(1)
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet169.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet169.jet
new file mode 100644
index 00000000000..000536ce340
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet169.jet
@@ -0,0 +1,8 @@
+fun set(key : String, value : String) {
+  val a : String? = ""
+  when (a) {
+    "" => a<!UNSAFE_CALL!>.<!>get(0)
+    is String, is Any => a.compareTo("")
+    else => a.toString()
+  }
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet17.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet17.jet
new file mode 100644
index 00000000000..32cf98cd2fc
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet17.jet
@@ -0,0 +1,6 @@
+// JET-17 Do not infer property types by the initializer before the containing scope is ready
+
+class WithC() {
+  val a = 1
+  val b = $a // error here, but must not be
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet183-1.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet183-1.jet
new file mode 100644
index 00000000000..37c72d83ef6
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet183-1.jet
@@ -0,0 +1,21 @@
+abstract enum class ProtocolState {
+  WAITING {
+    override fun signal() = ProtocolState.TALKING
+  }
+
+  TALKING {
+    override fun signal() = ProtocolState.WAITING
+  }
+
+  abstract fun signal() : ProtocolState
+}
+
+
+fun box(): String {
+   val x: ProtocolState = ProtocolState.WAITING
+   x = x.signal()
+   if (x != ProtocolState.TALKING) return "fail 1"
+   x = x.signal()
+   if (x != ProtocolState.WAITING) return "fail 2"
+   return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet183.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet183.jet
new file mode 100644
index 00000000000..59df6e106d6
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet183.jet
@@ -0,0 +1,22 @@
+abstract enum class ProtocolState {
+  WAITING {
+    override fun signal() = ProtocolState.TALKING
+  }
+
+  TALKING {
+    override fun signal() = ProtocolState.WAITING
+  }
+
+  abstract fun signal() : ProtocolState
+}
+
+enum class Foo<T> {
+  <!NO_GENERICS_IN_SUPERTYPE_SPECIFIER!>X<!>
+
+}
+
+
+
+fun box() {
+   val x: ProtocolState = ProtocolState.WAITING
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet53.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet53.jet
new file mode 100644
index 00000000000..e880fe25bbd
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet53.jet
@@ -0,0 +1,4 @@
+import java.util.Collections
+import java.util.List
+
+val ab = Collections.emptyList<Int>() : List<Int>?
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet67.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet67.jet
new file mode 100644
index 00000000000..7c2248a5f6a
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet67.jet
@@ -0,0 +1,4 @@
+abstract class XXX {
+  abstract val a : Int abstract get
+
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet68.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet68.jet
new file mode 100644
index 00000000000..2d9cc4c7b21
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet68.jet
@@ -0,0 +1,11 @@
+class Foo()
+
+fun test() {
+  val f : Foo? = null
+  if (f == null) {
+
+  }
+  if (f != null) {
+
+  }
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet69.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet69.jet
new file mode 100644
index 00000000000..dd198aa0f61
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet69.jet
@@ -0,0 +1,10 @@
+class Command() {}
+
+fun parse(cmd: String): Command? { return null  }
+
+fun Any.equals(other : Any?) : Boolean = this === other
+
+fun main(args: Array<String>) {
+    val command = parse("")
+    if (command == null) 1 // error on this line, but must be OK
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet72.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet72.jet
new file mode 100644
index 00000000000..d3d3272c8e3
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet72.jet
@@ -0,0 +1,17 @@
+// JET-72 Type inference doesn't work when iterating over ArrayList
+
+import java.util.ArrayList
+
+abstract class Item(val room: Object) {
+   abstract val name : String
+}
+
+val items: ArrayList<Item> = ArrayList<Item>
+
+fun test(room : Object) {
+  for(val item: Item in items) {
+    if (item.room === room) {
+      System.out?.println("You see " + item.name)
+    }
+  }
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/Jet81.jet b/idea/testData/checkerWithErrorTypes/full/regression/Jet81.jet
new file mode 100644
index 00000000000..a3ff4596172
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/Jet81.jet
@@ -0,0 +1,22 @@
+// JET-81 Assertion fails when processing self-referring anonymous objects
+
+val y = object {
+  val a = y;
+}
+
+val z = y.a;
+
+object A {
+  val x = A
+}
+
+val a = object {
+  {
+    b + 1
+  }
+  val x = b
+  val y = 1
+}
+
+val b = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!>.x
+val c = a.y
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/OverrideResolution.jet b/idea/testData/checkerWithErrorTypes/full/regression/OverrideResolution.jet
new file mode 100644
index 00000000000..b58ac616160
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/OverrideResolution.jet
@@ -0,0 +1,16 @@
+fun box() {
+    val a : C
+    a.foo()
+}
+
+open class A {
+    open fun foo() {}
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+open class C : B {
+    override fun foo() {}
+}
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet b/idea/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet
new file mode 100644
index 00000000000..2cac1044074
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet
@@ -0,0 +1,18 @@
+  class Foo(var bar : Int, barr : Int, val barrr : Int) {
+    {
+      bar = 1
+      barr = 1
+      barrr = 1
+      1 : Int
+      this : Foo
+    }
+
+    this(val bar : Int) : this(1, 1, 1) {
+      bar = 1
+      this.bar
+      1 : Int
+      val a : Int =1
+      this : Foo
+    }
+  }
+
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/SpecififcityByReceiver.jet b/idea/testData/checkerWithErrorTypes/full/regression/SpecififcityByReceiver.jet
new file mode 100644
index 00000000000..bbca53527c8
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/SpecififcityByReceiver.jet
@@ -0,0 +1,9 @@
+fun Any.equals(other : Any?) : Boolean = true
+
+fun main(args: Array<String>) {
+
+    val command : Any = 1
+
+    command<!UNNECESSARY_SAFE_CALL!>?.<!>equals(null)
+    command.equals(null)
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/ThisConstructorInGenericClass.jet b/idea/testData/checkerWithErrorTypes/full/regression/ThisConstructorInGenericClass.jet
new file mode 100644
index 00000000000..cb4408bd600
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/ThisConstructorInGenericClass.jet
@@ -0,0 +1,3 @@
+class Z() {
+    this(x : Int) : this() {}
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/WrongTraceInCallResolver.jet b/idea/testData/checkerWithErrorTypes/full/regression/WrongTraceInCallResolver.jet
new file mode 100644
index 00000000000..952ac6c3dbe
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/WrongTraceInCallResolver.jet
@@ -0,0 +1,9 @@
+open class Foo {}
+open class Bar {}
+
+fun <T : Bar, T1> foo(x : Int) {}
+fun <T1, T : Foo> foo(x : Long) {}
+
+fun f(): Unit {
+    foo<<!UPPER_BOUND_VIOLATED!>Int<!>, Int>(1)
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/kt251.jet b/idea/testData/checkerWithErrorTypes/full/regression/kt251.jet
new file mode 100644
index 00000000000..bfbc0784224
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/kt251.jet
@@ -0,0 +1,33 @@
+class A() {
+    var x: Int = 0
+        get() = <!TYPE_MISMATCH!>"s"<!>
+        set(value: <!WRONG_SETTER_PARAMETER_TYPE!>String<!>) {
+            $x = <!TYPE_MISMATCH!>value<!>
+        }
+    val y: Int
+        get(): <!WRONG_GETTER_RETURN_TYPE!>String<!> = "s"
+    val z: Int
+        get() {
+            return <!TYPE_MISMATCH!>"s"<!>
+        }
+
+    var a: Any = 1
+        set(v: <!WRONG_SETTER_PARAMETER_TYPE!>String<!>) {
+            $a = v
+        }
+    val b: Int
+        get(): <!WRONG_GETTER_RETURN_TYPE!>Any<!> = "s"
+    val c: Int
+        get() {
+            return 1
+        }
+    val d = 1
+        get() {
+            return $d
+        }
+    val e = 1
+        get(): <!WRONG_GETTER_RETURN_TYPE!>String<!> {
+            return <!TYPE_MISMATCH!>$e<!>
+        }
+
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/full/regression/kt303.jet b/idea/testData/checkerWithErrorTypes/full/regression/kt303.jet
new file mode 100644
index 00000000000..ed38edc0bf0
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/full/regression/kt303.jet
@@ -0,0 +1,11 @@
+// KT-303 Stack overflow on a cyclic class hierarchy
+
+open class Foo() : <!CYCLIC_INHERITANCE_HIERARCHY!>Bar<!>() {
+  val a : Int = 1
+}
+
+open class Bar() : <!CYCLIC_INHERITANCE_HIERARCHY!>Foo<!>() {
+
+}
+
+val x : Int = <!TYPE_MISMATCH!>Foo()<!>
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet b/idea/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet
new file mode 100644
index 00000000000..ef474b07d54
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet
@@ -0,0 +1,32 @@
+fun text() {
+    "direct:a" to "mock:a"
+    "direct:a" on {it.body == "<hello/>"} to "mock:a"
+    "direct:a" on {it => it.body == "<hello/>"} to "mock:a"
+    bar <!TYPE_MISMATCH!>{1}<!>
+    bar <!TYPE_MISMATCH!>{<!UNRESOLVED_REFERENCE!>it<!> + 1}<!>
+    bar {it, it1 => it}
+
+    bar1 {1}
+    bar1 {it + 1}
+
+    bar2 <!TYPE_MISMATCH!>{<!TYPE_MISMATCH!><!>}<!>
+    bar2 {1}
+    bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
+    bar2 <!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>it<!> => it}<!>
+}
+
+fun bar(f : fun (Int, Int) : Int) {}
+fun bar1(f : fun (Int) : Int) {}
+fun bar2(f : fun () : Int) {}
+
+fun String.to(dest : String) {
+
+}
+
+fun String.on(predicate : fun (s : URI) : Boolean) : URI {
+    return URI(this)
+}
+
+class URI(val body : Any) {
+    fun to(dest : String) {}
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/quick/Basic.jet b/idea/testData/checkerWithErrorTypes/quick/Basic.jet
new file mode 100644
index 00000000000..dea3b44a6e1
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/Basic.jet
@@ -0,0 +1,15 @@
+fun foo(u : Unit) : Int = 1
+
+fun test() : Int {
+    foo(<!TYPE_MISMATCH!>1<!>)
+    val a : fun() : Unit = {
+        foo(<!TYPE_MISMATCH!>1<!>)
+    }
+    return 1 <!NONE_APPLICABLE!>-<!> "1"
+}
+
+class A() {
+    val x : Int = <!TYPE_MISMATCH!>foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)<!>
+}
+
+fun foo1() {}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet b/idea/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet
new file mode 100644
index 00000000000..55df425bc64
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet
@@ -0,0 +1,5 @@
+val x = ""
+
+fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = <!TYPE_MISMATCH!>x<!>, z : String = <!UNRESOLVED_REFERENCE!>y<!>) {
+
+}
diff --git a/idea/testData/checkerWithErrorTypes/quick/DeferredTypes.jet b/idea/testData/checkerWithErrorTypes/quick/DeferredTypes.jet
new file mode 100644
index 00000000000..8125ddbc904
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/DeferredTypes.jet
@@ -0,0 +1,3 @@
+trait T {
+  val a = <!PROPERTY_INITIALIZER_IN_TRAIT!><!UNRESOLVED_REFERENCE!>Foo<!>.bar()<!>
+}
diff --git a/idea/testData/checkerWithErrorTypes/quick/DelegationAndOverriding.jet b/idea/testData/checkerWithErrorTypes/quick/DelegationAndOverriding.jet
new file mode 100644
index 00000000000..388653da85a
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/DelegationAndOverriding.jet
@@ -0,0 +1,38 @@
+//namespace override
+
+trait T {
+    fun foo()
+    val v : Int
+}
+
+open class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Br<!>(t : T) : T {
+
+}
+
+class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Br3<!>(t : T) : Br(t) {
+
+}
+
+open class Br1(t : T) : T by t {
+
+}
+
+class Br2(t : T) : Br1(t) {
+
+}
+
+trait G<T> {
+    fun foo(t : T) : T
+}
+
+class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>GC<!>() : G<Int> {
+
+}
+
+open class GC1(g : G<Int>) : G<Int> by g {
+
+}
+
+open class GC2(g : G<Int>) : GC1(g) {
+
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/quick/DelegationNotTotrait.jet b/idea/testData/checkerWithErrorTypes/quick/DelegationNotTotrait.jet
new file mode 100644
index 00000000000..646fba1f94d
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/DelegationNotTotrait.jet
@@ -0,0 +1,13 @@
+open class Foo() {
+
+}
+
+class Barrr() : <!DELEGATION_NOT_TO_TRAIT!>Foo<!> by Foo() {}
+
+trait T {}
+
+class Br(t : T) : T by t {}
+
+open enum class E() {}
+
+class Test2(e : E) : <!DELEGATION_NOT_TO_TRAIT!>E<!> by e {}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet b/idea/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet
new file mode 100644
index 00000000000..9e75a3ae821
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet
@@ -0,0 +1,23 @@
+fun foo(a : Int = 1, b : String = "abc") {
+}
+
+fun bar(x : Int = 1, y : Int = 1, z : String) {
+}
+
+fun test() {
+    foo()
+    foo(2)
+    foo(<!TYPE_MISMATCH!>""<!>)
+    foo(b = "")
+    foo(1, "")
+    foo(a = 2)
+    foo(1, "", <!TOO_MANY_ARGUMENTS!>""<!>)
+
+    bar(z = "")
+    <!NO_VALUE_FOR_PARAMETER!>bar<!>()
+    <!NO_VALUE_FOR_PARAMETER!>bar<!>("")
+    bar(1, 1, "")
+    bar(1, 1, "")
+    bar(1, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>z<!> = "")
+    <!NO_VALUE_FOR_PARAMETER!>bar<!>(1, <!UNRESOLVED_REFERENCE, MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>zz<!> = "", <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!><!UNRESOLVED_REFERENCE!>zz<!>.foo<!>)
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/quick/Override.jet b/idea/testData/checkerWithErrorTypes/quick/Override.jet
new file mode 100644
index 00000000000..ce46dadac07
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/Override.jet
@@ -0,0 +1,113 @@
+namespace override
+
+namespace normal {
+    trait MyTrait {
+        fun foo()
+        val pr : Unit
+    }
+
+    abstract class MyAbstractClass {
+        abstract fun bar()
+        abstract val prr : Unit
+
+    }
+
+    open class MyClass() : MyTrait, MyAbstractClass {
+        override fun foo() {}
+        override fun bar() {}
+
+        override val pr : Unit = ()
+        override val prr : Unit = ()
+    }
+
+    class MyChildClass() : MyClass() {}
+
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass<!> : MyTrait, MyAbstractClass {}
+
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!>() : MyTrait, MyAbstractClass {
+        override fun foo() {}
+        override val pr : Unit = ()
+        override val prr : Unit = ()
+    }
+
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass3<!>() : MyTrait, MyAbstractClass {
+        override fun bar() {}
+        override val pr : Unit = ()
+        override val prr : Unit = ()
+    }
+
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass4<!>() : MyTrait, MyAbstractClass {
+        fun <!VIRTUAL_MEMBER_HIDDEN!>foo<!>() {}
+        val <!VIRTUAL_MEMBER_HIDDEN, MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>pr<!> : Unit
+        <!NOTHING_TO_OVERRIDE!>override<!> fun other() {}
+        <!NOTHING_TO_OVERRIDE!>override<!> val otherPr : Int = 1
+    }
+
+    class MyChildClass1() : MyClass() {
+        fun <!VIRTUAL_MEMBER_HIDDEN!>foo<!>() {}
+        val <!VIRTUAL_MEMBER_HIDDEN!>pr<!> : Unit = ()
+        override fun bar() {}
+        override val prr : Unit = ()
+    }
+}
+
+namespace generics {
+    trait MyTrait<T> {
+        fun foo(t: T) : T
+    }
+
+    abstract class MyAbstractClass<T> {
+        abstract fun bar(t: T) : T
+        abstract val pr : T
+    }
+
+    trait MyProps<T> {
+        val p : T
+    }
+
+    open class MyGenericClass<T>(t : T) : MyTrait<T>, MyAbstractClass<T>, MyProps<T> {
+        override fun foo(t: T) = t
+        override fun bar(t: T) = t
+        override val p : T = t
+        override val pr : T = t
+    }
+
+    class MyChildClass() : MyGenericClass<Int>(1) {}
+    class MyChildClass1<T>(t : T) : MyGenericClass<T>(t) {}
+    class MyChildClass2<T>(t : T) : MyGenericClass<T>(t) {
+        fun <!VIRTUAL_MEMBER_HIDDEN!>foo<!>(t: T) = t
+        val <!VIRTUAL_MEMBER_HIDDEN!>pr<!> : T = t
+        override fun bar(t: T) = t
+        override val p : T = t
+    }
+
+    open class MyClass() : MyTrait<Int>, MyAbstractClass<String> {
+        override fun foo(i: Int) = i
+        override fun bar(s: String) = s
+        override val pr : String = "1"
+    }
+
+    abstract class MyAbstractClass1 : MyTrait<Int>, MyAbstractClass<String> {
+        override fun foo(i: Int) = i
+        override fun bar(s: String) = s
+    }
+
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T> {}
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass2<!><T, R>(r : R) : MyTrait<T>, MyAbstractClass<R> {
+        <!NOTHING_TO_OVERRIDE!>override<!> fun foo(r: R) = r
+        <!NOTHING_TO_OVERRIDE!>override<!> val <T> pr : R = r
+    }
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String> {}
+    abstract class MyLegalAbstractClass1 : MyTrait<Int>, MyAbstractClass<String> {}
+
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!><T>(t : T) : MyTrait<Int>, MyAbstractClass<Int> {
+        fun foo(t: T) = t
+        fun bar(t: T) = t
+        val <R> pr : T = t
+    }
+    abstract class MyLegalAbstractClass2<T>(t : T) : MyTrait<Int>, MyAbstractClass<Int> {
+        fun foo(t: T) = t
+        fun bar(t: T) = t
+        val <R> pr : T = t
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/checkerWithErrorTypes/quick/OverridingVarByVal.jet b/idea/testData/checkerWithErrorTypes/quick/OverridingVarByVal.jet
new file mode 100644
index 00000000000..e14eef6b41e
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/OverridingVarByVal.jet
@@ -0,0 +1,15 @@
+open class Var() {
+  open var v : Int = 1
+}
+
+trait VarT {
+  var v : Int
+}
+
+class Val() : Var(), VarT {
+  override <!VAR_OVERRIDDEN_BY_VAL!>val<!> v : Int = 1
+}
+
+class Var2() : Var() {
+  override var v : Int = 1
+}
diff --git a/idea/testData/checkerWithErrorTypes/quick/Varargs.jet b/idea/testData/checkerWithErrorTypes/quick/Varargs.jet
new file mode 100644
index 00000000000..7904791df5a
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/Varargs.jet
@@ -0,0 +1,17 @@
+fun v(x : Int, y : String, vararg f : Long) {}
+fun v1(vararg f : fun (Int) : Unit) {}
+
+fun test() {
+    v(1, "")
+    v(1, "", 1)
+    v(1, "", 1, 1, 1)
+    v(1, "", 1, 1, 1)
+
+    v1()
+    v1({})
+    v1({}, {})
+    v1({}, <!ERROR_COMPILE_TIME_VALUE!>1<!>, {})
+    v1({}, {}, {it})
+    v1({}) <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
+    v1 <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
+}
diff --git a/idea/testData/checkerWithErrorTypes/quick/regressions/kt306.jet b/idea/testData/checkerWithErrorTypes/quick/regressions/kt306.jet
new file mode 100644
index 00000000000..4356fe5e10c
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/regressions/kt306.jet
@@ -0,0 +1,22 @@
+// KT-306 Ambiguity when different this's have same-looking functions
+
+fun test() {
+    {Foo.() =>
+        bar()
+        {Barr.() =>
+            this.bar()
+            bar()
+        }
+    }
+    {Barr.() =>
+        bar()
+    }
+}
+
+class Foo {
+    fun bar() {}
+}
+
+class Barr {
+    fun bar() {}
+}
diff --git a/idea/testData/checkerWithErrorTypes/quick/regressions/kt307.jet b/idea/testData/checkerWithErrorTypes/quick/regressions/kt307.jet
new file mode 100644
index 00000000000..bdd29c2979e
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/regressions/kt307.jet
@@ -0,0 +1,11 @@
+// KT-307 Unresolved reference
+
+open class AL {
+    fun get(i : Int) : Any? = i
+}
+
+trait ALE<T> : AL {
+fun getOrNull(index: Int, value: T) : T {
+return get(index) as? T ?: value
+}
+}
diff --git a/idea/testData/checkerWithErrorTypes/quick/regressions/kt316.jet b/idea/testData/checkerWithErrorTypes/quick/regressions/kt316.jet
new file mode 100644
index 00000000000..a794d90d035
--- /dev/null
+++ b/idea/testData/checkerWithErrorTypes/quick/regressions/kt316.jet
@@ -0,0 +1,10 @@
+// KT-316 Members of traits must be open by default
+
+trait B {
+    fun bar() {}
+    fun foo() {}
+}
+
+open class A() : B{
+    override fun foo() {}
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/bridge.jet b/idea/testData/codegen/bridge.jet
new file mode 100644
index 00000000000..4efc72ba09e
--- /dev/null
+++ b/idea/testData/codegen/bridge.jet
@@ -0,0 +1,15 @@
+import java.lang.Integer
+
+open class C {
+    open fun f(): Any = "C f"
+}
+
+class D() : C {
+    override fun f(): String = "D f"
+}
+
+fun box(): String{
+    val d : C = D()
+    if(d.f() != "D f") return "fail f"
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/classes/classObjectInterface.jet b/idea/testData/codegen/classes/classObjectInterface.jet
index 8c0cb8210c4..432bb37bee0 100644
--- a/idea/testData/codegen/classes/classObjectInterface.jet
+++ b/idea/testData/codegen/classes/classObjectInterface.jet
@@ -2,7 +2,7 @@ class C() {
   fun getInstance(): Runnable = C
 
   class object: Runnable {
-    fun run(): Unit { }
+    override fun run(): Unit { }
   }
 }
 
diff --git a/idea/testData/codegen/classes/classObjectMethod.jet b/idea/testData/codegen/classes/classObjectMethod.jet
index 2a5d25f6213..d7d70a86d96 100644
--- a/idea/testData/codegen/classes/classObjectMethod.jet
+++ b/idea/testData/codegen/classes/classObjectMethod.jet
@@ -1,5 +1,5 @@
 abstract open class Default {
-  fun defaultValue(): Int
+  abstract fun defaultValue(): Int
 }
 
 class MyInt() {
diff --git a/idea/testData/codegen/classes/diamondInheritance.jet b/idea/testData/codegen/classes/diamondInheritance.jet
index 63116f267b8..210aecafedc 100644
--- a/idea/testData/codegen/classes/diamondInheritance.jet
+++ b/idea/testData/codegen/classes/diamondInheritance.jet
@@ -1,11 +1,13 @@
-class Base() {
-    public var v : Int
+// Changed when traits were introduced. May not make sense any more
+
+open class Base() {
+    public var v : Int = 0
 }
 
-class Left() : Base() {}
-class Right() : Base() {}
+open class Left() : Base() {}
+trait Right : Base {}
 
-class D() : Left(), Right()
+class D() : Left(), Right
 
 fun vl(l : Left) : Int = l.v
 fun vr(r : Right) : Int = r.v
diff --git a/idea/testData/codegen/classes/funDelegation.jet b/idea/testData/codegen/classes/funDelegation.jet
index f56f9d0d29b..10a1f408b09 100644
--- a/idea/testData/codegen/classes/funDelegation.jet
+++ b/idea/testData/codegen/classes/funDelegation.jet
@@ -1,8 +1,8 @@
-class Base() {
+open class Base() {
     fun n(n : Int) : Int = n + 1
 }
 
-class Abstract {}
+trait Abstract {}
 
 class Derived1() : Base(), Abstract {}
 class Derived2() : Abstract, Base() {}
diff --git a/idea/testData/codegen/classes/inheritance.jet b/idea/testData/codegen/classes/inheritance.jet
index 54445e1f860..0bfdb4e497f 100644
--- a/idea/testData/codegen/classes/inheritance.jet
+++ b/idea/testData/codegen/classes/inheritance.jet
@@ -1,9 +1,17 @@
-class X(val x : Int) {}
-class Y(val y : Int) {}
+// Changed when traits were introduced. May not make sense any more
 
-class Point(x : Int, y : Int) : X(x) , Y(y) {}
+open class X(val x : Int) {}
+trait Y {
+    abstract val y : Int
+}
 
-class Abstract {}
+class YImpl(override val y : Int) : Y {}
+
+class Point(x : Int, yy : Int) : X(x) , Y {
+    override val y : Int = yy
+}
+
+trait Abstract {}
 
 class P1(x : Int, yy : Y) : Abstract, X(x), Y by yy {}
 class P2(x : Int, yy : Y) : X(x), Abstract, Y by yy {}
@@ -12,12 +20,12 @@ class P4(x : Int, yy : Y) : Y by yy, Abstract, X(x) {}
 
 fun box() : String {
     if (X(239).x != 239) return "FAIL #1"
-    if (Y(239).y != 239) return "FAIL #2"
+    if (YImpl(239).y != 239) return "FAIL #2"
 
     val p = Point(240, -1)
     if (p.x + p.y != 239) return "FAIL #3"
 
-    val y = Y(-1)
+    val y = YImpl(-1)
     val p1 = P1(240, y)
     if (p1.x + p1.y != 239) return "FAIL #4"
     val p2 = P2(240, y)
diff --git a/idea/testData/codegen/classes/inheritedInnerClass.jet b/idea/testData/codegen/classes/inheritedInnerClass.jet
index 54a7b4bb78c..4717bea55a8 100644
--- a/idea/testData/codegen/classes/inheritedInnerClass.jet
+++ b/idea/testData/codegen/classes/inheritedInnerClass.jet
@@ -1,5 +1,5 @@
 class Outer() {
-  class InnerBase() {
+  open class InnerBase() {
   }
 
   class InnerDerived(): InnerBase() {
diff --git a/idea/testData/codegen/classes/inheritedMethod.jet b/idea/testData/codegen/classes/inheritedMethod.jet
index 1005cd31be7..597910dc7b4 100644
--- a/idea/testData/codegen/classes/inheritedMethod.jet
+++ b/idea/testData/codegen/classes/inheritedMethod.jet
@@ -1,4 +1,4 @@
-class Foo {
+open class Foo {
   fun xyzzy(): String = "xyzzy"
 }
 
diff --git a/idea/testData/codegen/classes/initializerBlock.jet b/idea/testData/codegen/classes/initializerBlock.jet
index 0c41f783a05..c89deeda87d 100644
--- a/idea/testData/codegen/classes/initializerBlock.jet
+++ b/idea/testData/codegen/classes/initializerBlock.jet
@@ -2,7 +2,7 @@ class C() {
   public var f: Int
 
   {
-    f = 610
+    $f = 610
   }
 }
 
diff --git a/idea/testData/codegen/classes/propertyDelegation.jet b/idea/testData/codegen/classes/propertyDelegation.jet
index dca646f0aef..0d030e74a8a 100644
--- a/idea/testData/codegen/classes/propertyDelegation.jet
+++ b/idea/testData/codegen/classes/propertyDelegation.jet
@@ -1,16 +1,16 @@
-class Base() {
+open class Base() {
     public val plain = 239
     public val read : Int
       get() = 239
 
-    public var readwrite : Int
+    public var readwrite : Int = 0
       get() = $readwrite + 1
       set(n : Int) {
         $readwrite = n
       }
 }
 
-class Abstract {}
+trait Abstract {}
 
 class Derived1() : Base(), Abstract {}
 class Derived2() : Abstract, Base() {}
diff --git a/idea/testData/codegen/classes/propertyInInitializer.jet b/idea/testData/codegen/classes/propertyInInitializer.jet
index 824da2313aa..ed507f6278f 100644
--- a/idea/testData/codegen/classes/propertyInInitializer.jet
+++ b/idea/testData/codegen/classes/propertyInInitializer.jet
@@ -1,7 +1,7 @@
 class Outer() {
   public val s = "xyzzy"
 
-  class InnerBase(public val name: String) {
+  open class InnerBase(public val name: String) {
   }
 
   class InnerDerived(): InnerBase(s) {
diff --git a/idea/testData/codegen/classes/rightHandOverride.jet b/idea/testData/codegen/classes/rightHandOverride.jet
index 66c47d7c1cc..e99e60bd863 100644
--- a/idea/testData/codegen/classes/rightHandOverride.jet
+++ b/idea/testData/codegen/classes/rightHandOverride.jet
@@ -1,9 +1,11 @@
-class Left() {}
-class Right() {
-    virtual fun f() = 42
+// Changed when traits were introduced. May not make sense any more
+
+trait Left {}
+open class Right() {
+    open fun f() = 42
 }
 
-class D() : Left(), Right() {
+class D() : Left, Right() {
     override fun f() = 239
 }
 
diff --git a/idea/testData/codegen/controlStructures/forIntArray.jet b/idea/testData/codegen/controlStructures/forIntArray.jet
new file mode 100644
index 00000000000..abfce4113f7
--- /dev/null
+++ b/idea/testData/codegen/controlStructures/forIntArray.jet
@@ -0,0 +1,14 @@
+fun box() : String {
+    val a = Array<Int> (5, {0})
+    var i = 0
+    var sum = 0
+    for(el in 0..4) {
+       a[i] = i++
+    }
+    for (el in a) {
+        sum = sum + el
+    }
+    if(sum != 10) return "a failed"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/controlStructures/forNullableIntArray.jet b/idea/testData/codegen/controlStructures/forNullableIntArray.jet
new file mode 100644
index 00000000000..5877bfc97fc
--- /dev/null
+++ b/idea/testData/codegen/controlStructures/forNullableIntArray.jet
@@ -0,0 +1,16 @@
+fun box() : String {
+    val b : Array<Int?> = Array<Int?> (5)
+    var i = 0
+    var sum = 0
+    while(i < 5) {
+       b[i] = i++
+    }
+    sum = 0
+    for (el in b) {
+        sum = sum + (el ?: 0)
+    }
+    System.out?.println(sum)
+    if(sum != 10) return "b failed"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/controlStructures/forPrimitiveIntArray.jet b/idea/testData/codegen/controlStructures/forPrimitiveIntArray.jet
new file mode 100644
index 00000000000..0822b4f6aac
--- /dev/null
+++ b/idea/testData/codegen/controlStructures/forPrimitiveIntArray.jet
@@ -0,0 +1,14 @@
+fun box() : String {
+    val a = IntArray (5)
+    var i = 0
+    var sum = 0
+    for(el in 0..4) {
+       a[i] = i++
+    }
+    for (el in a) {
+        sum = sum + el
+    }
+    if(sum != 10) return "a failed"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/controlStructures/forUserType.jet b/idea/testData/codegen/controlStructures/forUserType.jet
new file mode 100644
index 00000000000..0332dc28bf1
--- /dev/null
+++ b/idea/testData/codegen/controlStructures/forUserType.jet
@@ -0,0 +1,115 @@
+fun box() : String {
+    var sum : Int = 0
+    var i = 0
+
+    val c6 = MyCollection4()
+    sum = 0
+    for (el in c6) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c6 failed"
+
+    val c5 = MyCollection3()
+    sum = 0
+    for (el in c5) {
+        sum = sum + (el ?: 0)
+    }
+    if(sum != 15) return "c5 failed"
+
+    val c1: java.lang.Iterable<Int> = MyCollection1()
+    sum = 0
+    for (el in c1) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c1 failed"
+
+    val c2 = MyCollection1()
+    sum = 0
+    for (el in c2) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c2 failed"
+
+    val c3: Iterable<Int> = MyCollection2()
+    sum = 0
+    for (el in c3) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c3 failed"
+
+    val c4 = MyCollection2()
+    sum = 0
+    for (el in c4) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c4 failed"
+
+    val a : Array<Int> = Array<Int> (5, {0})
+    for(el in 0..4) {
+       a[i] = i++
+    }
+    sum = 0
+    for (el in a) {
+        sum = sum + el
+    }
+    if(sum != 10) return "a failed"
+
+    val b : Array<Int?> = Array<Int?> (5)
+    i = 0
+    while(i < 5) {
+       b[i] = i++
+    }
+    sum = 0
+    for (el in b) {
+        sum = sum + (el ?: 0)
+    }
+    System.out?.println(sum)
+    if(sum != 10) return "b failed"
+
+    return "OK"
+}
+
+class MyCollection1(): java.lang.Iterable<Int> {
+    override fun iterator(): java.util.Iterator<Int> = MyIterator()
+
+    class MyIterator(): java.util.Iterator<Int> {
+        var k : Int = 5
+
+        override fun next() : Int = k--
+        override fun hasNext() = k > 0
+        override fun remove() {}
+    }
+}
+
+class MyCollection2(): Iterable<Int> {
+    override fun iterator(): Iterator<Int> = MyIterator()
+
+    class MyIterator(): Iterator<Int> {
+        var k : Int = 5
+
+        override fun next() : Int = k--
+        override fun hasNext() = k > 0
+    }
+}
+
+class MyCollection3() {
+    fun iterator() = MyIterator()
+
+    class MyIterator() {
+        var k : Int = 5
+
+        fun next() : Int? = k--
+        fun hasNext() = k > 0
+    }
+}
+
+class MyCollection4() {
+    fun iterator() = MyIterator()
+
+    class MyIterator() {
+        var k : Int = 5
+
+        fun next() : Int = k--
+        fun hasNext() = k > 0
+    }
+}
diff --git a/idea/testData/codegen/patternMatching/inrange.jet b/idea/testData/codegen/patternMatching/inrange.jet
new file mode 100644
index 00000000000..e883e5dbb9c
--- /dev/null
+++ b/idea/testData/codegen/patternMatching/inrange.jet
@@ -0,0 +1,9 @@
+fun isDigit(a: Int) : String {
+    val aa = java.util.ArrayList<Int> ()
+    aa.add(239)
+
+    if(a in aa) return "array list"
+    if(a in 0..9)  return "digit"
+    if(a !in 0..100) return "not small"
+    return "something"
+}
diff --git a/idea/testData/codegen/patternMatching/is.jet b/idea/testData/codegen/patternMatching/is.jet
new file mode 100644
index 00000000000..a5b5f33195f
--- /dev/null
+++ b/idea/testData/codegen/patternMatching/is.jet
@@ -0,0 +1,11 @@
+fun typeName(a: Any?) : String {
+    return when(a) {
+        is java.util.ArrayList<Int> => "array list"
+        else => "no idea"
+    }
+}
+
+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/idea/testData/codegen/patternMatching/range.jet b/idea/testData/codegen/patternMatching/range.jet
index 329a4234971..5010f350b68 100644
--- a/idea/testData/codegen/patternMatching/range.jet
+++ b/idea/testData/codegen/patternMatching/range.jet
@@ -1,4 +1,11 @@
-fun isDigit(a: Int) = when(a) {
-  in 0..9 => "digit"
-  else => "something"
+fun isDigit(a: Int) : String {
+    val aa = java.util.ArrayList<Int> ()
+    aa.add(239)
+
+    return when(a) {
+      in aa => "array list"
+      in 0..9 => "digit"
+     !in 0..100 => "not small"
+      else => "something"
+    }
 }
diff --git a/idea/testData/codegen/regressions/kt232.jet b/idea/testData/codegen/regressions/kt232.jet
new file mode 100644
index 00000000000..c356e429d72
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt232.jet
@@ -0,0 +1,10 @@
+class A() {
+    fun foo() {
+        System.out?.println(1)
+    }
+}
+
+fun box() : String {
+    val a : A = A()
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt237.jet b/idea/testData/codegen/regressions/kt237.jet
new file mode 100644
index 00000000000..aaa60b5904f
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt237.jet
@@ -0,0 +1,41 @@
+fun main(args: Array<String>?) {
+    val y: Unit = () //do not compile
+    A<Unit>()        //do not compile
+    C<Unit>(())      //do not compile
+        //do not compile
+    System.out?.println(fff<Unit>(()))  //do not compile
+    System.out?.println(id<Unit>(y))  //do not compile
+    System.out?.println(fff<Unit>(id<Unit>(y)) == id<Unit>(foreach(Array<Int>(0,{0}),{(e : Int) : Unit => })))  //do not compile
+}
+class A<T>()
+
+class C<T>(val value: T) {
+    fun foo(): T = value
+}
+
+fun <T> fff(x: T) : T { return x }
+
+fun <T> id(value: T): T = value
+
+fun foreach(array: Array<Int>?, action: fun(Int): Unit) {
+    for (el in array) {
+       action(el) //exception through compilation (see below)
+    }
+}
+
+fun almostFilter(array: Array<Int>, action: fun(Int): Int) {
+    for (el in array) {
+       action(el)
+    }
+}
+
+fun box() : String {
+    val a = Array<Int> (3,{-1})
+    a[0] = 0
+    a[1] = 1
+    a[2] = 2
+    foreach(a, { (el : Int) : Unit => System.out?.println(el) })
+    almostFilter(a, { (el : Int) : Int => el })
+    main(null)
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt238.jet b/idea/testData/codegen/regressions/kt238.jet
new file mode 100644
index 00000000000..9332cbf870f
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt238.jet
@@ -0,0 +1,58 @@
+fun t1 () {
+    val a1 = Array<String?>(1)
+    a1[0] = "0" //ok
+    val s = a1[0] //ok
+}
+
+fun t2 () {
+    val a2 = Array<Int>(1,{0})
+    a2[0] = 0 //ok
+    var i = a2[0] //ok
+}
+
+fun t3 () {
+    val a3 = Array<Int?>(1)
+    a3[0] = 0 //verify error
+    var j = a3[0] //ok
+    var k : Int = a3[0] ?: 5 //ok
+}
+
+fun t4 () {
+    val b1 = StrangeIntArray(10)
+    b1[4] = 5 //ok
+    var i = b1[1] //ok
+}
+
+fun t5 () {
+    val b2 = StrangeArray<Int>(10, 0)
+    b2.set(4, 5) //ok
+    b2[4] = 5 //verify error
+    var i = b2.get(2) //ok
+    i = b2[1] //verify error
+}
+
+fun t6() {
+    val b3 = StrangeArray<Int?>(10, 0)
+    b3.set(5, 6) //ok
+    b3[4] = 5 //verify error
+    val v = b3[1] //ok
+}
+
+fun box() : String {
+    return "OK"
+}
+
+class StrangeArray<T>(size: Int, private var defaultValue: T) {
+    fun get(index: Int): T = defaultValue
+    fun set(index: Int, v: T) {
+        defaultValue = v
+    }
+}
+
+class StrangeIntArray(size: Int) {
+    private var defaultValue = 0
+    fun get(index: Int): Int = defaultValue
+    fun set(index: Int, v: Int) {
+        defaultValue = v
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt239.jet b/idea/testData/codegen/regressions/kt239.jet
new file mode 100644
index 00000000000..ca9e1cc1d5e
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt239.jet
@@ -0,0 +1,3 @@
+fun box(i: Int?) {
+    val j = i?.plus(3) //verify error
+}
diff --git a/idea/testData/codegen/regressions/kt242.jet b/idea/testData/codegen/regressions/kt242.jet
new file mode 100644
index 00000000000..4e2de93cff3
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt242.jet
@@ -0,0 +1,19 @@
+fun box() : String {
+    val i: Int? = 7
+    val j: Int? = null
+    val k = 7
+
+    //verify errors
+    if (i == 7) {}
+    if (7 == i) {}
+
+    if (j == 7) {}
+    if (7 == j) {}
+
+    if (i == k) {}
+    if (k == i) {}
+
+    if (j == k) {}
+    if (k == j) {}
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt243.jet b/idea/testData/codegen/regressions/kt243.jet
new file mode 100644
index 00000000000..1e96f08fe50
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt243.jet
@@ -0,0 +1,8 @@
+fun box() : String {
+    val t = java.lang.String.copyValueOf(java.lang.String("s").toCharArray())
+    val i = java.lang.Integer.MAX_VALUE
+    val j = java.lang.Integer.valueOf(15)
+    val s = java.lang.String.valueOf(1)
+    val l = java.util.Collections.emptyList<Int>()
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt245.jet b/idea/testData/codegen/regressions/kt245.jet
new file mode 100644
index 00000000000..3a40068ec94
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt245.jet
@@ -0,0 +1,32 @@
+fun foo() {
+    val l = java.util.ArrayList<Int>(2)
+    l.add(1)
+
+    for (el in l) {}
+
+    //verify error "Expecting to find integer on stack"
+    val iterator = l.iterator()
+
+    //another verify error "Mismatched stack types"
+    while (iterator?.hasNext() ?: false) {
+        val i = iterator?.next()
+    }
+
+    //the same
+    if (iterator != null) {
+        while (iterator.hasNext()) {
+            val i = iterator?.next()
+        }
+    }
+
+    //this way it works
+    if (iterator != null) {
+        while (iterator.hasNext()) {
+            iterator.next() //because of the bug KT-244 i can't write "val i = iterator.next()"
+        }
+    }
+}
+
+fun box() : String {
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt247.jet b/idea/testData/codegen/regressions/kt247.jet
new file mode 100644
index 00000000000..49637518d25
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt247.jet
@@ -0,0 +1,38 @@
+fun t1() : Boolean {
+    val s1 : String? = "sff"
+    val s2 : String? = null
+    return s1?.length == 3 && s2?.length == null
+}
+
+fun t2() : Boolean {
+    val c1: C? = C(1)
+    val c2: C? = null
+    return c1?.x == 1 && c2?.x == null
+}
+
+fun t3() {
+    val d: D = D("s")
+    System.out?.println(d?.s)
+    System.out?.println(d?.s == "s") //prints true
+    System.out?.println(d)    //ok
+}
+
+fun t4() {
+    val e: E? = E()
+    System.out?.println(e?.foo() == e) //verify error
+    System.out?.println(e?.foo())  //verify error
+}
+
+fun box() : String {
+    if(!t1 ()) return "fail"
+    if(!t2 ()) return "fail"
+    t3()
+    t4()
+    return "OK"
+}
+
+class C(val x: Int)
+class D(val s: String)
+class E() {
+    fun foo() = 1
+}
diff --git a/idea/testData/codegen/regressions/kt248.jet b/idea/testData/codegen/regressions/kt248.jet
new file mode 100644
index 00000000000..0607b21341f
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt248.jet
@@ -0,0 +1,7 @@
+fun box() : String {
+    val b = true as? Boolean //exception
+    val i = 1 as Int         //exception
+    val j = 1 as Int?        //ok
+    val s = "s" as String    //ok
+    return "OK"
+}
diff --git a/idea/testData/codegen/regressions/kt249.jet b/idea/testData/codegen/regressions/kt249.jet
new file mode 100644
index 00000000000..d4f61650fd6
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt249.jet
@@ -0,0 +1,35 @@
+namespace x
+
+class Outer(val name: String) {
+    class Inner() {
+        val me = name
+
+        class object {
+           fun bar() = "bar"
+        }
+    }
+
+    class object {
+        class StaticInner() {
+            class object {
+                fun f() = "oo"
+            }
+        }
+    }
+}
+
+fun box (): String {
+    val inner  = Outer("mama").Inner() //verify error
+    if(inner.me != "mama")
+        return "fail"
+
+    val outer = Outer ("papa")
+    val inner2 = outer.Inner ()
+    if(inner2.me != "papa")
+        return "fail"
+
+    if(Outer.StaticInner.f() != "oo" )
+        return "fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt257.jet b/idea/testData/codegen/regressions/kt257.jet
new file mode 100644
index 00000000000..45482c59216
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt257.jet
@@ -0,0 +1,20 @@
+class A<T>(var t: T) {}
+class B<R>(val r: R) {}
+
+fun box() : String {
+    val ai = A<Int>(1)
+    val aai = A<A<Int>>(ai)
+    if(aai.t.t != 1)  return "fail"
+/*
+    aai.t.t = 2
+    if(aai.t.t != 2)  return "fail"
+
+    if(ai.t != 2)  return "fail"
+    if(aai.t != ai)  return "fail"
+    if(aai.t !== ai) return "fail"
+
+    val abi = A<B<Int>>(B<Int>(1))
+    if(abi.t.r != 1) return "fail"
+*/
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt259.jet b/idea/testData/codegen/regressions/kt259.jet
new file mode 100644
index 00000000000..59a99b1bcbb
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt259.jet
@@ -0,0 +1,251 @@
+class A() {}
+open class B<T>() {
+    fun isT (a : Any?) : Boolean {
+        return a is T
+    }
+}
+
+class C() : B<String>() {
+}
+
+class D<T>() : B<B<T>>() {
+}
+
+fun t1() : Boolean {
+    val a = A()
+    if(a !is A)   return false
+    return true
+}
+
+fun t2() : Boolean {
+    val a = A()
+    if(a !is A?)   return false
+    return true
+}
+
+fun t3() : Boolean {
+    val a = A()
+    if(null !is A?)   return false
+    return true
+}
+
+fun t4 () : Boolean {
+    val b = B<String>()
+    if(b !is B<String>)   return false
+    return true
+}
+
+fun t5 () : Boolean {
+    val b = B<String>()
+    if(b !is B<String>?)  return false
+    return true
+}
+
+fun t6 () : Boolean {
+    if(null !is B<String>?)  return false
+    return true
+}
+
+fun t7 () : Boolean {
+    val b = B<String>()
+    if(!b.isT("aaa")) return false
+    return true
+}
+
+fun t8 () : Boolean {
+    val b = B<String>()
+    if(b.isT(10))     return false
+    return true
+}
+
+fun t9 () : Boolean {
+    val b = B<String>()
+    if(b.isT(null))   return false
+    return true
+}
+
+fun t10 () : Boolean {
+    val d = B<String?>()
+    if(!d.isT("aaa")) return false
+    return true
+}
+fun t11 () : Boolean {
+    val d = B<String?>()
+    if(d.isT(10))     return false
+    return true
+}
+
+fun t12 () : Boolean {
+    val d = B<String?>()
+    if(!d.isT(null))  return false
+    return true
+}
+
+fun t13 () : Boolean {
+    val f = B<java.lang.String?>()
+    if(!f.isT("aaa")) return false
+    return true
+}
+
+fun t14 () : Boolean {
+    val f = B<java.lang.String?>()
+    if(f.isT(10))     return false
+    return true
+}
+
+fun t15 () : Boolean {
+    val f = B<java.lang.String?>()
+    if(!f.isT(null))  return false
+    return true
+}
+
+fun t16 () : Boolean {
+    val c = B<Int>()
+    if(c.isT("aaa")) return false
+    return true
+}
+
+fun t17 () : Boolean {
+    val c = B<Int>()
+    if(!c.isT(10))   return false
+    return true
+}
+
+fun t18 () : Boolean {
+    val c = B<Int>()
+    if(c.isT(null)) return false
+    return true
+}
+
+fun t19 () : Boolean {
+    val e = B<Int?>()
+    if(e.isT("aaa")) return false
+    return true
+}
+
+fun t20 () : Boolean {
+    val e = B<Int?>()
+    if(!e.isT(10))   return false
+    return true
+}
+
+fun t21 () : Boolean {
+    val e = B<Int?>()
+    if(!e.isT(null)) return false
+    return true
+}
+
+fun t22 () : Boolean {
+    val b = B<String>()
+    val w : B<String>? = b as B<String>   //ok
+    val x = w as B<String>?  //TypeCastException
+    return true
+}
+
+fun t23 () : Boolean {
+    val b = B<String>()
+    val v = b as B<String>   //ok
+    return true
+}
+
+fun t24 () : Boolean {
+    val b = B<String>()
+    val u = b as B<String>?  //TypeCastException
+    return true
+}
+
+fun t25 () : Boolean {
+    val c = C()
+    if(!c.isT("aaa")) return false
+    return true
+}
+
+fun t26 () : Boolean {
+    val d = D<String>()
+    if(!d.isT(B<String>())) return false
+    return true
+}
+
+fun box() : String {
+/*
+    if(!t1()) {
+        return "t1 failed"
+    }
+    if(!t2()) {
+        return "t2 failed"
+    }
+    if(!t3()) {
+        return "t3 failed"
+    }
+    if(!t4()) {
+         return "t4 failed"
+     }
+     if(!t5()) {
+         return "t5 failed"
+     }
+     if(!t6()) {
+         return "t6 failed"
+     }
+     if(!t7()) {
+         return "t7 failed"
+     }
+    if(!t8()) {
+        return "t8 failed"
+    }
+    if(!t9()) {
+        return "t9 failed"
+    }
+    if(!t10()) {
+        return "t10 failed"
+    }
+    if(!t11()) {
+         return "t11 failed"
+     }
+     if(!t12()) {
+         return "t12 failed"
+     }
+     if(!t13()) {
+         return "t13 failed"
+     }
+     if(!t14()) {
+         return "t14 failed"
+     }
+    if(!t15()) {
+        return "t15 failed"
+    }
+    if(!t16()) {
+        return "t16 failed"
+    }
+    if(!t17()) {
+        return "t17 failed"
+    }
+    if(!t18()) {
+         return "t18 failed"
+     }
+     if(!t19()) {
+         return "t19 failed"
+     }
+     if(!t20()) {
+         return "t10 failed"
+     }
+     if(!t21()) {
+         return "t21 failed"
+     }
+     if(!t22()) {
+         return "t22 failed"
+     }
+     if(!t23()) {
+         return "t23 failed"
+     }
+     if(!t24()) {
+         return "t24 failed"
+     }
+     if(!t25()) {
+         return "t25 failed"
+     }
+     */
+     if(!t26()) {
+         return "t26 failed"
+     }
+     return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt297.jet b/idea/testData/codegen/regressions/kt297.jet
new file mode 100644
index 00000000000..0a6ad8f82a5
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt297.jet
@@ -0,0 +1,4 @@
+// KT-297 Overload resolution ambiguity with required in trait
+trait ALE<T> : java.util.ArrayList<T> {
+   fun getOrValue(index: Int, value : T) : T = if(index >= 0 && index < size()) get(index) else value
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt299.jet b/idea/testData/codegen/regressions/kt299.jet
new file mode 100644
index 00000000000..4aa31a44dc8
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt299.jet
@@ -0,0 +1,17 @@
+class MyRange1() : Range<Int> {
+    override fun contains(item: Int) = true
+}
+
+class MyRange2() {
+    fun contains(item: Int) = true
+}
+
+fun box(): String {
+    if (1 in MyRange1()) {
+        if (1 in MyRange2()) {
+            return "OK"
+        }
+        return "fail 2"
+    }
+    return "fail 1"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/regressions/kt326.jet b/idea/testData/codegen/regressions/kt326.jet
new file mode 100644
index 00000000000..8afc31e7eab
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt326.jet
@@ -0,0 +1,49 @@
+namespace test
+
+class List<T>(len: Int) {
+  val a : Array<T> = Array<T>(len)
+
+  fun reverse() {
+    var i = 0
+    var j = a.size-1
+    while(i < j) {
+        val x  = a[i]
+        a[i++] = a[j]
+        a[j--] = x
+    }
+  }
+}
+
+fun box() : String {
+  val d = List<Int>(1)
+  d.a[0] = 10
+  println(d.a[0])
+
+  val a = List<String>(1)
+  a.a[0] = "1"
+  println(a.a[0])
+
+  val b = List<Int?>(1)
+  b.a[0] = 10
+  println(b.a[0])
+
+  val c = List<Array<Int>>(1)
+  c.a[0] = Array<Int>(4,{-1})
+  println(c.a[0].size)
+
+  val e = List<Int>(5)
+  e.a[0] = 0
+  e.a[1] = 1
+  e.a[2] = 2
+  e.a[3] = 3
+  e.a[4] = 4
+  e.reverse()
+  for(el in e.a)
+    println(el)
+
+  return "OK"
+}
+
+fun println(s : Any?) {
+  System.out?.println(s);
+}
diff --git a/idea/testData/codegen/regressions/kt48.jet b/idea/testData/codegen/regressions/kt48.jet
new file mode 100644
index 00000000000..609f1d50969
--- /dev/null
+++ b/idea/testData/codegen/regressions/kt48.jet
@@ -0,0 +1,29 @@
+class A() {
+    var xi = 0
+    var xin : Int? = 0
+    var xinn : Int? = null
+
+    var xl = 0.lng
+    var xln : Long? = 0.lng
+    var xlnn : Long? = null
+
+    var xb = 0.byt
+    var xbn : Byte? = 0.byt
+    var xbnn : Byte? = null
+
+    var xf = 0.flt
+    var xfn : Float? = 0.flt
+    var xfnn : Float? = null
+
+    var xd = 0.dbl
+    var xdn : Double? = 0.dbl
+    var xdnn : Double? = null
+
+    var xs = 0.sht
+    var xsn : Short? = 0.sht
+    var xsnn : Short? = null
+}
+
+fun box() : String {
+    return "OK"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/traits/multiple.jet b/idea/testData/codegen/traits/multiple.jet
new file mode 100644
index 00000000000..da0c9da4a36
--- /dev/null
+++ b/idea/testData/codegen/traits/multiple.jet
@@ -0,0 +1,21 @@
+trait AL {
+    fun get(index: Int) : Any? = null
+}
+
+trait ALE<T> : AL {
+    fun getOrNull(index: Int, value: T) : T {
+        val r = get(index) as? T
+        return r ?: value
+    }
+}
+
+open class SmartArrayList() : ALE<String> {
+}
+
+class SmartArrayList2() : SmartArrayList(), AL {
+}
+
+fun box() : String {
+  val c = SmartArrayList2()
+  return if("239" == c.getOrNull(0, "239")) "OK" else "fail"
+}
diff --git a/idea/testData/codegen/traits/simple.jet b/idea/testData/codegen/traits/simple.jet
new file mode 100644
index 00000000000..f8119547d2d
--- /dev/null
+++ b/idea/testData/codegen/traits/simple.jet
@@ -0,0 +1,12 @@
+trait SimpleClass : java.lang.Object {
+    fun foo() : String = "239 " + toString ()
+}
+
+class SimpleClassImpl() : SimpleClass {
+   override fun toString() = "SimpleClassImpl"
+}
+
+fun box() : String {
+  val c = SimpleClassImpl()
+  return if("239 SimpleClassImpl" == c.foo()) "OK" else "fail"
+}
\ No newline at end of file
diff --git a/idea/testData/codegen/traits/stdlib.jet b/idea/testData/codegen/traits/stdlib.jet
new file mode 100644
index 00000000000..aa9fe5d5072
--- /dev/null
+++ b/idea/testData/codegen/traits/stdlib.jet
@@ -0,0 +1,60 @@
+trait ISized {
+    val size : Int
+}
+
+trait javaUtilIterator<T> : java.util.Iterator<T> {
+    override fun remove() : Unit {
+        throw UnsupportedOperationException()
+    }
+}
+
+class MyIterator<T>(val array : ReadOnlyArray<T>) : javaUtilIterator<T> {
+    private var index = 0
+
+    override fun hasNext() : Boolean = index < array.size
+
+    override fun next() : T = array.get(index++)
+}
+
+trait ReadOnlyArray<out T> : ISized, java.lang.Iterable<T> {
+  fun get(index : Int) : T
+
+  class Default {
+    fun check(v: Any) =  v is T
+  }
+
+  override fun iterator() : java.util.Iterator<T> = MyIterator<T>(this)
+}
+
+trait WriteOnlyArray<in T> : ISized {
+  fun set(index : Int, value : T) : Unit
+
+  fun set(from: Int, count: Int, value: T) {
+    for(i in from..from+count-1) {
+        set(i, value)
+    }
+  }
+}
+
+class MutableArray<T>(length: Int) : ReadOnlyArray<T>, WriteOnlyArray<T> {
+    private val array = Array<T>(length)
+
+    override fun get(index : Int) : T = array[index]
+    override fun set(index : Int, value : T) : Unit { array[index] = value }
+
+    override val size : Int
+        get() = array.size
+}
+
+fun box() : String {
+    var a = MutableArray<Int> (4)
+    a [0] = 10
+    a.set(1, 2, 13)
+    a [3] = 40
+    System.out?.println(a.iterator())
+    System.out?.println(a.iterator().hasNext())
+    for(el in a) {
+        System.out?.println(el)
+    }
+    return "OK"
+}
diff --git a/idea/testData/codegen/traits/withRequired.jet b/idea/testData/codegen/traits/withRequired.jet
new file mode 100644
index 00000000000..64e4df814ee
--- /dev/null
+++ b/idea/testData/codegen/traits/withRequired.jet
@@ -0,0 +1,15 @@
+open class AL<T> {
+    fun get(index: Int) : T? = null
+}
+
+trait ALE<T> : AL<T> {
+    fun getOrValue(index: Int, value : T) : T = get(index) ?: value
+}
+
+class SmartArrayList() : ALE<String>, AL<String> {
+}
+
+fun box() : String {
+  val c = SmartArrayList()
+  return if("239" == c.getOrValue(0, "239")) "OK" else "fail"
+}
diff --git a/idea/testData/codegen/typeInfo/inner.jet b/idea/testData/codegen/typeInfo/inner.jet
new file mode 100644
index 00000000000..49db9252b35
--- /dev/null
+++ b/idea/testData/codegen/typeInfo/inner.jet
@@ -0,0 +1,15 @@
+class Box<T>() {
+    open class Inner () {
+        fun isT(s : Any) = if(s is T) "OK" else "fail"
+    }
+
+    class Inner2() : Inner() {
+
+    }
+
+    fun inner() = Inner2()
+}
+
+fun box(): String {
+  return Box<String>.inner().isT("OK")
+}
diff --git a/idea/testData/psi/Attributes.jet b/idea/testData/psi/Attributes.jet
index 1302b343c9d..321691b72dc 100644
--- a/idea/testData/psi/Attributes.jet
+++ b/idea/testData/psi/Attributes.jet
@@ -1,12 +1,12 @@
 namespace foo.bar.goo
 
 abstract
-virtual
+open
 enum
 open
-attribute
+annotation
 override
-virtual
+open
 abstract
 private
 protected
@@ -19,15 +19,15 @@ in
 out
 ref
  class Bar<abstract
-virtual
+open
 [sdfsdf(1+1) a]
 [sdfsdf(1+1)]
 [a() sdfsdf(1+1)]
 enum
 open
-attribute
+annotation
 override
-virtual
+open
 abstract
 [sdfsd sdfsd a.b.f.c]
 private
diff --git a/idea/testData/psi/Attributes.txt b/idea/testData/psi/Attributes.txt
index 55913b333cc..150a51c535c 100644
--- a/idea/testData/psi/Attributes.txt
+++ b/idea/testData/psi/Attributes.txt
@@ -13,17 +13,17 @@ JetFile: Attributes.jet
       MODIFIER_LIST
         PsiElement(abstract)('abstract')
         PsiWhiteSpace('\n')
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
         PsiWhiteSpace('\n')
         PsiElement(enum)('enum')
         PsiWhiteSpace('\n')
         PsiElement(open)('open')
         PsiWhiteSpace('\n')
-        PsiElement(attribute)('attribute')
+        PsiElement(annotation)('annotation')
         PsiWhiteSpace('\n')
         PsiElement(override)('override')
         PsiWhiteSpace('\n')
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
         PsiWhiteSpace('\n')
         PsiElement(abstract)('abstract')
         PsiWhiteSpace('\n')
@@ -163,7 +163,7 @@ JetFile: Attributes.jet
           MODIFIER_LIST
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n')
             ANNOTATION
               PsiElement(LBRACKET)('[')
@@ -249,11 +249,11 @@ JetFile: Attributes.jet
             PsiWhiteSpace('\n')
             PsiElement(open)('open')
             PsiWhiteSpace('\n')
-            PsiElement(attribute)('attribute')
+            PsiElement(annotation)('annotation')
             PsiWhiteSpace('\n')
             PsiElement(override)('override')
             PsiWhiteSpace('\n')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n')
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n')
diff --git a/idea/testData/psi/Attributes_ERR.jet b/idea/testData/psi/Attributes_ERR.jet
index ae9e2810c36..03e73f7b999 100644
--- a/idea/testData/psi/Attributes_ERR.jet
+++ b/idea/testData/psi/Attributes_ERR.jet
@@ -1,12 +1,12 @@
 namespace foo.bar.goo
 
 abstract
-virtual
+open
 enum
 open
-attribute
+annotation
 override
-virtual
+open
 abstract
 []
 private
@@ -21,12 +21,12 @@ in
 out
 ref
  class Bar<abstract
-virtual
+open
 enum
 open
-attribute
+annotation
 override
-virtual
+open
 abstract
 [sdfsd sdfsd a.b.f.c]
 private
diff --git a/idea/testData/psi/Attributes_ERR.txt b/idea/testData/psi/Attributes_ERR.txt
index e9295b81795..99f597d7dc9 100644
--- a/idea/testData/psi/Attributes_ERR.txt
+++ b/idea/testData/psi/Attributes_ERR.txt
@@ -13,17 +13,17 @@ JetFile: Attributes_ERR.jet
       MODIFIER_LIST
         PsiElement(abstract)('abstract')
         PsiWhiteSpace('\n')
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
         PsiWhiteSpace('\n')
         PsiElement(enum)('enum')
         PsiWhiteSpace('\n')
         PsiElement(open)('open')
         PsiWhiteSpace('\n')
-        PsiElement(attribute)('attribute')
+        PsiElement(annotation)('annotation')
         PsiWhiteSpace('\n')
         PsiElement(override)('override')
         PsiWhiteSpace('\n')
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
         PsiWhiteSpace('\n')
         PsiElement(abstract)('abstract')
         PsiWhiteSpace('\n')
@@ -199,17 +199,17 @@ JetFile: Attributes_ERR.jet
           MODIFIER_LIST
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n')
             PsiElement(enum)('enum')
             PsiWhiteSpace('\n')
             PsiElement(open)('open')
             PsiWhiteSpace('\n')
-            PsiElement(attribute)('attribute')
+            PsiElement(annotation)('annotation')
             PsiWhiteSpace('\n')
             PsiElement(override)('override')
             PsiWhiteSpace('\n')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n')
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n')
diff --git a/idea/testData/psi/BabySteps.txt b/idea/testData/psi/BabySteps.txt
index 7acbef60384..959b9d0b58b 100644
--- a/idea/testData/psi/BabySteps.txt
+++ b/idea/testData/psi/BabySteps.txt
@@ -47,7 +47,9 @@ JetFile: BabySteps.jet
           VALUE_ARGUMENT_LIST
             PsiElement(LPAR)('(')
             VALUE_ARGUMENT
-              PsiElement(IDENTIFIER)('d')
+              VALUE_ARGUMENT_NAME
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('d')
               PsiElement(EQ)('=')
               INTEGER_CONSTANT
                 PsiElement(INTEGER_LITERAL)('0')
diff --git a/idea/testData/psi/BabySteps_ERR.txt b/idea/testData/psi/BabySteps_ERR.txt
index 10f833378f0..b6c52df6421 100644
--- a/idea/testData/psi/BabySteps_ERR.txt
+++ b/idea/testData/psi/BabySteps_ERR.txt
@@ -47,7 +47,9 @@ JetFile: BabySteps_ERR.jet
           VALUE_ARGUMENT_LIST
             PsiElement(LPAR)('(')
             VALUE_ARGUMENT
-              PsiElement(IDENTIFIER)('d')
+              VALUE_ARGUMENT_NAME
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('d')
               PsiElement(EQ)('=')
               INTEGER_CONSTANT
                 PsiElement(INTEGER_LITERAL)('0')
diff --git a/idea/testData/psi/ControlStructures.txt b/idea/testData/psi/ControlStructures.txt
index 4273155b270..8b7e70fd7d0 100644
--- a/idea/testData/psi/ControlStructures.txt
+++ b/idea/testData/psi/ControlStructures.txt
@@ -535,12 +535,9 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  <empty list>
-                PsiElement(RBRACE)('}')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         WHILE
           PsiElement(while)('while')
@@ -552,24 +549,18 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  <empty list>
-                PsiElement(RBRACE)('}')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         DO_WHILE
           PsiElement(do)('do')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n\n  ')
-                BLOCK
-                  <empty list>
-                PsiElement(RBRACE)('}')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n\n  ')
+              PsiElement(RBRACE)('}')
           PsiWhiteSpace(' ')
           PsiElement(while)('while')
           PsiWhiteSpace(' ')
@@ -625,12 +616,9 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  <empty list>
-                PsiElement(RBRACE)('}')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         FOR
           PsiElement(for)('for')
@@ -647,15 +635,13 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n      ')
-                BLOCK
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('b')
-                PsiWhiteSpace('\n    ')
-                PsiElement(RBRACE)('}')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n      ')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('b')
+              PsiWhiteSpace('\n    ')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         FOR
           PsiElement(for)('for')
@@ -714,15 +700,13 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n      ')
-                BLOCK
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('b')
-                PsiWhiteSpace('\n    ')
-                PsiElement(RBRACE)('}')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n      ')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('b')
+              PsiWhiteSpace('\n    ')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         WHILE
           PsiElement(while)('while')
@@ -756,12 +740,9 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  <empty list>
-                PsiElement(RBRACE)('}')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         IF
           PsiElement(if)('if')
@@ -980,24 +961,22 @@ JetFile: ControlStructures.jet
           PsiElement(do)('do')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  PsiElement(SEMICOLON)(';')
-                  PsiElement(SEMICOLON)(';')
-                  PsiElement(SEMICOLON)(';')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('foo')
-                  PsiElement(SEMICOLON)(';')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('bar')
-                  PsiElement(SEMICOLON)(';')
-                  PsiElement(SEMICOLON)(';')
-                  PsiElement(SEMICOLON)(';')
-                  PsiElement(SEMICOLON)(';')
-                PsiWhiteSpace(' ')
-                PsiElement(RBRACE)('}')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiElement(SEMICOLON)(';')
+              PsiElement(SEMICOLON)(';')
+              PsiElement(SEMICOLON)(';')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('foo')
+              PsiElement(SEMICOLON)(';')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+              PsiElement(SEMICOLON)(';')
+              PsiElement(SEMICOLON)(';')
+              PsiElement(SEMICOLON)(';')
+              PsiElement(SEMICOLON)(';')
+              PsiWhiteSpace(' ')
+              PsiElement(RBRACE)('}')
           PsiWhiteSpace(' ')
           PsiElement(while)('while')
           PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/Expressions_ERR.txt b/idea/testData/psi/Expressions_ERR.txt
index 66a07a57f5c..456496b2c99 100644
--- a/idea/testData/psi/Expressions_ERR.txt
+++ b/idea/testData/psi/Expressions_ERR.txt
@@ -23,37 +23,35 @@ JetFile: Expressions_ERR.jet
         PsiElement(else)('else')
         PsiWhiteSpace(' ')
         ELSE
-          FUNCTION_LITERAL_EXPRESSION
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              PsiWhiteSpace('\n  ')
-              BLOCK
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('dfsd')
-                PsiWhiteSpace('\n  ')
-                PsiErrorElement:Expecting an element
-                  PsiElement(RPAR)(')')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                PsiErrorElement:Expecting an element
-                  PsiElement(RPAR)(')')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                PsiErrorElement:Expecting an element
-                  PsiElement(BAD_CHARACTER)('~')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                PsiWhiteSpace('\n  ')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('srgsdfg')
-                PsiWhiteSpace('\n\n  ')
-                PsiErrorElement:Expecting an element
-                  PsiElement(BAD_CHARACTER)('~')
-                PsiWhiteSpace('\n\n  ')
-                PsiErrorElement:Expecting an element
-                  PsiElement(RBRACKET)(']')
-              PsiWhiteSpace('\n')
-              PsiElement(RBRACE)('}')
\ No newline at end of file
+          BLOCK
+            PsiElement(LBRACE)('{')
+            PsiWhiteSpace('\n  ')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('dfsd')
+            PsiWhiteSpace('\n  ')
+            PsiErrorElement:Expecting an element
+              PsiElement(RPAR)(')')
+            PsiElement(SEMICOLON)(';')
+            PsiElement(SEMICOLON)(';')
+            PsiElement(SEMICOLON)(';')
+            PsiErrorElement:Expecting an element
+              PsiElement(RPAR)(')')
+            PsiElement(SEMICOLON)(';')
+            PsiElement(SEMICOLON)(';')
+            PsiElement(SEMICOLON)(';')
+            PsiErrorElement:Expecting an element
+              PsiElement(BAD_CHARACTER)('~')
+            PsiElement(SEMICOLON)(';')
+            PsiElement(SEMICOLON)(';')
+            PsiElement(SEMICOLON)(';')
+            PsiWhiteSpace('\n  ')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('srgsdfg')
+            PsiWhiteSpace('\n\n  ')
+            PsiErrorElement:Expecting an element
+              PsiElement(BAD_CHARACTER)('~')
+            PsiWhiteSpace('\n\n  ')
+            PsiErrorElement:Expecting an element
+              PsiElement(RBRACKET)(']')
+            PsiWhiteSpace('\n')
+            PsiElement(RBRACE)('}')
\ No newline at end of file
diff --git a/idea/testData/psi/Functions.jet b/idea/testData/psi/Functions.jet
index dd2c0aec7a8..bc7ed706c1d 100644
--- a/idea/testData/psi/Functions.jet
+++ b/idea/testData/psi/Functions.jet
@@ -18,4 +18,5 @@ fun [a()] T.foo<T : fun (a) : b>(a : foo) : bar {}
 
 fun [a()] T.foo<T : [a] fun (a) : b>(a : foo) : bar {}
 
-fun A?.foo() : bar?
\ No newline at end of file
+fun A?.foo() : bar?
+fun A? .foo() : bar?
\ No newline at end of file
diff --git a/idea/testData/psi/Functions.txt b/idea/testData/psi/Functions.txt
index 028974d83f7..811bf8d332c 100644
--- a/idea/testData/psi/Functions.txt
+++ b/idea/testData/psi/Functions.txt
@@ -587,7 +587,33 @@ JetFile: Functions.jet
           USER_TYPE
             REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('A')
-      PsiElement(SAFE_ACCESS)('?.')
+          PsiElement(QUEST)('?')
+      PsiElement(DOT)('.')
+      PsiElement(IDENTIFIER)('foo')
+      VALUE_PARAMETER_LIST
+        PsiElement(LPAR)('(')
+        PsiElement(RPAR)(')')
+      PsiWhiteSpace(' ')
+      PsiElement(COLON)(':')
+      PsiWhiteSpace(' ')
+      TYPE_REFERENCE
+        NULLABLE_TYPE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+          PsiElement(QUEST)('?')
+    PsiWhiteSpace('\n')
+    FUN
+      PsiElement(fun)('fun')
+      PsiWhiteSpace(' ')
+      TYPE_REFERENCE
+        NULLABLE_TYPE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('A')
+          PsiElement(QUEST)('?')
+      PsiWhiteSpace(' ')
+      PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('foo')
       VALUE_PARAMETER_LIST
         PsiElement(LPAR)('(')
diff --git a/idea/testData/psi/IfWithPropery.txt b/idea/testData/psi/IfWithPropery.txt
index 1891ebe0f4d..6e3d344b660 100644
--- a/idea/testData/psi/IfWithPropery.txt
+++ b/idea/testData/psi/IfWithPropery.txt
@@ -16,34 +16,30 @@ JetFile: IfWithPropery.jet
         PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
         THEN
-          FUNCTION_LITERAL_EXPRESSION
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BLOCK
-                PROPERTY
-                  PsiElement(var)('var')
-                  PsiWhiteSpace(' ')
-                  PsiElement(IDENTIFIER)('f')
-                  PsiWhiteSpace(' ')
-                  PsiElement(EQ)('=')
-                  PsiWhiteSpace(' ')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-                PsiElement(SEMICOLON)(';')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-              PsiElement(RBRACE)('}')
+          BLOCK
+            PsiElement(LBRACE)('{')
+            PROPERTY
+              PsiElement(var)('var')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('f')
+              PsiWhiteSpace(' ')
+              PsiElement(EQ)('=')
+              PsiWhiteSpace(' ')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(SEMICOLON)(';')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
         PsiElement(else)('else')
         PsiWhiteSpace(' ')
         ELSE
-          FUNCTION_LITERAL_EXPRESSION
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BLOCK
-                NULL
-                  PsiElement(null)('null')
-              PsiElement(RBRACE)('}')
+          BLOCK
+            PsiElement(LBRACE)('{')
+            NULL
+              PsiElement(null)('null')
+            PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -61,34 +57,30 @@ JetFile: IfWithPropery.jet
         PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
         THEN
-          FUNCTION_LITERAL_EXPRESSION
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              PsiWhiteSpace('\n  ')
-              BLOCK
-                PROPERTY
-                  PsiElement(var)('var')
-                  PsiWhiteSpace(' ')
-                  PsiElement(IDENTIFIER)('f')
-                  PsiWhiteSpace(' ')
-                  PsiElement(EQ)('=')
-                  PsiWhiteSpace(' ')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-                PsiElement(SEMICOLON)(';')
-                PsiWhiteSpace('\n  ')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace('\n')
-              PsiElement(RBRACE)('}')
+          BLOCK
+            PsiElement(LBRACE)('{')
+            PsiWhiteSpace('\n  ')
+            PROPERTY
+              PsiElement(var)('var')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('f')
+              PsiWhiteSpace(' ')
+              PsiElement(EQ)('=')
+              PsiWhiteSpace(' ')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(SEMICOLON)(';')
+            PsiWhiteSpace('\n  ')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
+            PsiWhiteSpace('\n')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
         PsiElement(else)('else')
         PsiWhiteSpace(' ')
         ELSE
-          FUNCTION_LITERAL_EXPRESSION
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BLOCK
-                NULL
-                  PsiElement(null)('null')
-              PsiElement(RBRACE)('}')
\ No newline at end of file
+          BLOCK
+            PsiElement(LBRACE)('{')
+            NULL
+              PsiElement(null)('null')
+            PsiElement(RBRACE)('}')
\ No newline at end of file
diff --git a/idea/testData/psi/Properties.jet b/idea/testData/psi/Properties.jet
index 3549ca9edc7..54939d28aba 100644
--- a/idea/testData/psi/Properties.jet
+++ b/idea/testData/psi/Properties.jet
@@ -50,4 +50,5 @@ fun foo() {
 val IList<T>.lastIndex : Int
   get() = this.size - 1
 
-val Int?.opt : Int
\ No newline at end of file
+val Int?.opt : Int
+val Int? .opt : Int
\ No newline at end of file
diff --git a/idea/testData/psi/Properties.txt b/idea/testData/psi/Properties.txt
index 1cfc779d614..17287b0a841 100644
--- a/idea/testData/psi/Properties.txt
+++ b/idea/testData/psi/Properties.txt
@@ -415,7 +415,28 @@ JetFile: Properties.jet
           USER_TYPE
             REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('Int')
-      PsiElement(SAFE_ACCESS)('?.')
+          PsiElement(QUEST)('?')
+      PsiElement(DOT)('.')
+      PsiElement(IDENTIFIER)('opt')
+      PsiWhiteSpace(' ')
+      PsiElement(COLON)(':')
+      PsiWhiteSpace(' ')
+      TYPE_REFERENCE
+        USER_TYPE
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('Int')
+    PsiWhiteSpace('\n')
+    PROPERTY
+      PsiElement(val)('val')
+      PsiWhiteSpace(' ')
+      TYPE_REFERENCE
+        NULLABLE_TYPE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+          PsiElement(QUEST)('?')
+      PsiWhiteSpace(' ')
+      PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('opt')
       PsiWhiteSpace(' ')
       PsiElement(COLON)(':')
diff --git a/idea/testData/psi/RootNamespace.txt b/idea/testData/psi/RootNamespace.txt
index 8e9ebf86805..4b1f87ba7ea 100644
--- a/idea/testData/psi/RootNamespace.txt
+++ b/idea/testData/psi/RootNamespace.txt
@@ -115,12 +115,9 @@ JetFile: RootNamespace.jet
                 PsiWhiteSpace(' ')
                 PsiElement(DOUBLE_ARROW)('=>')
                 PsiWhiteSpace(' ')
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    BLOCK
-                      <empty list>
-                    PsiElement(RBRACE)('}')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiElement(RBRACE)('}')
               PsiWhiteSpace('\n    ')
               PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
diff --git a/idea/testData/psi/SimpleModifiers.jet b/idea/testData/psi/SimpleModifiers.jet
index 004627a09f9..407ad761e34 100644
--- a/idea/testData/psi/SimpleModifiers.jet
+++ b/idea/testData/psi/SimpleModifiers.jet
@@ -1,12 +1,12 @@
 namespace foo.bar.goo
 
 abstract
-virtual
+open
 enum
 open
-attribute
+annotation
 override
-virtual
+open
 abstract
 private
 protected
@@ -16,12 +16,12 @@ in
 out
 ref
  class Bar<abstract
-        virtual
+        open
         enum
         open
-        attribute
+        annotation
         override
-        virtual
+        open
         abstract
         private
         protected
@@ -31,12 +31,12 @@ ref
         out
         ref T> {
     val abstract
-    val virtual
+    val open
     val enum
     val open
-    val attribute
+    val annotation
     val override
-    val virtual
+    val open
     val abstract
     val private
     val protected
diff --git a/idea/testData/psi/SimpleModifiers.txt b/idea/testData/psi/SimpleModifiers.txt
index 9e29a05a5c6..aca1212c64b 100644
--- a/idea/testData/psi/SimpleModifiers.txt
+++ b/idea/testData/psi/SimpleModifiers.txt
@@ -13,17 +13,17 @@ JetFile: SimpleModifiers.jet
       MODIFIER_LIST
         PsiElement(abstract)('abstract')
         PsiWhiteSpace('\n')
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
         PsiWhiteSpace('\n')
         PsiElement(enum)('enum')
         PsiWhiteSpace('\n')
         PsiElement(open)('open')
         PsiWhiteSpace('\n')
-        PsiElement(attribute)('attribute')
+        PsiElement(annotation)('annotation')
         PsiWhiteSpace('\n')
         PsiElement(override)('override')
         PsiWhiteSpace('\n')
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
         PsiWhiteSpace('\n')
         PsiElement(abstract)('abstract')
         PsiWhiteSpace('\n')
@@ -50,17 +50,17 @@ JetFile: SimpleModifiers.jet
           MODIFIER_LIST
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n        ')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n        ')
             PsiElement(enum)('enum')
             PsiWhiteSpace('\n        ')
             PsiElement(open)('open')
             PsiWhiteSpace('\n        ')
-            PsiElement(attribute)('attribute')
+            PsiElement(annotation)('annotation')
             PsiWhiteSpace('\n        ')
             PsiElement(override)('override')
             PsiWhiteSpace('\n        ')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n        ')
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n        ')
@@ -92,7 +92,7 @@ JetFile: SimpleModifiers.jet
         PROPERTY
           PsiElement(val)('val')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('virtual')
+          PsiElement(IDENTIFIER)('open')
         PsiWhiteSpace('\n    ')
         PROPERTY
           PsiElement(val)('val')
@@ -107,7 +107,7 @@ JetFile: SimpleModifiers.jet
         PROPERTY
           PsiElement(val)('val')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('attribute')
+          PsiElement(IDENTIFIER)('annotation')
         PsiWhiteSpace('\n    ')
         PROPERTY
           PsiElement(val)('val')
@@ -117,7 +117,7 @@ JetFile: SimpleModifiers.jet
         PROPERTY
           PsiElement(val)('val')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('virtual')
+          PsiElement(IDENTIFIER)('open')
         PsiWhiteSpace('\n    ')
         PROPERTY
           PsiElement(val)('val')
diff --git a/idea/testData/psi/SoftKeywords.jet b/idea/testData/psi/SoftKeywords.jet
index 20e52c05e89..829934a583a 100644
--- a/idea/testData/psi/SoftKeywords.jet
+++ b/idea/testData/psi/SoftKeywords.jet
@@ -4,12 +4,12 @@ import foo
 
 public protected private internal
 abstract
-virtual
+open
 enum
 open
-attribute
+annotation
 override
-virtual
+open
 abstract
 private
 protected
@@ -18,27 +18,27 @@ internal
 in
 out
 ref
- class Bar<abstract, abstract enum : T, out virtual,
+ class Bar<abstract, abstract enum : T, out open,
     public protected private internal abstract
-    virtual
+    open
     enum
     open
-    attribute
+    annotation
     override
-    virtual
+    open
     abstract
     private
     protected
     public
     internal open
- > wraps (a : B) : A by b {
+ > (a : B) : A by b {
     public protected private internal val abstract
-    val virtual
+    val open
     val enum
     val open
-    val attribute
+    val annotation
     val override
-    val virtual
+    val open
     val abstract
     val private
     val protected
@@ -61,12 +61,12 @@ ref
 
     public protected private internal
     fun abstract  () : abstract
-    fun virtual   () : virtual
+    fun open   () : open
     fun enum      () : enum
     fun open      () : open
-    fun attribute () : attribute
+    fun annotation () : annotation
     fun override  () : override
-    fun virtual   () : virtual
+    fun open   () : open
     fun abstract  () : abstract
     fun private   () : private
     fun protected () : protected
@@ -86,12 +86,12 @@ ref
 
     fun test(
         abstract  : t,
-        virtual   : t,
+        open   : t,
         enum      : t,
         open      : t,
-        attribute : t,
+        annotation : t,
         override  : t,
-        virtual   : t,
+        open   : t,
         abstract  : t,
         private   : t,
         protected : t,
@@ -109,12 +109,12 @@ ref
         protected : t,
         internal  : t,
     public protected private internal abstract
-    virtual
+    open
     enum
     open
-    attribute
+    annotation
     override
-    virtual
+    open
     abstract
     private
     protected
@@ -128,12 +128,12 @@ ref
 
 class F(val foo : bar,
         abstract  : t,
-        virtual   : t,
+        open   : t,
         enum      : t,
         open      : t,
-        attribute : t,
+        annotation : t,
         override  : t,
-        virtual   : t,
+        open   : t,
         abstract  : t,
         private   : t,
         protected : t,
@@ -151,12 +151,12 @@ class F(val foo : bar,
         protected : t,
         internal  : t,
     public protected private internal abstract
-    virtual
+    open
     enum
     open
-    attribute
+    annotation
     override
-    virtual
+    open
     abstract
     private
     protected
diff --git a/idea/testData/psi/SoftKeywords.txt b/idea/testData/psi/SoftKeywords.txt
index 68aaec1fd2f..eb76e1c326c 100644
--- a/idea/testData/psi/SoftKeywords.txt
+++ b/idea/testData/psi/SoftKeywords.txt
@@ -27,17 +27,17 @@ JetFile: SoftKeywords.jet
         PsiWhiteSpace('\n')
         PsiElement(abstract)('abstract')
         PsiWhiteSpace('\n')
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
         PsiWhiteSpace('\n')
         PsiElement(enum)('enum')
         PsiWhiteSpace('\n')
         PsiElement(open)('open')
         PsiWhiteSpace('\n')
-        PsiElement(attribute)('attribute')
+        PsiElement(annotation)('annotation')
         PsiWhiteSpace('\n')
         PsiElement(override)('override')
         PsiWhiteSpace('\n')
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
         PsiWhiteSpace('\n')
         PsiElement(abstract)('abstract')
         PsiWhiteSpace('\n')
@@ -82,7 +82,7 @@ JetFile: SoftKeywords.jet
           MODIFIER_LIST
             PsiElement(out)('out')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('virtual')
+          PsiElement(IDENTIFIER)('open')
         PsiElement(COMMA)(',')
         PsiWhiteSpace('\n    ')
         TYPE_PARAMETER
@@ -97,17 +97,17 @@ JetFile: SoftKeywords.jet
             PsiWhiteSpace(' ')
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n    ')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n    ')
             PsiElement(enum)('enum')
             PsiWhiteSpace('\n    ')
             PsiElement(open)('open')
             PsiWhiteSpace('\n    ')
-            PsiElement(attribute)('attribute')
+            PsiElement(annotation)('annotation')
             PsiWhiteSpace('\n    ')
             PsiElement(override)('override')
             PsiWhiteSpace('\n    ')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n    ')
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n    ')
@@ -123,8 +123,6 @@ JetFile: SoftKeywords.jet
         PsiWhiteSpace('\n ')
         PsiElement(GT)('>')
       PsiWhiteSpace(' ')
-      PsiElement(wraps)('wraps')
-      PsiWhiteSpace(' ')
       VALUE_PARAMETER_LIST
         PsiElement(LPAR)('(')
         VALUE_PARAMETER
@@ -172,7 +170,7 @@ JetFile: SoftKeywords.jet
         PROPERTY
           PsiElement(val)('val')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('virtual')
+          PsiElement(IDENTIFIER)('open')
         PsiWhiteSpace('\n    ')
         PROPERTY
           PsiElement(val)('val')
@@ -187,7 +185,7 @@ JetFile: SoftKeywords.jet
         PROPERTY
           PsiElement(val)('val')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('attribute')
+          PsiElement(IDENTIFIER)('annotation')
         PsiWhiteSpace('\n    ')
         PROPERTY
           PsiElement(val)('val')
@@ -197,7 +195,7 @@ JetFile: SoftKeywords.jet
         PROPERTY
           PsiElement(val)('val')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('virtual')
+          PsiElement(IDENTIFIER)('open')
         PsiWhiteSpace('\n    ')
         PROPERTY
           PsiElement(val)('val')
@@ -336,7 +334,7 @@ JetFile: SoftKeywords.jet
         FUN
           PsiElement(fun)('fun')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('virtual')
+          PsiElement(IDENTIFIER)('open')
           PsiWhiteSpace('   ')
           VALUE_PARAMETER_LIST
             PsiElement(LPAR)('(')
@@ -347,7 +345,7 @@ JetFile: SoftKeywords.jet
           TYPE_REFERENCE
             USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('virtual')
+                PsiElement(IDENTIFIER)('open')
         PsiWhiteSpace('\n    ')
         FUN
           PsiElement(fun)('fun')
@@ -384,7 +382,7 @@ JetFile: SoftKeywords.jet
         FUN
           PsiElement(fun)('fun')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('attribute')
+          PsiElement(IDENTIFIER)('annotation')
           PsiWhiteSpace(' ')
           VALUE_PARAMETER_LIST
             PsiElement(LPAR)('(')
@@ -395,7 +393,7 @@ JetFile: SoftKeywords.jet
           TYPE_REFERENCE
             USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('attribute')
+                PsiElement(IDENTIFIER)('annotation')
         PsiWhiteSpace('\n    ')
         FUN
           PsiElement(fun)('fun')
@@ -416,7 +414,7 @@ JetFile: SoftKeywords.jet
         FUN
           PsiElement(fun)('fun')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('virtual')
+          PsiElement(IDENTIFIER)('open')
           PsiWhiteSpace('   ')
           VALUE_PARAMETER_LIST
             PsiElement(LPAR)('(')
@@ -427,7 +425,7 @@ JetFile: SoftKeywords.jet
           TYPE_REFERENCE
             USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('virtual')
+                PsiElement(IDENTIFIER)('open')
         PsiWhiteSpace('\n    ')
         FUN
           PsiElement(fun)('fun')
@@ -704,7 +702,7 @@ JetFile: SoftKeywords.jet
             PsiElement(COMMA)(',')
             PsiWhiteSpace('\n        ')
             VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('virtual')
+              PsiElement(IDENTIFIER)('open')
               PsiWhiteSpace('   ')
               PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
@@ -737,7 +735,7 @@ JetFile: SoftKeywords.jet
             PsiElement(COMMA)(',')
             PsiWhiteSpace('\n        ')
             VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('attribute')
+              PsiElement(IDENTIFIER)('annotation')
               PsiWhiteSpace(' ')
               PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
@@ -759,7 +757,7 @@ JetFile: SoftKeywords.jet
             PsiElement(COMMA)(',')
             PsiWhiteSpace('\n        ')
             VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('virtual')
+              PsiElement(IDENTIFIER)('open')
               PsiWhiteSpace('   ')
               PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
@@ -957,17 +955,17 @@ JetFile: SoftKeywords.jet
                 PsiWhiteSpace(' ')
                 PsiElement(abstract)('abstract')
                 PsiWhiteSpace('\n    ')
-                PsiElement(virtual)('virtual')
+                PsiElement(open)('open')
                 PsiWhiteSpace('\n    ')
                 PsiElement(enum)('enum')
                 PsiWhiteSpace('\n    ')
                 PsiElement(open)('open')
                 PsiWhiteSpace('\n    ')
-                PsiElement(attribute)('attribute')
+                PsiElement(annotation)('annotation')
                 PsiWhiteSpace('\n    ')
                 PsiElement(override)('override')
                 PsiWhiteSpace('\n    ')
-                PsiElement(virtual)('virtual')
+                PsiElement(open)('open')
                 PsiWhiteSpace('\n    ')
                 PsiElement(abstract)('abstract')
                 PsiWhiteSpace('\n    ')
@@ -1025,7 +1023,7 @@ JetFile: SoftKeywords.jet
         PsiElement(COMMA)(',')
         PsiWhiteSpace('\n        ')
         VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('virtual')
+          PsiElement(IDENTIFIER)('open')
           PsiWhiteSpace('   ')
           PsiElement(COLON)(':')
           PsiWhiteSpace(' ')
@@ -1058,7 +1056,7 @@ JetFile: SoftKeywords.jet
         PsiElement(COMMA)(',')
         PsiWhiteSpace('\n        ')
         VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('attribute')
+          PsiElement(IDENTIFIER)('annotation')
           PsiWhiteSpace(' ')
           PsiElement(COLON)(':')
           PsiWhiteSpace(' ')
@@ -1080,7 +1078,7 @@ JetFile: SoftKeywords.jet
         PsiElement(COMMA)(',')
         PsiWhiteSpace('\n        ')
         VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('virtual')
+          PsiElement(IDENTIFIER)('open')
           PsiWhiteSpace('   ')
           PsiElement(COLON)(':')
           PsiWhiteSpace(' ')
@@ -1278,17 +1276,17 @@ JetFile: SoftKeywords.jet
             PsiWhiteSpace(' ')
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n    ')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n    ')
             PsiElement(enum)('enum')
             PsiWhiteSpace('\n    ')
             PsiElement(open)('open')
             PsiWhiteSpace('\n    ')
-            PsiElement(attribute)('attribute')
+            PsiElement(annotation)('annotation')
             PsiWhiteSpace('\n    ')
             PsiElement(override)('override')
             PsiWhiteSpace('\n    ')
-            PsiElement(virtual)('virtual')
+            PsiElement(open)('open')
             PsiWhiteSpace('\n    ')
             PsiElement(abstract)('abstract')
             PsiWhiteSpace('\n    ')
diff --git a/idea/testData/psi/examples/BinaryTree.txt b/idea/testData/psi/examples/BinaryTree.txt
index 36008ffeaa0..41e839f7454 100644
--- a/idea/testData/psi/examples/BinaryTree.txt
+++ b/idea/testData/psi/examples/BinaryTree.txt
@@ -556,30 +556,28 @@ JetFile: BinaryTree.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      POSTFIX_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('size')
-                        OPERATION_REFERENCE
-                          PsiElement(PLUSPLUS)('++')
-                      PsiWhiteSpace('\n      ')
-                      POSTFIX_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('version')
-                        OPERATION_REFERENCE
-                          PsiElement(PLUSPLUS)('++')
-                      PsiWhiteSpace('\n      ')
-                      RETURN
-                        PsiElement(return)('return')
-                        PsiWhiteSpace(' ')
-                        BOOLEAN_CONSTANT
-                          PsiElement(true)('true')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  POSTFIX_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('size')
+                    OPERATION_REFERENCE
+                      PsiElement(PLUSPLUS)('++')
+                  PsiWhiteSpace('\n      ')
+                  POSTFIX_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('version')
+                    OPERATION_REFERENCE
+                      PsiElement(PLUSPLUS)('++')
+                  PsiWhiteSpace('\n      ')
+                  RETURN
+                    PsiElement(return)('return')
+                    PsiWhiteSpace(' ')
+                    BOOLEAN_CONSTANT
+                      PsiElement(true)('true')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             RETURN
               PsiElement(return)('return')
@@ -649,40 +647,38 @@ JetFile: BinaryTree.jet
                   PsiElement(RPAR)(')')
                   PsiWhiteSpace(' ')
                   THEN
-                    FUNCTION_LITERAL_EXPRESSION
-                      FUNCTION_LITERAL
-                        PsiElement(LBRACE)('{')
-                        PsiWhiteSpace('\n        ')
-                        BLOCK
-                          BINARY_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('node')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(EQ)('=')
-                            PsiWhiteSpace(' ')
-                            CALL_EXPRESSION
+                    BLOCK
+                      PsiElement(LBRACE)('{')
+                      PsiWhiteSpace('\n        ')
+                      BINARY_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('node')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('TreeNode')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            VALUE_ARGUMENT
                               REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('TreeNode')
-                              VALUE_ARGUMENT_LIST
-                                PsiElement(LPAR)('(')
-                                VALUE_ARGUMENT
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('item')
-                                PsiElement(COMMA)(',')
-                                PsiWhiteSpace(' ')
-                                VALUE_ARGUMENT
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('parent')
-                                PsiElement(RPAR)(')')
-                          PsiWhiteSpace('\n        ')
-                          RETURN
-                            PsiElement(return)('return')
+                                PsiElement(IDENTIFIER)('item')
+                            PsiElement(COMMA)(',')
                             PsiWhiteSpace(' ')
-                            BOOLEAN_CONSTANT
-                              PsiElement(true)('true')
-                        PsiWhiteSpace('\n      ')
-                        PsiElement(RBRACE)('}')
+                            VALUE_ARGUMENT
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('parent')
+                            PsiElement(RPAR)(')')
+                      PsiWhiteSpace('\n        ')
+                      RETURN
+                        PsiElement(return)('return')
+                        PsiWhiteSpace(' ')
+                        BOOLEAN_CONSTANT
+                          PsiElement(true)('true')
+                      PsiWhiteSpace('\n      ')
+                      PsiElement(RBRACE)('}')
                 PsiWhiteSpace('\n      ')
                 WHEN
                   PsiElement(when)('when')
@@ -829,40 +825,38 @@ JetFile: BinaryTree.jet
                   PsiElement(RPAR)(')')
                   PsiWhiteSpace(' ')
                   THEN
-                    FUNCTION_LITERAL_EXPRESSION
-                      FUNCTION_LITERAL
-                        PsiElement(LBRACE)('{')
-                        PsiWhiteSpace('\n        ')
-                        BLOCK
-                          BINARY_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('root')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(EQ)('=')
-                            PsiWhiteSpace(' ')
-                            CALL_EXPRESSION
+                    BLOCK
+                      PsiElement(LBRACE)('{')
+                      PsiWhiteSpace('\n        ')
+                      BINARY_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('root')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('TreeNode')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            VALUE_ARGUMENT
                               REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('TreeNode')
-                              VALUE_ARGUMENT_LIST
-                                PsiElement(LPAR)('(')
-                                VALUE_ARGUMENT
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('item')
-                                PsiElement(COMMA)(',')
-                                PsiWhiteSpace(' ')
-                                VALUE_ARGUMENT
-                                  NULL
-                                    PsiElement(null)('null')
-                                PsiElement(RPAR)(')')
-                          PsiWhiteSpace('\n        ')
-                          RETURN
-                            PsiElement(return)('return')
+                                PsiElement(IDENTIFIER)('item')
+                            PsiElement(COMMA)(',')
                             PsiWhiteSpace(' ')
-                            BOOLEAN_CONSTANT
-                              PsiElement(true)('true')
-                        PsiWhiteSpace('\n      ')
-                        PsiElement(RBRACE)('}')
+                            VALUE_ARGUMENT
+                              NULL
+                                PsiElement(null)('null')
+                            PsiElement(RPAR)(')')
+                      PsiWhiteSpace('\n        ')
+                      RETURN
+                        PsiElement(return)('return')
+                        PsiWhiteSpace(' ')
+                        BOOLEAN_CONSTANT
+                          PsiElement(true)('true')
+                      PsiWhiteSpace('\n      ')
+                      PsiElement(RBRACE)('}')
                 PsiWhiteSpace('\n      ')
                 WHEN
                   PsiElement(when)('when')
@@ -933,44 +927,42 @@ JetFile: BinaryTree.jet
                       PsiElement(RPAR)(')')
                       PsiWhiteSpace(' ')
                       THEN
-                        FUNCTION_LITERAL_EXPRESSION
-                          FUNCTION_LITERAL
-                            PsiElement(LBRACE)('{')
-                            PsiWhiteSpace('\n            ')
-                            BLOCK
-                              BINARY_EXPRESSION
-                                DOT_QUALIFIED_EXPRESSION
+                        BLOCK
+                          PsiElement(LBRACE)('{')
+                          PsiWhiteSpace('\n            ')
+                          BINARY_EXPRESSION
+                            DOT_QUALIFIED_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('node')
+                              PsiElement(DOT)('.')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('left')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(EQ)('=')
+                            PsiWhiteSpace(' ')
+                            CALL_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('TreeNode')
+                              VALUE_ARGUMENT_LIST
+                                PsiElement(LPAR)('(')
+                                VALUE_ARGUMENT
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('item')
+                                PsiElement(COMMA)(',')
+                                PsiWhiteSpace(' ')
+                                VALUE_ARGUMENT
                                   REFERENCE_EXPRESSION
                                     PsiElement(IDENTIFIER)('node')
-                                  PsiElement(DOT)('.')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('left')
-                                PsiWhiteSpace(' ')
-                                OPERATION_REFERENCE
-                                  PsiElement(EQ)('=')
-                                PsiWhiteSpace(' ')
-                                CALL_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('TreeNode')
-                                  VALUE_ARGUMENT_LIST
-                                    PsiElement(LPAR)('(')
-                                    VALUE_ARGUMENT
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('item')
-                                    PsiElement(COMMA)(',')
-                                    PsiWhiteSpace(' ')
-                                    VALUE_ARGUMENT
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('node')
-                                    PsiElement(RPAR)(')')
-                              PsiWhiteSpace('\n            ')
-                              RETURN
-                                PsiElement(return)('return')
-                                PsiWhiteSpace(' ')
-                                BOOLEAN_CONSTANT
-                                  PsiElement(true)('true')
-                            PsiWhiteSpace('\n          ')
-                            PsiElement(RBRACE)('}')
+                                PsiElement(RPAR)(')')
+                          PsiWhiteSpace('\n            ')
+                          RETURN
+                            PsiElement(return)('return')
+                            PsiWhiteSpace(' ')
+                            BOOLEAN_CONSTANT
+                              PsiElement(true)('true')
+                          PsiWhiteSpace('\n          ')
+                          PsiElement(RBRACE)('}')
                       PsiWhiteSpace(' ')
                       PsiElement(else)('else')
                       PsiWhiteSpace(' ')
@@ -1021,44 +1013,42 @@ JetFile: BinaryTree.jet
                       PsiElement(RPAR)(')')
                       PsiWhiteSpace(' ')
                       THEN
-                        FUNCTION_LITERAL_EXPRESSION
-                          FUNCTION_LITERAL
-                            PsiElement(LBRACE)('{')
-                            PsiWhiteSpace('\n            ')
-                            BLOCK
-                              BINARY_EXPRESSION
-                                DOT_QUALIFIED_EXPRESSION
+                        BLOCK
+                          PsiElement(LBRACE)('{')
+                          PsiWhiteSpace('\n            ')
+                          BINARY_EXPRESSION
+                            DOT_QUALIFIED_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('node')
+                              PsiElement(DOT)('.')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('right')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(EQ)('=')
+                            PsiWhiteSpace(' ')
+                            CALL_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('TreeNode')
+                              VALUE_ARGUMENT_LIST
+                                PsiElement(LPAR)('(')
+                                VALUE_ARGUMENT
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('item')
+                                PsiElement(COMMA)(',')
+                                PsiWhiteSpace(' ')
+                                VALUE_ARGUMENT
                                   REFERENCE_EXPRESSION
                                     PsiElement(IDENTIFIER)('node')
-                                  PsiElement(DOT)('.')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('right')
-                                PsiWhiteSpace(' ')
-                                OPERATION_REFERENCE
-                                  PsiElement(EQ)('=')
-                                PsiWhiteSpace(' ')
-                                CALL_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('TreeNode')
-                                  VALUE_ARGUMENT_LIST
-                                    PsiElement(LPAR)('(')
-                                    VALUE_ARGUMENT
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('item')
-                                    PsiElement(COMMA)(',')
-                                    PsiWhiteSpace(' ')
-                                    VALUE_ARGUMENT
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('node')
-                                    PsiElement(RPAR)(')')
-                              PsiWhiteSpace('\n            ')
-                              RETURN
-                                PsiElement(return)('return')
-                                PsiWhiteSpace(' ')
-                                BOOLEAN_CONSTANT
-                                  PsiElement(true)('true')
-                            PsiWhiteSpace('\n          ')
-                            PsiElement(RBRACE)('}')
+                                PsiElement(RPAR)(')')
+                          PsiWhiteSpace('\n            ')
+                          RETURN
+                            PsiElement(return)('return')
+                            PsiWhiteSpace(' ')
+                            BOOLEAN_CONSTANT
+                              PsiElement(true)('true')
+                          PsiWhiteSpace('\n          ')
+                          PsiElement(RBRACE)('}')
                       PsiWhiteSpace(' ')
                       PsiElement(else)('else')
                       PsiWhiteSpace(' ')
@@ -1516,61 +1506,59 @@ JetFile: BinaryTree.jet
                 PsiWhiteSpace(' ')
                 PsiElement(DOUBLE_ARROW)('=>')
                 PsiWhiteSpace(' ')
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n        ')
-                    BLOCK
-                      PROPERTY
-                        PsiElement(val)('val')
-                        PsiWhiteSpace(' ')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n        ')
+                  PROPERTY
+                    PsiElement(val)('val')
+                    PsiWhiteSpace(' ')
+                    PsiElement(IDENTIFIER)('min')
+                    PsiWhiteSpace(' ')
+                    PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    CALL_EXPRESSION
+                      REFERENCE_EXPRESSION
                         PsiElement(IDENTIFIER)('min')
-                        PsiWhiteSpace(' ')
-                        PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        CALL_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('min')
-                          VALUE_ARGUMENT_LIST
-                            PsiElement(LPAR)('(')
-                            VALUE_ARGUMENT
-                              DOT_QUALIFIED_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('node')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('right')
-                            PsiElement(RPAR)(')')
-                      PsiWhiteSpace('\n        ')
-                      BINARY_EXPRESSION
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('node')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('value')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('min')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('value')
-                      PsiWhiteSpace('\n        ')
-                      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('remove')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          VALUE_ARGUMENT
+                      VALUE_ARGUMENT_LIST
+                        PsiElement(LPAR)('(')
+                        VALUE_ARGUMENT
+                          DOT_QUALIFIED_EXPRESSION
                             REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('min')
-                          PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n      ')
-                    PsiElement(RBRACE)('}')
+                              PsiElement(IDENTIFIER)('node')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('right')
+                        PsiElement(RPAR)(')')
+                  PsiWhiteSpace('\n        ')
+                  BINARY_EXPRESSION
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('node')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('value')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('min')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('value')
+                  PsiWhiteSpace('\n        ')
+                  CALL_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('remove')
+                    VALUE_ARGUMENT_LIST
+                      PsiElement(LPAR)('(')
+                      VALUE_ARGUMENT
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('min')
+                      PsiElement(RPAR)(')')
+                  PsiWhiteSpace('\n      ')
+                  PsiElement(RBRACE)('}')
               PsiWhiteSpace('\n    ')
               PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n    ')
@@ -1622,25 +1610,23 @@ JetFile: BinaryTree.jet
                   PsiElement(RPAR)(')')
                   PsiWhiteSpace(' ')
                   THEN
-                    FUNCTION_LITERAL_EXPRESSION
-                      FUNCTION_LITERAL
-                        PsiElement(LBRACE)('{')
-                        PsiWhiteSpace('\n        ')
-                        BLOCK
-                          BINARY_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('root')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(EQ)('=')
-                            PsiWhiteSpace(' ')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('replace')
-                          PsiWhiteSpace('\n        ')
-                          RETURN
-                            PsiElement(return)('return')
-                        PsiWhiteSpace('\n      ')
-                        PsiElement(RBRACE)('}')
+                    BLOCK
+                      PsiElement(LBRACE)('{')
+                      PsiWhiteSpace('\n        ')
+                      BINARY_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('root')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('replace')
+                      PsiWhiteSpace('\n        ')
+                      RETURN
+                        PsiElement(return)('return')
+                      PsiWhiteSpace('\n      ')
+                      PsiElement(RBRACE)('}')
                 PsiWhiteSpace('\n      ')
                 IF
                   PsiElement(if)('if')
@@ -1667,30 +1653,28 @@ JetFile: BinaryTree.jet
                   PsiElement(RPAR)(')')
                   PsiWhiteSpace(' ')
                   THEN
-                    FUNCTION_LITERAL_EXPRESSION
-                      FUNCTION_LITERAL
-                        PsiElement(LBRACE)('{')
-                        PsiWhiteSpace('\n        ')
-                        BLOCK
-                          BINARY_EXPRESSION
-                            DOT_QUALIFIED_EXPRESSION
-                              DOT_QUALIFIED_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('node')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('parent')
-                              PsiElement(DOT)('.')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('left')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(EQ)('=')
-                            PsiWhiteSpace(' ')
+                    BLOCK
+                      PsiElement(LBRACE)('{')
+                      PsiWhiteSpace('\n        ')
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          DOT_QUALIFIED_EXPRESSION
                             REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('replace')
-                        PsiWhiteSpace('\n      ')
-                        PsiElement(RBRACE)('}')
+                              PsiElement(IDENTIFIER)('node')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('parent')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('left')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('replace')
+                      PsiWhiteSpace('\n      ')
+                      PsiElement(RBRACE)('}')
                   PsiWhiteSpace(' ')
                   PsiElement(else)('else')
                   PsiWhiteSpace(' ')
@@ -1720,30 +1704,28 @@ JetFile: BinaryTree.jet
                       PsiElement(RPAR)(')')
                       PsiWhiteSpace(' ')
                       THEN
-                        FUNCTION_LITERAL_EXPRESSION
-                          FUNCTION_LITERAL
-                            PsiElement(LBRACE)('{')
-                            PsiWhiteSpace('\n        ')
-                            BLOCK
-                              BINARY_EXPRESSION
-                                DOT_QUALIFIED_EXPRESSION
-                                  DOT_QUALIFIED_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('node')
-                                    PsiElement(DOT)('.')
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('parent')
-                                  PsiElement(DOT)('.')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('right')
-                                PsiWhiteSpace(' ')
-                                OPERATION_REFERENCE
-                                  PsiElement(EQ)('=')
-                                PsiWhiteSpace(' ')
+                        BLOCK
+                          PsiElement(LBRACE)('{')
+                          PsiWhiteSpace('\n        ')
+                          BINARY_EXPRESSION
+                            DOT_QUALIFIED_EXPRESSION
+                              DOT_QUALIFIED_EXPRESSION
                                 REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('replace')
-                            PsiWhiteSpace('\n      ')
-                            PsiElement(RBRACE)('}')
+                                  PsiElement(IDENTIFIER)('node')
+                                PsiElement(DOT)('.')
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('parent')
+                              PsiElement(DOT)('.')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('right')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(EQ)('=')
+                            PsiWhiteSpace(' ')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('replace')
+                          PsiWhiteSpace('\n      ')
+                          PsiElement(RBRACE)('}')
                       PsiWhiteSpace(' ')
                       PsiElement(else)('else')
                       PsiWhiteSpace(' ')
@@ -2134,257 +2116,243 @@ JetFile: BinaryTree.jet
                       PsiElement(RPAR)(')')
                       PsiWhiteSpace(' ')
                       BODY
-                        FUNCTION_LITERAL_EXPRESSION
-                          FUNCTION_LITERAL
-                            PsiElement(LBRACE)('{')
-                            PsiWhiteSpace('\n        ')
-                            BLOCK
-                              IF
-                                PsiElement(if)('if')
-                                PsiWhiteSpace(' ')
-                                PsiElement(LPAR)('(')
-                                CONDITION
-                                  PREFIX_EXPRESSION
-                                    OPERATION_REFERENCE
-                                      PsiElement(EXCL)('!')
-                                    DOT_QUALIFIED_EXPRESSION
+                        BLOCK
+                          PsiElement(LBRACE)('{')
+                          PsiWhiteSpace('\n        ')
+                          IF
+                            PsiElement(if)('if')
+                            PsiWhiteSpace(' ')
+                            PsiElement(LPAR)('(')
+                            CONDITION
+                              PREFIX_EXPRESSION
+                                OPERATION_REFERENCE
+                                  PsiElement(EXCL)('!')
+                                DOT_QUALIFIED_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('down')
+                                  PsiElement(DOT)('.')
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('isEmpty')
+                            PsiElement(RPAR)(')')
+                            PsiWhiteSpace(' ')
+                            THEN
+                              BLOCK
+                                PsiElement(LBRACE)('{')
+                                PsiWhiteSpace('\n          ')
+                                PROPERTY
+                                  PsiElement(val)('val')
+                                  PsiWhiteSpace(' ')
+                                  PsiElement(IDENTIFIER)('curNode')
+                                  PsiWhiteSpace(' ')
+                                  PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  DOT_QUALIFIED_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('down')
+                                    PsiElement(DOT)('.')
+                                    CALL_EXPRESSION
                                       REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('down')
-                                      PsiElement(DOT)('.')
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('isEmpty')
-                                PsiElement(RPAR)(')')
-                                PsiWhiteSpace(' ')
-                                THEN
-                                  FUNCTION_LITERAL_EXPRESSION
-                                    FUNCTION_LITERAL
-                                      PsiElement(LBRACE)('{')
-                                      PsiWhiteSpace('\n          ')
-                                      BLOCK
-                                        PROPERTY
-                                          PsiElement(val)('val')
-                                          PsiWhiteSpace(' ')
+                                        PsiElement(IDENTIFIER)('pop')
+                                      VALUE_ARGUMENT_LIST
+                                        PsiElement(LPAR)('(')
+                                        PsiElement(RPAR)(')')
+                                PsiWhiteSpace('\n          ')
+                                IF
+                                  PsiElement(if)('if')
+                                  PsiWhiteSpace(' ')
+                                  PsiElement(LPAR)('(')
+                                  CONDITION
+                                    BINARY_EXPRESSION
+                                      DOT_QUALIFIED_EXPRESSION
+                                        REFERENCE_EXPRESSION
                                           PsiElement(IDENTIFIER)('curNode')
-                                          PsiWhiteSpace(' ')
-                                          PsiElement(EQ)('=')
-                                          PsiWhiteSpace(' ')
-                                          DOT_QUALIFIED_EXPRESSION
-                                            REFERENCE_EXPRESSION
-                                              PsiElement(IDENTIFIER)('down')
-                                            PsiElement(DOT)('.')
-                                            CALL_EXPRESSION
+                                        PsiElement(DOT)('.')
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('left')
+                                      PsiWhiteSpace(' ')
+                                      OPERATION_REFERENCE
+                                        PsiElement(EXCLEQ)('!=')
+                                      PsiWhiteSpace(' ')
+                                      NULL
+                                        PsiElement(null)('null')
+                                  PsiElement(RPAR)(')')
+                                  PsiWhiteSpace(' ')
+                                  THEN
+                                    BLOCK
+                                      PsiElement(LBRACE)('{')
+                                      PsiWhiteSpace('\n            ')
+                                      DOT_QUALIFIED_EXPRESSION
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('up')
+                                        PsiElement(DOT)('.')
+                                        CALL_EXPRESSION
+                                          REFERENCE_EXPRESSION
+                                            PsiElement(IDENTIFIER)('push')
+                                          VALUE_ARGUMENT_LIST
+                                            PsiElement(LPAR)('(')
+                                            VALUE_ARGUMENT
                                               REFERENCE_EXPRESSION
-                                                PsiElement(IDENTIFIER)('pop')
-                                              VALUE_ARGUMENT_LIST
-                                                PsiElement(LPAR)('(')
-                                                PsiElement(RPAR)(')')
-                                        PsiWhiteSpace('\n          ')
-                                        IF
-                                          PsiElement(if)('if')
-                                          PsiWhiteSpace(' ')
-                                          PsiElement(LPAR)('(')
-                                          CONDITION
-                                            BINARY_EXPRESSION
+                                                PsiElement(IDENTIFIER)('curNode')
+                                            PsiElement(RPAR)(')')
+                                      PsiWhiteSpace('\n            ')
+                                      DOT_QUALIFIED_EXPRESSION
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('down')
+                                        PsiElement(DOT)('.')
+                                        CALL_EXPRESSION
+                                          REFERENCE_EXPRESSION
+                                            PsiElement(IDENTIFIER)('push')
+                                          VALUE_ARGUMENT_LIST
+                                            PsiElement(LPAR)('(')
+                                            VALUE_ARGUMENT
                                               DOT_QUALIFIED_EXPRESSION
                                                 REFERENCE_EXPRESSION
                                                   PsiElement(IDENTIFIER)('curNode')
                                                 PsiElement(DOT)('.')
                                                 REFERENCE_EXPRESSION
                                                   PsiElement(IDENTIFIER)('left')
-                                              PsiWhiteSpace(' ')
-                                              OPERATION_REFERENCE
-                                                PsiElement(EXCLEQ)('!=')
-                                              PsiWhiteSpace(' ')
-                                              NULL
-                                                PsiElement(null)('null')
-                                          PsiElement(RPAR)(')')
-                                          PsiWhiteSpace(' ')
-                                          THEN
-                                            FUNCTION_LITERAL_EXPRESSION
-                                              FUNCTION_LITERAL
-                                                PsiElement(LBRACE)('{')
-                                                PsiWhiteSpace('\n            ')
-                                                BLOCK
-                                                  DOT_QUALIFIED_EXPRESSION
-                                                    REFERENCE_EXPRESSION
-                                                      PsiElement(IDENTIFIER)('up')
-                                                    PsiElement(DOT)('.')
-                                                    CALL_EXPRESSION
-                                                      REFERENCE_EXPRESSION
-                                                        PsiElement(IDENTIFIER)('push')
-                                                      VALUE_ARGUMENT_LIST
-                                                        PsiElement(LPAR)('(')
-                                                        VALUE_ARGUMENT
-                                                          REFERENCE_EXPRESSION
-                                                            PsiElement(IDENTIFIER)('curNode')
-                                                        PsiElement(RPAR)(')')
-                                                  PsiWhiteSpace('\n            ')
-                                                  DOT_QUALIFIED_EXPRESSION
-                                                    REFERENCE_EXPRESSION
-                                                      PsiElement(IDENTIFIER)('down')
-                                                    PsiElement(DOT)('.')
-                                                    CALL_EXPRESSION
-                                                      REFERENCE_EXPRESSION
-                                                        PsiElement(IDENTIFIER)('push')
-                                                      VALUE_ARGUMENT_LIST
-                                                        PsiElement(LPAR)('(')
-                                                        VALUE_ARGUMENT
-                                                          DOT_QUALIFIED_EXPRESSION
-                                                            REFERENCE_EXPRESSION
-                                                              PsiElement(IDENTIFIER)('curNode')
-                                                            PsiElement(DOT)('.')
-                                                            REFERENCE_EXPRESSION
-                                                              PsiElement(IDENTIFIER)('left')
-                                                        PsiElement(RPAR)(')')
-                                                PsiWhiteSpace('\n          ')
-                                                PsiElement(RBRACE)('}')
-                                          PsiWhiteSpace(' ')
-                                          PsiElement(else)('else')
-                                          PsiWhiteSpace(' ')
-                                          ELSE
-                                            FUNCTION_LITERAL_EXPRESSION
-                                              FUNCTION_LITERAL
-                                                PsiElement(LBRACE)('{')
-                                                PsiWhiteSpace('\n            ')
-                                                BLOCK
-                                                  IF
-                                                    PsiElement(if)('if')
-                                                    PsiWhiteSpace(' ')
-                                                    PsiElement(LPAR)('(')
-                                                    CONDITION
-                                                      BINARY_EXPRESSION
-                                                        DOT_QUALIFIED_EXPRESSION
-                                                          REFERENCE_EXPRESSION
-                                                            PsiElement(IDENTIFIER)('curNode')
-                                                          PsiElement(DOT)('.')
-                                                          REFERENCE_EXPRESSION
-                                                            PsiElement(IDENTIFIER)('right')
-                                                        PsiWhiteSpace(' ')
-                                                        OPERATION_REFERENCE
-                                                          PsiElement(EXCLEQ)('!=')
-                                                        PsiWhiteSpace(' ')
-                                                        NULL
-                                                          PsiElement(null)('null')
-                                                    PsiElement(RPAR)(')')
-                                                    PsiWhiteSpace(' ')
-                                                    THEN
-                                                      FUNCTION_LITERAL_EXPRESSION
-                                                        FUNCTION_LITERAL
-                                                          PsiElement(LBRACE)('{')
-                                                          PsiWhiteSpace('\n              ')
-                                                          BLOCK
-                                                            DOT_QUALIFIED_EXPRESSION
-                                                              REFERENCE_EXPRESSION
-                                                                PsiElement(IDENTIFIER)('down')
-                                                              PsiElement(DOT)('.')
-                                                              CALL_EXPRESSION
-                                                                REFERENCE_EXPRESSION
-                                                                  PsiElement(IDENTIFIER)('push')
-                                                                VALUE_ARGUMENT_LIST
-                                                                  PsiElement(LPAR)('(')
-                                                                  VALUE_ARGUMENT
-                                                                    DOT_QUALIFIED_EXPRESSION
-                                                                      REFERENCE_EXPRESSION
-                                                                        PsiElement(IDENTIFIER)('curNode')
-                                                                      PsiElement(DOT)('.')
-                                                                      REFERENCE_EXPRESSION
-                                                                        PsiElement(IDENTIFIER)('right')
-                                                                  PsiElement(RPAR)(')')
-                                                          PsiWhiteSpace('\n            ')
-                                                          PsiElement(RBRACE)('}')
-                                                  PsiWhiteSpace('\n            ')
-                                                  RETURN
-                                                    PsiElement(return)('return')
-                                                    PsiWhiteSpace(' ')
-                                                    REFERENCE_EXPRESSION
-                                                      PsiElement(IDENTIFIER)('curNode')
-                                                  PsiElement(SEMICOLON)(';')
-                                                PsiWhiteSpace('\n          ')
-                                                PsiElement(RBRACE)('}')
-                                      PsiWhiteSpace('\n        ')
-                                      PsiElement(RBRACE)('}')
-                                PsiWhiteSpace(' ')
-                                PsiElement(else)('else')
-                                PsiWhiteSpace(' ')
-                                ELSE
-                                  FUNCTION_LITERAL_EXPRESSION
-                                    FUNCTION_LITERAL
-                                      PsiElement(LBRACE)('{')
+                                            PsiElement(RPAR)(')')
                                       PsiWhiteSpace('\n          ')
-                                      BLOCK
-                                        PROPERTY
-                                          PsiElement(val)('val')
-                                          PsiWhiteSpace(' ')
-                                          PsiElement(IDENTIFIER)('curNode')
-                                          PsiWhiteSpace(' ')
-                                          PsiElement(EQ)('=')
-                                          PsiWhiteSpace(' ')
-                                          DOT_QUALIFIED_EXPRESSION
-                                            REFERENCE_EXPRESSION
-                                              PsiElement(IDENTIFIER)('up')
-                                            PsiElement(DOT)('.')
-                                            CALL_EXPRESSION
+                                      PsiElement(RBRACE)('}')
+                                  PsiWhiteSpace(' ')
+                                  PsiElement(else)('else')
+                                  PsiWhiteSpace(' ')
+                                  ELSE
+                                    BLOCK
+                                      PsiElement(LBRACE)('{')
+                                      PsiWhiteSpace('\n            ')
+                                      IF
+                                        PsiElement(if)('if')
+                                        PsiWhiteSpace(' ')
+                                        PsiElement(LPAR)('(')
+                                        CONDITION
+                                          BINARY_EXPRESSION
+                                            DOT_QUALIFIED_EXPRESSION
                                               REFERENCE_EXPRESSION
-                                                PsiElement(IDENTIFIER)('pop')
-                                              VALUE_ARGUMENT_LIST
-                                                PsiElement(LPAR)('(')
-                                                PsiElement(RPAR)(')')
-                                        PsiWhiteSpace('\n          ')
-                                        IF
-                                          PsiElement(if)('if')
-                                          PsiWhiteSpace(' ')
-                                          PsiElement(LPAR)('(')
-                                          CONDITION
-                                            BINARY_EXPRESSION
+                                                PsiElement(IDENTIFIER)('curNode')
+                                              PsiElement(DOT)('.')
+                                              REFERENCE_EXPRESSION
+                                                PsiElement(IDENTIFIER)('right')
+                                            PsiWhiteSpace(' ')
+                                            OPERATION_REFERENCE
+                                              PsiElement(EXCLEQ)('!=')
+                                            PsiWhiteSpace(' ')
+                                            NULL
+                                              PsiElement(null)('null')
+                                        PsiElement(RPAR)(')')
+                                        PsiWhiteSpace(' ')
+                                        THEN
+                                          BLOCK
+                                            PsiElement(LBRACE)('{')
+                                            PsiWhiteSpace('\n              ')
+                                            DOT_QUALIFIED_EXPRESSION
+                                              REFERENCE_EXPRESSION
+                                                PsiElement(IDENTIFIER)('down')
+                                              PsiElement(DOT)('.')
+                                              CALL_EXPRESSION
+                                                REFERENCE_EXPRESSION
+                                                  PsiElement(IDENTIFIER)('push')
+                                                VALUE_ARGUMENT_LIST
+                                                  PsiElement(LPAR)('(')
+                                                  VALUE_ARGUMENT
+                                                    DOT_QUALIFIED_EXPRESSION
+                                                      REFERENCE_EXPRESSION
+                                                        PsiElement(IDENTIFIER)('curNode')
+                                                      PsiElement(DOT)('.')
+                                                      REFERENCE_EXPRESSION
+                                                        PsiElement(IDENTIFIER)('right')
+                                                  PsiElement(RPAR)(')')
+                                            PsiWhiteSpace('\n            ')
+                                            PsiElement(RBRACE)('}')
+                                      PsiWhiteSpace('\n            ')
+                                      RETURN
+                                        PsiElement(return)('return')
+                                        PsiWhiteSpace(' ')
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('curNode')
+                                      PsiElement(SEMICOLON)(';')
+                                      PsiWhiteSpace('\n          ')
+                                      PsiElement(RBRACE)('}')
+                                PsiWhiteSpace('\n        ')
+                                PsiElement(RBRACE)('}')
+                            PsiWhiteSpace(' ')
+                            PsiElement(else)('else')
+                            PsiWhiteSpace(' ')
+                            ELSE
+                              BLOCK
+                                PsiElement(LBRACE)('{')
+                                PsiWhiteSpace('\n          ')
+                                PROPERTY
+                                  PsiElement(val)('val')
+                                  PsiWhiteSpace(' ')
+                                  PsiElement(IDENTIFIER)('curNode')
+                                  PsiWhiteSpace(' ')
+                                  PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  DOT_QUALIFIED_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('up')
+                                    PsiElement(DOT)('.')
+                                    CALL_EXPRESSION
+                                      REFERENCE_EXPRESSION
+                                        PsiElement(IDENTIFIER)('pop')
+                                      VALUE_ARGUMENT_LIST
+                                        PsiElement(LPAR)('(')
+                                        PsiElement(RPAR)(')')
+                                PsiWhiteSpace('\n          ')
+                                IF
+                                  PsiElement(if)('if')
+                                  PsiWhiteSpace(' ')
+                                  PsiElement(LPAR)('(')
+                                  CONDITION
+                                    BINARY_EXPRESSION
+                                      DOT_QUALIFIED_EXPRESSION
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('curNode')
+                                        PsiElement(DOT)('.')
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('right')
+                                      PsiWhiteSpace(' ')
+                                      OPERATION_REFERENCE
+                                        PsiElement(EXCLEQ)('!=')
+                                      PsiWhiteSpace(' ')
+                                      NULL
+                                        PsiElement(null)('null')
+                                  PsiElement(RPAR)(')')
+                                  PsiWhiteSpace(' ')
+                                  THEN
+                                    BLOCK
+                                      PsiElement(LBRACE)('{')
+                                      PsiWhiteSpace('\n            ')
+                                      DOT_QUALIFIED_EXPRESSION
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('down')
+                                        PsiElement(DOT)('.')
+                                        CALL_EXPRESSION
+                                          REFERENCE_EXPRESSION
+                                            PsiElement(IDENTIFIER)('push')
+                                          VALUE_ARGUMENT_LIST
+                                            PsiElement(LPAR)('(')
+                                            VALUE_ARGUMENT
                                               DOT_QUALIFIED_EXPRESSION
                                                 REFERENCE_EXPRESSION
                                                   PsiElement(IDENTIFIER)('curNode')
                                                 PsiElement(DOT)('.')
                                                 REFERENCE_EXPRESSION
                                                   PsiElement(IDENTIFIER)('right')
-                                              PsiWhiteSpace(' ')
-                                              OPERATION_REFERENCE
-                                                PsiElement(EXCLEQ)('!=')
-                                              PsiWhiteSpace(' ')
-                                              NULL
-                                                PsiElement(null)('null')
-                                          PsiElement(RPAR)(')')
-                                          PsiWhiteSpace(' ')
-                                          THEN
-                                            FUNCTION_LITERAL_EXPRESSION
-                                              FUNCTION_LITERAL
-                                                PsiElement(LBRACE)('{')
-                                                PsiWhiteSpace('\n            ')
-                                                BLOCK
-                                                  DOT_QUALIFIED_EXPRESSION
-                                                    REFERENCE_EXPRESSION
-                                                      PsiElement(IDENTIFIER)('down')
-                                                    PsiElement(DOT)('.')
-                                                    CALL_EXPRESSION
-                                                      REFERENCE_EXPRESSION
-                                                        PsiElement(IDENTIFIER)('push')
-                                                      VALUE_ARGUMENT_LIST
-                                                        PsiElement(LPAR)('(')
-                                                        VALUE_ARGUMENT
-                                                          DOT_QUALIFIED_EXPRESSION
-                                                            REFERENCE_EXPRESSION
-                                                              PsiElement(IDENTIFIER)('curNode')
-                                                            PsiElement(DOT)('.')
-                                                            REFERENCE_EXPRESSION
-                                                              PsiElement(IDENTIFIER)('right')
-                                                        PsiElement(RPAR)(')')
-                                                PsiWhiteSpace('\n          ')
-                                                PsiElement(RBRACE)('}')
-                                        PsiWhiteSpace('\n          ')
-                                        RETURN
-                                          PsiElement(return)('return')
-                                          PsiWhiteSpace(' ')
-                                          REFERENCE_EXPRESSION
-                                            PsiElement(IDENTIFIER)('curNode')
-                                      PsiWhiteSpace('\n        ')
+                                            PsiElement(RPAR)(')')
+                                      PsiWhiteSpace('\n          ')
                                       PsiElement(RBRACE)('}')
-                            PsiWhiteSpace('\n      ')
-                            PsiElement(RBRACE)('}')
+                                PsiWhiteSpace('\n          ')
+                                RETURN
+                                  PsiElement(return)('return')
+                                  PsiWhiteSpace(' ')
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('curNode')
+                                PsiWhiteSpace('\n        ')
+                                PsiElement(RBRACE)('}')
+                          PsiWhiteSpace('\n      ')
+                          PsiElement(RBRACE)('}')
                     PsiWhiteSpace('\n    ')
                     PsiElement(RBRACE)('}')
                 PsiWhiteSpace('\n\n    ')
@@ -2565,22 +2533,20 @@ JetFile: BinaryTree.jet
                       PsiElement(RPAR)(')')
                       PsiWhiteSpace(' ')
                       THEN
-                        FUNCTION_LITERAL_EXPRESSION
-                          FUNCTION_LITERAL
-                            PsiElement(LBRACE)('{')
-                            PsiWhiteSpace('\n        ')
-                            BLOCK
-                              THROW
-                                PsiElement(throw)('throw')
-                                PsiWhiteSpace(' ')
-                                CALL_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('ConcurrentModificationException')
-                                  VALUE_ARGUMENT_LIST
-                                    PsiElement(LPAR)('(')
-                                    PsiElement(RPAR)(')')
-                            PsiWhiteSpace('\n      ')
-                            PsiElement(RBRACE)('}')
+                        BLOCK
+                          PsiElement(LBRACE)('{')
+                          PsiWhiteSpace('\n        ')
+                          THROW
+                            PsiElement(throw)('throw')
+                            PsiWhiteSpace(' ')
+                            CALL_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('ConcurrentModificationException')
+                              VALUE_ARGUMENT_LIST
+                                PsiElement(LPAR)('(')
+                                PsiElement(RPAR)(')')
+                          PsiWhiteSpace('\n      ')
+                          PsiElement(RBRACE)('}')
                     PsiWhiteSpace('                                              \n    ')
                     PsiElement(RBRACE)('}')
                 PsiWhiteSpace('\n  ')
diff --git a/idea/testData/psi/examples/BitArith.jet b/idea/testData/psi/examples/BitArith.jet
index 39c56be06c7..3bd6f14fa8a 100644
--- a/idea/testData/psi/examples/BitArith.jet
+++ b/idea/testData/psi/examples/BitArith.jet
@@ -21,7 +21,7 @@ fun countOnes(x : INumber) = if (x == 0) 0 else mostSignificantBit(x) + countOne
 
 fun Int.matchMask(mask : Int) = this and mask == mask
 
-virtual class INumber : IComparable<This> {
+open class INumber : IComparable<This> {
   val bits : Int
   [operator] fun plus(other : This) : This
   [operator] fun shl(bits : Int) : This
diff --git a/idea/testData/psi/examples/BitArith.txt b/idea/testData/psi/examples/BitArith.txt
index bb961a436f6..dba6f016498 100644
--- a/idea/testData/psi/examples/BitArith.txt
+++ b/idea/testData/psi/examples/BitArith.txt
@@ -288,46 +288,44 @@ JetFile: BitArith.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n    ')
-                BLOCK
-                  BINARY_EXPRESSION
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('result')
-                    PsiWhiteSpace(' ')
-                    OPERATION_REFERENCE
-                      PsiElement(PLUSEQ)('+=')
-                    PsiWhiteSpace(' ')
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(IDENTIFIER)('and')
-                      PsiWhiteSpace(' ')
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                  PsiWhiteSpace('\n    ')
-                  BINARY_EXPRESSION
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('x')
-                    PsiWhiteSpace(' ')
-                    OPERATION_REFERENCE
-                      PsiElement(EQ)('=')
-                    PsiWhiteSpace(' ')
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(IDENTIFIER)('ushr')
-                      PsiWhiteSpace(' ')
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                PsiWhiteSpace('\n  ')
-                PsiElement(RBRACE)('}')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n    ')
+              BINARY_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('result')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(PLUSEQ)('+=')
+                PsiWhiteSpace(' ')
+                BINARY_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('x')
+                  PsiWhiteSpace(' ')
+                  OPERATION_REFERENCE
+                    PsiElement(IDENTIFIER)('and')
+                  PsiWhiteSpace(' ')
+                  INTEGER_CONSTANT
+                    PsiElement(INTEGER_LITERAL)('1')
+              PsiWhiteSpace('\n    ')
+              BINARY_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('x')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(EQ)('=')
+                PsiWhiteSpace(' ')
+                BINARY_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('x')
+                  PsiWhiteSpace(' ')
+                  OPERATION_REFERENCE
+                    PsiElement(IDENTIFIER)('ushr')
+                  PsiWhiteSpace(' ')
+                  INTEGER_CONSTANT
+                    PsiElement(INTEGER_LITERAL)('1')
+              PsiWhiteSpace('\n  ')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n  ')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('result')
@@ -517,7 +515,7 @@ JetFile: BitArith.jet
     PsiWhiteSpace('\n\n')
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/Graph.txt b/idea/testData/psi/examples/Graph.txt
index b259175e054..a21315c0896 100644
--- a/idea/testData/psi/examples/Graph.txt
+++ b/idea/testData/psi/examples/Graph.txt
@@ -878,113 +878,109 @@ JetFile: Graph.jet
                         PsiElement(RPAR)(')')
                         PsiWhiteSpace(' ')
                         BODY
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
-                                PROPERTY
-                                  PsiElement(val)('val')
-                                  PsiWhiteSpace(' ')
-                                  PsiElement(IDENTIFIER)('current')
-                                  PsiWhiteSpace(' ')
-                                  PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  DOT_QUALIFIED_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('pending')
-                                    PsiElement(DOT)('.')
-                                    CALL_EXPRESSION
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('pop')
-                                      VALUE_ARGUMENT_LIST
-                                        PsiElement(LPAR)('(')
-                                        PsiElement(RPAR)(')')
-                                PsiWhiteSpace('\n        ')
+                          BLOCK
+                            PsiElement(LBRACE)('{')
+                            PsiWhiteSpace('\n        ')
+                            PROPERTY
+                              PsiElement(val)('val')
+                              PsiWhiteSpace(' ')
+                              PsiElement(IDENTIFIER)('current')
+                              PsiWhiteSpace(' ')
+                              PsiElement(EQ)('=')
+                              PsiWhiteSpace(' ')
+                              DOT_QUALIFIED_EXPRESSION
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('pending')
+                                PsiElement(DOT)('.')
                                 CALL_EXPRESSION
                                   REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('handler')
+                                    PsiElement(IDENTIFIER)('pop')
                                   VALUE_ARGUMENT_LIST
                                     PsiElement(LPAR)('(')
-                                    VALUE_ARGUMENT
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('current')
                                     PsiElement(RPAR)(')')
-                                PsiElement(SEMICOLON)(';')
-                                PsiWhiteSpace('\n        ')
-                                DOT_QUALIFIED_EXPRESSION
-                                  CALL_EXPRESSION
+                            PsiWhiteSpace('\n        ')
+                            CALL_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('handler')
+                              VALUE_ARGUMENT_LIST
+                                PsiElement(LPAR)('(')
+                                VALUE_ARGUMENT
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('current')
+                                PsiElement(RPAR)(')')
+                            PsiElement(SEMICOLON)(';')
+                            PsiWhiteSpace('\n        ')
+                            DOT_QUALIFIED_EXPRESSION
+                              CALL_EXPRESSION
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('neighbours')
+                                VALUE_ARGUMENT_LIST
+                                  PsiElement(LPAR)('(')
+                                  VALUE_ARGUMENT
                                     REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('neighbours')
-                                    VALUE_ARGUMENT_LIST
-                                      PsiElement(LPAR)('(')
-                                      VALUE_ARGUMENT
-                                        REFERENCE_EXPRESSION
-                                          PsiElement(IDENTIFIER)('current')
-                                      PsiElement(RPAR)(')')
-                                  PsiElement(DOT)('.')
-                                  CALL_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('foreach')
+                                      PsiElement(IDENTIFIER)('current')
+                                  PsiElement(RPAR)(')')
+                              PsiElement(DOT)('.')
+                              CALL_EXPRESSION
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('foreach')
+                                PsiWhiteSpace(' ')
+                                FUNCTION_LITERAL_EXPRESSION
+                                  FUNCTION_LITERAL
+                                    PsiElement(LBRACE)('{')
                                     PsiWhiteSpace(' ')
-                                    FUNCTION_LITERAL_EXPRESSION
-                                      FUNCTION_LITERAL
-                                        PsiElement(LBRACE)('{')
+                                    VALUE_PARAMETER_LIST
+                                      VALUE_PARAMETER
+                                        PsiElement(IDENTIFIER)('n')
+                                    PsiWhiteSpace(' ')
+                                    PsiElement(DOUBLE_ARROW)('=>')
+                                    PsiWhiteSpace('\n          ')
+                                    BLOCK
+                                      IF
+                                        PsiElement(if)('if')
                                         PsiWhiteSpace(' ')
-                                        VALUE_PARAMETER_LIST
-                                          VALUE_PARAMETER
-                                            PsiElement(IDENTIFIER)('n')
-                                        PsiWhiteSpace(' ')
-                                        PsiElement(DOUBLE_ARROW)('=>')
-                                        PsiWhiteSpace('\n          ')
-                                        BLOCK
-                                          IF
-                                            PsiElement(if)('if')
-                                            PsiWhiteSpace(' ')
-                                            PsiElement(LPAR)('(')
-                                            CONDITION
-                                              DOT_QUALIFIED_EXPRESSION
-                                                REFERENCE_EXPRESSION
-                                                  PsiElement(IDENTIFIER)('visited')
-                                                PsiElement(DOT)('.')
-                                                CALL_EXPRESSION
+                                        PsiElement(LPAR)('(')
+                                        CONDITION
+                                          DOT_QUALIFIED_EXPRESSION
+                                            REFERENCE_EXPRESSION
+                                              PsiElement(IDENTIFIER)('visited')
+                                            PsiElement(DOT)('.')
+                                            CALL_EXPRESSION
+                                              REFERENCE_EXPRESSION
+                                                PsiElement(IDENTIFIER)('add')
+                                              VALUE_ARGUMENT_LIST
+                                                PsiElement(LPAR)('(')
+                                                VALUE_ARGUMENT
                                                   REFERENCE_EXPRESSION
-                                                    PsiElement(IDENTIFIER)('add')
-                                                  VALUE_ARGUMENT_LIST
-                                                    PsiElement(LPAR)('(')
-                                                    VALUE_ARGUMENT
-                                                      REFERENCE_EXPRESSION
-                                                        PsiElement(IDENTIFIER)('n')
-                                                    PsiElement(RPAR)(')')
-                                            PsiElement(RPAR)(')')
-                                            PsiWhiteSpace(' ')
-                                            THEN
-                                              FUNCTION_LITERAL_EXPRESSION
-                                                FUNCTION_LITERAL
-                                                  PsiElement(LBRACE)('{')
-                                                  PsiWhiteSpace('\n            ')
-                                                  BLOCK
-                                                    DOT_QUALIFIED_EXPRESSION
-                                                      REFERENCE_EXPRESSION
-                                                        PsiElement(IDENTIFIER)('pending')
-                                                      PsiElement(DOT)('.')
-                                                      CALL_EXPRESSION
-                                                        REFERENCE_EXPRESSION
-                                                          PsiElement(IDENTIFIER)('push')
-                                                        VALUE_ARGUMENT_LIST
-                                                          PsiElement(LPAR)('(')
-                                                          VALUE_ARGUMENT
-                                                            REFERENCE_EXPRESSION
-                                                              PsiElement(IDENTIFIER)('n')
-                                                          PsiElement(RPAR)(')')
-                                                  PsiWhiteSpace('\n          ')
-                                                  PsiElement(RBRACE)('}')
-                                        PsiWhiteSpace('\n        ')
-                                        PsiElement(RBRACE)('}')
-                              PsiWhiteSpace('\n    ')
-                              PsiComment(BLOCK_COMMENT)('/* alternative\n        pending->push(neighbours(current).filter{n => !visited[n])})\n        // -> means that if push(x : T) and actual parameter y is IIterable<T>, this compiles into\n          y.foreach{ n => push(n) }\n     */')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
+                                                    PsiElement(IDENTIFIER)('n')
+                                                PsiElement(RPAR)(')')
+                                        PsiElement(RPAR)(')')
+                                        PsiWhiteSpace(' ')
+                                        THEN
+                                          BLOCK
+                                            PsiElement(LBRACE)('{')
+                                            PsiWhiteSpace('\n            ')
+                                            DOT_QUALIFIED_EXPRESSION
+                                              REFERENCE_EXPRESSION
+                                                PsiElement(IDENTIFIER)('pending')
+                                              PsiElement(DOT)('.')
+                                              CALL_EXPRESSION
+                                                REFERENCE_EXPRESSION
+                                                  PsiElement(IDENTIFIER)('push')
+                                                VALUE_ARGUMENT_LIST
+                                                  PsiElement(LPAR)('(')
+                                                  VALUE_ARGUMENT
+                                                    REFERENCE_EXPRESSION
+                                                      PsiElement(IDENTIFIER)('n')
+                                                  PsiElement(RPAR)(')')
+                                            PsiWhiteSpace('\n          ')
+                                            PsiElement(RBRACE)('}')
+                                    PsiWhiteSpace('\n        ')
+                                    PsiElement(RBRACE)('}')
+                            PsiWhiteSpace('\n    ')
+                            PsiComment(BLOCK_COMMENT)('/* alternative\n        pending->push(neighbours(current).filter{n => !visited[n])})\n        // -> means that if push(x : T) and actual parameter y is IIterable<T>, this compiles into\n          y.foreach{ n => push(n) }\n     */')
+                            PsiWhiteSpace('\n      ')
+                            PsiElement(RBRACE)('}')
                     PsiWhiteSpace('\n    ')
                     PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
diff --git a/idea/testData/psi/examples/IPushPop.jet b/idea/testData/psi/examples/IPushPop.jet
index 09b1f2d8267..84725423fdc 100644
--- a/idea/testData/psi/examples/IPushPop.jet
+++ b/idea/testData/psi/examples/IPushPop.jet
@@ -1,4 +1,4 @@
-virtual class IPushPop<T> {
+open class IPushPop<T> {
   val isEmpty : Boolean
   fun push(item : T)
   fun pop() : T
diff --git a/idea/testData/psi/examples/IPushPop.txt b/idea/testData/psi/examples/IPushPop.txt
index 8aba5674908..ba028b8aa59 100644
--- a/idea/testData/psi/examples/IPushPop.txt
+++ b/idea/testData/psi/examples/IPushPop.txt
@@ -2,7 +2,7 @@ JetFile: IPushPop.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/PolymorphicClassObjects.jet b/idea/testData/psi/examples/PolymorphicClassObjects.jet
index b296741e0db..fefa5d52ea4 100644
--- a/idea/testData/psi/examples/PolymorphicClassObjects.jet
+++ b/idea/testData/psi/examples/PolymorphicClassObjects.jet
@@ -1,9 +1,9 @@
-virtual class Builder<E, R> {
+open class Builder<E, R> {
   [operator] fun plusAssign(item : E)
   fun result() : R
 }
 
-virtual class Buildable {
+open class Buildable {
   fun newBuilder<E, R>() : Builder<E, R>
 }
 
diff --git a/idea/testData/psi/examples/PolymorphicClassObjects.txt b/idea/testData/psi/examples/PolymorphicClassObjects.txt
index dcc30974cee..0ecb4dce0fe 100644
--- a/idea/testData/psi/examples/PolymorphicClassObjects.txt
+++ b/idea/testData/psi/examples/PolymorphicClassObjects.txt
@@ -2,7 +2,7 @@ JetFile: PolymorphicClassObjects.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
@@ -67,7 +67,7 @@ JetFile: PolymorphicClassObjects.jet
     PsiWhiteSpace('\n\n')
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
@@ -371,29 +371,27 @@ JetFile: PolymorphicClassObjects.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n    ')
-                    BLOCK
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('builder')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(PLUSEQ)('+=')
-                        PsiWhiteSpace(' ')
-                        CALL_EXPRESSION
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n    ')
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('builder')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(PLUSEQ)('+=')
+                    PsiWhiteSpace(' ')
+                    CALL_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('f')
+                      VALUE_ARGUMENT_LIST
+                        PsiElement(LPAR)('(')
+                        VALUE_ARGUMENT
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('f')
-                          VALUE_ARGUMENT_LIST
-                            PsiElement(LPAR)('(')
-                            VALUE_ARGUMENT
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('e')
-                            PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n  ')
-                    PsiElement(RBRACE)('}')
+                            PsiElement(IDENTIFIER)('e')
+                        PsiElement(RPAR)(')')
+                  PsiWhiteSpace('\n  ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             DOT_QUALIFIED_EXPRESSION
               REFERENCE_EXPRESSION
diff --git a/idea/testData/psi/examples/Queue.txt b/idea/testData/psi/examples/Queue.txt
index d1d91f81253..335c7217d56 100644
--- a/idea/testData/psi/examples/Queue.txt
+++ b/idea/testData/psi/examples/Queue.txt
@@ -191,66 +191,62 @@ JetFile: Queue.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('head')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('i')
-                      PsiWhiteSpace('\n      ')
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('tail')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('head')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('head')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('i')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('tail')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('head')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
               PsiWhiteSpace(' ')
               PsiElement(else)('else')
               PsiWhiteSpace(' ')
               ELSE
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      BINARY_EXPRESSION
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('tail')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('i')
-                      PsiWhiteSpace('\n      ')
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('tail')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('i')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('tail')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('i')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('tail')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('i')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -297,70 +293,68 @@ JetFile: Queue.jet
             PsiElement(else)('else')
             PsiWhiteSpace(' ')
             ELSE
-              FUNCTION_LITERAL_EXPRESSION
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BLOCK
-                    PROPERTY
-                      PsiElement(val)('val')
-                      PsiWhiteSpace(' ')
-                      PsiElement(IDENTIFIER)('result')
-                      PsiWhiteSpace(' ')
-                      PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      DOT_QUALIFIED_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('head')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('data')
-                    PsiWhiteSpace('\n      ')
+              BLOCK
+                PsiElement(LBRACE)('{')
+                PsiWhiteSpace('\n      ')
+                PROPERTY
+                  PsiElement(val)('val')
+                  PsiWhiteSpace(' ')
+                  PsiElement(IDENTIFIER)('result')
+                  PsiWhiteSpace(' ')
+                  PsiElement(EQ)('=')
+                  PsiWhiteSpace(' ')
+                  DOT_QUALIFIED_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('head')
+                    PsiElement(DOT)('.')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('data')
+                PsiWhiteSpace('\n      ')
+                BINARY_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('head')
+                  PsiWhiteSpace(' ')
+                  OPERATION_REFERENCE
+                    PsiElement(EQ)('=')
+                  PsiWhiteSpace(' ')
+                  DOT_QUALIFIED_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('head')
+                    PsiElement(DOT)('.')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('next')
+                PsiWhiteSpace('\n      ')
+                IF
+                  PsiElement(if)('if')
+                  PsiWhiteSpace(' ')
+                  PsiElement(LPAR)('(')
+                  CONDITION
                     BINARY_EXPRESSION
                       REFERENCE_EXPRESSION
                         PsiElement(IDENTIFIER)('head')
                       PsiWhiteSpace(' ')
+                      OPERATION_REFERENCE
+                        PsiElement(EQEQ)('==')
+                      PsiWhiteSpace(' ')
+                      NULL
+                        PsiElement(null)('null')
+                  PsiElement(RPAR)(')')
+                  PsiWhiteSpace('\n        ')
+                  THEN
+                    BINARY_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('tail')
+                      PsiWhiteSpace(' ')
                       OPERATION_REFERENCE
                         PsiElement(EQ)('=')
                       PsiWhiteSpace(' ')
-                      DOT_QUALIFIED_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('head')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                    PsiWhiteSpace('\n      ')
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        BINARY_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('head')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQEQ)('==')
-                          PsiWhiteSpace(' ')
-                          NULL
-                            PsiElement(null)('null')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace('\n        ')
-                      THEN
-                        BINARY_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('tail')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQ)('=')
-                          PsiWhiteSpace(' ')
-                          NULL
-                            PsiElement(null)('null')
-                    PsiWhiteSpace('\n      ')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('result')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                      NULL
+                        PsiElement(null)('null')
+                PsiWhiteSpace('\n      ')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('result')
+                PsiWhiteSpace('\n    ')
+                PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         PROPERTY
           MODIFIER_LIST
diff --git a/idea/testData/psi/examples/UnionFind.txt b/idea/testData/psi/examples/UnionFind.txt
index 1e92c93b621..a349879dc7d 100644
--- a/idea/testData/psi/examples/UnionFind.txt
+++ b/idea/testData/psi/examples/UnionFind.txt
@@ -150,19 +150,17 @@ JetFile: UnionFind.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      RETURN
-                        PsiElement(return)('return')
-                        PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('x')
-                      PsiElement(SEMICOLON)(';')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  RETURN
+                    PsiElement(return)('return')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('x')
+                  PsiElement(SEMICOLON)(';')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             PROPERTY
               PsiElement(val)('val')
@@ -283,83 +281,77 @@ JetFile: UnionFind.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      IF
-                        PsiElement(if)('if')
-                        PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          DOT_QUALIFIED_EXPRESSION
-                            DOT_QUALIFIED_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('Random')
-                              PsiElement(DOT)('.')
-                              CALL_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('nextInt')
-                                VALUE_ARGUMENT_LIST
-                                  PsiElement(LPAR)('(')
-                                  PsiElement(RPAR)(')')
-                            PsiElement(DOT)('.')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
+                      DOT_QUALIFIED_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('Random')
+                          PsiElement(DOT)('.')
+                          CALL_EXPRESSION
                             REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('isOdd')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace(' ')
-                        THEN
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
-                                BINARY_EXPRESSION
-                                  ARRAY_ACCESS_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('data')
-                                    INDICES
-                                      PsiElement(LBRACKET)('[')
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('pb')
-                                      PsiElement(RBRACKET)(']')
-                                  PsiWhiteSpace(' ')
-                                  OPERATION_REFERENCE
-                                    PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('pa')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
-                        PsiWhiteSpace(' ')
-                        PsiElement(else)('else')
-                        PsiWhiteSpace(' ')
-                        ELSE
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
-                                BINARY_EXPRESSION
-                                  ARRAY_ACCESS_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('data')
-                                    INDICES
-                                      PsiElement(LBRACKET)('[')
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('pa')
-                                      PsiElement(RBRACKET)(']')
-                                  PsiWhiteSpace(' ')
-                                  OPERATION_REFERENCE
-                                    PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('pb')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                              PsiElement(IDENTIFIER)('nextInt')
+                            VALUE_ARGUMENT_LIST
+                              PsiElement(LPAR)('(')
+                              PsiElement(RPAR)(')')
+                        PsiElement(DOT)('.')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('isOdd')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    THEN
+                      BLOCK
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          ARRAY_ACCESS_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('data')
+                            INDICES
+                              PsiElement(LBRACKET)('[')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('pb')
+                              PsiElement(RBRACKET)(']')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('pa')
+                        PsiWhiteSpace('\n      ')
+                        PsiElement(RBRACE)('}')
+                    PsiWhiteSpace(' ')
+                    PsiElement(else)('else')
+                    PsiWhiteSpace(' ')
+                    ELSE
+                      BLOCK
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          ARRAY_ACCESS_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('data')
+                            INDICES
+                              PsiElement(LBRACKET)('[')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('pa')
+                              PsiElement(RBRACKET)(']')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('pb')
+                        PsiWhiteSpace('\n      ')
+                        PsiElement(RBRACE)('}')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n')
diff --git a/idea/testData/psi/examples/UpdateOperation.txt b/idea/testData/psi/examples/UpdateOperation.txt
index 77631d3f417..c624c2a4f1c 100644
--- a/idea/testData/psi/examples/UpdateOperation.txt
+++ b/idea/testData/psi/examples/UpdateOperation.txt
@@ -166,7 +166,9 @@ JetFile: UpdateOperation.jet
             PsiElement(COMMA)(',')
             PsiWhiteSpace(' ')
             VALUE_ARGUMENT
-              PsiElement(IDENTIFIER)('x')
+              VALUE_ARGUMENT_NAME
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('x')
               PsiWhiteSpace(' ')
               PsiElement(EQ)('=')
               PsiWhiteSpace(' ')
@@ -196,7 +198,9 @@ JetFile: UpdateOperation.jet
             PsiElement(COMMA)(',')
             PsiWhiteSpace(' ')
             VALUE_ARGUMENT
-              PsiElement(IDENTIFIER)('y')
+              VALUE_ARGUMENT_NAME
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('y')
               PsiWhiteSpace(' ')
               PsiElement(EQ)('=')
               PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/array/MutableArray.jet b/idea/testData/psi/examples/array/MutableArray.jet
index 311279c875c..cb270fa33a8 100644
--- a/idea/testData/psi/examples/array/MutableArray.jet
+++ b/idea/testData/psi/examples/array/MutableArray.jet
@@ -2,11 +2,11 @@
   These declarations are "shallow" in the sense that they are not really compiled, only the type-checker uses them
 */
 
-virtual class ReadOnlyArray<out T> : ISized {
+open class ReadOnlyArray<out T> : ISized {
   [operator] fun get(index : Int) : T
 }
 
-virtual class WriteOnlyArray<in T> : ISized { // This is needed to keep IIterator's <T> covariant
+open class WriteOnlyArray<in T> : ISized { // This is needed to keep IIterator's <T> covariant
   [operator] fun set(index : Int, value : T)
 }
 
diff --git a/idea/testData/psi/examples/array/MutableArray.txt b/idea/testData/psi/examples/array/MutableArray.txt
index 9d0f964dcfa..daa31179dbd 100644
--- a/idea/testData/psi/examples/array/MutableArray.txt
+++ b/idea/testData/psi/examples/array/MutableArray.txt
@@ -4,7 +4,7 @@ JetFile: MutableArray.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
@@ -69,7 +69,7 @@ JetFile: MutableArray.jet
     PsiWhiteSpace('\n\n')
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/ArrayList.txt b/idea/testData/psi/examples/collections/ArrayList.txt
index 769d27e1aa4..4ca13335330 100644
--- a/idea/testData/psi/examples/collections/ArrayList.txt
+++ b/idea/testData/psi/examples/collections/ArrayList.txt
@@ -672,31 +672,29 @@ JetFile: ArrayList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      BINARY_EXPRESSION
-                        ARRAY_ACCESS_EXPRESSION
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    ARRAY_ACCESS_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('data')
+                      INDICES
+                        PsiElement(LBRACKET)('[')
+                        POSTFIX_EXPRESSION
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('data')
-                          INDICES
-                            PsiElement(LBRACKET)('[')
-                            POSTFIX_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('used')
-                              OPERATION_REFERENCE
-                                PsiElement(PLUSPLUS)('++')
-                            PsiElement(RBRACKET)(']')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('value')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                            PsiElement(IDENTIFIER)('used')
+                          OPERATION_REFERENCE
+                            PsiElement(PLUSPLUS)('++')
+                        PsiElement(RBRACKET)(']')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('value')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
               PsiWhiteSpace(' ')
               PsiElement(else)('else')
               PsiWhiteSpace(' ')
@@ -718,90 +716,88 @@ JetFile: ArrayList.jet
                   PsiElement(RPAR)(')')
                   PsiWhiteSpace(' ')
                   THEN
-                    FUNCTION_LITERAL_EXPRESSION
-                      FUNCTION_LITERAL
-                        PsiElement(LBRACE)('{')
-                        PsiWhiteSpace('\n      ')
-                        BLOCK
-                          FOR
-                            PsiElement(for)('for')
-                            PsiWhiteSpace(' ')
-                            PsiElement(LPAR)('(')
-                            LOOP_PARAMETER
-                              PsiElement(IDENTIFIER)('i')
-                            PsiWhiteSpace(' ')
-                            PsiElement(in)('in')
-                            PsiWhiteSpace(' ')
-                            LOOP_RANGE
-                              BINARY_EXPRESSION
-                                BINARY_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('used')
-                                  OPERATION_REFERENCE
-                                    PsiElement(MINUS)('-')
-                                  INTEGER_CONSTANT
-                                    PsiElement(INTEGER_LITERAL)('1')
-                                OPERATION_REFERENCE
-                                  PsiElement(RANGE)('..')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('index')
-                            PsiElement(RPAR)(')')
-                            PsiWhiteSpace(' ')
-                            PsiComment(EOL_COMMENT)('// backwards, special operator...  Need to optimize this to be a real indexed loop')
-                            PsiWhiteSpace('\n        ')
-                            BODY
-                              BINARY_EXPRESSION
-                                ARRAY_ACCESS_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('data')
-                                  INDICES
-                                    PsiElement(LBRACKET)('[')
-                                    BINARY_EXPRESSION
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('i')
-                                      PsiWhiteSpace(' ')
-                                      OPERATION_REFERENCE
-                                        PsiElement(PLUS)('+')
-                                      PsiWhiteSpace(' ')
-                                      INTEGER_CONSTANT
-                                        PsiElement(INTEGER_LITERAL)('1')
-                                    PsiElement(RBRACKET)(']')
-                                PsiWhiteSpace(' ')
-                                OPERATION_REFERENCE
-                                  PsiElement(EQ)('=')
-                                PsiWhiteSpace(' ')
-                                ARRAY_ACCESS_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('data')
-                                  INDICES
-                                    PsiElement(LBRACKET)('[')
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('i')
-                                    PsiElement(RBRACKET)(']')
-                          PsiWhiteSpace('\n      ')
+                    BLOCK
+                      PsiElement(LBRACE)('{')
+                      PsiWhiteSpace('\n      ')
+                      FOR
+                        PsiElement(for)('for')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        LOOP_PARAMETER
+                          PsiElement(IDENTIFIER)('i')
+                        PsiWhiteSpace(' ')
+                        PsiElement(in)('in')
+                        PsiWhiteSpace(' ')
+                        LOOP_RANGE
+                          BINARY_EXPRESSION
+                            BINARY_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('used')
+                              OPERATION_REFERENCE
+                                PsiElement(MINUS)('-')
+                              INTEGER_CONSTANT
+                                PsiElement(INTEGER_LITERAL)('1')
+                            OPERATION_REFERENCE
+                              PsiElement(RANGE)('..')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('index')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        PsiComment(EOL_COMMENT)('// backwards, special operator...  Need to optimize this to be a real indexed loop')
+                        PsiWhiteSpace('\n        ')
+                        BODY
                           BINARY_EXPRESSION
                             ARRAY_ACCESS_EXPRESSION
                               REFERENCE_EXPRESSION
                                 PsiElement(IDENTIFIER)('data')
                               INDICES
                                 PsiElement(LBRACKET)('[')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('index')
+                                BINARY_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('i')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(PLUS)('+')
+                                  PsiWhiteSpace(' ')
+                                  INTEGER_CONSTANT
+                                    PsiElement(INTEGER_LITERAL)('1')
                                 PsiElement(RBRACKET)(']')
                             PsiWhiteSpace(' ')
                             OPERATION_REFERENCE
                               PsiElement(EQ)('=')
                             PsiWhiteSpace(' ')
+                            ARRAY_ACCESS_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('data')
+                              INDICES
+                                PsiElement(LBRACKET)('[')
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('i')
+                                PsiElement(RBRACKET)(']')
+                      PsiWhiteSpace('\n      ')
+                      BINARY_EXPRESSION
+                        ARRAY_ACCESS_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('data')
+                          INDICES
+                            PsiElement(LBRACKET)('[')
                             REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('value')
-                          PsiWhiteSpace('\n      ')
-                          POSTFIX_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('used')
-                            OPERATION_REFERENCE
-                              PsiElement(PLUSPLUS)('++')
-                        PsiWhiteSpace('\n    ')
-                        PsiElement(RBRACE)('}')
+                              PsiElement(IDENTIFIER)('index')
+                            PsiElement(RBRACKET)(']')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('value')
+                      PsiWhiteSpace('\n      ')
+                      POSTFIX_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('used')
+                        OPERATION_REFERENCE
+                          PsiElement(PLUSPLUS)('++')
+                      PsiWhiteSpace('\n    ')
+                      PsiElement(RBRACE)('}')
                   PsiWhiteSpace(' ')
                   PsiElement(else)('else')
                   PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/HashMap.jet b/idea/testData/psi/examples/collections/HashMap.jet
index 03b4bfc1563..6243ee41618 100644
--- a/idea/testData/psi/examples/collections/HashMap.jet
+++ b/idea/testData/psi/examples/collections/HashMap.jet
@@ -1,27 +1,27 @@
-virtual class IEquality {
+open class IEquality {
   fun equals(other : Any) : Boolean
     = (this as java.lang.Object).equals(other as java.lang.Object)
 }
 
-virtual class IHashable : IEquality {
+open class IHashable : IEquality {
   val hashCode : Integer
     get() = (this as java.lang.Object).hashCode()
 
 }
 
-virtual class IMap<K, V> {
+open class IMap<K, V> {
   fun get(key : K) : V
   fun set(key : K, value : V) : V
   fun remove(key : K) : V
   fun containsKey(key : K) : Boolean
 }
 
-class HashableWrapper wraps (val obj : Any) : IHashable
+class HashableWrapper(val obj : Any) : IHashable
   // equals and hashCode implementations are inherited
 
 [inline] fun Any.hashable() : HashableWrapper = HashableWrapper(this)
 
-virtual class IHashingStrategy<K> {
+open class IHashingStrategy<K> {
   fun equals(a : K, b : K) : Boolean
   fun hashCode(a : K) : Integer
 }
diff --git a/idea/testData/psi/examples/collections/HashMap.txt b/idea/testData/psi/examples/collections/HashMap.txt
index fa4d6ace61f..4b00e65faa7 100644
--- a/idea/testData/psi/examples/collections/HashMap.txt
+++ b/idea/testData/psi/examples/collections/HashMap.txt
@@ -2,7 +2,7 @@ JetFile: HashMap.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
@@ -95,7 +95,7 @@ JetFile: HashMap.jet
     PsiWhiteSpace('\n\n')
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
@@ -170,7 +170,7 @@ JetFile: HashMap.jet
     PsiWhiteSpace('\n\n')
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
@@ -301,11 +301,8 @@ JetFile: HashMap.jet
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('HashableWrapper')
-      PsiWhiteSpace(' ')
       TYPE_PARAMETER_LIST
         <empty list>
-      PsiElement(wraps)('wraps')
-      PsiWhiteSpace(' ')
       VALUE_PARAMETER_LIST
         PsiElement(LPAR)('(')
         VALUE_PARAMETER
@@ -378,7 +375,7 @@ JetFile: HashMap.jet
     PsiWhiteSpace('\n\n')
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/IIterable.jet b/idea/testData/psi/examples/collections/IIterable.jet
index 5e69296338c..c9a55af4058 100644
--- a/idea/testData/psi/examples/collections/IIterable.jet
+++ b/idea/testData/psi/examples/collections/IIterable.jet
@@ -1,3 +1,3 @@
-virtual class IIterable<out T> {
+open class IIterable<out T> {
   fun iterator() : IIterator<T>
 }
diff --git a/idea/testData/psi/examples/collections/IIterable.txt b/idea/testData/psi/examples/collections/IIterable.txt
index fba44fb97b1..8b426629e5a 100644
--- a/idea/testData/psi/examples/collections/IIterable.txt
+++ b/idea/testData/psi/examples/collections/IIterable.txt
@@ -2,7 +2,7 @@ JetFile: IIterable.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/IIterator.jet b/idea/testData/psi/examples/collections/IIterator.jet
index faeb4d40a5c..1739eae7a01 100644
--- a/idea/testData/psi/examples/collections/IIterator.jet
+++ b/idea/testData/psi/examples/collections/IIterator.jet
@@ -1,4 +1,4 @@
-virtual class IIterator<out T> {
+open class IIterator<out T> {
   fun next() : T
   val hasNext : Boolean
 
diff --git a/idea/testData/psi/examples/collections/IIterator.txt b/idea/testData/psi/examples/collections/IIterator.txt
index 113721a69eb..a11d81c631e 100644
--- a/idea/testData/psi/examples/collections/IIterator.txt
+++ b/idea/testData/psi/examples/collections/IIterator.txt
@@ -2,7 +2,7 @@ JetFile: IIterator.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
@@ -251,23 +251,21 @@ JetFile: IIterator.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      THROW
-                        PsiElement(throw)('throw')
-                        PsiWhiteSpace(' ')
-                        CALL_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('IndexOutOfBoundsException')
-                          VALUE_ARGUMENT_LIST
-                            PsiElement(LPAR)('(')
-                            PsiElement(RPAR)(')')
-                      PsiElement(SEMICOLON)(';')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  THROW
+                    PsiElement(throw)('throw')
+                    PsiWhiteSpace(' ')
+                    CALL_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('IndexOutOfBoundsException')
+                      VALUE_ARGUMENT_LIST
+                        PsiElement(LPAR)('(')
+                        PsiElement(RPAR)(')')
+                  PsiElement(SEMICOLON)(';')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n    ')
             IF
               PsiElement(if)('if')
@@ -339,57 +337,55 @@ JetFile: IIterator.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      IF
-                        PsiElement(if)('if')
-                        PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          PREFIX_EXPRESSION
-                            OPERATION_REFERENCE
-                              PsiElement(EXCL)('!')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('hasNext')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace('\n        ')
-                        THEN
-                          RETURN
-                            PsiElement(return)('return')
-                            PsiWhiteSpace(' ')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('count')
-                      PsiWhiteSpace('\n      ')
-                      BINARY_EXPRESSION
-                        ARRAY_ACCESS_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('buffer')
-                          INDICES
-                            PsiElement(LBRACKET)('[')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('i')
-                            PsiElement(RBRACKET)(']')
-                        PsiWhiteSpace(' ')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
+                      PREFIX_EXPRESSION
                         OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
+                          PsiElement(EXCL)('!')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('hasNext')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace('\n        ')
+                    THEN
+                      RETURN
+                        PsiElement(return)('return')
                         PsiWhiteSpace(' ')
-                        CALL_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                          VALUE_ARGUMENT_LIST
-                            PsiElement(LPAR)('(')
-                            PsiElement(RPAR)(')')
-                      PsiWhiteSpace('\n      ')
-                      POSTFIX_EXPRESSION
                         REFERENCE_EXPRESSION
                           PsiElement(IDENTIFIER)('count')
-                        OPERATION_REFERENCE
-                          PsiElement(PLUSPLUS)('++')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    ARRAY_ACCESS_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('buffer')
+                      INDICES
+                        PsiElement(LBRACKET)('[')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('i')
+                        PsiElement(RBRACKET)(']')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    CALL_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                      VALUE_ARGUMENT_LIST
+                        PsiElement(LPAR)('(')
+                        PsiElement(RPAR)(')')
+                  PsiWhiteSpace('\n      ')
+                  POSTFIX_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('count')
+                    OPERATION_REFERENCE
+                      PsiElement(PLUSPLUS)('++')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             RETURN
               PsiElement(return)('return')
diff --git a/idea/testData/psi/examples/collections/IList.jet b/idea/testData/psi/examples/collections/IList.jet
index 6daa67bac0f..69fff05ca87 100644
--- a/idea/testData/psi/examples/collections/IList.jet
+++ b/idea/testData/psi/examples/collections/IList.jet
@@ -1,4 +1,4 @@
-virtual class IList<out T> : IIterable<T>, ISized {
+open class IList<out T> : IIterable<T>, ISized {
   [operator] fun get(index : Int) : T
   val isEmpty : Boolean
 }
\ No newline at end of file
diff --git a/idea/testData/psi/examples/collections/IList.txt b/idea/testData/psi/examples/collections/IList.txt
index e27ab630e52..36ff6a29f39 100644
--- a/idea/testData/psi/examples/collections/IList.txt
+++ b/idea/testData/psi/examples/collections/IList.txt
@@ -2,7 +2,7 @@ JetFile: IList.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/IMutableIterable.jet b/idea/testData/psi/examples/collections/IMutableIterable.jet
index 22b6e017d8e..1ad49e2aec9 100644
--- a/idea/testData/psi/examples/collections/IMutableIterable.jet
+++ b/idea/testData/psi/examples/collections/IMutableIterable.jet
@@ -1,3 +1,3 @@
-virtual class IMutableIterable<out T> : IIterable<T> {
+open class IMutableIterable<out T> : IIterable<T> {
   fun mutableIterator() : IMutableIterator<T>
 }
\ No newline at end of file
diff --git a/idea/testData/psi/examples/collections/IMutableIterable.txt b/idea/testData/psi/examples/collections/IMutableIterable.txt
index 14d939be026..4e443c5ca4b 100644
--- a/idea/testData/psi/examples/collections/IMutableIterable.txt
+++ b/idea/testData/psi/examples/collections/IMutableIterable.txt
@@ -2,7 +2,7 @@ JetFile: IMutableIterable.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/IMutableIterator.jet b/idea/testData/psi/examples/collections/IMutableIterator.jet
index 51111049926..1449ab40dca 100644
--- a/idea/testData/psi/examples/collections/IMutableIterator.jet
+++ b/idea/testData/psi/examples/collections/IMutableIterator.jet
@@ -1,4 +1,4 @@
-virtual class IMutableIterator<out T> : IIterator<T> {
+open class IMutableIterator<out T> : IIterator<T> {
   fun remove() : T
 
 /*
diff --git a/idea/testData/psi/examples/collections/IMutableIterator.txt b/idea/testData/psi/examples/collections/IMutableIterator.txt
index 1014211edea..4a92a5971d5 100644
--- a/idea/testData/psi/examples/collections/IMutableIterator.txt
+++ b/idea/testData/psi/examples/collections/IMutableIterator.txt
@@ -2,7 +2,7 @@ JetFile: IMutableIterator.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/IMutableList.jet b/idea/testData/psi/examples/collections/IMutableList.jet
index 711f0d6bfc7..55fd048e7a7 100644
--- a/idea/testData/psi/examples/collections/IMutableList.jet
+++ b/idea/testData/psi/examples/collections/IMutableList.jet
@@ -1,4 +1,4 @@
-virtual class IMutableList<T> : IList<T>, IMutableIterable<T> {
+open class IMutableList<T> : IList<T>, IMutableIterable<T> {
   fun set(index : Int, value : T) : T
   fun add(index : Int, value : T)
   fun remove(index : Int) : T
diff --git a/idea/testData/psi/examples/collections/IMutableList.txt b/idea/testData/psi/examples/collections/IMutableList.txt
index ec023e54ba4..0fce42fbf1f 100644
--- a/idea/testData/psi/examples/collections/IMutableList.txt
+++ b/idea/testData/psi/examples/collections/IMutableList.txt
@@ -2,7 +2,7 @@ JetFile: IMutableList.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/IMutableSet.jet b/idea/testData/psi/examples/collections/IMutableSet.jet
index eacb0d740ec..95eb05d2456 100644
--- a/idea/testData/psi/examples/collections/IMutableSet.jet
+++ b/idea/testData/psi/examples/collections/IMutableSet.jet
@@ -1,4 +1,4 @@
-virtual class IMutableSet<T> : ISet<T>, IMutableIterable<T> {
+open class IMutableSet<T> : ISet<T>, IMutableIterable<T> {
   fun add(item : T) : Boolean
   fun remove(item : T) : Boolean
 }
\ No newline at end of file
diff --git a/idea/testData/psi/examples/collections/IMutableSet.txt b/idea/testData/psi/examples/collections/IMutableSet.txt
index 50c295b41c5..82c94b8ff19 100644
--- a/idea/testData/psi/examples/collections/IMutableSet.txt
+++ b/idea/testData/psi/examples/collections/IMutableSet.txt
@@ -2,7 +2,7 @@ JetFile: IMutableSet.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/ISet.jet b/idea/testData/psi/examples/collections/ISet.jet
index bfe2753b8df..0b6741470fd 100644
--- a/idea/testData/psi/examples/collections/ISet.jet
+++ b/idea/testData/psi/examples/collections/ISet.jet
@@ -1,3 +1,3 @@
-virtual class ISet<T> : IIterable<T>, ISized {
+open class ISet<T> : IIterable<T>, ISized {
   fun contains(item : T) : Boolean
 }
diff --git a/idea/testData/psi/examples/collections/ISet.txt b/idea/testData/psi/examples/collections/ISet.txt
index 11afd7dc48d..f1736c73dee 100644
--- a/idea/testData/psi/examples/collections/ISet.txt
+++ b/idea/testData/psi/examples/collections/ISet.txt
@@ -2,7 +2,7 @@ JetFile: ISet.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/ISized.jet b/idea/testData/psi/examples/collections/ISized.jet
index 9f12cb218b0..5e5977f253e 100644
--- a/idea/testData/psi/examples/collections/ISized.jet
+++ b/idea/testData/psi/examples/collections/ISized.jet
@@ -1,3 +1,3 @@
-virtual class ISized {
+open class ISized {
   val size : Int
 }
\ No newline at end of file
diff --git a/idea/testData/psi/examples/collections/ISized.txt b/idea/testData/psi/examples/collections/ISized.txt
index 20a7d2d6ad5..dacafb7e2eb 100644
--- a/idea/testData/psi/examples/collections/ISized.txt
+++ b/idea/testData/psi/examples/collections/ISized.txt
@@ -2,7 +2,7 @@ JetFile: ISized.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/collections/LinkedList.txt b/idea/testData/psi/examples/collections/LinkedList.txt
index e382676f705..70ecbe15074 100644
--- a/idea/testData/psi/examples/collections/LinkedList.txt
+++ b/idea/testData/psi/examples/collections/LinkedList.txt
@@ -224,163 +224,155 @@ JetFile: LinkedList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      BINARY_EXPRESSION
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('newItem')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('head')
-                      PsiWhiteSpace('\n      ')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('newItem')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('head')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('head')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('newItem')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
                       BINARY_EXPRESSION
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('head')
+                          PsiElement(IDENTIFIER)('tail')
                         PsiWhiteSpace(' ')
                         OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
+                          PsiElement(EQEQEQ)('===')
                         PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('newItem')
-                      PsiWhiteSpace('\n      ')
-                      IF
-                        PsiElement(if)('if')
-                        PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          BINARY_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('tail')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(EQEQEQ)('===')
-                            PsiWhiteSpace(' ')
-                            NULL
-                              PsiElement(null)('null')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace(' ')
-                        THEN
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
-                                BINARY_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('tail')
-                                  PsiWhiteSpace(' ')
-                                  OPERATION_REFERENCE
-                                    PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('head')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                        NULL
+                          PsiElement(null)('null')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    THEN
+                      BLOCK
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('tail')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('head')
+                        PsiWhiteSpace('\n      ')
+                        PsiElement(RBRACE)('}')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
               PsiWhiteSpace(' ')
               PsiElement(else)('else')
               PsiWhiteSpace(' ')
               ELSE
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      PROPERTY
-                        PsiElement(var)('var')
-                        PsiWhiteSpace(' ')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  PROPERTY
+                    PsiElement(var)('var')
+                    PsiWhiteSpace(' ')
+                    PsiElement(IDENTIFIER)('insertAfter')
+                    PsiWhiteSpace(' ')
+                    PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    CALL_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('itemAt')
+                      VALUE_ARGUMENT_LIST
+                        PsiElement(LPAR)('(')
+                        VALUE_ARGUMENT
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('index')
+                        PsiElement(RPAR)(')')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('newItem')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
                         PsiElement(IDENTIFIER)('insertAfter')
-                        PsiWhiteSpace(' ')
-                        PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        CALL_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('itemAt')
-                          VALUE_ARGUMENT_LIST
-                            PsiElement(LPAR)('(')
-                            VALUE_ARGUMENT
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('index')
-                            PsiElement(RPAR)(')')
-                      PsiWhiteSpace('\n      ')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('insertAfter')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('newItem')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
                       BINARY_EXPRESSION
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('newItem')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('tail')
                         PsiWhiteSpace(' ')
                         OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('insertAfter')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                      PsiWhiteSpace('\n      ')
-                      BINARY_EXPRESSION
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('insertAfter')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
+                          PsiElement(EQEQEQ)('===')
                         PsiWhiteSpace(' ')
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('newItem')
-                      PsiWhiteSpace('\n      ')
-                      IF
-                        PsiElement(if)('if')
-                        PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          BINARY_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('tail')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(EQEQEQ)('===')
-                            PsiWhiteSpace(' ')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('insertAfter')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace(' ')
-                        THEN
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
-                                BINARY_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('tail')
-                                  PsiWhiteSpace(' ')
-                                  OPERATION_REFERENCE
-                                    PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('newItem')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                          PsiElement(IDENTIFIER)('insertAfter')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    THEN
+                      BLOCK
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('tail')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('newItem')
+                        PsiWhiteSpace('\n      ')
+                        PsiElement(RBRACE)('}')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -434,25 +426,23 @@ JetFile: LinkedList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      THROW
-                        PsiElement(throw)('throw')
-                        PsiWhiteSpace(' ')
-                        CALL_EXPRESSION
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  THROW
+                    PsiElement(throw)('throw')
+                    PsiWhiteSpace(' ')
+                    CALL_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('IndexOutOfBoundsException')
+                      VALUE_ARGUMENT_LIST
+                        PsiElement(LPAR)('(')
+                        VALUE_ARGUMENT
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('IndexOutOfBoundsException')
-                          VALUE_ARGUMENT_LIST
-                            PsiElement(LPAR)('(')
-                            VALUE_ARGUMENT
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('index')
-                            PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                            PsiElement(IDENTIFIER)('index')
+                        PsiElement(RPAR)(')')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -530,158 +520,150 @@ JetFile: LinkedList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('head')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('item')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
                       BINARY_EXPRESSION
                         REFERENCE_EXPRESSION
                           PsiElement(IDENTIFIER)('head')
                         PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQEQEQ)('===')
+                        PsiWhiteSpace(' ')
+                        NULL
+                          PsiElement(null)('null')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace('\n        ')
+                    THEN
+                      BINARY_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('tail')
                         OPERATION_REFERENCE
                           PsiElement(EQ)('=')
                         PsiWhiteSpace(' ')
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('item')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                      PsiWhiteSpace('\n      ')
-                      IF
-                        PsiElement(if)('if')
-                        PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          BINARY_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('head')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(EQEQEQ)('===')
-                            PsiWhiteSpace(' ')
-                            NULL
-                              PsiElement(null)('null')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace('\n        ')
-                        THEN
-                          BINARY_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('tail')
-                            OPERATION_REFERENCE
-                              PsiElement(EQ)('=')
-                            PsiWhiteSpace(' ')
-                            NULL
-                              PsiElement(null)('null')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                        NULL
+                          PsiElement(null)('null')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
               PsiWhiteSpace(' ')
               PsiElement(else)('else')
               PsiWhiteSpace(' ')
               ELSE
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    DOT_QUALIFIED_EXPRESSION
+                      DOT_QUALIFIED_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('item')
+                        PsiElement(DOT)('.')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('previous')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('item')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
                       BINARY_EXPRESSION
                         DOT_QUALIFIED_EXPRESSION
-                          DOT_QUALIFIED_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('item')
-                            PsiElement(DOT)('.')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('previous')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('item')
                           PsiElement(DOT)('.')
                           REFERENCE_EXPRESSION
                             PsiElement(IDENTIFIER)('next')
                         PsiWhiteSpace(' ')
                         OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
+                          PsiElement(EQEQEQ)('===')
                         PsiWhiteSpace(' ')
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('item')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                      PsiWhiteSpace('\n      ')
-                      IF
-                        PsiElement(if)('if')
-                        PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          BINARY_EXPRESSION
+                        NULL
+                          PsiElement(null)('null')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    THEN
+                      BLOCK
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          DOT_QUALIFIED_EXPRESSION
                             DOT_QUALIFIED_EXPRESSION
                               REFERENCE_EXPRESSION
                                 PsiElement(IDENTIFIER)('item')
                               PsiElement(DOT)('.')
                               REFERENCE_EXPRESSION
                                 PsiElement(IDENTIFIER)('next')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(EQEQEQ)('===')
-                            PsiWhiteSpace(' ')
-                            NULL
-                              PsiElement(null)('null')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace(' ')
-                        THEN
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
-                                BINARY_EXPRESSION
-                                  DOT_QUALIFIED_EXPRESSION
-                                    DOT_QUALIFIED_EXPRESSION
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('item')
-                                      PsiElement(DOT)('.')
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('next')
-                                    PsiElement(DOT)('.')
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('previous')
-                                  PsiWhiteSpace(' ')
-                                  OPERATION_REFERENCE
-                                    PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  DOT_QUALIFIED_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('item')
-                                    PsiElement(DOT)('.')
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('previous')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
-                        PsiWhiteSpace(' ')
-                        PsiElement(else)('else')
-                        PsiWhiteSpace(' ')
-                        ELSE
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
-                                BINARY_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('tail')
-                                  PsiWhiteSpace(' ')
-                                  OPERATION_REFERENCE
-                                    PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  DOT_QUALIFIED_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('tail')
-                                    PsiElement(DOT)('.')
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('previous')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('previous')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          DOT_QUALIFIED_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('item')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('previous')
+                        PsiWhiteSpace('\n      ')
+                        PsiElement(RBRACE)('}')
+                    PsiWhiteSpace(' ')
+                    PsiElement(else)('else')
+                    PsiWhiteSpace(' ')
+                    ELSE
+                      BLOCK
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('tail')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          DOT_QUALIFIED_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('tail')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('previous')
+                        PsiWhiteSpace('\n      ')
+                        PsiElement(RBRACE)('}')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             POSTFIX_EXPRESSION
               REFERENCE_EXPRESSION
@@ -858,26 +840,24 @@ JetFile: LinkedList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('result')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        DOT_QUALIFIED_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('result')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('result')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('result')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             RETURN
               PsiElement(return)('return')
diff --git a/idea/testData/psi/examples/io/IOSamples.jet b/idea/testData/psi/examples/io/IOSamples.jet
index 4304fc00a38..621b6c0033b 100644
--- a/idea/testData/psi/examples/io/IOSamples.jet
+++ b/idea/testData/psi/examples/io/IOSamples.jet
@@ -1,8 +1,8 @@
-virtual class IAdder<in T> {
+open class IAdder<in T> {
   fun add(item : T) : Boolean
 }
 
-virtual class ICloseable {
+open class ICloseable {
   fun close()
 }
 
diff --git a/idea/testData/psi/examples/io/IOSamples.txt b/idea/testData/psi/examples/io/IOSamples.txt
index 9f6e5596509..4cdd7d38a23 100644
--- a/idea/testData/psi/examples/io/IOSamples.txt
+++ b/idea/testData/psi/examples/io/IOSamples.txt
@@ -2,7 +2,7 @@ JetFile: IOSamples.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
@@ -47,7 +47,7 @@ JetFile: IOSamples.jet
     PsiWhiteSpace('\n\n')
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
@@ -358,37 +358,35 @@ JetFile: IOSamples.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('nextUsed')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        BOOLEAN_CONSTANT
-                          PsiElement(true)('true')
-                      PsiWhiteSpace('\n      ')
-                      RETURN
-                        PsiElement(return)('return')
-                        PsiWhiteSpace(' ')
-                        BINARY_WITH_TYPE
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('nextUsed')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    BOOLEAN_CONSTANT
+                      PsiElement(true)('true')
+                  PsiWhiteSpace('\n      ')
+                  RETURN
+                    PsiElement(return)('return')
+                    PsiWhiteSpace(' ')
+                    BINARY_WITH_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                      PsiWhiteSpace(' ')
+                      OPERATION_REFERENCE
+                        PsiElement(as)('as')
+                      PsiWhiteSpace(' ')
+                      TYPE_REFERENCE
+                        USER_TYPE
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(as)('as')
-                          PsiWhiteSpace(' ')
-                          TYPE_REFERENCE
-                            USER_TYPE
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('Byte')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                            PsiElement(IDENTIFIER)('Byte')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             RETURN
               PsiElement(return)('return')
@@ -440,42 +438,40 @@ JetFile: IOSamples.jet
                 PsiElement(RPAR)(')')
                 PsiWhiteSpace(' ')
                 THEN
-                  FUNCTION_LITERAL_EXPRESSION
-                    FUNCTION_LITERAL
-                      PsiElement(LBRACE)('{')
-                      PsiWhiteSpace('\n        ')
-                      BLOCK
-                        BINARY_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('nextUsed')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQ)('=')
-                          PsiWhiteSpace(' ')
-                          BOOLEAN_CONSTANT
-                            PsiElement(false)('false')
-                        PsiWhiteSpace('\n        ')
-                        BINARY_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('next')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQ)('=')
-                          PsiWhiteSpace(' ')
-                          DOT_QUALIFIED_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('stream')
-                            PsiElement(DOT)('.')
-                            CALL_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('read')
-                              VALUE_ARGUMENT_LIST
-                                PsiElement(LPAR)('(')
-                                PsiElement(RPAR)(')')
+                  BLOCK
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n        ')
+                    BINARY_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('nextUsed')
                       PsiWhiteSpace(' ')
-                      PsiComment(EOL_COMMENT)('// throws IOException')
-                      PsiWhiteSpace('\n      ')
-                      PsiElement(RBRACE)('}')
+                      OPERATION_REFERENCE
+                        PsiElement(EQ)('=')
+                      PsiWhiteSpace(' ')
+                      BOOLEAN_CONSTANT
+                        PsiElement(false)('false')
+                    PsiWhiteSpace('\n        ')
+                    BINARY_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('next')
+                      PsiWhiteSpace(' ')
+                      OPERATION_REFERENCE
+                        PsiElement(EQ)('=')
+                      PsiWhiteSpace(' ')
+                      DOT_QUALIFIED_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('stream')
+                        PsiElement(DOT)('.')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('read')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    PsiComment(EOL_COMMENT)('// throws IOException')
+                    PsiWhiteSpace('\n      ')
+                    PsiElement(RBRACE)('}')
               PsiWhiteSpace('\n      ')
               RETURN
                 PsiElement(return)('return')
diff --git a/idea/testData/psi/examples/map/IMap.jet b/idea/testData/psi/examples/map/IMap.jet
index 0b912bb838d..da51189c006 100644
--- a/idea/testData/psi/examples/map/IMap.jet
+++ b/idea/testData/psi/examples/map/IMap.jet
@@ -1,4 +1,4 @@
-virtual class IMap<in K, out V> {
+open class IMap<in K, out V> {
   
 
 }
\ No newline at end of file
diff --git a/idea/testData/psi/examples/map/IMap.txt b/idea/testData/psi/examples/map/IMap.txt
index db79dcc4753..569ba8cb241 100644
--- a/idea/testData/psi/examples/map/IMap.txt
+++ b/idea/testData/psi/examples/map/IMap.txt
@@ -2,7 +2,7 @@ JetFile: IMap.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/priorityqueues/BinaryHeap.txt b/idea/testData/psi/examples/priorityqueues/BinaryHeap.txt
index 48d975a1f91..d585bc8ffed 100644
--- a/idea/testData/psi/examples/priorityqueues/BinaryHeap.txt
+++ b/idea/testData/psi/examples/priorityqueues/BinaryHeap.txt
@@ -209,22 +209,20 @@ JetFile: BinaryHeap.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      CALL_EXPRESSION
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  CALL_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('siftDown')
+                    VALUE_ARGUMENT_LIST
+                      PsiElement(LPAR)('(')
+                      VALUE_ARGUMENT
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('siftDown')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          VALUE_ARGUMENT
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('i')
-                          PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                          PsiElement(IDENTIFIER)('i')
+                      PsiElement(RPAR)(')')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -575,186 +573,180 @@ JetFile: BinaryHeap.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      PROPERTY
-                        PsiElement(var)('var')
-                        PsiWhiteSpace(' ')
-                        PsiElement(IDENTIFIER)('min')
-                        PsiWhiteSpace(' ')
-                        PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('current')
-                      PsiWhiteSpace('\n      ')
-                      IF
-                        PsiElement(if)('if')
-                        PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          BINARY_EXPRESSION
-                            DOT_QUALIFIED_EXPRESSION
-                              DOT_QUALIFIED_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('current')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('left')
-                              PsiElement(DOT)('.')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('value')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(LT)('<')
-                            PsiWhiteSpace(' ')
-                            DOT_QUALIFIED_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('min')
-                              PsiElement(DOT)('.')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('value')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace(' ')
-                        THEN
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
-                                BINARY_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('min')
-                                  PsiWhiteSpace(' ')
-                                  OPERATION_REFERENCE
-                                    PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  DOT_QUALIFIED_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('current')
-                                    PsiElement(DOT)('.')
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('left')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
-                      PsiWhiteSpace('\n      ')
-                      IF
-                        PsiElement(if)('if')
-                        PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          BINARY_EXPRESSION
-                            DOT_QUALIFIED_EXPRESSION
-                              DOT_QUALIFIED_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('current')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('right')
-                              PsiElement(DOT)('.')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('exists')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(ANDAND)('&&')
-                            PsiWhiteSpace(' ')
-                            BINARY_EXPRESSION
-                              DOT_QUALIFIED_EXPRESSION
-                                DOT_QUALIFIED_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('current')
-                                  PsiElement(DOT)('.')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('right')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('value')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(LT)('<')
-                              PsiWhiteSpace(' ')
-                              DOT_QUALIFIED_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('min')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('value')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace(' ')
-                        THEN
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
-                                BINARY_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('min')
-                                  PsiWhiteSpace(' ')
-                                  OPERATION_REFERENCE
-                                    PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  DOT_QUALIFIED_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('current')
-                                    PsiElement(DOT)('.')
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('right')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
-                      PsiWhiteSpace('\n      ')
-                      IF
-                        PsiElement(if)('if')
-                        PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          BINARY_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('min')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(EQEQ)('==')
-                            PsiWhiteSpace(' ')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  PROPERTY
+                    PsiElement(var)('var')
+                    PsiWhiteSpace(' ')
+                    PsiElement(IDENTIFIER)('min')
+                    PsiWhiteSpace(' ')
+                    PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('current')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          DOT_QUALIFIED_EXPRESSION
                             REFERENCE_EXPRESSION
                               PsiElement(IDENTIFIER)('current')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace(' ')
-                        THEN
-                          BREAK
-                            PsiElement(break)('break')
-                      PsiWhiteSpace('\n      ')
-                      DOT_QUALIFIED_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('data')
-                        PsiElement(DOT)('.')
-                        CALL_EXPRESSION
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('left')
+                          PsiElement(DOT)('.')
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('swap')
-                          VALUE_ARGUMENT_LIST
-                            PsiElement(LPAR)('(')
-                            VALUE_ARGUMENT
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('min')
-                            PsiElement(COMMA)(',')
-                            PsiWhiteSpace(' ')
-                            VALUE_ARGUMENT
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('current')
-                            PsiElement(RPAR)(')')
-                      PsiWhiteSpace('\n      ')
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('current')
+                            PsiElement(IDENTIFIER)('value')
                         PsiWhiteSpace(' ')
                         OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
+                          PsiElement(LT)('<')
                         PsiWhiteSpace(' ')
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('min')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('value')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    THEN
+                      BLOCK
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('min')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          DOT_QUALIFIED_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('current')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('left')
+                        PsiWhiteSpace('\n      ')
+                        PsiElement(RBRACE)('}')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          DOT_QUALIFIED_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('current')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('right')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('exists')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(ANDAND)('&&')
+                        PsiWhiteSpace(' ')
+                        BINARY_EXPRESSION
+                          DOT_QUALIFIED_EXPRESSION
+                            DOT_QUALIFIED_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('current')
+                              PsiElement(DOT)('.')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('right')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('value')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(LT)('<')
+                          PsiWhiteSpace(' ')
+                          DOT_QUALIFIED_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('min')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('value')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    THEN
+                      BLOCK
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('min')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          DOT_QUALIFIED_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('current')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('right')
+                        PsiWhiteSpace('\n      ')
+                        PsiElement(RBRACE)('}')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
+                      BINARY_EXPRESSION
                         REFERENCE_EXPRESSION
                           PsiElement(IDENTIFIER)('min')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQEQ)('==')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('current')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    THEN
+                      BREAK
+                        PsiElement(break)('break')
+                  PsiWhiteSpace('\n      ')
+                  DOT_QUALIFIED_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('data')
+                    PsiElement(DOT)('.')
+                    CALL_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('swap')
+                      VALUE_ARGUMENT_LIST
+                        PsiElement(LPAR)('(')
+                        VALUE_ARGUMENT
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('min')
+                        PsiElement(COMMA)(',')
+                        PsiWhiteSpace(' ')
+                        VALUE_ARGUMENT
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('current')
+                        PsiElement(RPAR)(')')
+                  PsiWhiteSpace('\n      ')
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('current')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(EQ)('=')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('min')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -829,85 +821,81 @@ JetFile: BinaryHeap.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BLOCK
-                      IF
-                        PsiElement(if)('if')
+                BLOCK
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  IF
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('current')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('value')
                         PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
-                        CONDITION
-                          BINARY_EXPRESSION
-                            DOT_QUALIFIED_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('current')
-                              PsiElement(DOT)('.')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('value')
-                            PsiWhiteSpace(' ')
-                            OPERATION_REFERENCE
-                              PsiElement(LT)('<')
-                            PsiWhiteSpace(' ')
-                            DOT_QUALIFIED_EXPRESSION
-                              DOT_QUALIFIED_EXPRESSION
+                        OPERATION_REFERENCE
+                          PsiElement(LT)('<')
+                        PsiWhiteSpace(' ')
+                        DOT_QUALIFIED_EXPRESSION
+                          DOT_QUALIFIED_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('current')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('parent')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('value')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    THEN
+                      BLOCK
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n        ')
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('data')
+                          PsiElement(DOT)('.')
+                          CALL_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('swap')
+                            VALUE_ARGUMENT_LIST
+                              PsiElement(LPAR)('(')
+                              VALUE_ARGUMENT
                                 REFERENCE_EXPRESSION
                                   PsiElement(IDENTIFIER)('current')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('parent')
-                              PsiElement(DOT)('.')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('value')
-                        PsiElement(RPAR)(')')
-                        PsiWhiteSpace(' ')
-                        THEN
-                          FUNCTION_LITERAL_EXPRESSION
-                            FUNCTION_LITERAL
-                              PsiElement(LBRACE)('{')
-                              PsiWhiteSpace('\n        ')
-                              BLOCK
+                              PsiElement(COMMA)(',')
+                              PsiWhiteSpace(' ')
+                              VALUE_ARGUMENT
                                 DOT_QUALIFIED_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('data')
-                                  PsiElement(DOT)('.')
-                                  CALL_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('swap')
-                                    VALUE_ARGUMENT_LIST
-                                      PsiElement(LPAR)('(')
-                                      VALUE_ARGUMENT
-                                        REFERENCE_EXPRESSION
-                                          PsiElement(IDENTIFIER)('current')
-                                      PsiElement(COMMA)(',')
-                                      PsiWhiteSpace(' ')
-                                      VALUE_ARGUMENT
-                                        DOT_QUALIFIED_EXPRESSION
-                                          REFERENCE_EXPRESSION
-                                            PsiElement(IDENTIFIER)('current')
-                                          PsiElement(DOT)('.')
-                                          REFERENCE_EXPRESSION
-                                            PsiElement(IDENTIFIER)('parent')
-                                      PsiElement(RPAR)(')')
-                                PsiWhiteSpace('\n        ')
-                                BINARY_EXPRESSION
                                   REFERENCE_EXPRESSION
                                     PsiElement(IDENTIFIER)('current')
-                                  PsiWhiteSpace(' ')
-                                  OPERATION_REFERENCE
-                                    PsiElement(EQ)('=')
-                                  PsiWhiteSpace(' ')
-                                  DOT_QUALIFIED_EXPRESSION
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('current')
-                                    PsiElement(DOT)('.')
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('parent')
-                              PsiWhiteSpace('\n      ')
-                              PsiElement(RBRACE)('}')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
+                                  PsiElement(DOT)('.')
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('parent')
+                              PsiElement(RPAR)(')')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('current')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          DOT_QUALIFIED_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('current')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('parent')
+                        PsiWhiteSpace('\n      ')
+                        PsiElement(RBRACE)('}')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
diff --git a/idea/testData/psi/examples/priorityqueues/IPriorityQueue.jet b/idea/testData/psi/examples/priorityqueues/IPriorityQueue.jet
index b343cd49cc3..ee694f5c9d4 100644
--- a/idea/testData/psi/examples/priorityqueues/IPriorityQueue.jet
+++ b/idea/testData/psi/examples/priorityqueues/IPriorityQueue.jet
@@ -1,4 +1,4 @@
-virtual class IPriorityQueue<T> {
+open class IPriorityQueue<T> {
   fun extract() : T
   fun add(item : T)
   val isEmpty : Boolean
diff --git a/idea/testData/psi/examples/priorityqueues/IPriorityQueue.txt b/idea/testData/psi/examples/priorityqueues/IPriorityQueue.txt
index 340dac8a68c..626b44d7c56 100644
--- a/idea/testData/psi/examples/priorityqueues/IPriorityQueue.txt
+++ b/idea/testData/psi/examples/priorityqueues/IPriorityQueue.txt
@@ -2,7 +2,7 @@ JetFile: IPriorityQueue.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.jet b/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.jet
index 2d20c5666e7..86f317b7972 100644
--- a/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.jet
+++ b/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.jet
@@ -1,4 +1,4 @@
-class PriorityQueueAsPushPop<T> wraps(wrapped : IPriorityQueue<T>) : IPushPop<T> {
+class PriorityQueueAsPushPop<T>(wrapped : IPriorityQueue<T>) : IPushPop<T> {
   override fun pop() = wrapped.extract()
   override fun push(item : T) = wrapped.add(item)
   override val isEmpty
diff --git a/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.txt b/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.txt
index 504d73ee76e..dcc8cfb2507 100644
--- a/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.txt
+++ b/idea/testData/psi/examples/priorityqueues/PriorityQueueAsPushPop.txt
@@ -9,8 +9,6 @@ JetFile: PriorityQueueAsPushPop.jet
         TYPE_PARAMETER
           PsiElement(IDENTIFIER)('T')
         PsiElement(GT)('>')
-      PsiWhiteSpace(' ')
-      PsiElement(wraps)('wraps')
       VALUE_PARAMETER_LIST
         PsiElement(LPAR)('(')
         VALUE_PARAMETER
diff --git a/idea/testData/psi/examples/util/IComparable.jet b/idea/testData/psi/examples/util/IComparable.jet
index b802c381464..1ce3f600ea6 100644
--- a/idea/testData/psi/examples/util/IComparable.jet
+++ b/idea/testData/psi/examples/util/IComparable.jet
@@ -1,3 +1,3 @@
-virtual class IComparable<in T> {
+open class IComparable<in T> {
   fun compareTo(other : T) : Int
 }
\ No newline at end of file
diff --git a/idea/testData/psi/examples/util/IComparable.txt b/idea/testData/psi/examples/util/IComparable.txt
index 1fd73634c0d..9404cdf4eb1 100644
--- a/idea/testData/psi/examples/util/IComparable.txt
+++ b/idea/testData/psi/examples/util/IComparable.txt
@@ -2,7 +2,7 @@ JetFile: IComparable.jet
   NAMESPACE
     CLASS
       MODIFIER_LIST
-        PsiElement(virtual)('virtual')
+        PsiElement(open)('open')
       PsiWhiteSpace(' ')
       PsiElement(class)('class')
       PsiWhiteSpace(' ')
diff --git a/idea/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.jet b/idea/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.jet
index dd64b7d8b13..10bc73447c1 100644
--- a/idea/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.jet
+++ b/idea/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.jet
@@ -12,11 +12,11 @@ val {foo.bar.() : ()}.foo = foo
 
 val {foo.bar.() : ()}.foo : bar = foo
    [a] public get() {}
-   virtual set(a : b) {}
+   open set(a : b) {}
 
 
 val {foo.bar.() : ()}.foo : bar = foo
-   virtual set(a : b) {}
+   open set(a : b) {}
 
 
 val {foo.bar.() : ()}.foo : bar = foo
diff --git a/idea/testData/quickfix/abstract/afterAbstractFunctionInNonAbstractClass.kt b/idea/testData/quickfix/abstract/afterAbstractFunctionInNonAbstractClass.kt
new file mode 100644
index 00000000000..6ec19a0bac8
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractFunctionInNonAbstractClass.kt
@@ -0,0 +1,4 @@
+// "Make 'foo' not abstract" "true"
+class A() {
+    <caret>fun foo()
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/afterAbstractFunctionWithBody.kt b/idea/testData/quickfix/abstract/afterAbstractFunctionWithBody.kt
new file mode 100644
index 00000000000..f2086d5f409
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractFunctionWithBody.kt
@@ -0,0 +1,4 @@
+// "Remove function body" "true"
+abstract class A() {
+    <caret>abstract fun foo()
+}
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyInNonAbstractClass1.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyInNonAbstractClass1.kt
new file mode 100644
index 00000000000..945ce429d17
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyInNonAbstractClass1.kt
@@ -0,0 +1,4 @@
+// "Make 'A' abstract" "true"
+abstract class A() {
+    <caret>abstract var i : Int
+}
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyInNonAbstractClass2.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyInNonAbstractClass2.kt
new file mode 100644
index 00000000000..6aa96573108
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyInNonAbstractClass2.kt
@@ -0,0 +1,4 @@
+// "Make 'i' not abstract" "true"
+class A() {
+    <caret>var i : Int
+}
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyInPrimaryConstructorParameters.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyInPrimaryConstructorParameters.kt
new file mode 100644
index 00000000000..8bb9648d6fa
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyInPrimaryConstructorParameters.kt
@@ -0,0 +1,2 @@
+// "Make 'i' not abstract" "true"
+class A(<caret>val i: Int) {}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyNotInClass.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyNotInClass.kt
new file mode 100644
index 00000000000..d4db626ee31
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyNotInClass.kt
@@ -0,0 +1,2 @@
+// "Make 'i' not abstract" "true"
+<caret>val i: Int = 1
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyWIthInitializer2.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyWIthInitializer2.kt
new file mode 100644
index 00000000000..50e6e0f7847
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyWIthInitializer2.kt
@@ -0,0 +1,4 @@
+// "Remove initializer from property" "true"
+abstract class A {
+    abstract var i : Int<caret>
+}
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyWIthInitializer3.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyWIthInitializer3.kt
new file mode 100644
index 00000000000..50e6e0f7847
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyWIthInitializer3.kt
@@ -0,0 +1,4 @@
+// "Remove initializer from property" "true"
+abstract class A {
+    abstract var i : Int<caret>
+}
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyWithGetter1.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyWithGetter1.kt
new file mode 100644
index 00000000000..ccea9aaf50b
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyWithGetter1.kt
@@ -0,0 +1,5 @@
+// "Make 'i' not abstract" "true"
+class B {
+    <caret>val i: Int
+        get() = $i
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyWithGetter2.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyWithGetter2.kt
new file mode 100644
index 00000000000..8e7404cd9e2
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyWithGetter2.kt
@@ -0,0 +1,5 @@
+// "Remove getter and initializer from property" "true"
+abstract class B {
+    abstract val i : <caret>Int
+
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyWithInitializer1.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyWithInitializer1.kt
new file mode 100644
index 00000000000..01d5197a882
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyWithInitializer1.kt
@@ -0,0 +1,4 @@
+// "Make 'i' not abstract" "true"
+class A {
+    <caret>var i = 0
+}
diff --git a/idea/testData/quickfix/abstract/afterAbstractPropertyWithSetter.kt b/idea/testData/quickfix/abstract/afterAbstractPropertyWithSetter.kt
new file mode 100644
index 00000000000..ffbac65767b
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterAbstractPropertyWithSetter.kt
@@ -0,0 +1,5 @@
+// "Make 'j' not abstract" "true"
+class B {
+    <caret>var j: Int
+        set(v: Int) {}
+}
diff --git a/idea/testData/quickfix/abstract/afterMustBeInitializedOrBeAbstract.kt b/idea/testData/quickfix/abstract/afterMustBeInitializedOrBeAbstract.kt
new file mode 100644
index 00000000000..bdefbb28222
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterMustBeInitializedOrBeAbstract.kt
@@ -0,0 +1,4 @@
+// "Make 'i' abstract" "true"
+abstract class A() {
+    abstract var <caret>i : Int
+}
diff --git a/idea/testData/quickfix/abstract/afterNonAbstractFunctionWithNoBody.kt b/idea/testData/quickfix/abstract/afterNonAbstractFunctionWithNoBody.kt
new file mode 100644
index 00000000000..59958ef927e
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterNonAbstractFunctionWithNoBody.kt
@@ -0,0 +1,4 @@
+// "Add function body" "true"
+class A() {
+    fun <caret>foo() {}
+}
diff --git a/idea/testData/quickfix/abstract/afterNonMemberAbstractAccessor.kt b/idea/testData/quickfix/abstract/afterNonMemberAbstractAccessor.kt
new file mode 100644
index 00000000000..9d9d46b6606
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterNonMemberAbstractAccessor.kt
@@ -0,0 +1,2 @@
+// "Make 'get' not abstract" "true"
+val i : Int = 0; <caret>get
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/afterNonMemberAbstractFunction.kt b/idea/testData/quickfix/abstract/afterNonMemberAbstractFunction.kt
new file mode 100644
index 00000000000..6724f07e1d7
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterNonMemberAbstractFunction.kt
@@ -0,0 +1,2 @@
+// "Make 'foo' not abstract" "true"
+<caret>fun foo()
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/afterNonMemberFunctionNoBody.kt b/idea/testData/quickfix/abstract/afterNonMemberFunctionNoBody.kt
new file mode 100644
index 00000000000..2be242ece22
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterNonMemberFunctionNoBody.kt
@@ -0,0 +1,4 @@
+// "Add function body" "true"
+namespace a {
+fun <caret>foo() {}
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/afterRedundantAbstract.kt b/idea/testData/quickfix/abstract/afterRedundantAbstract.kt
new file mode 100644
index 00000000000..6fc13b24bc1
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterRedundantAbstract.kt
@@ -0,0 +1,4 @@
+// "Remove redundant 'abstract' modifier" "true"
+trait A {
+    <caret>fun foo()
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/afterReplaceOpen.kt b/idea/testData/quickfix/abstract/afterReplaceOpen.kt
new file mode 100644
index 00000000000..d9af1d8ce42
--- /dev/null
+++ b/idea/testData/quickfix/abstract/afterReplaceOpen.kt
@@ -0,0 +1,4 @@
+// "Make 'foo' abstract" "true"
+abstract class B() {
+    abstract fun <caret>foo()
+}
diff --git a/idea/testData/quickfix/abstract/beforeAbstractFunctionInNonAbstractClass.kt b/idea/testData/quickfix/abstract/beforeAbstractFunctionInNonAbstractClass.kt
new file mode 100644
index 00000000000..1e408668e99
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractFunctionInNonAbstractClass.kt
@@ -0,0 +1,4 @@
+// "Make 'foo' not abstract" "true"
+class A() {
+    <caret>abstract fun foo()
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/beforeAbstractFunctionWithBody.kt b/idea/testData/quickfix/abstract/beforeAbstractFunctionWithBody.kt
new file mode 100644
index 00000000000..0d0d468f1a0
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractFunctionWithBody.kt
@@ -0,0 +1,4 @@
+// "Remove function body" "true"
+abstract class A() {
+    <caret>abstract fun foo() {}
+}
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyInNonAbstractClass1.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyInNonAbstractClass1.kt
new file mode 100644
index 00000000000..68fa4959c71
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyInNonAbstractClass1.kt
@@ -0,0 +1,4 @@
+// "Make 'A' abstract" "true"
+class A() {
+    <caret>abstract var i : Int
+}
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyInNonAbstractClass2.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyInNonAbstractClass2.kt
new file mode 100644
index 00000000000..21218b3a76c
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyInNonAbstractClass2.kt
@@ -0,0 +1,4 @@
+// "Make 'i' not abstract" "true"
+class A() {
+    <caret>abstract var i : Int
+}
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyInPrimaryConstructorParameters.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyInPrimaryConstructorParameters.kt
new file mode 100644
index 00000000000..cfb081250c7
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyInPrimaryConstructorParameters.kt
@@ -0,0 +1,2 @@
+// "Make 'i' not abstract" "true"
+class A(<caret>abstract val i: Int) {}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyNotInClass.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyNotInClass.kt
new file mode 100644
index 00000000000..0355005d55c
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyNotInClass.kt
@@ -0,0 +1,2 @@
+// "Make 'i' not abstract" "true"
+<caret>abstract val i: Int = 1
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyWIthInitializer2.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyWIthInitializer2.kt
new file mode 100644
index 00000000000..bfd6c3ad884
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyWIthInitializer2.kt
@@ -0,0 +1,4 @@
+// "Remove initializer from property" "true"
+abstract class A {
+    abstract var i = 0<caret>
+}
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyWIthInitializer3.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyWIthInitializer3.kt
new file mode 100644
index 00000000000..1cfb78a0ed2
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyWIthInitializer3.kt
@@ -0,0 +1,4 @@
+// "Remove initializer from property" "true"
+abstract class A {
+    abstract var i : Int = 0<caret>
+}
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyWithGetter1.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyWithGetter1.kt
new file mode 100644
index 00000000000..1270309c17a
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyWithGetter1.kt
@@ -0,0 +1,5 @@
+// "Make 'i' not abstract" "true"
+class B {
+    <caret>abstract val i: Int
+        get() = $i
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyWithGetter2.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyWithGetter2.kt
new file mode 100644
index 00000000000..4466a5712a5
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyWithGetter2.kt
@@ -0,0 +1,5 @@
+// "Remove getter and initializer from property" "true"
+abstract class B {
+    abstract val i = <caret>0
+        get() = $i
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyWithInitializer1.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyWithInitializer1.kt
new file mode 100644
index 00000000000..c56a70cde06
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyWithInitializer1.kt
@@ -0,0 +1,4 @@
+// "Make 'i' not abstract" "true"
+class A {
+    <caret>abstract var i = 0
+}
diff --git a/idea/testData/quickfix/abstract/beforeAbstractPropertyWithSetter.kt b/idea/testData/quickfix/abstract/beforeAbstractPropertyWithSetter.kt
new file mode 100644
index 00000000000..eb13af31fce
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeAbstractPropertyWithSetter.kt
@@ -0,0 +1,5 @@
+// "Make 'j' not abstract" "true"
+class B {
+    abstract<caret> var j: Int
+        set(v: Int) {}
+}
diff --git a/idea/testData/quickfix/abstract/beforeMustBeInitializedOrBeAbstract.kt b/idea/testData/quickfix/abstract/beforeMustBeInitializedOrBeAbstract.kt
new file mode 100644
index 00000000000..57e7f65c5f0
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeMustBeInitializedOrBeAbstract.kt
@@ -0,0 +1,4 @@
+// "Make 'i' abstract" "true"
+abstract class A() {
+    var <caret>i : Int
+}
diff --git a/idea/testData/quickfix/abstract/beforeNonAbstractFunctionWithNoBody.kt b/idea/testData/quickfix/abstract/beforeNonAbstractFunctionWithNoBody.kt
new file mode 100644
index 00000000000..0e070005a49
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeNonAbstractFunctionWithNoBody.kt
@@ -0,0 +1,4 @@
+// "Add function body" "true"
+class A() {
+    fun <caret>foo()
+}
diff --git a/idea/testData/quickfix/abstract/beforeNonMemberAbstractAccessor.kt b/idea/testData/quickfix/abstract/beforeNonMemberAbstractAccessor.kt
new file mode 100644
index 00000000000..4eab8790a9e
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeNonMemberAbstractAccessor.kt
@@ -0,0 +1,2 @@
+// "Make 'get' not abstract" "true"
+val i : Int = 0; <caret>abstract get
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/beforeNonMemberAbstractFunction.kt b/idea/testData/quickfix/abstract/beforeNonMemberAbstractFunction.kt
new file mode 100644
index 00000000000..f696d0ea6dd
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeNonMemberAbstractFunction.kt
@@ -0,0 +1,2 @@
+// "Make 'foo' not abstract" "true"
+<caret>abstract fun foo()
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/beforeNonMemberFunctionNoBody.kt b/idea/testData/quickfix/abstract/beforeNonMemberFunctionNoBody.kt
new file mode 100644
index 00000000000..01680ddc843
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeNonMemberFunctionNoBody.kt
@@ -0,0 +1,4 @@
+// "Add function body" "true"
+namespace a {
+fun <caret>foo()
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/beforeRedundantAbstract.kt b/idea/testData/quickfix/abstract/beforeRedundantAbstract.kt
new file mode 100644
index 00000000000..4cf5dd59500
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeRedundantAbstract.kt
@@ -0,0 +1,4 @@
+// "Remove redundant 'abstract' modifier" "true"
+trait A {
+    <caret>abstract fun foo()
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/abstract/beforeReplaceOpen.kt b/idea/testData/quickfix/abstract/beforeReplaceOpen.kt
new file mode 100644
index 00000000000..0eac584df28
--- /dev/null
+++ b/idea/testData/quickfix/abstract/beforeReplaceOpen.kt
@@ -0,0 +1,4 @@
+// "Make 'foo' abstract" "true"
+abstract class B() {
+    open fun <caret>foo()
+}
diff --git a/idea/testData/quickfix/addPrimaryConstructor/afterAddPrimaryConstructor1.kt b/idea/testData/quickfix/addPrimaryConstructor/afterAddPrimaryConstructor1.kt
new file mode 100644
index 00000000000..bf7a9a22a5d
--- /dev/null
+++ b/idea/testData/quickfix/addPrimaryConstructor/afterAddPrimaryConstructor1.kt
@@ -0,0 +1,6 @@
+// "Add primary constructor to A" "true"
+namespace a
+
+class A() {
+    var i : Int = <caret>1
+}
diff --git a/idea/testData/quickfix/addPrimaryConstructor/afterAddPrimaryConstructor2.kt b/idea/testData/quickfix/addPrimaryConstructor/afterAddPrimaryConstructor2.kt
new file mode 100644
index 00000000000..71ddc338e46
--- /dev/null
+++ b/idea/testData/quickfix/addPrimaryConstructor/afterAddPrimaryConstructor2.kt
@@ -0,0 +1,6 @@
+// "Add primary constructor to A" "true"
+namespace a
+
+class A<caret>() {
+    var i : Int = 1
+}
diff --git a/idea/testData/quickfix/addPrimaryConstructor/beforeAddPrimaryConstructor1.kt b/idea/testData/quickfix/addPrimaryConstructor/beforeAddPrimaryConstructor1.kt
new file mode 100644
index 00000000000..8d4c44c292f
--- /dev/null
+++ b/idea/testData/quickfix/addPrimaryConstructor/beforeAddPrimaryConstructor1.kt
@@ -0,0 +1,6 @@
+// "Add primary constructor to A" "true"
+namespace a
+
+class A {
+    var i : Int = <caret>1
+}
diff --git a/idea/testData/quickfix/addPrimaryConstructor/beforeAddPrimaryConstructor2.kt b/idea/testData/quickfix/addPrimaryConstructor/beforeAddPrimaryConstructor2.kt
new file mode 100644
index 00000000000..dd6ce1b5889
--- /dev/null
+++ b/idea/testData/quickfix/addPrimaryConstructor/beforeAddPrimaryConstructor2.kt
@@ -0,0 +1,6 @@
+// "Add primary constructor to A" "true"
+namespace a
+
+class A<caret> {
+    var i : Int = 1
+}
diff --git a/idea/testData/quickfix/changeVariableMutability/afterValWithSetter.kt b/idea/testData/quickfix/changeVariableMutability/afterValWithSetter.kt
new file mode 100644
index 00000000000..86d2423c318
--- /dev/null
+++ b/idea/testData/quickfix/changeVariableMutability/afterValWithSetter.kt
@@ -0,0 +1,5 @@
+// "Make variable mutable" "true"
+class A() {
+    var a: Int = 0
+        <caret>set(v: Int) {}
+}
diff --git a/idea/testData/quickfix/changeVariableMutability/beforeValWithSetter.kt b/idea/testData/quickfix/changeVariableMutability/beforeValWithSetter.kt
new file mode 100644
index 00000000000..8cd3efeb193
--- /dev/null
+++ b/idea/testData/quickfix/changeVariableMutability/beforeValWithSetter.kt
@@ -0,0 +1,5 @@
+// "Make variable mutable" "true"
+class A() {
+    val a: Int = 0
+        <caret>set(v: Int) {}
+}
diff --git a/idea/testData/quickfix/classImport/afterHasThisImport.kt b/idea/testData/quickfix/classImport/afterHasThisImport.kt
new file mode 100644
index 00000000000..097dd252598
--- /dev/null
+++ b/idea/testData/quickfix/classImport/afterHasThisImport.kt
@@ -0,0 +1,15 @@
+// "Remove initializer from property" "true"
+namespace a
+
+import java.util.Collections
+
+namespace b {
+
+import java.util.List
+
+class M {
+    trait A {
+        val l : <caret>List<Int>?
+    }
+}
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/classImport/afterNoImportJavaLang.kt b/idea/testData/quickfix/classImport/afterNoImportJavaLang.kt
new file mode 100644
index 00000000000..1ffb2769998
--- /dev/null
+++ b/idea/testData/quickfix/classImport/afterNoImportJavaLang.kt
@@ -0,0 +1,8 @@
+// "Remove initializer from property" "true"
+namespace a
+
+class M {
+    trait A {
+        abstract val e : <caret>Exception
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/classImport/afterNoImportJetStandard.kt b/idea/testData/quickfix/classImport/afterNoImportJetStandard.kt
new file mode 100644
index 00000000000..dc3f621c67e
--- /dev/null
+++ b/idea/testData/quickfix/classImport/afterNoImportJetStandard.kt
@@ -0,0 +1,8 @@
+// "Remove initializer from property" "true"
+namespace a
+
+class M {
+    trait A {
+        abstract val i : <caret>Int
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/classImport/afterToImport1.kt b/idea/testData/quickfix/classImport/afterToImport1.kt
new file mode 100644
index 00000000000..60d9ffb0c1b
--- /dev/null
+++ b/idea/testData/quickfix/classImport/afterToImport1.kt
@@ -0,0 +1,11 @@
+// "Remove initializer from property" "true"
+namespace a
+
+import java.util.Collections
+import java.util.List
+
+class M {
+    trait A {
+        abstract val l : <caret>List<Int>?
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/classImport/afterToImport2.kt b/idea/testData/quickfix/classImport/afterToImport2.kt
new file mode 100644
index 00000000000..60556ccd964
--- /dev/null
+++ b/idea/testData/quickfix/classImport/afterToImport2.kt
@@ -0,0 +1,15 @@
+// "Remove initializer from property" "true"
+namespace a
+
+import java.util.Collections
+
+namespace b {
+
+import java.util.List
+
+class M {
+    trait A {
+        abstract val l : <caret>List<Int>?
+    }
+}
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/classImport/beforeHasThisImport.kt b/idea/testData/quickfix/classImport/beforeHasThisImport.kt
new file mode 100644
index 00000000000..bfcc05e9b9c
--- /dev/null
+++ b/idea/testData/quickfix/classImport/beforeHasThisImport.kt
@@ -0,0 +1,15 @@
+// "Remove initializer from property" "true"
+namespace a
+
+import java.util.Collections
+
+namespace b {
+
+import java.util.List
+
+class M {
+    trait A {
+        val l = <caret>Collections.emptyList<Int>()
+    }
+}
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/classImport/beforeNoImportJavaLang.kt b/idea/testData/quickfix/classImport/beforeNoImportJavaLang.kt
new file mode 100644
index 00000000000..d81efa4eaa8
--- /dev/null
+++ b/idea/testData/quickfix/classImport/beforeNoImportJavaLang.kt
@@ -0,0 +1,8 @@
+// "Remove initializer from property" "true"
+namespace a
+
+class M {
+    trait A {
+        abstract val e = <caret>Exception("")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/classImport/beforeNoImportJetStandard.kt b/idea/testData/quickfix/classImport/beforeNoImportJetStandard.kt
new file mode 100644
index 00000000000..320776e668a
--- /dev/null
+++ b/idea/testData/quickfix/classImport/beforeNoImportJetStandard.kt
@@ -0,0 +1,8 @@
+// "Remove initializer from property" "true"
+namespace a
+
+class M {
+    trait A {
+        abstract val i = <caret>10
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/classImport/beforeToImport1.kt b/idea/testData/quickfix/classImport/beforeToImport1.kt
new file mode 100644
index 00000000000..075adebf27d
--- /dev/null
+++ b/idea/testData/quickfix/classImport/beforeToImport1.kt
@@ -0,0 +1,10 @@
+// "Remove initializer from property" "true"
+namespace a
+
+import java.util.Collections
+
+class M {
+    trait A {
+        abstract val l = <caret>Collections.emptyList<Int>()
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/classImport/beforeToImport2.kt b/idea/testData/quickfix/classImport/beforeToImport2.kt
new file mode 100644
index 00000000000..c99cd4ebe4d
--- /dev/null
+++ b/idea/testData/quickfix/classImport/beforeToImport2.kt
@@ -0,0 +1,13 @@
+// "Remove initializer from property" "true"
+namespace a
+
+import java.util.Collections
+
+namespace b {
+
+class M {
+    trait A {
+        abstract val l = <caret>Collections.emptyList<Int>()
+    }
+}
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/expressions/afterUnnecessarySafeCall1.kt b/idea/testData/quickfix/expressions/afterUnnecessarySafeCall1.kt
new file mode 100644
index 00000000000..7422cfd3f6b
--- /dev/null
+++ b/idea/testData/quickfix/expressions/afterUnnecessarySafeCall1.kt
@@ -0,0 +1,4 @@
+// "Replace to dot call" "true"
+fun foo(a: Any) {
+    <caret>a.equals(0)
+}
diff --git a/idea/testData/quickfix/expressions/afterUnnecessarySafeCall2.kt b/idea/testData/quickfix/expressions/afterUnnecessarySafeCall2.kt
new file mode 100644
index 00000000000..f5efe05b2ea
--- /dev/null
+++ b/idea/testData/quickfix/expressions/afterUnnecessarySafeCall2.kt
@@ -0,0 +1,7 @@
+// "Replace to dot call" "true"
+fun foo(a: Any) {
+    when (a) {
+        .equals(0) => true
+        else => false
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/expressions/afterUselessCast.kt b/idea/testData/quickfix/expressions/afterUselessCast.kt
new file mode 100644
index 00000000000..792e9c049bb
--- /dev/null
+++ b/idea/testData/quickfix/expressions/afterUselessCast.kt
@@ -0,0 +1,4 @@
+// "Replace a cast with a static assert" "true"
+fun foo(a: String) {
+    val b = a : Any
+}
diff --git a/idea/testData/quickfix/expressions/afterUselessCastStaticAssertIsFine.kt b/idea/testData/quickfix/expressions/afterUselessCastStaticAssertIsFine.kt
new file mode 100644
index 00000000000..ff2e05cc364
--- /dev/null
+++ b/idea/testData/quickfix/expressions/afterUselessCastStaticAssertIsFine.kt
@@ -0,0 +1,4 @@
+// "Remove cast" "true"
+fun foo(a: Any) {
+    val b = a<caret>
+}
diff --git a/idea/testData/quickfix/expressions/afterUselessElvis.kt b/idea/testData/quickfix/expressions/afterUselessElvis.kt
new file mode 100644
index 00000000000..e76b3b56841
--- /dev/null
+++ b/idea/testData/quickfix/expressions/afterUselessElvis.kt
@@ -0,0 +1,4 @@
+// "Remove elvis operator" "true"
+fun foo(a: String) {
+    val b : String = <caret>a
+}
diff --git a/idea/testData/quickfix/expressions/beforeUnnecessarySafeCall1.kt b/idea/testData/quickfix/expressions/beforeUnnecessarySafeCall1.kt
new file mode 100644
index 00000000000..61063ff4cc4
--- /dev/null
+++ b/idea/testData/quickfix/expressions/beforeUnnecessarySafeCall1.kt
@@ -0,0 +1,4 @@
+// "Replace to dot call" "true"
+fun foo(a: Any) {
+    a<caret>?.equals(0)
+}
diff --git a/idea/testData/quickfix/expressions/beforeUnnecessarySafeCall2.kt b/idea/testData/quickfix/expressions/beforeUnnecessarySafeCall2.kt
new file mode 100644
index 00000000000..40f33005054
--- /dev/null
+++ b/idea/testData/quickfix/expressions/beforeUnnecessarySafeCall2.kt
@@ -0,0 +1,7 @@
+// "Replace to dot call" "true"
+fun foo(a: Any) {
+    when (a) {
+        <caret>?.equals(0) => true
+        else => false
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/expressions/beforeUselessCast.kt b/idea/testData/quickfix/expressions/beforeUselessCast.kt
new file mode 100644
index 00000000000..ab4debc2fe2
--- /dev/null
+++ b/idea/testData/quickfix/expressions/beforeUselessCast.kt
@@ -0,0 +1,4 @@
+// "Replace a cast with a static assert" "true"
+fun foo(a: String) {
+    val b = a <caret>as Any
+}
diff --git a/idea/testData/quickfix/expressions/beforeUselessCastStaticAssertIsFine.kt b/idea/testData/quickfix/expressions/beforeUselessCastStaticAssertIsFine.kt
new file mode 100644
index 00000000000..3d29461c52e
--- /dev/null
+++ b/idea/testData/quickfix/expressions/beforeUselessCastStaticAssertIsFine.kt
@@ -0,0 +1,4 @@
+// "Remove cast" "true"
+fun foo(a: Any) {
+    val b = a <caret>as Any
+}
diff --git a/idea/testData/quickfix/expressions/beforeUselessElvis.kt b/idea/testData/quickfix/expressions/beforeUselessElvis.kt
new file mode 100644
index 00000000000..3f046028f6c
--- /dev/null
+++ b/idea/testData/quickfix/expressions/beforeUselessElvis.kt
@@ -0,0 +1,4 @@
+// "Remove elvis operator" "true"
+fun foo(a: String) {
+    val b : String = <caret>a ?: "s"
+}
diff --git a/idea/testData/quickfix/modifiers/afterFinalTrait.kt b/idea/testData/quickfix/modifiers/afterFinalTrait.kt
new file mode 100644
index 00000000000..d5b8bbf86c6
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/afterFinalTrait.kt
@@ -0,0 +1,2 @@
+// "Remove 'final' modifier" "true"
+<caret>trait A {}
\ No newline at end of file
diff --git a/idea/testData/quickfix/modifiers/afterNonFinalAccessorOfFinalProperty1.kt b/idea/testData/quickfix/modifiers/afterNonFinalAccessorOfFinalProperty1.kt
new file mode 100644
index 00000000000..7ae88e4147a
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/afterNonFinalAccessorOfFinalProperty1.kt
@@ -0,0 +1,5 @@
+// "Make 'i' open" "true"
+open class A() {
+    open val i: Int = 1
+    <caret>open get(): Int = $i
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/modifiers/afterNonFinalAccessorOfFinalProperty2.kt b/idea/testData/quickfix/modifiers/afterNonFinalAccessorOfFinalProperty2.kt
new file mode 100644
index 00000000000..62cf211cb44
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/afterNonFinalAccessorOfFinalProperty2.kt
@@ -0,0 +1,5 @@
+// "Make 'get' not open" "true"
+open class A() {
+    val i: Int = 1
+    <caret>get(): Int = $i
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/modifiers/afterOpenMemberInFinalClass1.kt b/idea/testData/quickfix/modifiers/afterOpenMemberInFinalClass1.kt
new file mode 100644
index 00000000000..cf2f155fc9a
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/afterOpenMemberInFinalClass1.kt
@@ -0,0 +1,4 @@
+// "Make 'A' open" "true"
+open class A() {
+    <caret>open fun foo() {}
+}
diff --git a/idea/testData/quickfix/modifiers/afterOpenMemberInFinalClass2.kt b/idea/testData/quickfix/modifiers/afterOpenMemberInFinalClass2.kt
new file mode 100644
index 00000000000..1d4c97459f7
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/afterOpenMemberInFinalClass2.kt
@@ -0,0 +1,4 @@
+// "Make 'foo' not open" "true"
+class A() {
+    <caret>fun foo() {}
+}
diff --git a/idea/testData/quickfix/modifiers/afterRemoveRedundantModifier1.kt b/idea/testData/quickfix/modifiers/afterRemoveRedundantModifier1.kt
new file mode 100644
index 00000000000..38c63050707
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/afterRemoveRedundantModifier1.kt
@@ -0,0 +1,8 @@
+// "Remove redundant 'open' modifier" "true"
+abstract class B() {
+    abstract fun foo()
+}
+
+abstract class A() : B() {
+    <caret>abstract override fun foo()
+}
diff --git a/idea/testData/quickfix/modifiers/afterRemoveRedundantModifier2.kt b/idea/testData/quickfix/modifiers/afterRemoveRedundantModifier2.kt
new file mode 100644
index 00000000000..181b7b6aadc
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/afterRemoveRedundantModifier2.kt
@@ -0,0 +1,8 @@
+// "Remove redundant 'open' modifier" "true"
+abstract class B() {
+    abstract fun foo()
+}
+
+abstract class A() : B() {
+    abstract <caret>override fun foo()
+}
diff --git a/idea/testData/quickfix/modifiers/afterRemoveRedundantModifier3.kt b/idea/testData/quickfix/modifiers/afterRemoveRedundantModifier3.kt
new file mode 100644
index 00000000000..2f6b03af29c
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/afterRemoveRedundantModifier3.kt
@@ -0,0 +1,8 @@
+// "Remove redundant 'open' modifier" "true"
+abstract class B() {
+    abstract fun foo()
+}
+
+abstract class A() : B() {
+    abstract override<caret> fun foo()
+}
diff --git a/idea/testData/quickfix/modifiers/beforeFinalTrait.kt b/idea/testData/quickfix/modifiers/beforeFinalTrait.kt
new file mode 100644
index 00000000000..61895997169
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/beforeFinalTrait.kt
@@ -0,0 +1,2 @@
+// "Remove 'final' modifier" "true"
+<caret>final trait A {}
\ No newline at end of file
diff --git a/idea/testData/quickfix/modifiers/beforeNonFinalAccessorOfFinalProperty1.kt b/idea/testData/quickfix/modifiers/beforeNonFinalAccessorOfFinalProperty1.kt
new file mode 100644
index 00000000000..da2f748ec26
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/beforeNonFinalAccessorOfFinalProperty1.kt
@@ -0,0 +1,5 @@
+// "Make 'i' open" "true"
+open class A() {
+    val i: Int = 1
+    <caret>open get(): Int = $i
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/modifiers/beforeNonFinalAccessorOfFinalProperty2.kt b/idea/testData/quickfix/modifiers/beforeNonFinalAccessorOfFinalProperty2.kt
new file mode 100644
index 00000000000..868366c07ba
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/beforeNonFinalAccessorOfFinalProperty2.kt
@@ -0,0 +1,5 @@
+// "Make 'get' not open" "true"
+open class A() {
+    val i: Int = 1
+    <caret>open get(): Int = $i
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/modifiers/beforeOpenMemberInFinalClass1.kt b/idea/testData/quickfix/modifiers/beforeOpenMemberInFinalClass1.kt
new file mode 100644
index 00000000000..7fe2cfa5d53
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/beforeOpenMemberInFinalClass1.kt
@@ -0,0 +1,4 @@
+// "Make 'A' open" "true"
+class A() {
+    <caret>open fun foo() {}
+}
diff --git a/idea/testData/quickfix/modifiers/beforeOpenMemberInFinalClass2.kt b/idea/testData/quickfix/modifiers/beforeOpenMemberInFinalClass2.kt
new file mode 100644
index 00000000000..f46a98892ae
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/beforeOpenMemberInFinalClass2.kt
@@ -0,0 +1,4 @@
+// "Make 'foo' not open" "true"
+class A() {
+    <caret>open fun foo() {}
+}
diff --git a/idea/testData/quickfix/modifiers/beforeRemoveRedundantModifier1.kt b/idea/testData/quickfix/modifiers/beforeRemoveRedundantModifier1.kt
new file mode 100644
index 00000000000..acec3eb7ca5
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/beforeRemoveRedundantModifier1.kt
@@ -0,0 +1,8 @@
+// "Remove redundant 'open' modifier" "true"
+abstract class B() {
+    abstract fun foo()
+}
+
+abstract class A() : B() {
+    <caret>open abstract override fun foo()
+}
diff --git a/idea/testData/quickfix/modifiers/beforeRemoveRedundantModifier2.kt b/idea/testData/quickfix/modifiers/beforeRemoveRedundantModifier2.kt
new file mode 100644
index 00000000000..0e158cee4dc
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/beforeRemoveRedundantModifier2.kt
@@ -0,0 +1,8 @@
+// "Remove redundant 'open' modifier" "true"
+abstract class B() {
+    abstract fun foo()
+}
+
+abstract class A() : B() {
+    abstract <caret>open override fun foo()
+}
diff --git a/idea/testData/quickfix/modifiers/beforeRemoveRedundantModifier3.kt b/idea/testData/quickfix/modifiers/beforeRemoveRedundantModifier3.kt
new file mode 100644
index 00000000000..7db5121da51
--- /dev/null
+++ b/idea/testData/quickfix/modifiers/beforeRemoveRedundantModifier3.kt
@@ -0,0 +1,8 @@
+// "Remove redundant 'open' modifier" "true"
+abstract class B() {
+    abstract fun foo()
+}
+
+abstract class A() : B() {
+    abstract override <caret>open fun foo()
+}
diff --git a/idea/testData/quickfix/override/afterNothingToOverride.kt b/idea/testData/quickfix/override/afterNothingToOverride.kt
new file mode 100644
index 00000000000..54d60343c52
--- /dev/null
+++ b/idea/testData/quickfix/override/afterNothingToOverride.kt
@@ -0,0 +1,4 @@
+// "Remove 'override' modifier" "true"
+class A() {
+    <caret>fun foo() {}
+}
diff --git a/idea/testData/quickfix/override/afterVirtualMethodHidden.kt b/idea/testData/quickfix/override/afterVirtualMethodHidden.kt
new file mode 100644
index 00000000000..9bc0fa63ac2
--- /dev/null
+++ b/idea/testData/quickfix/override/afterVirtualMethodHidden.kt
@@ -0,0 +1,8 @@
+// "Add 'override' modifier" "true"
+open class A() {
+    fun foo() {}
+}
+
+class B() : A() {
+    override fun <caret>foo() {}
+}
diff --git a/idea/testData/quickfix/override/beforeNothingToOverride.kt b/idea/testData/quickfix/override/beforeNothingToOverride.kt
new file mode 100644
index 00000000000..e33553d62a5
--- /dev/null
+++ b/idea/testData/quickfix/override/beforeNothingToOverride.kt
@@ -0,0 +1,4 @@
+// "Remove 'override' modifier" "true"
+class A() {
+    <caret>override fun foo() {}
+}
diff --git a/idea/testData/quickfix/override/beforeVirtualMethodHidden.kt b/idea/testData/quickfix/override/beforeVirtualMethodHidden.kt
new file mode 100644
index 00000000000..682cdee3abd
--- /dev/null
+++ b/idea/testData/quickfix/override/beforeVirtualMethodHidden.kt
@@ -0,0 +1,8 @@
+// "Add 'override' modifier" "true"
+open class A() {
+    fun foo() {}
+}
+
+class B() : A() {
+    fun <caret>foo() {}
+}
diff --git a/idea/testData/quickfix/typeAddition/afterWrongGetterParameterType.kt b/idea/testData/quickfix/typeAddition/afterWrongGetterParameterType.kt
new file mode 100644
index 00000000000..bd4fd0c6519
--- /dev/null
+++ b/idea/testData/quickfix/typeAddition/afterWrongGetterParameterType.kt
@@ -0,0 +1,5 @@
+// "Change getter type to Int" "true"
+class A() {
+    val i: Int
+    get(): Int = 1
+}
diff --git a/idea/testData/quickfix/typeAddition/afterWrongSetterParameterType.kt b/idea/testData/quickfix/typeAddition/afterWrongSetterParameterType.kt
new file mode 100644
index 00000000000..99e86a2179d
--- /dev/null
+++ b/idea/testData/quickfix/typeAddition/afterWrongSetterParameterType.kt
@@ -0,0 +1,5 @@
+// "Change setter parameter type to Int" "true"
+class A() {
+    var i: Int = 0
+    set(v: Int) {}
+}
diff --git a/idea/testData/quickfix/typeAddition/beforeWrongGetterParameterType.kt b/idea/testData/quickfix/typeAddition/beforeWrongGetterParameterType.kt
new file mode 100644
index 00000000000..5e9d12911c8
--- /dev/null
+++ b/idea/testData/quickfix/typeAddition/beforeWrongGetterParameterType.kt
@@ -0,0 +1,5 @@
+// "Change getter type to Int" "true"
+class A() {
+    val i: Int
+    get(): <caret>Any = 1
+}
diff --git a/idea/testData/quickfix/typeAddition/beforeWrongSetterParameterType.kt b/idea/testData/quickfix/typeAddition/beforeWrongSetterParameterType.kt
new file mode 100644
index 00000000000..b84c2887217
--- /dev/null
+++ b/idea/testData/quickfix/typeAddition/beforeWrongSetterParameterType.kt
@@ -0,0 +1,5 @@
+// "Change setter parameter type to Int" "true"
+class A() {
+    var i: Int = 0
+    set(v: <caret>Any) {}
+}
diff --git a/idea/testData/resolve/ClassObjects.jet b/idea/testData/resolve/ClassObjects.jet
index b4e898550d1..f698650f962 100644
--- a/idea/testData/resolve/ClassObjects.jet
+++ b/idea/testData/resolve/ClassObjects.jet
@@ -11,5 +11,5 @@ namespace Jet86
 }
 
 val a = `A`A.`A.x`x
-val c = `B`B.`!null`x
+val c = `B`B.`!error`x
 val d = B().`B.x`x
\ No newline at end of file
diff --git a/idea/testData/resolve/ErrorSupertype.jet b/idea/testData/resolve/ErrorSupertype.jet
new file mode 100644
index 00000000000..c1395fb8d1a
--- /dev/null
+++ b/idea/testData/resolve/ErrorSupertype.jet
@@ -0,0 +1,3 @@
+class C(x : `std::Int`Int) : NotFound {
+    val xx : `std::Int`Int
+}
\ No newline at end of file
diff --git a/idea/testData/resolve/ExtensionFunctions.jet b/idea/testData/resolve/ExtensionFunctions.jet
index 1570a549f4e..73d2ac45cfc 100644
--- a/idea/testData/resolve/ExtensionFunctions.jet
+++ b/idea/testData/resolve/ExtensionFunctions.jet
@@ -13,7 +13,7 @@ fun <~T~T, ~E~E> `T`T.foo(x : `E`E, y : `A`A) : `T`T   {
 ~+1~fun `A`A.plus(a : Any) {
 
   1.`foo`foo()
-  true.`foo`foo()
+  true.`!null`foo()
 
   1
 }
diff --git a/idea/testData/resolve/Objects.jet b/idea/testData/resolve/Objects.jet
index 92bbae39532..e59a6f1252c 100644
--- a/idea/testData/resolve/Objects.jet
+++ b/idea/testData/resolve/Objects.jet
@@ -1,6 +1,6 @@
 namespace toplevelObjectDeclarations {
   class Foo(y : Int) {
-    ~foo()~virtual fun foo() : Int = 1
+    ~foo()~open fun foo() : Int = 1
   }
 
   object ~A~A : Foo(0) {
diff --git a/idea/testData/resolve/Projections.jet b/idea/testData/resolve/Projections.jet
index 4c017746adf..65a2de5aab9 100644
--- a/idea/testData/resolve/Projections.jet
+++ b/idea/testData/resolve/Projections.jet
@@ -18,8 +18,8 @@ class Inv<T>() {
 fun testInOut() {
   In<String>().`In.f:T->Unit`f("1");
   (return : In<in String>).`In.f:T->Unit`f("1");
-  (return : In<out String>).`!`f("1")
-  (return : In<*>).`!`f("1");
+  (return : In<out String>).`In.f:Int->Int`f("1")
+  (return : In<*>).`In.f:Int->Int`f("1");
 
   In<String>().`In.f:Int->Int`f(1);
   (return : In<in String>).`In.f:Int->Int`f(1);
diff --git a/idea/testData/resolve/ResolveOfInfixExpressions.jet b/idea/testData/resolve/ResolveOfInfixExpressions.jet
index c7f22629218..de55e5a7ace 100644
--- a/idea/testData/resolve/ResolveOfInfixExpressions.jet
+++ b/idea/testData/resolve/ResolveOfInfixExpressions.jet
@@ -62,15 +62,15 @@ fun <T> tt(t : T) : T {
   val x : List<Int> = 0
   x`java::java.util.List.get()`[1]
   val foo = `Bar()`Bar()
-  foo`!`[null, 1]
+  foo`!!`[null, 1]
   foo`get2`[1, 1]
   foo`get1`[1]
   foo`set1`[1] = ""
-  foo`!`[1, 2] = ""
+  foo`set1`[1, 2] = ""
   x`java::java.util.List.set()`[1] = null
   (x`java::java.util.List.set()`[1]) = null
-  x`!`[null] = null
-  (x`!`[null, 2]) = null
+  x`java::java.util.List.set()`[null] = null
+  (x`java::java.util.List.set()`[null, 2]) = null
   (`not`!foo)[1]`:std::Char`
   val y = Bar()
   y`inc`++
diff --git a/idea/testData/resolve/ResolveToJava.jet b/idea/testData/resolve/ResolveToJava.jet
index 4991400172d..d9a0e8bf7dd 100644
--- a/idea/testData/resolve/ResolveToJava.jet
+++ b/idea/testData/resolve/ResolveToJava.jet
@@ -42,7 +42,7 @@ class B : `java::java.lang.Object`Object {
 fun <T> t(t : T) : T {
   `c`c(java.lang.Integer(1))
   System.out.`java::java.io.PrintStream.print(Object)`print(t)
-  System.out.`java::java.io.PrintStream.print(char[])`print(null : Array<Char>?)
+  System.out.`java::java.io.PrintStream.print(char[])`print(null : CharArray?)
   System.out.`java::java.io.PrintStream.print(Object)`print(null : Object?)
   System.out.`java::java.io.PrintStream.print(Int)`print(1)
   System.out.`java::java.io.PrintStream.print(Double)`print(1.0)
diff --git a/idea/testData/resolve/regressions/kt300.jet b/idea/testData/resolve/regressions/kt300.jet
new file mode 100644
index 00000000000..aaaf340f3a7
--- /dev/null
+++ b/idea/testData/resolve/regressions/kt300.jet
@@ -0,0 +1,9 @@
+// KT-300 Overload ambiguity while accessing range
+
+class MyRange() : Range<Int> {
+    ~in~override fun contains(item: Int) = true
+}
+
+fun foo(x: Int?, range: MyRange) {
+    x `in`in range // Int? found, but Int expected
+}
\ No newline at end of file
diff --git a/idea/tests/org/jetbrains/jet/JetLiteFixture.java b/idea/tests/org/jetbrains/jet/JetLiteFixture.java
new file mode 100644
index 00000000000..a2142bee57c
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/JetLiteFixture.java
@@ -0,0 +1,189 @@
+package org.jetbrains.jet;
+
+import com.intellij.ide.startup.impl.StartupManagerImpl;
+import com.intellij.lang.*;
+import com.intellij.lang.impl.PsiBuilderFactoryImpl;
+import com.intellij.mock.*;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.EditorFactory;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.fileEditor.impl.FileDocumentManagerImpl;
+import com.intellij.openapi.fileEditor.impl.LoadTextUtil;
+import com.intellij.openapi.fileTypes.FileTypeFactory;
+import com.intellij.openapi.fileTypes.FileTypeManager;
+import com.intellij.openapi.options.SchemesManagerFactory;
+import com.intellij.openapi.progress.impl.ProgressManagerImpl;
+import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.CharsetToolkit;
+import com.intellij.psi.*;
+import com.intellij.psi.impl.PsiCachedValuesFactory;
+import com.intellij.psi.impl.PsiFileFactoryImpl;
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistryImpl;
+import com.intellij.psi.util.CachedValuesManager;
+import com.intellij.testFramework.LightVirtualFile;
+import com.intellij.testFramework.MockSchemesManagerFactory;
+import com.intellij.testFramework.PlatformLiteFixture;
+import com.intellij.testFramework.TestDataFile;
+import com.intellij.util.CachedValuesManagerImpl;
+import com.intellij.util.Function;
+import com.intellij.util.messages.MessageBus;
+import com.intellij.util.messages.MessageBusFactory;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.jet.lang.parsing.JetParserDefinition;
+import org.picocontainer.MutablePicoContainer;
+import org.picocontainer.PicoContainer;
+import org.picocontainer.PicoInitializationException;
+import org.picocontainer.PicoIntrospectionException;
+import org.picocontainer.defaults.AbstractComponentAdapter;
+
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * @author abreslav
+ */
+public abstract class JetLiteFixture extends PlatformLiteFixture {
+    protected String myFileExt;
+    @NonNls
+    protected final String myFullDataPath;
+    protected PsiFile myFile;
+    private MockPsiManager myPsiManager;
+    private PsiFileFactoryImpl myFileFactory;
+    protected Language myLanguage;
+    protected final ParserDefinition[] myDefinitions;
+
+    public JetLiteFixture(@NonNls String dataPath) {
+        myFileExt = "jet";
+        myFullDataPath = getTestDataPath() + "/" + dataPath;
+        myDefinitions = new ParserDefinition[] {new JetParserDefinition()};
+    }
+
+    protected String getTestDataPath() {
+        return JetTestCaseBase.getTestDataPathBase();
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        initApplication();
+        getApplication().getPicoContainer().registerComponent(new AbstractComponentAdapter("com.intellij.openapi.progress.ProgressManager", Object.class) {
+            @Override
+            public Object getComponentInstance(PicoContainer container) throws PicoInitializationException, PicoIntrospectionException {
+                return new ProgressManagerImpl(getApplication());
+            }
+
+            @Override
+            public void verify(PicoContainer container) throws PicoIntrospectionException {
+            }
+        });
+        myProject = disposeOnTearDown(new MockProjectEx(getTestRootDisposable()));
+        myPsiManager = new MockPsiManager(myProject);
+        myFileFactory = new PsiFileFactoryImpl(myPsiManager);
+        final MutablePicoContainer appContainer = getApplication().getPicoContainer();
+        registerComponentInstance(appContainer, MessageBus.class, MessageBusFactory.newMessageBus(getApplication()));
+        registerComponentInstance(appContainer, SchemesManagerFactory.class, new MockSchemesManagerFactory());
+        final MockEditorFactory editorFactory = new MockEditorFactory();
+        registerComponentInstance(appContainer, EditorFactory.class, editorFactory);
+        registerComponentInstance(appContainer, FileDocumentManager.class, new MockFileDocumentManagerImpl(new Function<CharSequence, Document>() {
+            @Override
+            public Document fun(CharSequence charSequence) {
+                return editorFactory.createDocument(charSequence);
+            }
+        }, FileDocumentManagerImpl.DOCUMENT_KEY));
+        registerComponentInstance(appContainer, PsiDocumentManager.class, new MockPsiDocumentManager());
+        myLanguage = myLanguage == null && myDefinitions != null && myDefinitions.length > 0
+                     ? myDefinitions[0].getFileNodeType().getLanguage()
+                     : myLanguage;
+        registerComponentInstance(appContainer, FileTypeManager.class, new MockFileTypeManager(new MockLanguageFileType(myLanguage, myFileExt)));
+        registerApplicationService(PsiBuilderFactory.class, new PsiBuilderFactoryImpl());
+        registerApplicationService(DefaultASTFactory.class, new DefaultASTFactoryImpl());
+        registerApplicationService(ReferenceProvidersRegistry.class, new ReferenceProvidersRegistryImpl());
+        myProject.registerService(CachedValuesManager.class, new CachedValuesManagerImpl(myProject, new PsiCachedValuesFactory(myPsiManager)));
+        myProject.registerService(PsiManager.class, myPsiManager);
+        myProject.registerService(StartupManager.class, new StartupManagerImpl(myProject));
+        myProject.registerService(PsiFileFactory.class, new PsiFileFactoryImpl(myPsiManager));
+
+        registerExtensionPoint(FileTypeFactory.FILE_TYPE_FACTORY_EP, FileTypeFactory.class);
+
+        for (ParserDefinition definition : myDefinitions) {
+            addExplicitExtension(LanguageParserDefinitions.INSTANCE, definition.getFileNodeType().getLanguage(), definition);
+        }
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        myFile = null;
+        myProject = null;
+        myPsiManager = null;
+    }
+
+    protected String loadFile(@NonNls @TestDataFile String name) throws IOException {
+        return doLoadFile(myFullDataPath, name);
+    }
+
+    protected static String doLoadFile(String myFullDataPath, String name) throws IOException {
+        String fullName = myFullDataPath + File.separatorChar + name;
+        String text = FileUtil.loadFile(new File(fullName), CharsetToolkit.UTF8).trim();
+        text = StringUtil.convertLineSeparators(text);
+        return text;
+    }
+
+    protected PsiFile createPsiFile(String name, String text) {
+        return createFile(name + "." + myFileExt, text);
+    }
+
+    protected PsiFile createFile(@NonNls String name, String text) {
+        LightVirtualFile virtualFile = new LightVirtualFile(name, myLanguage, text);
+        virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
+        return myFileFactory.trySetupPsiForFile(virtualFile, myLanguage, true, false);
+    }
+
+    protected static void ensureParsed(PsiFile file) {
+        file.accept(new PsiElementVisitor() {
+            @Override
+            public void visitElement(PsiElement element) {
+                element.acceptChildren(this);
+            }
+        });
+    }
+
+    protected <T> void registerApplicationService(final Class<T> aClass, T object) {
+        getApplication().registerService(aClass, object);
+        Disposer.register(myProject, new Disposable() {
+            @Override
+            public void dispose() {
+                getApplication().getPicoContainer().unregisterComponent(aClass.getName());
+            }
+        });
+    }
+
+    protected <T> void addExplicitExtension(final LanguageExtension<T> instance, final Language language, final T object) {
+        instance.addExplicitExtension(language, object);
+        Disposer.register(myProject, new Disposable() {
+            @Override
+            public void dispose() {
+                instance.removeExplicitExtension(language, object);
+            }
+        });
+    }
+
+    protected void prepareForTest(String name) throws IOException {
+        String text = loadFile(name + "." + myFileExt);
+        createAndCheckPsiFile(name, text);
+    }
+
+    protected void createAndCheckPsiFile(String name, String text) {
+        myFile = createPsiFile(name, text);
+        ensureParsed(myFile);
+        assertEquals("light virtual file text mismatch", text, ((LightVirtualFile) myFile.getVirtualFile()).getContent().toString());
+        assertEquals("virtual file text mismatch", text, LoadTextUtil.loadText(myFile.getVirtualFile()));
+        assertEquals("doc text mismatch", text, myFile.getViewProvider().getDocument().getText());
+        assertEquals("psi text mismatch", text, myFile.getText());
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/JetTestCaseBase.java b/idea/tests/org/jetbrains/jet/JetTestCaseBase.java
index 5ae4d8ff51e..f6ba28dcb72 100644
--- a/idea/tests/org/jetbrains/jet/JetTestCaseBase.java
+++ b/idea/tests/org/jetbrains/jet/JetTestCaseBase.java
@@ -43,11 +43,11 @@ public abstract class JetTestCaseBase extends LightDaemonAnalyzerTestCase {
         return getTestDataPathBase();
     }
 
-    protected static String getTestDataPathBase() {
+    public static String getTestDataPathBase() {
         return getHomeDirectory() + "/idea/testData";
     }
 
-    private static String getHomeDirectory() {
+    public static String getHomeDirectory() {
        return new File(PathManager.getResourceRoot(JetTestCaseBase.class, "/org/jetbrains/jet/JetTestCaseBase.class")).getParentFile().getParentFile().getParent();
     }
 
@@ -68,7 +68,11 @@ public abstract class JetTestCaseBase extends LightDaemonAnalyzerTestCase {
 
     @NotNull
     protected String getTestFilePath() {
-        return dataPath + name + ".jet";
+        return dataPath + File.separator + name + ".jet";
+    }
+    
+    protected String getDataPath() {
+        return dataPath;
     }
 
     public interface NamedTestFactory {
diff --git a/idea/tests/org/jetbrains/jet/JetTestUtils.java b/idea/tests/org/jetbrains/jet/JetTestUtils.java
index 794ff6f564a..9cb42a1648e 100644
--- a/idea/tests/org/jetbrains/jet/JetTestUtils.java
+++ b/idea/tests/org/jetbrains/jet/JetTestUtils.java
@@ -1,13 +1,13 @@
 package org.jetbrains.jet;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ErrorHandler;
-import org.jetbrains.jet.lang.JetDiagnostic;
-import org.jetbrains.jet.lang.psi.JetReferenceExpression;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.diagnostics.Severity;
+import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.util.ReadOnlySlice;
-import org.jetbrains.jet.util.WritableSlice;
+import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
+import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 import java.util.Collection;
 
@@ -17,24 +17,13 @@ import java.util.Collection;
 public class JetTestUtils {
     public static final BindingTrace DUMMY_TRACE = new BindingTrace() {
 
-        @NotNull
-        @Override
-        public ErrorHandler getErrorHandler() {
-            return new ErrorHandler() {
-                @Override
-                public void unresolvedReference(@NotNull JetReferenceExpression referenceExpression) {
-                    throw new IllegalStateException("Unresolved: " + referenceExpression.getText());
-                }
-            };
-        }
-
 
         @Override
         public BindingContext getBindingContext() {
             return new BindingContext() {
 
                 @Override
-                public Collection<JetDiagnostic> getDiagnostics() {
+                public Collection<Diagnostic> getDiagnostics() {
                     throw new UnsupportedOperationException(); // TODO
                 }
 
@@ -58,5 +47,50 @@ public class JetTestUtils {
             if (slice == BindingContext.PROCESSED) return (V) Boolean.FALSE;
             return null;
         }
+
+        @Override
+        public void report(@NotNull Diagnostic diagnostic) {
+            if (diagnostic instanceof UnresolvedReferenceDiagnostic) {
+                UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic = (UnresolvedReferenceDiagnostic) diagnostic;
+                throw new IllegalStateException("Unresolved: " + unresolvedReferenceDiagnostic.getPsiElement().getText());
+            }
+        }
     };
+
+    public static BindingTrace DUMMY_EXCEPTION_ON_ERROR_TRACE = new BindingTrace() {
+            @Override
+            public BindingContext getBindingContext() {
+                return new BindingContext() {
+                    @Override
+                    public Collection<Diagnostic> getDiagnostics() {
+                        throw new UnsupportedOperationException();
+                    }
+
+                    @Override
+                    public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
+                        return DUMMY_EXCEPTION_ON_ERROR_TRACE.get(slice, key);
+                    }
+                };
+            }
+
+            @Override
+            public <K, V> void record(WritableSlice<K, V> slice, K key, V value) {
+            }
+
+            @Override
+            public <K> void record(WritableSlice<K, Boolean> slice, K key) {
+            }
+
+            @Override
+            public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
+                return null;
+            }
+
+            @Override
+            public void report(@NotNull Diagnostic diagnostic) {
+                if (diagnostic.getSeverity() == Severity.ERROR) {
+                    throw new IllegalStateException(diagnostic.getMessage());
+                }
+            }
+        };
 }
diff --git a/idea/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java b/idea/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java
index cb320013468..0399c97acf3 100644
--- a/idea/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java
+++ b/idea/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java
@@ -18,7 +18,7 @@ import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamedDeclaration;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -68,7 +68,7 @@ public class JetControlFlowTest extends JetTestCaseBase {
 
         };
 
-        AnalyzingUtils.analyzeNamespace(file.getRootNamespace(), new JetControlFlowDataTraceFactory() {
+        AnalyzerFacade.analyzeNamespace(file.getRootNamespace(), new JetControlFlowDataTraceFactory() {
             @NotNull
             @Override
             public JetPseudocodeTrace createTrace(JetElement element) {
diff --git a/idea/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java b/idea/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java
new file mode 100644
index 00000000000..319e0b06789
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java
@@ -0,0 +1,125 @@
+package org.jetbrains.jet.checkers;
+
+import com.google.common.collect.Lists;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.jet.JetLiteFixture;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.ImportingStrategy;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author abreslav
+ */
+public class CheckerTestUtilTest extends JetLiteFixture {
+
+    public CheckerTestUtilTest() {
+        super("checkerWithErrorTypes/checkerTestUtil");
+    }
+
+    protected void doTest(TheTest theTest) throws Exception {
+        prepareForTest("test");
+        theTest.test(myFile);
+    }
+
+    public void testEquals() throws Exception {
+        doTest(new TheTest() {
+            @Override
+            protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
+            }
+        });
+    }
+
+    public void testMissing() throws Exception {
+        doTest(new TheTest("Missing TYPE_MISMATCH at 56 to 57") {
+            @Override
+            protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
+                diagnostics.remove(0);
+            }
+        });
+    }
+
+    public void testUnexpected() throws Exception {
+        doTest(new TheTest("Unexpected TYPE_MISMATCH at 56 to 57") {
+            @Override
+            protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
+                diagnosedRanges.remove(0);
+            }
+        });
+    }
+
+    public void testBoth() throws Exception {
+        doTest(new TheTest("Unexpected TYPE_MISMATCH at 56 to 57", "Missing UNRESOLVED_REFERENCE at 166 to 168") {
+            @Override
+            protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
+                diagnosedRanges.remove(0);
+                diagnostics.remove(diagnostics.size() - 1);
+            }
+        });
+    }
+
+    public void testMissingInTheMiddle() throws Exception {
+        doTest(new TheTest("Unexpected NONE_APPLICABLE at 122 to 123", "Missing TYPE_MISMATCH at 161 to 169") {
+            @Override
+            protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
+                diagnosedRanges.remove(2);
+                diagnostics.remove(diagnostics.size() - 3);
+            }
+        });
+    }
+
+    private static abstract class TheTest {
+        private final String[] expected;
+
+        protected TheTest(String... expectedMessages) {
+            this.expected = expectedMessages;
+        }
+
+        public void test(PsiFile psiFile) {
+            BindingContext bindingContext = AnalyzingUtils.getInstance(ImportingStrategy.NONE).analyzeFileWithCache((JetFile) psiFile);
+            String expectedText = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, bindingContext).toString();
+
+            List<CheckerTestUtil.DiagnosedRange> diagnosedRanges = Lists.newArrayList();
+            CheckerTestUtil.parseDiagnosedRanges(expectedText, diagnosedRanges);
+
+            List<Diagnostic> diagnostics = Lists.newArrayList(bindingContext.getDiagnostics());
+            Collections.sort(diagnostics, CheckerTestUtil.DIAGNOSTIC_COMPARATOR);
+
+            makeTestData(diagnostics, diagnosedRanges);
+
+            final List<String> expectedMessages = Lists.newArrayList(expected);
+            final List<String> actualMessages = Lists.newArrayList();
+
+            CheckerTestUtil.diagnosticsDiff(diagnosedRanges, diagnostics, new CheckerTestUtil.DiagnosticDiffCallbacks() {
+                @Override
+                public void missingDiagnostic(String type, int expectedStart, int expectedEnd) {
+                    String message = "Missing " + type + " at " + expectedStart + " to " + expectedEnd;
+                    actualMessages.add(message);
+                }
+
+                @Override
+                public void unexpectedDiagnostic(String type, int actualStart, int actualEnd) {
+                    String message = "Unexpected " + type + " at " + actualStart + " to " + actualEnd;
+                    actualMessages.add(message);
+                }
+            });
+
+            assertEquals(listToString(expectedMessages), listToString(actualMessages));
+        }
+
+        private String listToString(List<String> expectedMessages) {
+            StringBuilder stringBuilder = new StringBuilder();
+            for (String expectedMessage : expectedMessages) {
+                stringBuilder.append(expectedMessage).append("\n");
+            }
+            return stringBuilder.toString();
+        }
+
+        protected abstract void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges);
+    }
+
+}
diff --git a/idea/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java b/idea/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java
new file mode 100644
index 00000000000..597eb5e2b95
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java
@@ -0,0 +1,117 @@
+package org.jetbrains.jet.checkers;
+
+import com.google.common.collect.Lists;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.CharsetToolkit;
+import junit.framework.Test;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @author abreslav
+ */
+public class FullJetPsiCheckerTest extends JetTestCaseBase {
+
+    public FullJetPsiCheckerTest(@NonNls String dataPath, String name) {
+        super(dataPath, name);
+    }
+
+
+    @Override
+    public void runTest() throws Exception {
+        String fileName = name + ".jet";
+        String fullPath = getTestDataPath() + getTestFilePath();
+
+
+        String expectedText = loadFile(fullPath);
+
+        List<CheckerTestUtil.DiagnosedRange> diagnosedRanges = Lists.newArrayList();
+        String clearText = CheckerTestUtil.parseDiagnosedRanges(expectedText, diagnosedRanges);
+
+        configureFromFileText(fileName, clearText);
+        JetFile jetFile = (JetFile) myFile;
+        BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(jetFile);
+
+        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(jetFile, bindingContext).toString();
+
+        assertEquals(expectedText, actualText);
+
+//        String myFullDataPath = getTestDataPath() + getDataPath();
+//        System.out.println("myFullDataPath = " + myFullDataPath);
+//        convert(new File(myFullDataPath + "/../../checker/"), new File(myFullDataPath));
+    }
+
+    private String loadFile(String fullPath) throws IOException {
+        final File ioFile = new File(fullPath);
+        String fileText = FileUtil.loadFile(ioFile, CharsetToolkit.UTF8);
+        return StringUtil.convertLineSeparators(fileText);
+    }
+
+    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 JetTestCaseBase.suiteForDirectory(JetTestCaseBase.getTestDataPathBase(), "/checkerWithErrorTypes/full/", true, new JetTestCaseBase.NamedTestFactory() {
+            @NotNull
+            @Override
+            public Test createTest(@NotNull String dataPath, @NotNull String name) {
+                return new FullJetPsiCheckerTest(dataPath, name);
+            }
+        });
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java b/idea/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java
new file mode 100644
index 00000000000..b76d37388c0
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java
@@ -0,0 +1,104 @@
+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.JetTestCaseBase;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.ImportingStrategy;
+
+import java.util.List;
+
+/**
+ * @author abreslav
+ */
+public class QuickJetPsiCheckerTest extends JetLiteFixture {
+    private String name;
+    
+    public QuickJetPsiCheckerTest(@NonNls String dataPath, String name) {
+        super(dataPath);
+        this.name = name;
+    }
+
+    @Override
+    public String getName() {
+        return "test" + name;
+    }
+
+    @Override
+    public void runTest() throws Exception {
+        String expectedText = loadFile(name + ".jet");
+        List<CheckerTestUtil.DiagnosedRange> diagnosedRanges = Lists.newArrayList();
+        String clearText = CheckerTestUtil.parseDiagnosedRanges(expectedText, diagnosedRanges);
+
+        createAndCheckPsiFile(name, clearText);
+        JetFile jetFile = (JetFile) myFile;
+        BindingContext bindingContext = AnalyzingUtils.getInstance(ImportingStrategy.NONE).analyzeFileWithCache(jetFile);
+
+        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(jetFile, bindingContext).toString();
+
+        assertEquals(expectedText, actualText);
+        
+//        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 = doLoadFile(file.getParentFile().getAbsolutePath(), file.getName());
+//                Pattern pattern = Pattern.compile("</?(error|warning)>");
+//                String clearText = pattern.matcher(text).replaceAll("");
+//                createAndCheckPsiFile(name, clearText);
+//
+//                BindingContext bindingContext = AnalyzingUtils.getInstance(ImportingStrategy.NONE).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 JetTestCaseBase.suiteForDirectory(JetTestCaseBase.getTestDataPathBase(), "/checkerWithErrorTypes/quick", true, new JetTestCaseBase.NamedTestFactory() {
+            @NotNull
+            @Override
+            public Test createTest(@NotNull String dataPath, @NotNull String name) {
+                return new QuickJetPsiCheckerTest(dataPath, name);
+            }
+        });
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/codegen/ArrayGenTest.java b/idea/tests/org/jetbrains/jet/codegen/ArrayGenTest.java
new file mode 100644
index 00000000000..dcd5e4d9783
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/codegen/ArrayGenTest.java
@@ -0,0 +1,61 @@
+package org.jetbrains.jet.codegen;
+
+import jet.typeinfo.TypeInfo;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+public class ArrayGenTest extends CodegenTestCase {
+    public void testKt238 () throws Exception {
+        blackBoxFile("regressions/kt238.jet");
+    }
+
+    public void testKt326 () throws Exception {
+        blackBoxFile("regressions/kt326.jet");
+        System.out.println(generateToText());
+    }
+
+    public void testCreateMultiInt () throws Exception {
+        loadText("fun foo() = Array<Array<Int>> (5, { Array<Int>(it, {239}) })");
+        Method foo = generateFunction();
+        Integer[][] invoke = (Integer[][]) foo.invoke(null);
+        assertEquals(invoke[2].length, 2);
+        assertEquals(invoke[4].length, 4);
+        assertEquals(invoke[4][2].intValue(), 239);
+    }
+
+    public void testCreateMultiIntNullable () throws Exception {
+        loadText("fun foo() = Array<Array<Int?>> (5, { Array<Int?>(it) })");
+        Method foo = generateFunction();
+        Integer[][] invoke = (Integer[][]) foo.invoke(null);
+        assertEquals(invoke[2].length, 2);
+        assertEquals(invoke[4].length, 4);
+    }
+
+    public void testCreateMultiString () throws Exception {
+        loadText("fun foo() = Array<Array<String>> (5, { Array<String>(0,{\"\"}) })");
+        Method foo = generateFunction();
+        Object invoke = foo.invoke(null);
+        System.out.println(invoke.getClass());
+        assertTrue(invoke instanceof Object[]);
+    }
+
+    public void testCreateMultiGenerics () throws Exception {
+        loadText("class L<T>() { val a = Array<T>(5) } fun foo() = L<Int>.a");
+        System.out.println(generateToText());
+        Method foo = generateFunction();
+        Object invoke = foo.invoke(null);
+        System.out.println(invoke.getClass());
+        assertTrue(invoke instanceof Integer[]);
+    }
+
+    public void testIntGenerics () throws Exception {
+        loadText("class L<T>(var a : T) {} fun foo() = L<Int>(5).a");
+        System.out.println(generateToText());
+        Method foo = generateFunction();
+        Object invoke = foo.invoke(null);
+        System.out.println(invoke.getClass());
+        assertTrue(invoke instanceof Integer);
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java b/idea/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java
new file mode 100644
index 00000000000..2f89c65b0e7
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java
@@ -0,0 +1,9 @@
+package org.jetbrains.jet.codegen;
+
+import java.util.List;
+
+public class BridgeMethodGenTest extends CodegenTestCase {
+    public void testBridgeMethod () throws Exception {
+        blackBoxFile("bridge.jet");
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java b/idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java
index 2a9fd6c98e7..4e6f7802f56 100644
--- a/idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java
+++ b/idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java
@@ -14,7 +14,9 @@ public class ClassGenTest extends CodegenTestCase {
 
         final Class aClass = loadClass("SimpleClass", generateClassesInFile());
         final Method[] methods = aClass.getDeclaredMethods();
-        assertEquals(1, methods.length);
+        // public int SimpleClass.foo()
+        // public jet.typeinfo.TypeInfo SimpleClass.getTypeInfo()
+        assertEquals(2, methods.length);
     }
 
     public void testArrayListInheritance() throws Exception {
@@ -72,14 +74,12 @@ public class ClassGenTest extends CodegenTestCase {
     }
 
     public void testAbstractMethod() throws Exception {
-        loadText("class Foo { abstract fun x(): String; fun y(): Int = 0 }");
+        loadText("abstract class Foo { abstract fun x(): String; fun y(): Int = 0 }");
 
         final ClassFileFactory codegens = generateClassesInFile();
         final Class aClass = loadClass("Foo", codegens);
         assertNotNull(aClass.getMethod("x"));
-        final Class implClass = loadClass("Foo$$Impl", codegens);
-        assertNull(findMethodByName(implClass, "x"));
-        assertNotNull(findMethodByName(implClass, "y"));
+        assertNotNull(findMethodByName(aClass, "y"));
     }
 
     public void testInheritedMethod() throws Exception {
@@ -113,7 +113,7 @@ public class ClassGenTest extends CodegenTestCase {
     public void testAbstractClass() throws Exception {
         loadText("abstract class SimpleClass() { }");
 
-        final Class aClass = loadAllClasses(generateClassesInFile()).get("SimpleClass$$Impl");
+        final Class aClass = loadAllClasses(generateClassesInFile()).get("SimpleClass");
         assertTrue((aClass.getModifiers() & Modifier.ABSTRACT) != 0);
     }
 
@@ -155,6 +155,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());
         final Field north = direction.getField("NORTH");
         assertEquals(direction, north.getType());
         assertInstanceOf(north.get(null), direction);
@@ -168,4 +169,13 @@ public class ClassGenTest extends CodegenTestCase {
         final Method rgbMethod = colorClass.getMethod("getRgb");
         assertEquals(0xFF0000, rgbMethod.invoke(redValue));
     }
+
+    public void testKt249() throws Exception {
+        blackBoxFile("regressions/kt249.jet");
+    }
+
+    public void testKt48 () throws Exception {
+        blackBoxFile("regressions/kt48.jet");
+        System.out.println(generateToText());
+    }
 }
diff --git a/idea/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/idea/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
index 54d0a7947c9..45731728ffc 100644
--- a/idea/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
+++ b/idea/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
@@ -89,9 +89,9 @@ public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase {
         final JetNamespace namespace = jetFile.getRootNamespace();
         String fqName = NamespaceCodegen.getJVMClassName(namespace.getFQName()).replace("/", ".");
         Class<?> namespaceClass = loader.loadClass(fqName);
-        Method method = namespaceClass.getMethod("box");
-        return (String) method.invoke(null);
-    }
+            Method method = namespaceClass.getMethod("box");
+            return (String) method.invoke(null);
+        }
 
     protected String generateToText() {
         GenerationState state = new GenerationState(getProject(), true);
@@ -197,8 +197,7 @@ public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase {
     }
 
     protected Class loadImplementationClass(ClassFileFactory codegens, final String name) {
-        loadClass(name, codegens);
-        return loadClass(name + "$$Impl", codegens);
+        return loadClass(name, codegens);
     }
 
     private static class MyClassLoader extends ClassLoader {
diff --git a/idea/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java b/idea/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java
index 37240187769..698c668b042 100644
--- a/idea/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java
+++ b/idea/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java
@@ -1,5 +1,7 @@
 package org.jetbrains.jet.codegen;
 
+import jet.typeinfo.TypeInfo;
+
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
@@ -150,4 +152,57 @@ public class ControlStructuresTest extends CodegenTestCase {
         assertTrue(caught);
         assertEquals("foobar", sb.toString());
     }
+
+    public void testForUserType() throws Exception {
+        blackBoxFile("controlStructures/forUserType.jet");
+    }
+
+    public void testForIntArray() throws Exception {
+        blackBoxFile("controlStructures/forIntArray.jet");
+    }
+
+    public void testForPrimitiveIntArray() throws Exception {
+        blackBoxFile("controlStructures/forPrimitiveIntArray.jet");
+    }
+
+    public void testForNullableIntArray() throws Exception {
+        blackBoxFile("controlStructures/forNullableIntArray.jet");
+    }
+
+    public void testKt237() throws Exception {
+        blackBoxFile("regressions/kt237.jet");
+    }
+
+    public void testCompareToNull() throws Exception {
+        loadText("fun foo(a: String?, b: String?): Boolean = a == null && b !== null && null == a && null !== b");
+        String text = generateToText();
+        assertTrue(!text.contains("java/lang/Object.equals"));
+        System.out.println(text);
+        final Method main = generateFunction();
+        assertEquals(true, main.invoke(null, null, "lala"));
+        assertEquals(false, main.invoke(null, null, null));
+    }
+
+    public void testCompareToNonnullableEq() throws Exception {
+        loadText("fun foo(a: String?, b: String): Boolean = a == b || b == a");
+        String text = generateToText();
+        System.out.println(text);
+        final Method main = generateFunction();
+        assertEquals(false, main.invoke(null, null, "lala"));
+        assertEquals(true, main.invoke(null, "papa", "papa"));
+    }
+
+    public void testCompareToNonnullableNotEq() throws Exception {
+        loadText("fun foo(a: String?, b: String): Boolean = a != b");
+        String text = generateToText();
+        System.out.println(text);
+        assertTrue(text.contains("IXOR"));
+        final Method main = generateFunction();
+        assertEquals(true, main.invoke(null, null, "lala"));
+        assertEquals(false, main.invoke(null, "papa", "papa"));
+    }
+
+    public void testKt299() throws Exception {
+        blackBoxFile("regressions/kt299.jet");
+    }
 }
diff --git a/idea/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java b/idea/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java
index 30a934920b6..a1f2940a78e 100644
--- a/idea/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java
+++ b/idea/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java
@@ -2,6 +2,7 @@ package org.jetbrains.jet.codegen;
 
 import jet.IntRange;
 import jet.Tuple2;
+import jet.typeinfo.TypeInfo;
 import org.jetbrains.jet.parsing.JetParsingTest;
 
 import java.awt.*;
@@ -209,6 +210,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());
         assertEquals(Boolean.TRUE, main.invoke(null, null, null));
         assertEquals(Boolean.FALSE, main.invoke(null, "jet", null));
         assertEquals(Boolean.FALSE, main.invoke(null, null, "jet"));
@@ -217,6 +219,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());
         assertEquals(Boolean.TRUE, main.invoke(null, new Object[] { null }));
         assertEquals(Boolean.FALSE, main.invoke(null, "jet"));
     }
@@ -256,7 +259,7 @@ public class NamespaceGenTest extends CodegenTestCase {
         loadText("fun foo(s1: String, s2: String, s3: String) = s1 + s2 + s3");
         final String text = generateToText();
         final int firstStringBuilderCreation = text.indexOf("NEW java/lang/StringBuilder");
-        assertEquals(-1, text.indexOf("NEW java/lang/StringBuilder", firstStringBuilderCreation+1));
+        assertEquals(-1, text.indexOf("NEW java/lang/StringBuilder", firstStringBuilderCreation + 1));
         final Method main = generateFunction();
         assertEquals("jet Lang", main.invoke(null, "jet", " ", "Lang"));
     }
@@ -341,7 +344,7 @@ public class NamespaceGenTest extends CodegenTestCase {
     public void testArrayRead() throws Exception {
         loadText("fun foo(c: Array<String>) = c[0]");
         final Method main = generateFunction();
-        assertEquals("main", main.invoke(null, new Object[] { new String[] { "main" } }));
+        assertEquals("main", main.invoke(null, new Object[]{new String[]{"main"}}));
     }
 
     public void testArrayWrite() throws Exception {
@@ -356,26 +359,73 @@ public class NamespaceGenTest extends CodegenTestCase {
         loadText("fun foo(c: Array<Int>) { c[0] *= 2 }");
         System.out.println(generateToText());
         final Method main = generateFunction();
-        int[] data = new int[] { 5 };
+        Integer[] data = new Integer[] { 5 };
         main.invoke(null, new Object[] { data });
-        assertEquals(10, data[0]);
+        assertEquals(10, data[0].intValue());
+    }
+
+    public void testArrayAugAssignLong() throws Exception {
+        loadText("fun foo(c: LongArray) { c[0] *= 2 }");
+        System.out.println(generateToText());
+        final Method main = generateFunction();
+        long[] data = new long[] { 5 };
+        main.invoke(null, new Object[] { data });
+        assertEquals(10L, data[0]);
     }
 
     public void testArrayNew() throws Exception {
-        loadText("fun foo() = Array<Int>(4)");
+        loadText("fun foo() = Array<Int>(4, { it })");
+        System.out.println(generateToText());
         final Method main = generateFunction();
-        int[] result = (int[]) main.invoke(null);
+        Integer[] result = (Integer[]) main.invoke(null);
         assertEquals(4, result.length);
+        assertEquals(0, result[0].intValue());
+        assertEquals(1, result[1].intValue());
+        assertEquals(2, result[2].intValue());
+        assertEquals(3, result[3].intValue());
+    }
+
+    public void testArrayNewNullable() throws Exception {
+        loadText("fun foo() = Array<Int?>(4)");
+        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());
+        final Method main = generateFunction();
+        float[] result = (float[]) main.invoke(null);
+        assertEquals(4, result.length);
+    }
+
+    public void testFloatArrayArrayNew() throws Exception {
+        loadText("fun foo() = Array<FloatArray>(4, { FloatArray(5-it) })");
+        System.out.println(generateToText());
+        final Method main = generateFunction();
+        float[][] result = (float[][]) main.invoke(null);
+        assertEquals(4, result.length);
+        assertEquals(2, result[3].length);
     }
 
     public void testArraySize() throws Exception {
         loadText("fun foo(a: Array<Int>) = a.size");
         System.out.println(generateToText());
         final Method main = generateFunction();
+        Object[] args = new Object[] { new Integer[4] };
+        int result = (Integer) main.invoke(null, args);
+        System.out.println(result);
+        assertEquals(4, result);
+    }
+
+    public void testIntArraySize() throws Exception {
+        loadText("fun foo(a: IntArray) = a.size");
+        System.out.println(generateToText());
+        final Method main = generateFunction();
         Object[] args = new Object[] { new int[4] };
         int result = (Integer) main.invoke(null, args);
         assertEquals(4, result);
-
     }
 
     public void testIntRange() throws Exception {
@@ -448,8 +498,14 @@ public class NamespaceGenTest extends CodegenTestCase {
     public void testPredicateOperator() throws Exception {
         loadText("fun foo(s: String) = s?startsWith(\"J\")");
         final Method main = generateFunction();
+        try {
         assertEquals("JetBrains", main.invoke(null, "JetBrains"));
         assertNull(main.invoke(null, "IntelliJ"));
+        }
+        catch (Throwable t) {
+            System.out.println(generateToText());
+            t.printStackTrace();
+        }
     }
 
     public void testEscapeSequence() throws Exception {
diff --git a/idea/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java b/idea/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java
index 1e5ac174c0d..60337ed4ff2 100644
--- a/idea/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java
+++ b/idea/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java
@@ -35,12 +35,34 @@ public class PatternMatchingTest extends CodegenTestCase {
         assertEquals("something", foo.invoke(null, new Object()));
     }
 
+    public void testInrange() throws Exception {
+        loadFile();
+        System.out.println(generateToText());
+        Method foo = generateFunction();
+        assertEquals("array list", foo.invoke(null, 239));
+        assertEquals("digit", foo.invoke(null, 0));
+        assertEquals("digit", foo.invoke(null, 9));
+        assertEquals("digit", foo.invoke(null, 5));
+        assertEquals("not small", foo.invoke(null, 190));
+        assertEquals("something", foo.invoke(null, 19));
+    }
+
+    public void testIs() throws Exception {
+        loadFile();
+        System.out.println(generateToText());
+        blackBox();
+    }
+
     public void testRange() throws Exception {
         loadFile();
         System.out.println(generateToText());
         Method foo = generateFunction();
+        assertEquals("array list", foo.invoke(null, 239));
+        assertEquals("digit", foo.invoke(null, 0));
         assertEquals("digit", foo.invoke(null, 9));
+        assertEquals("digit", foo.invoke(null, 5));
         assertEquals("something", foo.invoke(null, 19));
+        assertEquals("not small", foo.invoke(null, 190));
     }
 
     public void testRangeChar() throws Exception {
@@ -80,8 +102,14 @@ public class PatternMatchingTest extends CodegenTestCase {
     public void testCall() throws Exception {
         loadText("fun foo(s: String) = when(s) { .startsWith(\"J\") => \"JetBrains\"; else => \"something\" }");
         Method foo = generateFunction();
-        assertEquals("JetBrains", foo.invoke(null, "Java"));
-        assertEquals("something", foo.invoke(null, "C#"));
+        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 {
diff --git a/idea/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java b/idea/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
index 71369d938f8..389d6be3b04 100644
--- a/idea/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
+++ b/idea/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
@@ -259,5 +259,19 @@ public class PrimitiveTypesTest extends CodegenTestCase {
         assertEquals(expected, main.invoke(null, arg1, arg2));
     }
 
+    public void testKt242 () throws Exception {
+        blackBoxFile("regressions/kt242.jet");
+    }
 
+    public void testKt239 () throws Exception {
+        blackBoxFile("regressions/kt242.jet");
+    }
+
+    public void testKt243 () throws Exception {
+        blackBoxFile("regressions/kt243.jet");
+    }
+
+    public void testKt248 () throws Exception {
+        blackBoxFile("regressions/kt248.jet");
+    }
 }
diff --git a/idea/tests/org/jetbrains/jet/codegen/PropertyGenTest.java b/idea/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
index 28ab6b95901..fa54529a99f 100644
--- a/idea/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
+++ b/idea/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
@@ -125,9 +125,19 @@ public class PropertyGenTest extends CodegenTestCase {
     }
 
     public void testAbstractVal() throws Exception {
-        loadText("class Foo { public abstract val x: String }");
+        loadText("abstract class Foo { public abstract val x: String }");
         final ClassFileFactory codegens = generateClassesInFile();
         final Class aClass = loadClass("Foo", codegens);
         assertNotNull(aClass.getMethod("getX"));
     }
+
+    public void testKt257 () throws Exception {
+        blackBoxFile("regressions/kt257.jet");
+    }
+
+    public void testKt160() throws Exception {
+        loadText("public val s = java.lang.Double.toString(1.0)");
+        final Method method = generateFunction("getS");
+        assertEquals(method.invoke(null), "1.0");
+    }
 }
diff --git a/idea/tests/org/jetbrains/jet/codegen/SafeRefTest.java b/idea/tests/org/jetbrains/jet/codegen/SafeRefTest.java
new file mode 100644
index 00000000000..76c4e191086
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/codegen/SafeRefTest.java
@@ -0,0 +1,15 @@
+package org.jetbrains.jet.codegen;
+
+public class SafeRefTest extends CodegenTestCase {
+    public void test247 () throws Exception {
+        blackBoxFile("regressions/kt247.jet");
+    }
+
+    public void test245 () throws Exception {
+        blackBoxFile("regressions/kt245.jet");
+    }
+
+    public void test232 () throws Exception {
+        blackBoxFile("regressions/kt232.jet");
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/codegen/TraitsTest.java b/idea/tests/org/jetbrains/jet/codegen/TraitsTest.java
new file mode 100644
index 00000000000..b805c7d2147
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/codegen/TraitsTest.java
@@ -0,0 +1,26 @@
+package org.jetbrains.jet.codegen;
+
+public class TraitsTest  extends CodegenTestCase {
+    @Override
+    protected String getPrefix() {
+        return "traits";
+    }
+
+    public void testSimple () throws Exception {
+        blackBoxFile("traits/simple.jet");
+        System.out.println(generateToText());
+    }
+
+    public void testWithRequired () throws Exception {
+        blackBoxFile("traits/withRequired.jet");
+        System.out.println(generateToText());
+    }
+
+    public void testMultiple () throws Exception {
+        blackBoxFile("traits/multiple.jet");
+    }
+
+    public void testStdlib () throws Exception {
+        blackBoxFile("traits/stdlib.jet");
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/codegen/TypeInfoTest.java b/idea/tests/org/jetbrains/jet/codegen/TypeInfoTest.java
index d440c3abd22..da349baae39 100644
--- a/idea/tests/org/jetbrains/jet/codegen/TypeInfoTest.java
+++ b/idea/tests/org/jetbrains/jet/codegen/TypeInfoTest.java
@@ -113,6 +113,7 @@ public class TypeInfoTest extends CodegenTestCase {
 
     public void testClassObjectInTypeInfo() throws Exception {
         loadFile();
+        System.out.println(generateToText());
         Method foo = generateFunction();
         JetObject jetObject = (JetObject) foo.invoke(null);
         TypeInfo<?> typeInfo = jetObject.getTypeInfo();
@@ -128,5 +129,15 @@ public class TypeInfoTest extends CodegenTestCase {
             }
         };
     }
+
+    public void testKt259() throws Exception {
+        blackBoxFile("regressions/kt259.jet");
+        System.out.println(generateToText());
+    }
+
+    public void testInner() throws Exception {
+        blackBoxFile("typeInfo/inner.jet");
+        System.out.println(generateToText());
+    }
 }
 
diff --git a/idea/tests/org/jetbrains/jet/parsing/JetCodeConformanceTest.java b/idea/tests/org/jetbrains/jet/parsing/JetCodeConformanceTest.java
index 70b7bd096b2..512cb63711f 100644
--- a/idea/tests/org/jetbrains/jet/parsing/JetCodeConformanceTest.java
+++ b/idea/tests/org/jetbrains/jet/parsing/JetCodeConformanceTest.java
@@ -19,7 +19,7 @@ public class JetCodeConformanceTest extends TestCase {
         TestSuite suite = new TestSuite();
         TestSuite ats = new TestSuite("Side-effect-free at()'s in assertions");
         suite.addTest(ats);
-        File parsingSourceDir = new File("./idea/src/org/jetbrains/jet/lang/parsing");
+        File parsingSourceDir = new File("./compiler/frontend/src/org/jetbrains/jet/lang/parsing");
         for (File sourceFile : parsingSourceDir.listFiles()) {
             if (sourceFile.getName().endsWith(".java")) {
                 ats.addTest(new JetCodeConformanceTest(sourceFile.getName(), sourceFile));
diff --git a/idea/tests/org/jetbrains/jet/parsing/JetParsingTest.java b/idea/tests/org/jetbrains/jet/parsing/JetParsingTest.java
index d74d147bf1e..6e1b8238abf 100644
--- a/idea/tests/org/jetbrains/jet/parsing/JetParsingTest.java
+++ b/idea/tests/org/jetbrains/jet/parsing/JetParsingTest.java
@@ -69,7 +69,8 @@ public class JetParsingTest extends ParsingTestCase {
     private void checkPsiGetters(JetElement elem) throws Throwable {
         Method[] methods = elem.getClass().getDeclaredMethods();
         for (Method method : methods) {
-            if (!method.getName().startsWith("get") && !method.getName().startsWith("find")) continue;
+            String methodName = method.getName();
+            if (!methodName.startsWith("get") && !methodName.startsWith("find") || methodName.equals("getReference") || methodName.equals("getReferences")) continue;
             if (method.getParameterTypes().length > 0) continue;
             Class<?> declaringClass = method.getDeclaringClass();
             if (!declaringClass.getName().startsWith("org.jetbrains.jet")) continue;
@@ -79,7 +80,7 @@ public class JetParsingTest extends ParsingTestCase {
                 for (Annotation annotation : method.getDeclaredAnnotations()) {
                     if (annotation instanceof JetElement.IfNotParsed) {
                         assertNotNull(
-                                "Incomplete operation in parsed OK test, method " + method.getName() +
+                                "Incomplete operation in parsed OK test, method " + methodName +
                                 " in " + declaringClass.getSimpleName() + " returns null. Element text: \n" + elem.getText(),
                                 PsiTreeUtil.findChildOfType(elem, PsiErrorElement.class));
                     }
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractModifierFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractModifierFixTest.java
new file mode 100644
index 00000000000..cbade4283ca
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractModifierFixTest.java
@@ -0,0 +1,24 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
+import org.jetbrains.jet.JetTestCaseBase;
+
+/**
+ * @author svtk
+ */
+public class AbstractModifierFixTest extends LightQuickFixTestCase {
+
+    public void test() throws Exception {
+        doAllTests();
+    }
+
+    @Override
+    protected String getBasePath() {
+        return "/quickfix/abstract";
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        return JetTestCaseBase.getTestDataPathBase();
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFixTest.java
new file mode 100644
index 00000000000..c8a067576f9
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/AddPrimaryConstructorFixTest.java
@@ -0,0 +1,24 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
+import org.jetbrains.jet.JetTestCaseBase;
+
+/**
+ * @author svtk
+ */
+public class AddPrimaryConstructorFixTest extends LightQuickFixTestCase {
+
+    public void test() throws Exception {
+        doAllTests();
+    }
+
+    @Override
+    protected String getBasePath() {
+        return "/quickfix/addPrimaryConstructor";
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        return JetTestCaseBase.getTestDataPathBase();
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFixTest.java
new file mode 100644
index 00000000000..e2b04a75f1f
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFixTest.java
@@ -0,0 +1,24 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
+import org.jetbrains.jet.JetTestCaseBase;
+
+/**
+ * @author svtk
+ */
+public class ChangeVariableMutabilityFixTest extends LightQuickFixTestCase {
+
+    public void test() throws Exception {
+        doAllTests();
+    }
+
+    @Override
+    protected String getBasePath() {
+        return "/quickfix/changeVariableMutability";
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        return JetTestCaseBase.getTestDataPathBase();
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/ClassImportFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/ClassImportFixTest.java
new file mode 100644
index 00000000000..215a15eb5b2
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/ClassImportFixTest.java
@@ -0,0 +1,32 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
+import com.intellij.openapi.projectRoots.Sdk;
+import org.jetbrains.jet.JetTestCaseBase;
+
+/**
+ * @author svtk
+ */
+public class ClassImportFixTest extends LightQuickFixTestCase {
+
+    public void test() throws Exception {
+        doAllTests();
+    }
+
+    @Override
+    protected String getBasePath() {
+        return "/quickfix/classImport";
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        return JetTestCaseBase.getTestDataPathBase();
+    }
+
+    @Override
+    protected Sdk getProjectJDK() {
+        return JetTestCaseBase.jdkFromIdeaHome();
+    }
+
+}
+
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/ExpressionsFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/ExpressionsFixTest.java
new file mode 100644
index 00000000000..9e0affacba6
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/ExpressionsFixTest.java
@@ -0,0 +1,24 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
+import org.jetbrains.jet.JetTestCaseBase;
+
+/**
+ * @author svtk
+ */
+public class ExpressionsFixTest extends LightQuickFixTestCase {
+
+    public void test() throws Exception {
+        doAllTests();
+    }
+
+    @Override
+    protected String getBasePath() {
+        return "/quickfix/expressions";
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        return JetTestCaseBase.getTestDataPathBase();
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/ModifiersFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/ModifiersFixTest.java
new file mode 100644
index 00000000000..66b299fded9
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/ModifiersFixTest.java
@@ -0,0 +1,26 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
+import org.jetbrains.jet.JetTestCaseBase;
+
+/**
+ * @author svtk
+ */
+public class ModifiersFixTest extends LightQuickFixTestCase {
+
+    public void test() throws Exception {
+        doAllTests();
+    }
+
+    @Override
+    protected String getBasePath() {
+        return "/quickfix/modifiers";
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        return JetTestCaseBase.getTestDataPathBase();
+    }
+}
+
+
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/OverrideModifierFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/OverrideModifierFixTest.java
new file mode 100644
index 00000000000..2a67aa23aeb
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/OverrideModifierFixTest.java
@@ -0,0 +1,25 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
+import org.jetbrains.jet.JetTestCaseBase;
+
+/**
+ * @author svtk
+ */
+public class OverrideModifierFixTest extends LightQuickFixTestCase {
+
+    public void test() throws Exception {
+        doAllTests();
+    }
+
+    @Override
+    protected String getBasePath() {
+        return "/quickfix/override";
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        return JetTestCaseBase.getTestDataPathBase();
+    }
+}
+
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/TypeAdditionFixTests.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/TypeAdditionFixTests.java
new file mode 100644
index 00000000000..42c100016f6
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/TypeAdditionFixTests.java
@@ -0,0 +1,25 @@
+package org.jetbrains.jet.plugin.quickfix;
+
+import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
+import org.jetbrains.jet.JetTestCaseBase;
+
+/**
+ * @author svtk
+ */
+public class TypeAdditionFixTests extends LightQuickFixTestCase {
+
+    public void test() throws Exception {
+        doAllTests();
+    }
+
+    @Override
+    protected String getBasePath() {
+        return "/quickfix/typeAddition";
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        return JetTestCaseBase.getTestDataPathBase();
+    }
+}
+
diff --git a/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
index 37d37903b6f..6eae3034292 100644
--- a/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
+++ b/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
@@ -4,18 +4,20 @@ import com.intellij.openapi.command.WriteCommandAction;
 import com.intellij.openapi.editor.Document;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ErrorHandler;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
+import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
+import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
 
 import java.util.HashMap;
 import java.util.HashSet;
@@ -25,6 +27,8 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static junit.framework.Assert.*;
+import static org.jetbrains.jet.lang.resolve.BindingContext.AMBIGUOUS_REFERENCE_TARGET;
+import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
 
 /**
  * @author abreslav
@@ -92,13 +96,13 @@ public class ExpectedResolveData {
         JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(file.getProject());
         JetStandardLibrary lib = semanticServices.getStandardLibrary();
 
-        BindingContext bindingContext = AnalyzingUtils.analyzeNamespace(file.getRootNamespace(), JetControlFlowDataTraceFactory.EMPTY);
-        AnalyzingUtils.applyHandler(new ErrorHandler() {
-                    @Override
-                    public void unresolvedReference(@NotNull JetReferenceExpression referenceExpression) {
-                        unresolvedReferences.add(referenceExpression);
-                    }
-                }, bindingContext);
+        BindingContext bindingContext = AnalyzerFacade.analyzeNamespace(file.getRootNamespace(), JetControlFlowDataTraceFactory.EMPTY);
+        for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
+            if (diagnostic instanceof UnresolvedReferenceDiagnostic) {
+                UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic = (UnresolvedReferenceDiagnostic) diagnostic;
+                unresolvedReferences.add(unresolvedReferenceDiagnostic.getPsiElement());
+            }
+        }
 
         Map<String, JetDeclaration> nameToDeclaration = new HashMap<String, JetDeclaration>();
 
@@ -123,16 +127,33 @@ public class ExpectedResolveData {
                 assertTrue(
                         "Must have been unresolved: " +
                         renderReferenceInContext(referenceExpression) +
-                        " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(BindingContext.REFERENCE_TARGET, referenceExpression)),
+                        " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(REFERENCE_TARGET, referenceExpression)),
                         unresolvedReferences.contains(referenceExpression));
                 continue;
             }
+            if ("!!".equals(name)) {
+                assertTrue(
+                        "Must have been resolved to multiple descriptors: " +
+                        renderReferenceInContext(referenceExpression) +
+                        " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(REFERENCE_TARGET, referenceExpression)),
+                        bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, referenceExpression) != null);
+                continue;
+            }
             else if ("!null".equals(name)) {
                 assertTrue(
                        "Must have been resolved to null: " +
                         renderReferenceInContext(referenceExpression) +
-                        " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(BindingContext.REFERENCE_TARGET, referenceExpression)),
-                        bindingContext.get(BindingContext.EXPRESSION_TYPE, referenceExpression) == null
+                        " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(REFERENCE_TARGET, referenceExpression)),
+                        bindingContext.get(REFERENCE_TARGET, referenceExpression) == null
+                );
+                continue;
+            }
+            else if ("!error".equals(name)) {
+                assertTrue(
+                       "Must have been resolved to error: " +
+                        renderReferenceInContext(referenceExpression) +
+                        " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(REFERENCE_TARGET, referenceExpression)),
+                       ErrorUtils.isError(bindingContext.get(REFERENCE_TARGET, referenceExpression))
                 );
                 continue;
             }
@@ -150,7 +171,7 @@ public class ExpectedResolveData {
                 DeclarationDescriptor expectedDescriptor = nameToDescriptor.get(name);
                 JetTypeReference typeReference = getAncestorOfType(JetTypeReference.class, element);
                 if (expectedDescriptor != null) {
-                    DeclarationDescriptor actual = bindingContext.get(BindingContext.REFERENCE_TARGET, reference);
+                    DeclarationDescriptor actual = bindingContext.get(REFERENCE_TARGET, reference);
                     assertSame("Expected: " + name,  expectedDescriptor.getOriginal(), actual == null ? null : actual.getOriginal());
                     continue;
                 }
@@ -188,7 +209,7 @@ public class ExpectedResolveData {
                 }
 
 
-                DeclarationDescriptor actualDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, reference);
+                DeclarationDescriptor actualDescriptor = bindingContext.get(REFERENCE_TARGET, reference);
                 if (actualDescriptor instanceof VariableAsFunctionDescriptor) {
                     VariableAsFunctionDescriptor descriptor = (VariableAsFunctionDescriptor) actualDescriptor;
                     actualDescriptor = descriptor.getVariableDescriptor();
@@ -254,7 +275,10 @@ public class ExpectedResolveData {
             statement = (JetExpression) parent;
         }
         JetDeclaration declaration = PsiTreeUtil.getParentOfType(referenceExpression, JetDeclaration.class);
-        return referenceExpression.getText() +
+
+
+
+        return referenceExpression.getText() + " at " + DiagnosticUtils.atLocation(referenceExpression) +
                                     " in " + statement.getText() + (declaration == null ? "" : " in " + declaration.getText());
     }
 
diff --git a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java
index 32b084a67a6..309b9e984bd 100644
--- a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java
+++ b/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java
@@ -11,8 +11,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import junit.framework.Test;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.OverloadResolutionResult;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
+import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResult;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.parsing.JetParsingTest;
 
@@ -100,10 +104,12 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
 
     @NotNull
     private FunctionDescriptor standardFunction(ClassDescriptor classDescriptor, List<TypeProjection> typeArguments, String name, JetType... parameterType) {
-        FunctionGroup functionGroup = classDescriptor.getMemberScope(typeArguments).getFunctionGroup(name);
         List<JetType> parameterTypeList = Arrays.asList(parameterType);
-        OverloadResolutionResult functions = functionGroup.getPossiblyApplicableFunctions(Collections.<JetType>emptyList(), parameterTypeList);
-        for (FunctionDescriptor function : functions.getFunctionDescriptors()) {
+        JetTypeInferrer.Services typeInferrerServices = JetSemanticServices.createSemanticServices(getProject()).getTypeInferrerServices(new BindingTraceContext(), JetFlowInformationProvider.NONE);
+
+        OverloadResolutionResult<FunctionDescriptor> functions = typeInferrerServices.getCallResolver().resolveExactSignature(
+                classDescriptor.getMemberScope(typeArguments), ReceiverDescriptor.NO_RECEIVER, name, parameterTypeList);
+        for (FunctionDescriptor function : functions.getDescriptors()) {
             List<ValueParameterDescriptor> unsubstitutedValueParameters = function.getValueParameters();
             for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
                 ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i);
@@ -139,42 +145,6 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
         doTest(path, true, false);
     }
 
-//    public void testBasic() throws Exception {
-//        doTest("/resolve/Basic.jet", true, true);
-//    }
-//
-//    public void testResolveToJava() throws Exception {
-//        doTest("/resolve/ResolveToJava.jet", true, true);
-//    }
-//
-//    public void testResolveOfInfixExpressions() throws Exception {
-//        doTest("/resolve/ResolveOfInfixExpressions.jet", true, true);
-//    }
-//
-//    public void testProjections() throws Exception {
-//        doTest("/resolve/Projections.jet", true, true);
-//    }
-//
-//    public void testPrimaryConstructors() throws Exception {
-//        doTest("/resolve/PrimaryConstructors.jet", true, true);
-//    }
-//
-//    public void testClassifiers() throws Exception {
-//        doTest("/resolve/Classifiers.jet", true, true);
-//    }
-//
-//    public void testConstructorsAndInitializers() throws Exception {
-//        doTest("/resolve/ConstructorsAndInitializers.jet", true, true);
-//    }
-//
-//    public void testNamespaces() throws Exception {
-//        doTest("/resolve/Namespaces.jet", true, true);
-//    }
-//
-//    public void testTryCatch() throws Exception {
-//        doTest("/resolve/TryCatch.jet", true, true);
-//    }
-
     public static Test suite() {
         return JetTestCaseBase.suiteForDirectory(getHomeDirectory() + "/idea/testData/", "/resolve/", true, new JetTestCaseBase.NamedTestFactory() {
             @NotNull
diff --git a/idea/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/idea/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java
new file mode 100644
index 00000000000..2eb81e3b963
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java
@@ -0,0 +1,400 @@
+package org.jetbrains.jet.types;
+
+import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
+import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
+import org.jetbrains.jet.lang.types.JetStandardLibrary;
+import org.jetbrains.jet.plugin.AnalyzerFacade;
+
+import java.util.List;
+
+/**
+ * @author svtk
+ */
+public class JetDefaultModalityModifiersTest extends LightDaemonAnalyzerTestCase {
+    private JetDefaultModalityModifiersTestCase tc = new JetDefaultModalityModifiersTestCase();
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        tc.setUp();
+    }
+
+    public static class JetDefaultModalityModifiersTestCase  {
+        private ModuleDescriptor root = new ModuleDescriptor("test_root");
+        private ClassDescriptorResolver classDescriptorResolver;
+        private JetScope scope;
+
+        public void setUp() throws Exception {
+            JetStandardLibrary library = JetStandardLibrary.getJetStandardLibrary(getProject());
+            JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(library);
+            classDescriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_EXCEPTION_ON_ERROR_TRACE);
+            scope = createScope(library.getLibraryScope());
+        }
+
+        private JetScope createScope(JetScope libraryScope) {
+            JetFile file = JetPsiFactory.createFile(getProject(), "abstract class C { abstract fun foo(); abstract val a: Int }");
+            List<JetDeclaration> declarations = file.getRootNamespace().getDeclarations();
+            JetDeclaration aClass = declarations.get(0);
+            assert aClass instanceof JetClass;
+            BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
+            DeclarationDescriptor classDescriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass);
+            WritableScopeImpl scope = new WritableScopeImpl(libraryScope, root, RedeclarationHandler.DO_NOTHING);
+            assert classDescriptor instanceof ClassifierDescriptor;
+            scope.addClassifierDescriptor((ClassifierDescriptor) classDescriptor);
+            return scope;
+        }
+
+        private MutableClassDescriptor createClassDescriptor(ClassKind kind, JetClass aClass) {
+            MutableClassDescriptor classDescriptor = new MutableClassDescriptor(JetTestUtils.DUMMY_TRACE, root, scope, kind);
+            classDescriptorResolver.resolveMutableClassDescriptor(aClass, classDescriptor);
+            return classDescriptor;
+        }
+
+        private void testClassModality(String classDeclaration, ClassKind kind, Modality expectedModality) {
+            JetClass aClass = JetPsiFactory.createClass(getProject(), classDeclaration);
+            MutableClassDescriptor classDescriptor = createClassDescriptor(kind, aClass);
+
+            assertEquals(expectedModality, classDescriptor.getModality());
+        }
+
+
+        private void testFunctionModality(String classWithFunction, ClassKind kind, Modality expectedFunctionModality) {
+            JetClass aClass = JetPsiFactory.createClass(getProject(), classWithFunction);
+            MutableClassDescriptor classDescriptor = createClassDescriptor(kind, aClass);
+
+            List<JetDeclaration> declarations = aClass.getDeclarations();
+            JetNamedFunction function = (JetNamedFunction) declarations.get(0);
+            FunctionDescriptorImpl functionDescriptor = classDescriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function);
+
+            assertEquals(expectedFunctionModality, functionDescriptor.getModality());
+        }
+
+        private void testPropertyModality(String classWithProperty, ClassKind kind, Modality expectedPropertyModality) {
+            JetClass aClass = JetPsiFactory.createClass(getProject(), classWithProperty);
+            MutableClassDescriptor classDescriptor = createClassDescriptor(kind, aClass);
+
+            List<JetDeclaration> declarations = aClass.getDeclarations();
+            JetProperty property = (JetProperty) declarations.get(0);
+            PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property);
+
+            assertEquals(expectedPropertyModality, propertyDescriptor.getModality());
+        }
+
+
+        private void testPropertyAccessorModality(String classWithPropertyWithAccessor, ClassKind kind, Modality expectedPropertyAccessorModality, boolean isGetter) {
+            JetClass aClass = JetPsiFactory.createClass(getProject(), classWithPropertyWithAccessor);
+            MutableClassDescriptor classDescriptor = createClassDescriptor(kind, aClass);
+
+            List<JetDeclaration> declarations = aClass.getDeclarations();
+            JetProperty property = (JetProperty) declarations.get(0);
+            PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property);
+            PropertyAccessorDescriptor propertyAccessor = isGetter
+                                                          ? propertyDescriptor.getGetter()
+                                                          : propertyDescriptor.getSetter();
+            assert propertyAccessor != null;
+            assertEquals(expectedPropertyAccessorModality, propertyAccessor.getModality());
+        }
+
+        public void testClassModality(String classDeclaration, Modality expectedModality) {
+            testClassModality(classDeclaration, ClassKind.CLASS, expectedModality);
+        }
+
+        public void testTraitModality(String classDeclaration, Modality expectedModality) {
+            testClassModality(classDeclaration, ClassKind.TRAIT, expectedModality);
+        }
+
+        public void testEnumModality(String classDeclaration, Modality expectedModality) {
+            testClassModality(classDeclaration, ClassKind.ENUM_CLASS, expectedModality);
+        }
+
+        public void testFunctionModalityInClass(String classWithFunction, Modality expectedModality) {
+            testFunctionModality(classWithFunction, ClassKind.CLASS, expectedModality);
+        }
+
+        public void testFunctionModalityInEnum(String classWithFunction, Modality expectedModality) {
+            testFunctionModality(classWithFunction, ClassKind.ENUM_CLASS, expectedModality);
+        }
+
+        public void testFunctionModalityInTrait(String classWithFunction, Modality expectedModality) {
+            testFunctionModality(classWithFunction, ClassKind.TRAIT, expectedModality);
+        }
+
+        public void testPropertyModalityInClass(String classWithProperty, Modality expectedModality) {
+            testPropertyModality(classWithProperty, ClassKind.CLASS, expectedModality);
+        }
+
+        public void testPropertyModalityInEnum(String classWithProperty, Modality expectedModality) {
+            testPropertyModality(classWithProperty, ClassKind.ENUM_CLASS, expectedModality);
+        }
+
+        public void testPropertyModalityInTrait(String classWithProperty, Modality expectedModality) {
+            testPropertyModality(classWithProperty, ClassKind.TRAIT, expectedModality);
+        }
+
+        public void testPropertyAccessorModalityInClass(String classWithPropertyWithAccessor, Modality expectedModality) {
+            testPropertyAccessorModality(classWithPropertyWithAccessor, ClassKind.CLASS, expectedModality, true);
+        }
+
+        public void testPropertyAccessorModalityInTrait(String classWithPropertyWithAccessor, Modality expectedModality) {
+            testPropertyAccessorModality(classWithPropertyWithAccessor, ClassKind.TRAIT, expectedModality, true);
+        }
+
+        public void testPropertyAccessorModalityInClass(String classWithPropertyWithAccessor, Modality expectedModality, boolean isGetter) {
+            testPropertyAccessorModality(classWithPropertyWithAccessor, ClassKind.CLASS, expectedModality, isGetter);
+        }
+
+        public void testPropertyAccessorModalityInTrait(String classWithPropertyWithAccessor, Modality expectedModality, boolean isGetter) {
+            testPropertyAccessorModality(classWithPropertyWithAccessor, ClassKind.TRAIT, expectedModality, isGetter);
+        }
+    }
+
+    public void testClassModality() {
+        tc.testClassModality("class A {}", Modality.FINAL);
+        tc.testClassModality("open class A {}", Modality.OPEN);
+        tc.testClassModality("abstract class A {}", Modality.ABSTRACT);
+        tc.testClassModality("final class A {}", Modality.FINAL);
+        tc.testClassModality("open abstract class A {}", Modality.ABSTRACT);
+
+        tc.testEnumModality("enum class A {}", Modality.FINAL);
+        tc.testEnumModality("open enum class A {}", Modality.OPEN);
+        tc.testEnumModality("abstract enum class A {}", Modality.ABSTRACT);
+        tc.testEnumModality("final enum class A {}", Modality.FINAL);
+
+        tc.testTraitModality("trait A {}", Modality.ABSTRACT);
+        tc.testTraitModality("open trait A {}", Modality.ABSTRACT);
+        tc.testTraitModality("abstract trait A {}", Modality.ABSTRACT);
+    }
+
+    public void testFunctionModality() {
+        tc.testFunctionModalityInClass("class A { fun foo() {} }", Modality.FINAL);
+        tc.testFunctionModalityInClass("class A { open fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInClass("class A { final fun foo() {} }", Modality.FINAL);
+        tc.testFunctionModalityInClass("open class A { fun foo() {} }", Modality.FINAL);
+        tc.testFunctionModalityInClass("open class A { open fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInClass("open class A { final fun foo() {} }", Modality.FINAL);
+        tc.testFunctionModalityInClass("abstract class A { open fun foo() }", Modality.OPEN);
+        tc.testFunctionModalityInClass("abstract class A { abstract fun foo() }", Modality.ABSTRACT);
+
+        tc.testFunctionModalityInEnum("enum class A { fun foo() {} }", Modality.FINAL);
+        tc.testFunctionModalityInEnum("enum class A { final fun foo() {} }", Modality.FINAL);
+        tc.testFunctionModalityInEnum("open enum class A { open fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInEnum("abstract enum class A { open fun foo() }", Modality.OPEN);
+        tc.testFunctionModalityInEnum("abstract enum class A { abstract fun foo() }", Modality.ABSTRACT);
+
+        tc.testFunctionModalityInTrait("trait A { fun foo() }", Modality.ABSTRACT);
+        tc.testFunctionModalityInTrait("trait A { abstract fun foo() }", Modality.ABSTRACT);
+        tc.testFunctionModalityInTrait("trait A { fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInTrait("trait A { open fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInTrait("trait A { final fun foo() {} }", Modality.FINAL);
+    }
+
+    public void testFunctionModalityWithOverride() {
+        tc.testFunctionModalityInClass("class A : C { override fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInClass("class A : C { open override fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInClass("class A : C { final override fun foo() {} }", Modality.FINAL);
+
+        tc.testFunctionModalityInClass("open class A : C { override fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInClass("open class A : C { open override fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInClass("open class A : C { final override fun foo() {} }", Modality.FINAL);
+        tc.testFunctionModalityInClass("abstract class A : C { open override  fun foo() }", Modality.OPEN);
+        tc.testFunctionModalityInClass("abstract class A : C { abstract override fun foo() }", Modality.ABSTRACT);
+
+        tc.testFunctionModalityInEnum("enum class A : C { override fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInEnum("enum class A : C { final override fun foo() {} }", Modality.FINAL);
+        tc.testFunctionModalityInEnum("open enum class A : C { open override fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInEnum("abstract enum class A : C { open override fun foo() }", Modality.OPEN);
+        tc.testFunctionModalityInEnum("abstract enum class A : C { abstract override fun foo() }", Modality.ABSTRACT);
+
+        tc.testFunctionModalityInTrait("trait A : C { override fun foo() }", Modality.ABSTRACT);
+        tc.testFunctionModalityInTrait("trait A : C { abstract override fun foo() }", Modality.ABSTRACT);
+        tc.testFunctionModalityInTrait("trait A : C { override fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInTrait("trait A : C { open override fun foo() {} }", Modality.OPEN);
+        tc.testFunctionModalityInTrait("trait A : C { final override fun foo() {} }", Modality.FINAL);
+    }
+
+    public void testPropertyModality() {
+        tc.testPropertyModalityInClass("class A { val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInClass("class A { final val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInClass("open class A { val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInClass("open class A { final val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInClass("open class A { open val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInClass("abstract class A { val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInClass("abstract class A { open val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInClass("abstract class A { abstract val a: Int }", Modality.ABSTRACT);
+
+        tc.testPropertyModalityInEnum("enum class A { val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInEnum("enum class A { final val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInEnum("open enum class A { val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInEnum("open enum class A { final val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInEnum("open enum class A { open val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInEnum("abstract enum class A { open val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInEnum("abstract enum class A { abstract val a: Int }", Modality.ABSTRACT);
+
+        tc.testPropertyModalityInTrait("trait A { val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A { open val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A { abstract val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A { open abstract val a: Int }", Modality.ABSTRACT);
+
+        tc.testPropertyModalityInTrait("trait A { val a: Int get() = 10 }", Modality.OPEN);
+        tc.testPropertyModalityInTrait("trait A { var a: Int get() = 1; set(v: Int) {} }", Modality.OPEN);
+        tc.testPropertyModalityInTrait("trait A { val a: Int open get }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A { var a: Int open get open set}", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A { open val a: Int get }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A { open val a: Int get() = 1 }", Modality.OPEN);
+        tc.testPropertyModalityInTrait("trait A { open val a: Int final get() = 1 }", Modality.OPEN);
+    }
+
+    public void testPropertyModalityWithOverride() {
+        tc.testPropertyModalityInClass("class A : C { override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInClass("class A : C { final override val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInClass("open class A : C { override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInClass("open class A : C { final override val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInClass("open class A : C { open override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInClass("abstract class A : C { override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInClass("abstract class A : C { open override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInClass("abstract class A : C { abstract override val a: Int }", Modality.ABSTRACT);
+
+        tc.testPropertyModalityInEnum("enum class A : C { override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInEnum("enum class A : C { final override val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInEnum("open enum class A : C { override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInEnum("open enum class A : C { final override val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyModalityInEnum("open enum class A : C { open override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInEnum("abstract enum class A : C { open override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyModalityInEnum("abstract enum class A : C { abstract override val a: Int }", Modality.ABSTRACT);
+
+        tc.testPropertyModalityInTrait("trait A : C { override val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A : C { open override val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A : C { abstract override val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A : C { open abstract override val a: Int }", Modality.ABSTRACT);
+
+        tc.testPropertyModalityInTrait("trait A : C { override val a: Int get() = 10 }", Modality.OPEN);
+        tc.testPropertyModalityInTrait("trait A : C { override var a: Int get() = 1; set(v: Int) {} }", Modality.OPEN);
+        tc.testPropertyModalityInTrait("trait A : C { override val a: Int open get }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A : C { override var a: Int open get open set }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A : C { open override val a: Int get }", Modality.ABSTRACT);
+        tc.testPropertyModalityInTrait("trait A : C { open override val a: Int get() = 1 }", Modality.OPEN);
+        tc.testPropertyModalityInTrait("trait A : C { open override val a: Int final get() = 1 }", Modality.OPEN);
+    }
+
+    public void testPropertyAccessorModality() {
+        tc.testPropertyAccessorModalityInClass("class A { val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("class A { val a: Int = 0; get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("class A { val a: Int = 0; final get }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("class A { final val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("class A { final val a: Int = 0; get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("class A { final val a: Int = 0; final get }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("open class A { val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("open class A { val a: Int = 0; get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("open class A { val a: Int = 0; final get }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("open class A { open val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A { open val a: Int = 0; get }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A { open val a: Int = 0; open get }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A { open val a: Int = 0; final get }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("open class A { final val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("open class A { final val a: Int = 0; get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("open class A { final val a: Int = 0; final get }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("abstract class A { abstract val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A { abstract val a: Int get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A { abstract val a: Int open get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A { abstract val a: Int abstract get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A { val a: Int get() = 10 }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("abstract class A { val a: Int open get() = 10 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("abstract class A { val a: Int final get() = 10 }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("abstract class A { open abstract val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A { open abstract val a: Int get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A { open abstract val a: Int open get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A { open abstract val a: Int abstract get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A { open val a: Int get() = 10 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("abstract class A { open val a: Int open get() = 10 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("abstract class A { open val a: Int final get() = 10 }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInTrait("trait A { val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("trait A { val a: Int get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("trait A { val a: Int get() = 1 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInTrait("trait A { val a: Int abstract get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("trait A { val a: Int open get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("trait A { val a: Int open get() = 1 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInTrait("trait A { val a: Int final get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInTrait("trait A { val a: Int final get() = 1 }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInTrait("abstract trait A { val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("abstract trait A { val a: Int get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("abstract trait A { val a: Int get() = 1 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInTrait("abstract trait A { val a: Int abstract get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("abstract trait A { val a: Int open get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("abstract trait A { val a: Int open get() = 1 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInTrait("abstract trait A { val a: Int final get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInTrait("abstract trait A { val a: Int final get() = 1 }", Modality.FINAL);
+    }
+
+    public void testPropertyAccessorModalityWithOverride() {
+        tc.testPropertyAccessorModalityInClass("class A : C { override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("class A : C { override val a: Int = 0; get }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("class A : C { override val a: Int = 0; final get }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("class A : C { final override val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("class A : C { final override val a: Int = 0; get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("class A : C { final override val a: Int = 0; final get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("class A : C { final override val a: Int = 0; override get() = 2 }", Modality.OPEN);
+
+        tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; get }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; open get }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; final get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; override get() = 2 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; final override get() = 2 }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; get }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; open get }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; final get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; override get() = 2 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; final override get() = 2 }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0 }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0; get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0; final get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0; override get() = 2 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0; final override get() = 2 }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { abstract override val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { abstract override val a: Int get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { abstract override val a: Int open get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { abstract override val a: Int abstract get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { override val a: Int override get() = 10 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { override val a: Int open override get() = 10 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { override val a: Int final override get() = 10 }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { open abstract override val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { open abstract override val a: Int get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { open abstract override val a: Int open get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { open abstract override val a: Int abstract get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { open override val a: Int override get() = 10 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { open override val a: Int open override get() = 10 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInClass("abstract class A : C { open override val a: Int final override  get() = 10 }", Modality.FINAL);
+
+        tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int override get() = 1 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int abstract get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int open get }", Modality.ABSTRACT);
+        tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int open override get() = 1 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int override get() = 1 }", Modality.OPEN);
+        tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int final get }", Modality.FINAL);
+        tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int final override get() = 1 }", Modality.FINAL);
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java b/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java
index 2c6bfc6502e..913fdecbd7e 100644
--- a/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java
+++ b/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java
@@ -5,11 +5,11 @@ import com.intellij.openapi.application.PathManager;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptorUtil;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.psi.JetChangeUtil;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.OverridingUtil;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.parsing.JetParsingTest;
 
@@ -70,7 +70,7 @@ public class JetOverridingTest extends LightDaemonAnalyzerTestCase {
                 "fun ab() : Int",
                 "fun a() : Int");
 
-        assertNotOverridable(
+        assertOverridable(
                 "fun a() : Int",
                 "fun a() : Any");
 
@@ -98,7 +98,7 @@ public class JetOverridingTest extends LightDaemonAnalyzerTestCase {
                 "fun a<T1, X : T1>(a : T1) : T1",
                 "fun a<T, Y : T>(a : Y) : T");
 
-        assertNotOverridable(
+        assertOverridable(
                 "fun a<T1, X : T1>(a : T1) : X",
                 "fun a<T, Y : T>(a : T) : T");
 
@@ -139,12 +139,12 @@ public class JetOverridingTest extends LightDaemonAnalyzerTestCase {
     private void assertOverridabilityRelation(String superFun, String subFun, boolean expectedIsError) {
         FunctionDescriptor a = makeFunction(superFun);
         FunctionDescriptor b = makeFunction(subFun);
-        FunctionDescriptorUtil.OverrideCompatibilityInfo overridableWith = FunctionDescriptorUtil.isOverridableBy(semanticServices.getTypeChecker(), a, b);
+        OverridingUtil.OverrideCompatibilityInfo overridableWith = OverridingUtil.isOverridableBy(a, b);
         assertEquals(overridableWith.getMessage(), expectedIsError, !overridableWith.isSuccess());
     }
 
     private FunctionDescriptor makeFunction(String funDecl) {
-        JetNamedFunction function = JetChangeUtil.createFunction(getProject(), funDecl);
+        JetNamedFunction function = JetPsiFactory.createFunction(getProject(), funDecl);
         return classDescriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function);
     }
 }
diff --git a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
index 387b536df01..1903d2b13f1 100644
--- a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+++ b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
@@ -6,19 +6,22 @@ import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.projectRoots.Sdk;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetTestCaseBase;
 import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.lang.ErrorHandler;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.psi.JetChangeUtil;
-import org.jetbrains.jet.lang.psi.JetClass;
-import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.scopes.*;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.parsing.JetParsingTest;
 
 import java.io.File;
@@ -34,6 +37,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
     private ClassDefinitions classDefinitions;
     private ClassDescriptorResolver classDescriptorResolver;
     private JetScope scopeWithImports;
+    private TypeResolver typeResolver;
 
     @Override
     public void setUp() throws Exception {
@@ -43,6 +47,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
         classDefinitions = new ClassDefinitions();
         classDescriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
         scopeWithImports = addImports(classDefinitions.BASIC_SCOPE);
+        typeResolver = new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true);
     }
 
     @Override
@@ -487,25 +492,25 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
 
     private void assertType(String expression, JetType expectedType) {
         Project project = getProject();
-        JetExpression jetExpression = JetChangeUtil.createExpression(project, expression);
-        JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE, JetFlowInformationProvider.NONE).getType(scopeWithImports, jetExpression, false, JetTypeInferrer.NO_EXPECTED_TYPE);
+        JetExpression jetExpression = JetPsiFactory.createExpression(project, expression);
+        JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE, JetFlowInformationProvider.NONE).getType(scopeWithImports, jetExpression, JetTypeInferrer.NO_EXPECTED_TYPE);
         assertTrue(type + " != " + expectedType, type.equals(expectedType));
     }
 
     private void assertErrorType(String expression) {
         Project project = getProject();
-        JetExpression jetExpression = JetChangeUtil.createExpression(project, expression);
-        JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE, JetFlowInformationProvider.NONE).safeGetType(scopeWithImports, jetExpression, false, JetTypeInferrer.NO_EXPECTED_TYPE);
+        JetExpression jetExpression = JetPsiFactory.createExpression(project, expression);
+        JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE, JetFlowInformationProvider.NONE).safeGetType(scopeWithImports, jetExpression, JetTypeInferrer.NO_EXPECTED_TYPE);
         assertTrue("Error type expected but " + type + " returned", ErrorUtils.isErrorType(type));
     }
 
-    private void assertType(String contextType, String expression, String expectedType) {
+    private void assertType(String contextType, final String expression, String expectedType) {
         final JetType thisType = makeType(contextType);
         JetScope scope = new JetScopeAdapter(classDefinitions.BASIC_SCOPE) {
             @NotNull
             @Override
-            public JetType getThisType() {
-                return thisType;
+            public ReceiverDescriptor getImplicitReceiver() {
+                return new ExpressionReceiver(JetPsiFactory.createExpression(getProject(), expression), thisType);
             }
         };
         assertType(scope, expression, expectedType);
@@ -517,14 +522,14 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
 
     private void assertType(JetScope scope, String expression, String expectedTypeStr) {
         Project project = getProject();
-        JetExpression jetExpression = JetChangeUtil.createExpression(project, expression);
-        JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE, JetFlowInformationProvider.NONE).getType(addImports(scope), jetExpression, false, JetTypeInferrer.NO_EXPECTED_TYPE);
+        JetExpression jetExpression = JetPsiFactory.createExpression(project, expression);
+        JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE, JetFlowInformationProvider.NONE).getType(addImports(scope), jetExpression, JetTypeInferrer.NO_EXPECTED_TYPE);
         JetType expectedType = expectedTypeStr == null ? null : makeType(expectedTypeStr);
         assertEquals(expectedType, type);
     }
 
     private WritableScopeImpl addImports(JetScope scope) {
-        WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), ErrorHandler.DO_NOTHING);
+        WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING);
         writableScope.importScope(library.getLibraryScope());
         JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), semanticServices, JetTestUtils.DUMMY_TRACE);
         writableScope.importScope(new JavaPackageScope("", null, javaSemanticServices));
@@ -537,7 +542,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
     }
 
     private JetType makeType(JetScope scope, String typeStr) {
-        return new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true).resolveType(scope, JetChangeUtil.createType(getProject(), typeStr));
+        return new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true).resolveType(scope, JetPsiFactory.createType(getProject(), typeStr));
     }
 
     @Override
@@ -591,8 +596,8 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
             public ClassifierDescriptor getClassifier(@NotNull String name) {
                 if (CLASSES.isEmpty()) {
                     for (String classDeclaration : CLASS_DECLARATIONS) {
-                        JetClass classElement = JetChangeUtil.createClass(getProject(), classDeclaration);
-                        ClassDescriptor classDescriptor = classDescriptorResolver.resolveClassDescriptor(this, classElement);
+                        JetClass classElement = JetPsiFactory.createClass(getProject(), classDeclaration);
+                        ClassDescriptor classDescriptor = resolveClassDescriptor(this, classElement);
                         CLASSES.put(classDescriptor.getName(), classDescriptor);
                     }
                 }
@@ -605,21 +610,103 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
 
             @NotNull
             @Override
-            public FunctionGroup getFunctionGroup(@NotNull String name) {
-                ClassifierDescriptor classifier = getClassifier(name);
-                if (classifier instanceof ClassDescriptor) {
-                    ClassDescriptor classDescriptor = (ClassDescriptor) classifier;
-                    return classDescriptor.getConstructors();
-                }
-                WritableFunctionGroup writableFunctionGroup = new WritableFunctionGroup(name);
+            public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+                Set<FunctionDescriptor> writableFunctionGroup = Sets.newLinkedHashSet();
+                ModuleDescriptor module = new ModuleDescriptor("TypeCheckerTest");
                 for (String funDecl : FUNCTION_DECLARATIONS) {
-                    FunctionDescriptor functionDescriptor = classDescriptorResolver.resolveFunctionDescriptor(JetStandardClasses.getAny(), this, JetChangeUtil.createFunction(getProject(), funDecl));
+                    FunctionDescriptor functionDescriptor = classDescriptorResolver.resolveFunctionDescriptor(module, this, JetPsiFactory.createFunction(getProject(), funDecl));
                     if (name.equals(functionDescriptor.getName())) {
-                        writableFunctionGroup.addFunction(functionDescriptor);
+                        writableFunctionGroup.add(functionDescriptor);
                     }
                 }
                 return writableFunctionGroup;
             }
         };
+
+        @Nullable
+        public ClassDescriptor resolveClassDescriptor(@NotNull JetScope scope, @NotNull JetClass classElement) {
+            final ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
+                    scope.getContainingDeclaration(),
+                    Collections.<AnnotationDescriptor>emptyList(),
+                    JetPsiUtil.safeName(classElement.getName()));
+
+            BindingTrace trace = JetTestUtils.DUMMY_TRACE;
+
+            trace.record(BindingContext.CLASS, classElement, classDescriptor);
+
+            final WritableScope parameterScope = new WritableScopeImpl(scope, classDescriptor, new TraceBasedRedeclarationHandler(trace));
+
+            // This call has side-effects on the parameterScope (fills it in)
+            List<TypeParameterDescriptor> typeParameters
+                    = classDescriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters());
+            classDescriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters);
+
+            List<JetDelegationSpecifier> delegationSpecifiers = classElement.getDelegationSpecifiers();
+            // TODO : assuming that the hierarchy is acyclic
+            Collection<JetType> supertypes = delegationSpecifiers.isEmpty()
+                    ? Collections.singleton(JetStandardClasses.getAnyType())
+                    : classDescriptorResolver.resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver);
+    //        for (JetType supertype: supertypes) {
+    //            if (supertype.getConstructor().isSealed()) {
+    //                trace.getErrorHandler().genericError(classElement.getNameAsDeclaration().getNode(), "Class " + classElement.getName() + " can not extend final type " + supertype);
+    //            }
+    //        }
+            boolean open = classElement.hasModifier(JetTokens.OPEN_KEYWORD);
+
+            final WritableScope memberDeclarations = new WritableScopeImpl(JetScope.EMPTY, classDescriptor, new TraceBasedRedeclarationHandler(trace));
+
+            List<JetDeclaration> declarations = classElement.getDeclarations();
+            for (JetDeclaration declaration : declarations) {
+                declaration.accept(new JetVisitorVoid() {
+                    @Override
+                    public void visitProperty(JetProperty property) {
+                        if (property.getPropertyTypeRef() != null) {
+                            memberDeclarations.addVariableDescriptor(classDescriptorResolver.resolvePropertyDescriptor(classDescriptor, parameterScope, property));
+                        } else {
+                            // TODO : Caution: a cyclic dependency possible
+                            throw new UnsupportedOperationException();
+                        }
+                    }
+
+                    @Override
+                    public void visitNamedFunction(JetNamedFunction function) {
+                        if (function.getReturnTypeRef() != null) {
+                            memberDeclarations.addFunctionDescriptor(classDescriptorResolver.resolveFunctionDescriptor(classDescriptor, parameterScope, function));
+                        } else {
+                            // TODO : Caution: a cyclic dependency possible
+                            throw new UnsupportedOperationException();
+                        }
+                    }
+
+                    @Override
+                    public void visitJetElement(JetElement element) {
+                        throw new UnsupportedOperationException(element.toString());
+                    }
+                });
+            }
+
+            Set<FunctionDescriptor> constructors = Sets.newLinkedHashSet();
+            classDescriptor.initialize(
+                    !open,
+                    typeParameters,
+                    supertypes,
+                    memberDeclarations,
+                    constructors,
+                    null
+            );
+            for (JetConstructor constructor : classElement.getSecondaryConstructors()) {
+                ConstructorDescriptorImpl functionDescriptor = classDescriptorResolver.resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor);
+                functionDescriptor.setReturnType(classDescriptor.getDefaultType());
+                constructors.add(functionDescriptor);
+            }
+            ConstructorDescriptorImpl primaryConstructorDescriptor = classDescriptorResolver.resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement);
+            if (primaryConstructorDescriptor != null) {
+                primaryConstructorDescriptor.setReturnType(classDescriptor.getDefaultType());
+                constructors.add(primaryConstructorDescriptor);
+                classDescriptor.setPrimaryConstructor(primaryConstructorDescriptor);
+            }
+            return classDescriptor;
+        }
+
     }
 }
diff --git a/stdlib/src/jet/Iterable.java b/stdlib/src/jet/Iterable.java
new file mode 100644
index 00000000000..b105b995d04
--- /dev/null
+++ b/stdlib/src/jet/Iterable.java
@@ -0,0 +1,5 @@
+package jet;
+
+public interface Iterable<T> extends JetObject {
+    Iterator<T> iterator ();
+}
diff --git a/stdlib/src/jet/Iterator.java b/stdlib/src/jet/Iterator.java
new file mode 100644
index 00000000000..001bdd83863
--- /dev/null
+++ b/stdlib/src/jet/Iterator.java
@@ -0,0 +1,6 @@
+package jet;
+
+public interface Iterator<T> extends JetObject {
+    boolean hasNext();
+    T next ();
+}
diff --git a/stdlib/src/jet/Tuple0.java b/stdlib/src/jet/Tuple0.java
new file mode 100644
index 00000000000..8d9db829584
--- /dev/null
+++ b/stdlib/src/jet/Tuple0.java
@@ -0,0 +1,26 @@
+package jet;
+
+/**
+ * @author alex.tkachman
+ */
+public class Tuple0 {
+    public static final Tuple0 INSTANCE = new Tuple0();
+
+    private Tuple0() {
+    }
+
+    @Override
+    public String toString() {
+        return "()";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o == INSTANCE;
+    }
+
+    @Override
+    public int hashCode() {
+        return 239;
+    }
+}
\ No newline at end of file
diff --git a/stdlib/src/jet/typeinfo/JetSignature.java b/stdlib/src/jet/typeinfo/JetSignature.java
new file mode 100644
index 00000000000..ab2455903c2
--- /dev/null
+++ b/stdlib/src/jet/typeinfo/JetSignature.java
@@ -0,0 +1,15 @@
+package jet.typeinfo;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.TypeVariable;
+import java.util.*;
+
+/**
+ * @author alex.tkachman
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@interface JetSignature {
+    String value();
+
+}
diff --git a/stdlib/src/jet/typeinfo/TypeInfo.java b/stdlib/src/jet/typeinfo/TypeInfo.java
index 56607c87bbf..19bc40b4a5e 100644
--- a/stdlib/src/jet/typeinfo/TypeInfo.java
+++ b/stdlib/src/jet/typeinfo/TypeInfo.java
@@ -1,111 +1,716 @@
 package jet.typeinfo;
 
 import jet.JetObject;
+import jet.Tuple0;
 
+import java.lang.reflect.Array;
 import java.lang.reflect.Field;
-import java.util.Arrays;
+import java.lang.reflect.TypeVariable;
+import java.util.*;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 /**
  * @author abreslav
  * @author yole
+ * @author alex.tkachman
  */
-public class TypeInfo<T> implements JetObject {
-    private TypeInfo<?> typeInfo;
-    private final Class<T> theClass;
-    private final boolean nullable;
-    private final TypeInfo[] typeParameters;
+public abstract class TypeInfo<T> implements JetObject {
+    private final static TypeInfoProjection[] EMPTY = new TypeInfoProjection[0];
 
-    public TypeInfo(Class<T> theClass, boolean nullable) {
-        this.theClass = theClass;
-        this.nullable = nullable;
-        this.typeParameters = null;
+    public static final TypeInfo<Byte> BYTE_TYPE_INFO = getTypeInfo(Byte.class, false);
+    public static final TypeInfo<Short> SHORT_TYPE_INFO = getTypeInfo(Short.class, false);
+    public static final TypeInfo<Integer> INT_TYPE_INFO = getTypeInfo(Integer.class, false);
+    public static final TypeInfo<Long> LONG_TYPE_INFO = getTypeInfo(Long.class, false);
+    public static final TypeInfo<Character> CHAR_TYPE_INFO = getTypeInfo(Character.class, false);
+    public static final TypeInfo<Boolean> BOOL_TYPE_INFO = getTypeInfo(Boolean.class, false);
+    public static final TypeInfo<Float> FLOAT_TYPE_INFO = getTypeInfo(Float.class, false);
+    public static final TypeInfo<Double> DOUBLE_TYPE_INFO = getTypeInfo(Double.class, false);
+
+    public static final TypeInfo<byte[]> BYTE_ARRAY_TYPE_INFO = getTypeInfo(byte[].class, false);
+    public static final TypeInfo<short[]> SHORT_ARRAY_TYPE_INFO = getTypeInfo(short[].class, false);
+    public static final TypeInfo<int[]> INT_ARRAY_TYPE_INFO = getTypeInfo(int[].class, false);
+    public static final TypeInfo<long[]> LONG_ARRAY_TYPE_INFO = getTypeInfo(long[].class, false);
+    public static final TypeInfo<char[]> CHAR_ARRAY_TYPE_INFO = getTypeInfo(char[].class, false);
+    public static final TypeInfo<boolean[]> BOOL_ARRAY_TYPE_INFO = getTypeInfo(boolean[].class, false);
+    public static final TypeInfo<float[]> FLOAT_ARRAY_TYPE_INFO = getTypeInfo(float[].class, false);
+    public static final TypeInfo<double[]> DOUBLE_ARRAY_TYPE_INFO = getTypeInfo(double[].class, false);
+
+    public static final TypeInfo<String> STRING_TYPE_INFO = getTypeInfo(String.class, false);
+    public static final TypeInfo<Tuple0> TUPLE0_TYPE_INFO = getTypeInfo(Tuple0.class, false);
+
+    public static final TypeInfo<Byte> NULLABLE_BYTE_TYPE_INFO = getTypeInfo(Byte.class, true);
+    public static final TypeInfo<Short> NULLABLE_SHORT_TYPE_INFO = getTypeInfo(Short.class, true);
+    public static final TypeInfo<Integer> NULLABLE_INT_TYPE_INFO = getTypeInfo(Integer.class, true);
+    public static final TypeInfo<Long> NULLABLE_LONG_TYPE_INFO = getTypeInfo(Long.class, true);
+    public static final TypeInfo<Character> NULLABLE_CHAR_TYPE_INFO = getTypeInfo(Character.class, true);
+    public static final TypeInfo<Boolean> NULLABLE_BOOL_TYPE_INFO = getTypeInfo(Boolean.class, true);
+    public static final TypeInfo<Float> NULLABLE_FLOAT_TYPE_INFO = getTypeInfo(Float.class, true);
+    public static final TypeInfo<Double> NULLABLE_DOUBLE_TYPE_INFO = getTypeInfo(Double.class, true);
+    public static final TypeInfo<String> NULLABLE_STRING_TYPE_INFO = getTypeInfo(String.class, true);
+    public static final TypeInfo<Tuple0> NULLABLE_TUPLE0_TYPE_INFO = getTypeInfo(Tuple0.class, true);
+    
+    public static Object [] newArray(int length, TypeInfo typeInfo) {
+        return (Object[]) Array.newInstance(((TypeInfoImpl)typeInfo).signature.klazz, length);
     }
 
-    public TypeInfo(Class<T> theClass, boolean nullable, TypeInfo[] typeParameters) {
-        this.theClass = theClass;
-        this.nullable = nullable;
-        this.typeParameters = typeParameters;
+    public static <T> TypeInfoProjection invariantProjection(final TypeInfo<T> typeInfo) {
+        return (TypeInfoProjection) typeInfo;
     }
 
-    public Object getClassObject() {
-        try {
-            final Class implClass = theClass.getClassLoader().loadClass(theClass.getCanonicalName() + "$$Impl");
-            final Field classobj = implClass.getField("$classobj");
-            return classobj.get(null);
+    public static <T> TypeInfoProjection inProjection(TypeInfo<T> typeInfo) {
+        return new TypeInfoProjection.TypeInfoProjectionImpl(typeInfo) {
+//            @NotNull
+            @Override
+            public TypeInfoVariance getVariance() {
+                return TypeInfoVariance.IN_VARIANCE;
+            }
+        };
+    }
+
+    public static <T> TypeInfoProjection outProjection(TypeInfo<T> typeInfo) {
+        return new TypeInfoProjection.TypeInfoProjectionImpl(typeInfo) {
+//            @NotNull
+            @Override
+            public TypeInfoVariance getVariance() {
+                return TypeInfoVariance.OUT_VARIANCE;
+            }
+        };
+    }
+
+    public static <T> TypeInfo<T> getTypeInfo(Class<T> klazz, boolean nullable) {
+        return new TypeInfoImpl<T>(klazz, nullable);
+    }
+
+    public static <T> TypeInfo<T> getTypeInfo(Class<T> klazz, boolean nullable, TypeInfo outerTypeInfo) {
+        return new TypeInfoImpl<T>(klazz, nullable, outerTypeInfo);
+    }
+
+    public static <T> TypeInfo<T> getTypeInfo(Class<T> klazz, boolean nullable, TypeInfo outerTypeInfo, TypeInfoProjection[] projections) {
+        return new TypeInfoImpl<T>(klazz, nullable, outerTypeInfo, projections);
+    }
+
+    public static <T> TypeInfo<T> getTypeInfo(Class<T> klazz, boolean nullable, TypeInfoProjection[] projections) {
+        return new TypeInfoImpl<T>(klazz, nullable, projections);
+    }
+
+    public abstract Object getClassObject();
+
+    public abstract boolean isInstance(Object obj);
+
+    public abstract int getProjectionCount();
+
+    public abstract TypeInfo getOuterTypeInfo();
+
+    public abstract TypeInfoProjection getProjection(int index);
+
+    public abstract TypeInfo getArgumentType(Class klass, int index);
+    
+    protected abstract TypeInfo substitute(List<TypeInfo> myVars);
+
+    protected abstract TypeInfo substitute(TypeInfo outer, TypeInfoProjection[] projections);
+
+    private static class TypeInfoVar<T> extends TypeInfo<T> {
+        final int varIndex;
+        final Signature signature;
+        final boolean nullable;
+
+        private TypeInfoVar(Signature signature, Integer varIndex) {
+            this.signature = signature;
+            this.varIndex = varIndex;
+            nullable = false;
         }
-        catch(Exception e) {
+
+        public TypeInfoVar(Signature signature, boolean nullable, int varIndex) {
+            this.signature = signature;
+            this.nullable = nullable;
+            this.varIndex = varIndex;
+        }
+
+        @Override
+        public Object getClassObject() {
+            throw new UnsupportedOperationException("Abstract TypeInfo");
+        }
+
+        @Override
+        public boolean isInstance(Object obj) {
+            throw new UnsupportedOperationException("Abstract TypeInfo");
+        }
+
+        @Override
+        public int getProjectionCount() {
+            return 0;
+        }
+
+        @Override
+        public TypeInfo getOuterTypeInfo() {
             return null;
         }
+
+        @Override
+        public TypeInfoProjection getProjection(int index) {
+            throw new UnsupportedOperationException("Abstract TypeInfo");
+        }
+
+        @Override
+        public TypeInfo getArgumentType(Class klass, int index) {
+            throw new UnsupportedOperationException("Abstract TypeInfo");
+        }
+
+        @Override
+        public TypeInfo substitute(List<TypeInfo> myVars) {
+            return myVars.get(varIndex);
+        }
+
+        @Override
+        protected TypeInfo substitute(TypeInfo outer, TypeInfoProjection[] projections) {
+            return projections[varIndex].getType();
+        }
+
+        @Override
+        public TypeInfo<?> getTypeInfo() {
+            throw new UnsupportedOperationException("Abstract TypeInfo");
+        }
+
+        @Override
+        public String toString() {
+            return "T:" + signature.klazz.getName() + ":" + varIndex;
+        }
     }
 
-    public boolean isInstance(Object obj) {
-        if (obj instanceof JetObject) {
-            return isSubtypeOf(((JetObject) obj).getTypeInfo());
-        }
-        throw new UnsupportedOperationException(); // TODO
-    }
+    private static class TypeInfoImpl<T> extends TypeInfo<T> implements TypeInfoProjection {
+        private TypeInfo<?> typeInfo;
+        private final Signature signature;
+        private final boolean nullable;
+        private final TypeInfoProjection[] projections;
+        private final TypeInfo outerTypeInfo;
 
-    public boolean isSubtypeOf(TypeInfo<?> other) {
-        if (!theClass.isAssignableFrom(other.theClass)) {
-            return false;
+        private TypeInfoImpl(Class<T> theClass, boolean nullable) {
+            this(theClass, nullable, null, EMPTY);
         }
-        if (nullable && !other.nullable) {
-            return false;
+
+        private TypeInfoImpl(Class<T> theClass, boolean nullable, TypeInfo outerTypeInfo) {
+            this(theClass, nullable, outerTypeInfo, EMPTY);
         }
-        if (typeParameters != null) {
-            if (other.typeParameters == null || other.typeParameters.length != typeParameters.length) {
+
+        private TypeInfoImpl(Class<T> theClass, boolean nullable, TypeInfoProjection[] projections) {
+            this(theClass, nullable, null, projections);
+        }
+        
+        private TypeInfoImpl(Class<T> theClass, boolean nullable, TypeInfo outerTypeInfo, TypeInfoProjection[] projections) {
+            this.outerTypeInfo = outerTypeInfo;
+            this.signature = Parser.parse(theClass);
+            this.nullable = nullable;
+            this.projections = projections;
+            if(signature.variables.size() != projections.length)
+                throw new IllegalStateException("Wrong signature " + theClass.getName());
+        }
+
+        public final TypeInfoProjection getProjection(int index) {
+            return projections[index];
+        }
+
+        public final Object getClassObject() {
+            try {
+                final Class implClass = signature.klazz.getClassLoader().loadClass(signature.klazz.getCanonicalName());
+                final Field classobj = implClass.getField("$classobj");
+                return classobj.get(null);
+            } catch (Exception e) {
+                return null;
+            }
+        }
+
+        TypeInfo getSuperTypeInfo(Class klass) {
+            return signature.superSignatures.get(klass);
+        }
+
+        public final TypeInfo getArgumentType(Class klass, int index) {
+            if(klass == this.signature.klazz)
+                return projections[index].getType();
+            else {
+                return getSuperTypeInfo(klass).substitute(outerTypeInfo, projections).getArgumentType(klass, index);
+            }
+        }
+
+        @Override
+        public TypeInfo substitute(final List<TypeInfo> myVars) {
+            if(projections.length == 0)
+                return new TypeInfoImpl(this.signature.klazz, nullable, EMPTY);
+            else {
+                TypeInfoProjection [] proj = new TypeInfoProjection[projections.length];
+                for(int i = 0; i != proj.length; ++i) {
+                    final int finalI = i;
+                    final TypeInfo substitute = projections[finalI].getType().substitute(myVars);
+                    proj[i] = new TypeInfoProjection(){
+
+                        @Override
+                        public TypeInfoVariance getVariance() {
+                            return projections[finalI].getVariance();
+                        }
+
+                        @Override
+                        public TypeInfo getType() {
+                            return substitute;
+                        }
+
+                        @Override
+                        public String toString() {
+                            return getVariance().toString() + " " + substitute;
+                        }
+                    };
+                }
+                return new TypeInfoImpl(this.signature.klazz, nullable, proj);
+            }
+        }
+
+        @Override
+        protected TypeInfo substitute(TypeInfo outer, TypeInfoProjection[] prj) {
+            if(projections.length == 0)
+                return new TypeInfoImpl(signature.klazz, nullable, EMPTY);
+            else {
+                TypeInfoProjection [] proj = new TypeInfoProjection[projections.length];
+                for(int i = 0; i != proj.length; ++i) {
+                    final int finalI = i;
+                    final TypeInfo substitute = projections[finalI].getType().substitute(outer, prj);
+                    proj[i] = new TypeInfoProjection(){
+
+                        @Override
+                        public TypeInfoVariance getVariance() {
+                            return projections[finalI].getVariance();
+                        }
+
+                        @Override
+                        public TypeInfo getType() {
+                            return substitute;
+                        }
+
+                        @Override
+                        public String toString() {
+                            return getVariance().toString() + " " + substitute;
+                        }
+                    };
+                }
+                return new TypeInfoImpl(signature.klazz, nullable, proj);
+            }
+        }
+
+        @Override
+        public final boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            TypeInfoImpl typeInfo = (TypeInfoImpl) o;
+
+            if (!signature.klazz.equals(typeInfo.signature.klazz)) return false;
+            if (nullable != typeInfo.nullable) return false;
+            if (!Arrays.equals(projections, typeInfo.projections)) return false;
+
+            return true;
+        }
+
+//        @NotNull
+        @Override
+        public TypeInfoVariance getVariance() {
+            return TypeInfoVariance.INVARIANT;
+        }
+
+//        @NotNull
+        @Override
+        public TypeInfo getType() {
+            return this;
+        }
+
+        @Override
+        public final int hashCode() {
+            return 31 * signature.klazz.hashCode() + Arrays.hashCode(projections);
+        }
+
+        public final boolean isInstance(Object obj) {
+            if (obj == null) return nullable;
+
+            if (obj instanceof JetObject) {
+                return ((TypeInfoImpl)((JetObject) obj).getTypeInfo()).isSubtypeOf(this);
+            }
+
+            return signature.klazz.isAssignableFrom(obj.getClass());  // TODO
+        }
+
+        @Override
+        public int getProjectionCount() {
+            return projections.length;
+        }
+
+        @Override
+        public TypeInfo getOuterTypeInfo() {
+            return outerTypeInfo;
+        }
+
+        @Override
+        public final String toString() {
+            StringBuilder sb = new StringBuilder().append(signature.klazz.getName());
+            if (projections.length != 0) {
+                sb.append("<");
+                for (int i = 0; i != projections.length - 1; ++i) {
+                    sb.append(projections[i].toString()).append(",");
+                }
+                sb.append(projections[projections.length - 1].toString()).append(">");
+            }
+            if (nullable)
+                sb.append("?");
+            return sb.toString();
+        }
+
+        @Override
+        public final TypeInfo<?> getTypeInfo() {
+            if (typeInfo == null) {
+                // TODO: Implementation must be lazy, otherwise the result would be of an infinite size
+                throw new UnsupportedOperationException(); // TODO
+            }
+            return typeInfo;
+        }
+
+        public final boolean isSubtypeOf(TypeInfoImpl<?> superType) {
+            if (nullable && !superType.nullable) {
+                return false;
+            }
+            if (!superType.signature.klazz.isAssignableFrom(signature.klazz)) {
+                return false;
+            }
+            if (superType.projections == null || superType.projections.length != projections.length) {
                 throw new IllegalArgumentException("inconsistent type infos for the same class");
             }
-            for (int i = 0; i < typeParameters.length; i++) {
+            for (int i = 0; i < projections.length; i++) {
                 // TODO handle variance here
-                if (!typeParameters [i].equals(other.typeParameters [i])) {
+                if (!projections[i].getType().equals(superType.projections[i].getType())) {
                     return false;
                 }
             }
+            return true;
         }
-        return true;
+
     }
 
-    public TypeInfo getTypeParameter(int index) {
-        return typeParameters[index];
-    }
+    public static class Signature {
+        final Signature outer;
+        final Class klazz;
 
-    @Override
-    public TypeInfo<?> getTypeInfo() {
-        if (typeInfo == null) {
-            // TODO: Implementation must be lazy, otherwise the result would be of an infinite size
-            throw new UnsupportedOperationException(); // TODO
+        List<TypeInfoProjection> variables;
+        Map<String,Integer> varNames;
+        List<TypeInfo> superTypes;
+        
+        final HashMap<Class,TypeInfo> superSignatures = new HashMap<Class,TypeInfo>();
+
+        public Signature(Signature outer, Class klazz) {
+            this.outer = outer;
+            this.klazz = klazz;
+        }
+
+        protected void afterParse() {
+            List<TypeInfo> myVars = variables == null ? Collections.<TypeInfo>emptyList() : new LinkedList<TypeInfo>();
+            if(variables != null)
+                for(int i = 0; i != variables.size(); ++i)
+                    myVars.add(new TypeInfoVar(this, false, i));
+
+            for(TypeInfo superType : superTypes) {
+                if(superType instanceof TypeInfoImpl) {
+                    TypeInfoImpl type = (TypeInfoImpl) superType;
+                    Signature superSignature = Parser.parse(type.signature.klazz);
+
+                    TypeInfo substituted = type.substitute(myVars);
+                    superSignatures.put(type.signature.klazz, substituted);
+
+                    List<TypeInfo> vars = Collections.emptyList();
+                    if(superType.getProjectionCount() != 0) {
+                        vars = new LinkedList<TypeInfo>();
+                        for(int i=0; i != superType.getProjectionCount(); ++i) {
+                            TypeInfo substitute = superType.getProjection(i).getType().substitute(myVars);
+                            vars.add(substitute);
+                        }
+                    }
+
+                    for(Map.Entry<Class,TypeInfo> entry : superSignature.superSignatures.entrySet()) {
+                        superSignatures.put(entry.getKey(), entry.getValue().substitute(vars));
+                    }
+                }
+            }
         }
-        return typeInfo;
     }
 
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+    public static class Parser {
+        static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        static final WeakHashMap<Class,Signature> map = new WeakHashMap<Class,Signature>();
 
-        TypeInfo typeInfo = (TypeInfo) o;
+        int cur;
+        final char [] string;
 
-        if (!theClass.equals(typeInfo.theClass)) return false;
-        if (nullable != typeInfo.nullable) return false;
-        if (!Arrays.equals(typeParameters, typeInfo.typeParameters)) return false;
+        final ClassLoader classLoader;
 
-        return true;
+        Parser(String string, ClassLoader classLoader) {
+            this.classLoader = classLoader;
+            this.string = string.toCharArray();
+        }
+
+        public static Signature parse(Class klass) {
+            if(klass == null)
+                return null;
+
+            lock.readLock().lock();
+            Signature sig = map.get(klass);
+            lock.readLock().unlock();
+            if (sig == null) {
+                lock.writeLock().lock();
+
+                sig = map.get(klass);
+                if (sig == null) {
+                    sig = internalParse(klass);
+                }
+
+                lock.writeLock().unlock();
+            }
+            return sig;
+        }
+
+        private static Signature internalParse(Class klass) {
+            if(klass.isArray() && !klass.getComponentType().isPrimitive()) {
+                Signature signature = new ArraySignature(klass);
+                map.put(klass, signature);
+                return signature;
+            }
+
+            JetSignature annotation = (JetSignature) klass.getAnnotation(JetSignature.class);
+            if(annotation != null) {
+                String value = annotation.value();
+                if(value != null) {
+                    Parser parser = new Parser(value, klass.getClassLoader());
+                    Class enclosingClass = klass.getEnclosingClass();
+                    Signature signature = new Signature(parse(enclosingClass), klass);
+                    map.put(klass, signature);
+                    parser.parseVars(signature);
+                    parser.parseTypes(signature);
+                    signature.afterParse();
+                    return signature;
+                }
+            }
+            return getGenericSignature(klass);
+        }
+
+        private static Signature getGenericSignature(Class klass) {
+            // todo complete impl
+
+            java.lang.reflect.Type genericSuperclass = klass.getGenericSuperclass();
+            Signature signature = new Signature(parse(klass.getEnclosingClass()), klass);
+
+            TypeVariable[] typeParameters = klass.getTypeParameters();
+            if(typeParameters == null || typeParameters.length == 0) {
+                signature.varNames = Collections.emptyMap();
+                signature.variables = Collections.emptyList();
+            }
+            else {
+                signature.varNames = new HashMap<String, Integer>();
+                signature.variables = new LinkedList<TypeInfoProjection>();
+            }
+
+            if (typeParameters != null && typeParameters.length != 0) {
+                for (int i = 0; i < typeParameters.length; i++) {
+                    TypeVariable typeParameter = typeParameters[i];
+                    signature.varNames.put(typeParameter.getName(), i);
+                    final TypeInfoVar typeInfoVar = new TypeInfoVar(signature, false, i);
+                    signature.variables.add(new TypeInfoProjection(){
+
+                        @Override
+                        public TypeInfoVariance getVariance() {
+                            return TypeInfoVariance.INVARIANT;
+                        }
+
+                        @Override
+                        public TypeInfo getType() {
+                            return typeInfoVar;
+                        }
+
+                        @Override
+                        public String toString() {
+                            return typeInfoVar.toString();
+                        }
+                    });
+                }
+            }
+
+            return signature;
+        }
+
+        public void parseVars(Signature signature) {
+            while(cur < string.length && string[cur] == 'T') {
+                if(signature.variables == null) {
+                    signature.variables  = new LinkedList<TypeInfoProjection>();
+                    signature.varNames = new HashMap<String, Integer>();
+                }
+                cur++;
+                signature.variables.add(parseVar(signature));
+            }
+            signature.variables = signature.variables == null ? Collections.<TypeInfoProjection>emptyList() : signature.variables;
+            signature.varNames  = signature.varNames == null ? Collections.<String,Integer>emptyMap() : signature.varNames;
+        }
+
+        private TypeInfoProjection parseVar(Signature signature) {
+            final TypeInfoVariance variance = parseVariance();
+            String name = parseName();
+            final TypeInfoVar typeInfoVar = new TypeInfoVar(signature, signature.variables.size());
+            signature.varNames.put(name, signature.variables.size());
+            return new TypeInfoProjection(){
+                @Override
+                public TypeInfoVariance getVariance() {
+                    return variance;
+                }
+
+                @Override
+                public TypeInfo getType() {
+                    return typeInfoVar;
+                }
+
+                @Override
+                public String toString() {
+                    return typeInfoVar.toString();
+                }
+            };
+        }
+
+        private String parseName() {
+            int c = cur;
+            while (string[c] != ';') {
+                c++;
+            }
+            String name = new String(string, cur, c - cur);
+            cur = c+1;
+            return name;
+        }
+
+        private TypeInfoVariance parseVariance() {
+            if(string[cur] == 'i' && string[cur+1] == 'n' && string[cur+2] == ' ' ) {
+                cur += 3;
+                return TypeInfoVariance.IN_VARIANCE;
+            }
+            else if (string[cur] == 'o' && string[cur+1] == 'u' && string[cur+2] == 't' && string[cur+3] == ' ') {
+                cur += 4;
+                return TypeInfoVariance.OUT_VARIANCE;
+            }
+            else {
+                return TypeInfoVariance.INVARIANT;
+            }
+        }
+
+        public void parseTypes(Signature signature) {
+            List<TypeInfo> types = null;
+            while(cur != string.length) {
+                if(types == null) {
+                    types = new LinkedList<TypeInfo>();
+                }
+                types.add(parseType(signature));
+            }
+            signature.superTypes = types == null ? Collections.<TypeInfo>emptyList() : types;
+        }
+
+        private TypeInfo parseType(Signature signature) {
+            switch (string[cur]) {
+                case 'L':
+                    cur++;
+                    String name = parseName();
+                    Class<?> aClass;
+                    try {
+                        aClass = classLoader.loadClass(name.replace('/','.'));
+                    } catch (ClassNotFoundException e) {
+                        throw new RuntimeException(e);
+                    }
+                    List<TypeInfoProjection> proj = null;
+                    boolean nullable = false;
+                    if(cur != string.length && string[cur] == '<') {
+                        cur++;
+                        while(string[cur] != '>') {
+                            if(proj == null)
+                                proj = new LinkedList<TypeInfoProjection>();
+                            proj.add(parseProjection(signature));
+                        }
+                        cur++;
+                    }
+                    if(cur != string.length && string[cur] == '?') {
+                        cur++;
+                        nullable = true;
+                    }
+                    if(proj == null)
+                        proj = Collections.emptyList();
+                    return new TypeInfoImpl(aClass, nullable,proj.toArray(new TypeInfoProjection[proj.size()]));
+
+                case 'T':
+                    cur++;
+                    return parseTypeVar(signature);
+
+                default:
+                    throw new IllegalStateException(new String(string));
+            }
+        }
+
+        private TypeInfo parseTypeVar(Signature signature) {
+            TypeInfoVariance variance = parseVariance();
+            String klazz = parseName();
+            String name = parseName();
+            boolean nullable = false;
+            if(string[cur] == '?') {
+                nullable = true;
+                cur++;
+            }
+
+            if(klazz.equals(signature.klazz.getName()))
+                return new TypeInfoVar(signature, nullable, signature.varNames.get(name));
+            else {
+                Signature sig = signature;
+                while(!klazz.equals(sig.klazz.getName())) {
+                    sig = sig.outer;
+                    if(sig == null)
+                        throw new IllegalStateException();
+                }
+                
+                return new TypeInfoVar(sig, nullable, sig.varNames.get(name));
+            }
+        }
+
+        private TypeInfoProjection parseProjection(Signature signature) {
+            final TypeInfoVariance variance = parseVariance();
+            final TypeInfo type = parseType(signature);
+            return new TypeInfoProjection(){
+                @Override
+                public TypeInfoVariance getVariance() {
+                    return variance;
+                }
+
+                @Override
+                public TypeInfo getType() {
+                    return type;
+                }
+
+                @Override
+                public String toString() {
+                    return type.toString();
+                }
+            };
+        }
+
+        private static class ArraySignature extends Signature {
+            public ArraySignature(Class klass) {
+                super(null, klass);
+                variables  = new LinkedList<TypeInfoProjection>();
+                varNames = new HashMap<String, Integer>();
+                varNames.put("T", 0);
+                final TypeInfoVar typeInfoVar = new TypeInfoVar(this, 0);
+                variables.add(new TypeInfoProjection(){
+                    @Override
+                    public TypeInfoVariance getVariance() {
+                        return TypeInfoVariance.INVARIANT;
+                    }
+
+                    @Override
+                    public TypeInfo getType() {
+                        return typeInfoVar;
+                    }
+                });
+            }
+        }
     }
-
-    @Override
-    public int hashCode() {
-        int result = theClass.hashCode();
-        result = 31 * result + (typeParameters != null ? Arrays.hashCode(typeParameters) : 0);
-        return result;
-    }
-
-    public static final TypeInfo<Byte> BYTE_TYPE_INFO = new TypeInfo<Byte>(Byte.class, false);
-    public static final TypeInfo<Short> SHORT_TYPE_INFO = new TypeInfo<Short>(Short.class, false);
-    public static final TypeInfo<Integer> INT_TYPE_INFO = new TypeInfo<Integer>(Integer.class, false);
-    public static final TypeInfo<Long> LONG_TYPE_INFO = new TypeInfo<Long>(Long.class, false);
-    public static final TypeInfo<Character> CHAR_TYPE_INFO = new TypeInfo<Character>(Character.class, false);
-    public static final TypeInfo<Boolean> BOOL_TYPE_INFO = new TypeInfo<Boolean>(Boolean.class, false);
-    public static final TypeInfo<Float> FLOAT_TYPE_INFO = new TypeInfo<Float>(Float.class, false);
-    public static final TypeInfo<Double> DOUBLE_TYPE_INFO = new TypeInfo<Double>(Double.class, false);
 }
diff --git a/stdlib/src/jet/typeinfo/TypeInfoPattern.java b/stdlib/src/jet/typeinfo/TypeInfoPattern.java
new file mode 100644
index 00000000000..eff0ae819cc
--- /dev/null
+++ b/stdlib/src/jet/typeinfo/TypeInfoPattern.java
@@ -0,0 +1,100 @@
+package jet.typeinfo;
+
+/**
+ * This class represents how type info of super class should be matched against type parameters of subclass.
+ *
+ * For each subclass we create such pattern for subclass itself and all it super classes either during
+ * static initialization(or maybe when needed).
+ *
+ * For each instance of parametrized type we keep it type info, which can be understood as binding of type parameter variables.
+ *
+ * @author alex.tkachman
+ */
+public interface TypeInfoPattern {
+    TypeInfo substitute(TypeInfo[] variables);
+
+    class Var implements TypeInfoPattern {
+        public final int index;
+
+        public Var(int index) {
+            this.index = index;
+        }
+
+        @Override
+        public TypeInfo substitute(TypeInfo[] variables) {
+            return variables[index];
+        }
+    }
+
+    class Const implements TypeInfoPattern {
+        private final TypeInfo typeInfo;
+
+        public Const(TypeInfo typeInfo) {
+            this.typeInfo = typeInfo;
+        }
+
+        @Override
+        public TypeInfo substitute(TypeInfo[] variables) {
+            return typeInfo;
+        }
+    }
+
+    class Pattern implements TypeInfoPattern {
+        public static final TypeInfoPatternProjection[] EMPTY = new TypeInfoPatternProjection[0];
+        public final Class klazz;
+        public final boolean nullable;
+        public final TypeInfoPatternProjection [] patterns;
+
+        public Pattern(Class klazz, boolean nullable, TypeInfoPatternProjection[] patterns) {
+            this.klazz = klazz;
+            this.nullable = nullable;
+            this.patterns = patterns;
+        }
+
+        public Pattern(Class klazz, boolean nullable) {
+            this.klazz = klazz;
+            this.nullable = nullable;
+            this.patterns = EMPTY;
+        }
+
+        @Override
+        public TypeInfo substitute(TypeInfo[] variables) {
+            return TypeInfo.getTypeInfo(klazz, nullable, TypeInfoPatternProjection.substitute(patterns, variables));
+        }
+    }
+    
+    class TypeInfoPatternProjection {
+        public final TypeInfoVariance variance;
+
+        public final TypeInfoPattern pattern;
+
+        public TypeInfoPatternProjection(TypeInfoVariance variance, TypeInfoPattern pattern) {
+            this.variance = variance;
+            this.pattern = pattern;
+        }
+
+        public TypeInfoProjection substitute(final TypeInfo[] variables) {
+            return new TypeInfoProjection() {
+                @Override
+                public TypeInfoVariance getVariance() {
+                    return variance;
+                }
+
+                @Override
+                public TypeInfo getType() {
+                    return pattern.substitute(variables);
+                }
+            };
+        }
+
+        public static TypeInfoProjection[] substitute(TypeInfoPatternProjection[] patterns, TypeInfo[] variables) {
+            if(patterns.length == 0)
+                return TypeInfoProjection.EMPTY_ARRAY;
+            TypeInfoProjection [] projections = new TypeInfoProjection[patterns.length];
+            for (int i = 0; i < projections.length; i++) {
+                projections[i] = patterns[i].substitute(variables);
+            }
+            return projections;
+        }
+    }
+}
diff --git a/stdlib/src/jet/typeinfo/TypeInfoProjection.java b/stdlib/src/jet/typeinfo/TypeInfoProjection.java
new file mode 100644
index 00000000000..654794eb539
--- /dev/null
+++ b/stdlib/src/jet/typeinfo/TypeInfoProjection.java
@@ -0,0 +1,49 @@
+package jet.typeinfo;
+
+import java.util.List;
+
+/**
+ * @author alex.tkachman
+ */
+public interface TypeInfoProjection {
+    TypeInfoProjection[] EMPTY_ARRAY = new TypeInfoProjection[0];
+
+    TypeInfoVariance getVariance();
+
+    TypeInfo getType();
+
+    abstract class TypeInfoProjectionImpl implements TypeInfoProjection {
+        private final TypeInfo type;
+
+        TypeInfoProjectionImpl(TypeInfo typeInfo) {
+            this.type = typeInfo;
+        }
+
+        @Override
+        public final TypeInfo getType() {
+            return type;
+        }
+
+        @Override
+        public final boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            TypeInfoProjectionImpl that = (TypeInfoProjectionImpl) o;
+            // no need to compare variance as we compared classes already
+            return type.equals(that.type);
+        }
+
+        @Override
+        public final int hashCode() {
+            int result = type.hashCode();
+            result = 31 * result + (getVariance().hashCode());
+            return result;
+        }
+
+        @Override
+        public final String toString() {
+            return (getVariance() == TypeInfoVariance.INVARIANT ? "" : getVariance().toString() + " ") + type;
+        }
+    }
+}
diff --git a/stdlib/src/jet/typeinfo/TypeInfoVariance.java b/stdlib/src/jet/typeinfo/TypeInfoVariance.java
new file mode 100644
index 00000000000..410d45e3c49
--- /dev/null
+++ b/stdlib/src/jet/typeinfo/TypeInfoVariance.java
@@ -0,0 +1,21 @@
+package jet.typeinfo;
+
+/**
+ * @author alex.tkachman
+ */
+public enum TypeInfoVariance {
+    INVARIANT("") ,
+    IN_VARIANCE("in"),
+    OUT_VARIANCE("out");
+
+    private final String label;
+
+    TypeInfoVariance(String label) {
+        this.label = label;
+    }
+
+    @Override
+    public String toString() {
+        return label;
+    }
+}