diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java
index b062a56f417..3aa68b5b5ed 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java
@@ -1,5 +1,6 @@
 /*
  * @author max
+ * @author alex.tkachman
  */
 package org.jetbrains.jet.codegen;
 
@@ -16,9 +17,7 @@ import org.objectweb.asm.commons.Method;
 import org.objectweb.asm.signature.SignatureWriter;
 
 import java.util.Arrays;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 
 import static org.objectweb.asm.Opcodes.*;
 
@@ -152,6 +151,9 @@ public class ClosureCodegen extends FunctionOrClosureCodegen {
         final Method bridge = erasedInvokeSignature(funDescriptor);
         final Method delegate = invokeSignature(funDescriptor);
 
+        if(bridge.getDescriptor().equals(delegate.getDescriptor()))
+            return;
+
         final MethodVisitor mv = cv.visitMethod(ACC_PUBLIC, "invoke", bridge.getDescriptor(), state.getTypeMapper().genericSignature(funDescriptor), new String[0]);
         mv.visitCode();
 
@@ -212,7 +214,8 @@ public class ClosureCodegen extends FunctionOrClosureCodegen {
         ExpressionCodegen expressionCodegen = new ExpressionCodegen(mv, null, Type.VOID_TYPE, context, state);
 
         iv.load(0, Type.getObjectType(funClass));
-        expressionCodegen.generateTypeInfo(new ProjectionErasingJetType(returnType));
+//        expressionCodegen.generateTypeInfo(new ProjectionErasingJetType(returnType));
+        iv.aconst(null); // @todo
         iv.invokespecial(funClass, "<init>", "(Ljet/typeinfo/TypeInfo;)V");
 
         i = 1;
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
index e9483184889..a76f5e3d782 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
@@ -313,10 +313,6 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         myContinueTargets.pop();
     }
 
-    private DeclarationDescriptor contextType() {
-        return context.getContextClass();
-    }
-
     private OwnerKind contextKind() {
         return context.getContextKind();
     }
@@ -874,7 +870,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         String owner;
 
         boolean isInterface;
-        boolean isInsideClass = containingDeclaration == contextType();
+        boolean isInsideClass = containingDeclaration == context.getContextClass();
         if (isInsideClass || isStatic) {
             owner = typeMapper.getOwner(functionDescriptor, contextKind());
             isInterface = false;
@@ -904,7 +900,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
         boolean isStatic = containingDeclaration instanceof NamespaceDescriptorImpl;
         propertyDescriptor = propertyDescriptor.getOriginal();
-        boolean isInsideClass = !forceInterface && containingDeclaration == contextType();
+        boolean isInsideClass = !forceInterface && containingDeclaration == context.getContextClass();
         Method getter;
         Method setter;
         if (forceField) {
@@ -1024,10 +1020,6 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         return funDescriptor;
     }
 
-    public void invokeMethodWithArguments(CallableMethod callableMethod, JetCallElement expression) {
-        invokeMethodWithArguments(callableMethod, expression, StackValue.none());
-    }
-
     public void invokeMethodWithArguments(CallableMethod callableMethod, JetCallElement expression, StackValue receiver) {
         final Type calleeType = callableMethod.getGenerateCalleeType();
         if (calleeType != null && expression instanceof JetCallExpression) {
@@ -1053,7 +1045,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         }
         else {
             if (callableMethod.isNeedsReceiver()) {
-                receiver.put(JetTypeMapper.TYPE_OBJECT, v);
+                if (receiver == StackValue.none()) {
+                    v.load(0, JetTypeMapper.TYPE_OBJECT);
+                }
+                else
+                    receiver.put(JetTypeMapper.TYPE_OBJECT, v);
             }
         }
         
@@ -1812,7 +1808,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
                 }
 
                 CallableMethod method = typeMapper.mapToCallableMethod((ConstructorDescriptor) constructorDescriptor, OwnerKind.IMPLEMENTATION);
-                invokeMethodWithArguments(method, expression);
+                invokeMethodWithArguments(method, expression, StackValue.none());
             }
         }
         else {
@@ -1849,7 +1845,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         v.anew(type);
         v.dup();
         final CallableMethod callableMethod = typeMapper.mapToCallableMethod(constructor);
-        invokeMethodWithArguments(callableMethod, expression);
+        invokeMethodWithArguments(callableMethod, expression, StackValue.none());
         return type;
     }
 
@@ -1867,20 +1863,22 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
                 throw new CompilationException("primitive array constructor requires one argument");
             }
         }
-        gen(args.get(0).getArgumentExpression(), Type.INT_TYPE);
 
         if(isArray) {
             JetType elementType = typeMapper.getGenericsElementType(arrayType);
             if(elementType != null) {
                 generateTypeInfo(elementType);
-                v.invokestatic("jet/typeinfo/TypeInfo", "newArray", "(ILjet/typeinfo/TypeInfo;)[Ljava/lang/Object;");
+                gen(args.get(0).getArgumentExpression(), Type.INT_TYPE);
+                v.invokevirtual("jet/typeinfo/TypeInfo", "newArray", "(I)[Ljava/lang/Object;");
             }
             else {
+                gen(args.get(0).getArgumentExpression(), Type.INT_TYPE);
                 v.newarray(JetTypeMapper.boxType(typeMapper.mapType(arrayType.getArguments().get(0).getType())));
             }
         }
         else {
             Type type = typeMapper.mapType(arrayType, OwnerKind.IMPLEMENTATION);
+            gen(args.get(0).getArgumentExpression(), Type.INT_TYPE);
             v.newarray(type.getElementType());
         }
 
@@ -2311,12 +2309,12 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
             return;
         }
         DeclarationDescriptor containingDeclaration = typeParameterDescriptor.getContainingDeclaration();
-        if (contextType() instanceof ClassDescriptor) {
-            ClassDescriptor descriptor = (ClassDescriptor) contextType();
+        if (context.getContextClass() instanceof ClassDescriptor) {
+            ClassDescriptor descriptor = (ClassDescriptor) context.getContextClass();
             JetType defaultType = ((ClassDescriptor)containingDeclaration).getDefaultType();
             Type ownerType = typeMapper.mapType(defaultType);
             ownerType = JetTypeMapper.boxType(ownerType);
-            if (containingDeclaration == contextType()) {
+            if (containingDeclaration == context.getContextClass()) {
                 if(!CodegenUtil.isInterface(descriptor)) {
                     if (CodegenUtil.hasTypeInfoField(defaultType)) {
                         v.load(0, JetTypeMapper.TYPE_OBJECT);
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
index 97ea22a1428..69df0081b91 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
@@ -461,7 +461,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         }
 
         CallableMethod method = state.getTypeMapper().mapToCallableMethod(constructorDescriptor, kind);
-        codegen.invokeMethodWithArguments(method, constructorCall);
+        codegen.invokeMethodWithArguments(method, constructorCall, StackValue.none());
     }
 
     @Override
@@ -513,7 +513,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                     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);
+                    codegen.invokeMethodWithArguments(method, superCall, StackValue.none());
                 }
                 else {
                     throw new UnsupportedOperationException("unsupported type of enum constant initializer: " + specifier);
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
index edda1e0f96b..1d58a515884 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
@@ -75,6 +75,7 @@ public class IntrinsicMethods {
 
         declareOverload(myStdLib.getLibraryScope().getFunctions("toString"), 0, new ToString());
         declareOverload(myStdLib.getLibraryScope().getFunctions("equals"), 1, new Equals());
+        declareOverload(myStdLib.getLibraryScope().getFunctions("plus"), 1, new StringPlus());
 
 //        declareIntrinsicFunction("Any", "equals", 1, new Equals());
 //
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringPlus.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringPlus.java
new file mode 100644
index 00000000000..79995fe4abb
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringPlus.java
@@ -0,0 +1,28 @@
+package org.jetbrains.jet.codegen.intrinsics;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.codegen.ExpressionCodegen;
+import org.jetbrains.jet.codegen.JetTypeMapper;
+import org.jetbrains.jet.codegen.StackValue;
+import org.jetbrains.jet.lang.psi.JetCallExpression;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lexer.JetTokens;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.commons.InstructionAdapter;
+
+import java.util.List;
+
+/**
+ * @author alex.tkachman
+ */
+public class StringPlus implements IntrinsicMethod {
+    @Override
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
+        codegen.gen(arguments.get(0)).put(JetTypeMapper.JL_STRING_TYPE, v);
+        codegen.gen(arguments.get(1)).put(JetTypeMapper.TYPE_OBJECT, v);
+        v.invokestatic("jet/runtime/Intrinsics", "stringPlus", "(Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String;");
+        return StackValue.onStack(JetTypeMapper.JL_STRING_TYPE);
+    }
+}
diff --git a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java
index 105351a6f4f..68f4809ee36 100644
--- a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java
+++ b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java
@@ -1,6 +1,8 @@
 package org.jetbrains.jet.cli;
 
-import com.google.common.collect.*;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
 import com.intellij.core.JavaCoreEnvironment;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.project.Project;
@@ -10,6 +12,7 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
 import com.sampullara.cli.Args;
 import com.sampullara.cli.Argument;
+import org.jetbrains.jet.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
@@ -17,13 +20,11 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticWithTextRange;
 import org.jetbrains.jet.lang.diagnostics.Severity;
-import org.jetbrains.jet.lang.parsing.JetParserDefinition;
 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;
@@ -61,17 +62,13 @@ public class KotlinCompiler {
             public void dispose() {
             }
         };
-        JavaCoreEnvironment environment = new JavaCoreEnvironment(root);
+        JetCoreEnvironment environment = new JetCoreEnvironment(root);
 
         File rtJar = initJdk();
         if (rtJar == null) return;
 
         environment.addToClasspath(rtJar);
 
-        environment.registerFileType(JetFileType.INSTANCE, "kt");
-        environment.registerFileType(JetFileType.INSTANCE, "jet");
-        environment.registerParserDefinition(new JetParserDefinition());
-
         VirtualFile vFile = environment.getLocalFileSystem().findFileByPath(arguments.src);
         if (vFile == null) {
             System.out.print("File/directory not found: " + arguments.src);
diff --git a/compiler/frontend/src/jet/Library.jet b/compiler/frontend/src/jet/Library.jet
index 296cd1038e6..b88e5eb0287 100644
--- a/compiler/frontend/src/jet/Library.jet
+++ b/compiler/frontend/src/jet/Library.jet
@@ -40,6 +40,8 @@ fun Any?.equals(other : Any?) : Boolean// = this === other
 // Returns "null" for null
 fun Any?.toString() : String// = this === other
 
+fun String?.plus(other: Any?) : String
+
 trait Iterator<out T> {
   fun next()  : T
   val hasNext : Boolean
diff --git a/compiler/frontend/src/org/jetbrains/jet/JetCoreEnvironment.java b/compiler/frontend/src/org/jetbrains/jet/JetCoreEnvironment.java
index 2e95dde30b3..eac28f341d6 100644
--- a/compiler/frontend/src/org/jetbrains/jet/JetCoreEnvironment.java
+++ b/compiler/frontend/src/org/jetbrains/jet/JetCoreEnvironment.java
@@ -12,6 +12,8 @@ public class JetCoreEnvironment extends JavaCoreEnvironment {
     public JetCoreEnvironment(Disposable parentDisposable) {
         super(parentDisposable);
         registerFileType(JetFileType.INSTANCE, "kt");
+        registerFileType(JetFileType.INSTANCE, "kts");
+        registerFileType(JetFileType.INSTANCE, "ktm");
         registerFileType(JetFileType.INSTANCE, "jet");
         registerParserDefinition(new JetParserDefinition());
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowGraphTraverser.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowGraphTraverser.java
new file mode 100644
index 00000000000..4ac299453dd
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowGraphTraverser.java
@@ -0,0 +1,116 @@
+package org.jetbrains.jet.lang.cfg;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import org.jetbrains.jet.lang.cfg.pseudocode.Instruction;
+import org.jetbrains.jet.lang.cfg.pseudocode.LocalDeclarationInstruction;
+import org.jetbrains.jet.lang.cfg.pseudocode.Pseudocode;
+import org.jetbrains.jet.lang.cfg.pseudocode.SubroutineEnterInstruction;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author svtk
+ */
+public class JetControlFlowGraphTraverser {
+    public static <D> Map<Instruction, D> traverseInstructionGraphUntilFactsStabilization(
+            Pseudocode pseudocode,
+            InstructionsMergeStrategy<D> instructionsMergeStrategy,
+            D initialDataValue,
+            D initialDataValueForEnterInstruction,
+            boolean straightDirection) {
+        Map<Instruction, D> dataMap = Maps.newHashMap();
+        initializeDataMap(dataMap, pseudocode, initialDataValue);
+        dataMap.put(pseudocode.getEnterInstruction(), initialDataValueForEnterInstruction);
+
+        boolean[] changed = new boolean[1];
+        changed[0] = true;
+        while (changed[0]) {
+            changed[0] = false;
+            traverseSubGraph(pseudocode, instructionsMergeStrategy, Collections.<Instruction>emptyList(), straightDirection, dataMap, changed, false);
+        }
+        return dataMap;
+    }
+
+    private static <D> void initializeDataMap(
+            Map<Instruction, D> dataMap,
+            Pseudocode pseudocode,
+            D initialDataValue) {
+        List<Instruction> instructions = pseudocode.getInstructions();
+        for (Instruction instruction : instructions) {
+            dataMap.put(instruction, initialDataValue);
+            if (instruction instanceof LocalDeclarationInstruction) {
+                initializeDataMap(dataMap, ((LocalDeclarationInstruction) instruction).getBody(), initialDataValue);
+            }
+        }
+    }
+
+    private static <D> void traverseSubGraph(
+            Pseudocode pseudocode,
+            InstructionsMergeStrategy<D> instructionsMergeStrategy,
+            Collection<Instruction> previousSubGraphInstructions,
+            boolean straightDirection,
+            Map<Instruction, D> dataMap,
+            boolean[] changed,
+            boolean isLocal) {
+        List<Instruction> instructions = pseudocode.getInstructions();
+        SubroutineEnterInstruction enterInstruction = pseudocode.getEnterInstruction();
+        for (Instruction instruction : instructions) {
+            if (!isLocal && instruction instanceof SubroutineEnterInstruction) continue;
+
+            Collection<Instruction> allPreviousInstructions;
+            Collection<Instruction> previousInstructions = straightDirection
+                                                           ? instruction.getPreviousInstructions()
+                                                           : instruction.getNextInstructions();
+
+            if (instruction == enterInstruction && !previousSubGraphInstructions.isEmpty()) {
+                allPreviousInstructions = Lists.newArrayList(previousInstructions);
+                allPreviousInstructions.addAll(previousSubGraphInstructions);
+            }
+            else {
+                allPreviousInstructions = previousInstructions;
+            }
+
+            if (instruction instanceof LocalDeclarationInstruction) {
+                Pseudocode subroutinePseudocode = ((LocalDeclarationInstruction) instruction).getBody();
+                traverseSubGraph(subroutinePseudocode, instructionsMergeStrategy, previousInstructions, straightDirection, dataMap, changed, true);
+            }
+            D previousDataValue = dataMap.get(instruction);
+
+            Collection<D> incomingEdgesData = Sets.newHashSet();
+
+            for (Instruction previousInstruction : allPreviousInstructions) {
+                incomingEdgesData.add(dataMap.get(previousInstruction));
+            }
+            D mergedData = instructionsMergeStrategy.execute(instruction, incomingEdgesData);
+            if (!mergedData.equals(previousDataValue)) {
+                changed[0] = true;
+                dataMap.put(instruction, mergedData);
+            }
+        }
+    }
+
+    public static void traverseAndAnalyzeInstructionGraph(
+            Pseudocode pseudocode,
+            InstructionDataAnalyzeStrategy instructionDataAnalyzeStrategy) {
+        List<Instruction> instructions = pseudocode.getInstructions();
+        for (Instruction instruction : instructions) {
+            if (instruction instanceof LocalDeclarationInstruction) {
+                traverseAndAnalyzeInstructionGraph(((LocalDeclarationInstruction) instruction).getBody(), instructionDataAnalyzeStrategy);
+            }
+            instructionDataAnalyzeStrategy.execute(instruction);
+        }
+    }
+    
+    interface InstructionsMergeStrategy<D> {
+        D execute(Instruction instruction, Collection<D> incomingEdgesData);
+    }
+
+    interface InstructionDataAnalyzeStrategy {
+        void execute(Instruction instruction);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
index 15d55b7f5de..b2f14f97964 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
@@ -5,10 +5,12 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 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.BindingTrace;
+import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions;
@@ -590,6 +592,17 @@ public class JetControlFlowProcessor {
 
         @Override
         public void visitCallExpression(JetCallExpression expression) {
+            //inline functions after M1
+//            ResolvedCall<? extends CallableDescriptor> resolvedCall = trace.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression());
+//            assert resolvedCall != null;
+//            CallableDescriptor resultingDescriptor = resolvedCall.getResultingDescriptor();
+//            PsiElement element = trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, resultingDescriptor);
+//            if (element instanceof JetNamedFunction) {
+//                JetNamedFunction namedFunction = (JetNamedFunction) element;
+//                if (namedFunction.hasModifier(JetTokens.INLINE_KEYWORD)) {
+//                }
+//            }
+
             for (JetTypeProjection typeArgument : expression.getTypeArguments()) {
                 value(typeArgument, false);
             }
@@ -726,6 +739,9 @@ public class JetControlFlowProcessor {
 
         @Override
         public void visitObjectDeclaration(JetObjectDeclaration declaration) {
+//            for (JetDelegationSpecifier delegationSpecifier : declaration.getDelegationSpecifiers()) {
+//                value(delegationSpecifier, inCondition);
+//            }
             Queue<Label> declarationLabels = new LinkedList<Label>();
             List<JetDeclaration> declarations = declaration.getDeclarations();
             for (JetDeclaration localDeclaration : declarations) {
@@ -734,27 +750,19 @@ public class JetControlFlowProcessor {
             builder.nondeterministicJump(Lists.newArrayList(declarationLabels));
             for (JetDeclaration localDeclaration : declarations) {
                 if (localDeclaration instanceof JetNamedDeclaration) {
-                    if (localDeclaration instanceof JetFunction) {
-                        //TODO
-                        generate(localDeclaration, ((JetFunction) localDeclaration).getBodyExpression());
+                    if (localDeclaration instanceof JetDeclarationWithBody) {
+                        JetExpression bodyExpression = ((JetDeclarationWithBody) localDeclaration).getBodyExpression();
+                        generate(localDeclaration, bodyExpression != null ? bodyExpression : localDeclaration);
                     }
                     else {
                         generate(localDeclaration, localDeclaration);
                     }
-                } 
+                }
                 else {
-                    //todo
                     generate(declaration, localDeclaration);
                 }
                 builder.bindLabel(declarationLabels.remove());
             }
-//            for (JetDelegationSpecifier delegationSpecifier : declaration.getDelegationSpecifiers()) {
-//                value(delegationSpecifier, inCondition);
-//            }
-//            for (JetDeclaration jetDeclaration : declaration.getDeclarations()) {
-//                //FOR_LOCAL_CLASSES.
-//                value(jetDeclaration, false);
-//            }
         }
 
         @Override
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
index 5880ad7fc20..87436be68f5 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
@@ -8,10 +8,13 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.cfg.pseudocode.*;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.LocalVariableDescriptor;
+import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
+import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.types.JetStandardClasses;
 
 import java.util.*;
 
@@ -256,103 +259,25 @@ public class JetFlowInformationProvider {
 //            }
 //        }
 
-    private <D> Map<Instruction, D> traverseInstructionGraphUntilFactsStabilization(
-            Pseudocode pseudocode, 
-            InstructionsMergeHandler<D> instructionsMergeHandler, 
-            D initialDataValue,
-            D initialDataValueForEnterInstruction,
-            boolean straightDirection) {
-        Map<Instruction, D> dataMap = Maps.newHashMap();
-        initializeDataMap(dataMap, pseudocode, initialDataValue);
-        dataMap.put(pseudocode.getEnterInstruction(), initialDataValueForEnterInstruction);
-
-        boolean[] changed = new boolean[1];
-        changed[0] = true;
-        while (changed[0]) {
-            changed[0] = false;
-            traverseSubGraph(pseudocode, instructionsMergeHandler, Collections.<Instruction>emptyList(), straightDirection, dataMap, changed, false);
-        }
-        return dataMap;
-    }
-    
-    private <D> void initializeDataMap(
-            Map<Instruction, D> dataMap, 
-            Pseudocode pseudocode, 
-            D initialDataValue) {
-        List<Instruction> instructions = pseudocode.getInstructions();
-        for (Instruction instruction : instructions) {
-            dataMap.put(instruction, initialDataValue);
-            if (instruction instanceof LocalDeclarationInstruction) {
-                initializeDataMap(dataMap, ((LocalDeclarationInstruction) instruction).getBody(), initialDataValue);
-            }
-        }
-    }
-
-    private <D> void traverseSubGraph(
-            Pseudocode pseudocode,
-            InstructionsMergeHandler<D> instructionsMergeHandler,
-            Collection<Instruction> previousSubGraphInstructions,
-            boolean straightDirection,
-            Map<Instruction, D> dataMap,
-            boolean[] changed,
-            boolean isLocal) {
-        List<Instruction> instructions = pseudocode.getInstructions();
-        SubroutineEnterInstruction enterInstruction = pseudocode.getEnterInstruction();
-        for (Instruction instruction : instructions) {
-            if (!isLocal && instruction instanceof SubroutineEnterInstruction) continue;
-
-            Collection<Instruction> allPreviousInstructions;
-            Collection<Instruction> previousInstructions = straightDirection
-                                                           ? instruction.getPreviousInstructions()
-                                                           : instruction.getNextInstructions();
-
-            if (instruction == enterInstruction && !previousSubGraphInstructions.isEmpty()) {
-                allPreviousInstructions = Lists.newArrayList(previousInstructions);
-                allPreviousInstructions.addAll(previousSubGraphInstructions);
-            }
-            else {
-                allPreviousInstructions = previousInstructions;
-            }
-
-            if (instruction instanceof LocalDeclarationInstruction) {
-                Pseudocode subroutinePseudocode = ((LocalDeclarationInstruction) instruction).getBody();
-                traverseSubGraph(subroutinePseudocode, instructionsMergeHandler, previousInstructions, straightDirection, dataMap, changed, true);
-            }
-            D previousDataValue = dataMap.get(instruction);
-
-            Collection<D> incomingEdgesData = Sets.newHashSet();
-
-            for (Instruction previousInstruction : allPreviousInstructions) {
-                incomingEdgesData.add(dataMap.get(previousInstruction));
-            }
-            D mergedData = instructionsMergeHandler.merge(instruction, incomingEdgesData);
-            if (!mergedData.equals(previousDataValue)) {
-                changed[0] = true;
-                dataMap.put(instruction, mergedData);
-            }
-        }
-    }
-
-    public void markUninitializedVariables(@NotNull JetElement subroutine) {
+    public void markUninitializedVariables(@NotNull JetElement subroutine, List<? extends VariableDescriptor> initializedVariables) {
         Pseudocode pseudocode = pseudocodeMap.get(subroutine);
         assert pseudocode != null;
 
-        Collection<Instruction> instructions = pseudocode.getInstructions();
-        InstructionsMergeHandler<Map<LocalVariableDescriptor, InitializationPoints>> instructionsMergeHandler = new InstructionsMergeHandler<Map<LocalVariableDescriptor, InitializationPoints>>() {
+        JetControlFlowGraphTraverser.InstructionsMergeStrategy<Map<VariableDescriptor, InitializationPoints>> instructionsMergeStrategy = new JetControlFlowGraphTraverser.InstructionsMergeStrategy<Map<VariableDescriptor, InitializationPoints>>() {
             @Override
-            public Map<LocalVariableDescriptor, InitializationPoints> merge(
+            public Map<VariableDescriptor, InitializationPoints> execute(
                     Instruction instruction,
-                    Collection<Map<LocalVariableDescriptor, InitializationPoints>> incomingEdgesData) {
+                    Collection<Map<VariableDescriptor, InitializationPoints>> incomingEdgesData) {
 
-                Set<LocalVariableDescriptor> variablesInScope = Sets.newHashSet();
-                for (Map<LocalVariableDescriptor, InitializationPoints> edgePointsMap : incomingEdgesData) {
+                Set<VariableDescriptor> variablesInScope = Sets.newHashSet();
+                for (Map<VariableDescriptor, InitializationPoints> edgePointsMap : incomingEdgesData) {
                     variablesInScope.addAll(edgePointsMap.keySet());
                 }
 
-                Map<LocalVariableDescriptor, InitializationPoints> pointsMap = Maps.newHashMap();
-                for (LocalVariableDescriptor variable : variablesInScope) {
+                Map<VariableDescriptor, InitializationPoints> pointsMap = Maps.newHashMap();
+                for (VariableDescriptor variable : variablesInScope) {
                     Set<InitializationPoints> edgesDataForVariable = Sets.newHashSet();
-                    for (Map<LocalVariableDescriptor, InitializationPoints> edgePointsMap : incomingEdgesData) {
+                    for (Map<VariableDescriptor, InitializationPoints> edgePointsMap : incomingEdgesData) {
                         InitializationPoints points = edgePointsMap.get(variable);
                         if (points != null) {
                             edgesDataForVariable.add(points);
@@ -362,81 +287,95 @@ public class JetFlowInformationProvider {
                 }
                 
                 if (instruction instanceof WriteValueInstruction) {
-                    LocalVariableDescriptor variableDescriptor = extractVariableDescriptorIfAny(instruction);
-//                    DeclarationDescriptor descriptor = null;
-//                    JetElement lValue = ((WriteValueInstruction) instruction).getlValue();
-//                    if (lValue instanceof JetProperty || lValue instanceof JetParameter) {
-//                        descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, lValue);
-//                    }
-//                    else if (lValue instanceof JetSimpleNameExpression) {
-//                        descriptor = trace.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) lValue);
-//                    }
-//                    if (descriptor instanceof LocalVariableDescriptor) {
-//                        LocalVariableDescriptor variableDescriptor = (LocalVariableDescriptor) descriptor;
+                    VariableDescriptor variableDescriptor = extractVariableDescriptorIfAny(instruction);
                         InitializationPoints initializationAtThisPoint = new InitializationPoints(((WriteValueInstruction) instruction).getElement());
                         pointsMap.put(variableDescriptor, initializationAtThisPoint);
-//                    }
                 }
                 
                 return pointsMap;
             }
         };
 
-        Set<LocalVariableDescriptor> localVariables = collectAllLocalVariables(pseudocode);
-        Map<LocalVariableDescriptor, InitializationPoints> initialMapForStartInstruction = Maps.newHashMap();
-        InitializationPoints initialPoints = new InitializationPoints();
-        for (LocalVariableDescriptor variable : localVariables) {
-            initialMapForStartInstruction.put(variable, initialPoints);
+        Set<VariableDescriptor> localVariables = collectAllLocalVariables(pseudocode);
+        Map<VariableDescriptor, InitializationPoints> initialMapForStartInstruction = Maps.newHashMap();
+        InitializationPoints initialPointsForLocalVariable = new InitializationPoints(true);
+        for (VariableDescriptor variable : localVariables) {
+            initialMapForStartInstruction.put(variable, initialPointsForLocalVariable);
         }
-        Map<Instruction, Map<LocalVariableDescriptor, InitializationPoints>> dataMap =
-                traverseInstructionGraphUntilFactsStabilization(pseudocode, instructionsMergeHandler, Collections.<LocalVariableDescriptor, InitializationPoints>emptyMap(), initialMapForStartInstruction, true);
+        InitializationPoints initialPointsForParameter = new InitializationPoints(false);
+        for (VariableDescriptor initializedVariable : initializedVariables) {
+            initialMapForStartInstruction.put(initializedVariable, initialPointsForParameter);
+        }
+        final Map<Instruction, Map<VariableDescriptor, InitializationPoints>> dataMap =
+                JetControlFlowGraphTraverser.traverseInstructionGraphUntilFactsStabilization(pseudocode, instructionsMergeStrategy, Collections.<VariableDescriptor, InitializationPoints>emptyMap(), initialMapForStartInstruction, true);
 
-        InstructionDataAnalyzer<Map<LocalVariableDescriptor, InitializationPoints>> instructionDataAnalyzer = new InstructionDataAnalyzer<Map<LocalVariableDescriptor, InitializationPoints>>() {
+        JetControlFlowGraphTraverser.traverseAndAnalyzeInstructionGraph(pseudocode, new JetControlFlowGraphTraverser.InstructionDataAnalyzeStrategy() {
             @Override
-            public void analyze(Instruction instruction, Map<Instruction, Map<LocalVariableDescriptor, InitializationPoints>> dataMap) {
-                Map<LocalVariableDescriptor, InitializationPoints> variablesData = dataMap.get(instruction);
+            public void execute(Instruction instruction) {
+                Map<VariableDescriptor, InitializationPoints> variablesData = dataMap.get(instruction);
                 if (instruction instanceof ReadValueInstruction) {
-                    LocalVariableDescriptor variableDescriptor = extractVariableDescriptorIfAny(instruction);
+                    VariableDescriptor variableDescriptor = extractVariableDescriptorIfAny(instruction);
                     JetElement element = ((ReadValueInstruction) instruction).getElement();
-                    if (element instanceof JetSimpleNameExpression && variableDescriptor != null) {
-//                        DeclarationDescriptor descriptor = trace.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) element);
-//                        if (descriptor instanceof LocalVariableDescriptor) {
+                    if (element instanceof JetSimpleNameExpression && variableDescriptor instanceof LocalVariableDescriptor) {
                         InitializationPoints initializationPoints = variablesData.get(variableDescriptor);
                         assert  initializationPoints != null;
                         if (initializationPoints.canBeUninitialized) {
                             trace.report(Errors.UNINITIALIZED_VARIABLE.on((JetSimpleNameExpression) element, variableDescriptor));
                         }
-//                        }
                     }
                 }
                 else if (instruction instanceof WriteValueInstruction) {
                     JetElement element = ((WriteValueInstruction) instruction).getlValue();
-                    LocalVariableDescriptor variableDescriptor = extractVariableDescriptorIfAny(instruction);
+                    VariableDescriptor variableDescriptor = extractVariableDescriptorIfAny(instruction);
                     if (element instanceof JetSimpleNameExpression && variableDescriptor != null) {
-//                        DeclarationDescriptor descriptor = trace.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) element);
-//                        if (descriptor instanceof LocalVariableDescriptor) {
                         InitializationPoints initializationPoints = variablesData.get(variableDescriptor);
                         assert initializationPoints != null;
                         if (initializationPoints.hasPossibleInitializers() && !variableDescriptor.isVar()) {
                             trace.report(Errors.VAL_REASSIGNMENT.on((JetSimpleNameExpression) element, variableDescriptor));
                         }
-//                        }
                     }
                 }
             }
-        };
-        traverseAndAnalyzeInstructionGraph(instructions, dataMap, instructionDataAnalyzer);
+        });
+    }
+    
+    public void markNotOnlyInvokedFunctionVariables(@NotNull JetElement subroutine, List<? extends VariableDescriptor> variables) {
+        final List<VariableDescriptor> functionVariables = Lists.newArrayList();
+        for (VariableDescriptor variable : variables) {
+            if (JetStandardClasses.isFunctionType(variable.getReturnType())) {
+                functionVariables.add(variable);
+            }
+        }
+
+        Pseudocode pseudocode = pseudocodeMap.get(subroutine);
+        assert pseudocode != null;
+
+        JetControlFlowGraphTraverser.traverseAndAnalyzeInstructionGraph(pseudocode, new JetControlFlowGraphTraverser.InstructionDataAnalyzeStrategy() {
+            @Override
+            public void execute(Instruction instruction) {
+                if (instruction instanceof ReadValueInstruction) {
+                    VariableDescriptor variableDescriptor = extractVariableDescriptorIfAny(instruction);
+                    if (variableDescriptor != null && functionVariables.contains(variableDescriptor)) {
+                        //check that we only invoke this variable
+                        JetElement element = ((ReadValueInstruction) instruction).getElement();
+                        if (element instanceof JetSimpleNameExpression && !(element.getParent() instanceof JetCallExpression)) {
+                            trace.report(Errors.FUNCTION_PARAMETERS_OF_INLINE_FUNCTION.on((JetSimpleNameExpression)element, variableDescriptor));
+                        }
+                    }
+                }
+            }
+        });
     }
 
     @Nullable
-    private LocalVariableDescriptor extractVariableDescriptorIfAny(Instruction instruction) {
-        LocalVariableDescriptor variableDescriptor = null;
+    private VariableDescriptor extractVariableDescriptorIfAny(Instruction instruction) {
+        VariableDescriptor variableDescriptor = null;
         if (instruction instanceof ReadValueInstruction) {
             JetElement element = ((ReadValueInstruction) instruction).getElement();
             if (element instanceof JetSimpleNameExpression) {
                 DeclarationDescriptor descriptor = trace.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) element);
-                if (descriptor instanceof LocalVariableDescriptor) {
-                    variableDescriptor = (LocalVariableDescriptor) descriptor;
+                if (descriptor instanceof VariableDescriptor) {
+                    variableDescriptor = (VariableDescriptor) descriptor;
                 }
             }
         }
@@ -449,51 +388,34 @@ public class JetFlowInformationProvider {
             else if (lValue instanceof JetSimpleNameExpression) {
                 descriptor = trace.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) lValue);
             }
-            if (descriptor instanceof LocalVariableDescriptor) {
-                variableDescriptor = (LocalVariableDescriptor) descriptor;
+            if (descriptor instanceof VariableDescriptor) {
+                variableDescriptor = (VariableDescriptor) descriptor;
             }
         }
         return variableDescriptor;
     }
 
-    private Set<LocalVariableDescriptor> collectAllLocalVariables(Pseudocode pseudocode) {
-        final Set<LocalVariableDescriptor> localVariables = Sets.newHashSet();
-        InstructionDataAnalyzer<Void> analyzer = new InstructionDataAnalyzer<Void>() {
+    private Set<VariableDescriptor> collectAllLocalVariables(Pseudocode pseudocode) {
+        final Set<VariableDescriptor> localVariables = Sets.newHashSet();
+        JetControlFlowGraphTraverser.InstructionDataAnalyzeStrategy analyzeStrategy = new JetControlFlowGraphTraverser.InstructionDataAnalyzeStrategy() {
             @Override
-            public void analyze(Instruction instruction, Map<Instruction, Void> dataMap) {
-                LocalVariableDescriptor variableDescriptor = extractVariableDescriptorIfAny(instruction);
+            public void execute(Instruction instruction) {
+                VariableDescriptor variableDescriptor = extractVariableDescriptorIfAny(instruction);
                 if (variableDescriptor != null) {
                     localVariables.add(variableDescriptor);
                 }
             }
         };
-        traverseAndAnalyzeInstructionGraph(pseudocode.getInstructions(), Collections.<Instruction, Void>emptyMap(), analyzer);
+        JetControlFlowGraphTraverser.traverseAndAnalyzeInstructionGraph(pseudocode, analyzeStrategy);
         return localVariables;
     }
 
-    private <D> void traverseAndAnalyzeInstructionGraph(Collection<Instruction> instructions, Map<Instruction, D> dataMap, InstructionDataAnalyzer<D> instructionDataAnalyzer) {
-        for (Instruction instruction : instructions) {
-            if (instruction instanceof LocalDeclarationInstruction) {
-                traverseAndAnalyzeInstructionGraph(((LocalDeclarationInstruction) instruction).getBody().getInstructions(), dataMap, instructionDataAnalyzer);
-            }
-            instructionDataAnalyzer.analyze(instruction, dataMap);
-        }
-    }
-
-    interface InstructionsMergeHandler<D> {
-        D merge(Instruction instruction, Collection<D> incomingEdgesData);
-    }
-    
-    interface InstructionDataAnalyzer<D> {
-        void analyze(Instruction instruction, Map<Instruction, D> dataMap);
-    }
-
     private static class InitializationPoints {
         private Set<JetElement> possiblePoints = Sets.newHashSet();
         private boolean canBeUninitialized;
 
-        public InitializationPoints() {
-            canBeUninitialized = true;
+        public InitializationPoints(boolean canBeUninitialized) {
+            this.canBeUninitialized = canBeUninitialized;
         }
 
         public InitializationPoints(JetElement element) {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
index ede21587970..9fdd098d97a 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
@@ -145,6 +145,8 @@ public interface Errors {
     PsiElementOnlyDiagnosticFactory1<JetSimpleNameExpression, DeclarationDescriptor> UNINITIALIZED_VARIABLE = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Variable ''{0}'' must be initialized", NAME);
     PsiElementOnlyDiagnosticFactory1<JetSimpleNameExpression, DeclarationDescriptor> VAL_REASSIGNMENT = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Val can not be reassigned", NAME);
 
+    PsiElementOnlyDiagnosticFactory1<JetSimpleNameExpression, DeclarationDescriptor> FUNCTION_PARAMETERS_OF_INLINE_FUNCTION = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Funciton parameters of inline funciton can only be invoked", NAME);
+
     SimpleDiagnosticFactory UNREACHABLE_CODE = SimpleDiagnosticFactory.create(ERROR, "Unreachable code");
 
     SimpleDiagnosticFactory MANY_CLASS_OBJECTS = SimpleDiagnosticFactory.create(ERROR, "Only one class object is allowed per class");
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java
index c0e06521de1..fbea9ad37d4 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java
@@ -12,6 +12,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
+import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.List;
 import java.util.Map;
@@ -113,7 +114,12 @@ public class ControlFlowAnalyzer {
             });
         }
         if (!declaredLocally) {
-            flowInformationProvider.markUninitializedVariables(function.asElement());
+            flowInformationProvider.markUninitializedVariables(function.asElement(), functionDescriptor.getValueParameters());
+
+            if (((JetDeclaration) function).hasModifier(JetTokens.INLINE_KEYWORD)) {
+                //inline functions after M1
+//                flowInformationProvider.markNotOnlyInvokedFunctionVariables(function.asElement(), functionDescriptor.getValueParameters());
+            }
         }
     }
 
diff --git a/compiler/testData/checkerWithErrorTypes/full/FlowAnalyseVariables.jet b/compiler/testData/checkerWithErrorTypes/full/FlowAnalyseVariables.jet
index 81a49d26b02..0a92f3741a7 100644
--- a/compiler/testData/checkerWithErrorTypes/full/FlowAnalyseVariables.jet
+++ b/compiler/testData/checkerWithErrorTypes/full/FlowAnalyseVariables.jet
@@ -48,6 +48,13 @@ fun t2() {
 fun doSmth(s: String) {}
 fun doSmth(i: Int) {}
 
+class A() {}
+
+fun t4(a: A, val b: A, var c: A) {
+    <!VAL_REASSIGNMENT!>a<!> = A()
+    <!VAL_REASSIGNMENT!>b<!> = A()
+    c = A()
+}
 }
 
 namespace reassigned_vals {
diff --git a/compiler/testData/checkerWithErrorTypes/full/NamespaceQualified.jet b/compiler/testData/checkerWithErrorTypes/full/NamespaceQualified.jet
index a298efcacfe..213e2867d94 100644
--- a/compiler/testData/checkerWithErrorTypes/full/NamespaceQualified.jet
+++ b/compiler/testData/checkerWithErrorTypes/full/NamespaceQualified.jet
@@ -52,7 +52,7 @@ abstract class Sum() : Iteratee<Int, Int> {
 }
 
 abstract class Collection<E> : Iterable<E> {
-  fun iterate<O>(iteratee : Iteratee<E, O>) : O {
+  fun iterate<O>(var iteratee : Iteratee<E, O>) : O {
       for (x in this) {
         val it = iteratee.process(x)
         if (it.isDone) return it.result
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet b/compiler/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet
index 2cac1044074..80b5a321d89 100644
--- a/compiler/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet
+++ b/compiler/testData/checkerWithErrorTypes/full/regression/ScopeForSecondaryConstructors.jet
@@ -1,4 +1,4 @@
-  class Foo(var bar : Int, barr : Int, val barrr : Int) {
+  class Foo(var bar : Int, var barr : Int, var barrr : Int) {
     {
       bar = 1
       barr = 1
@@ -7,7 +7,7 @@
       this : Foo
     }
 
-    this(val bar : Int) : this(1, 1, 1) {
+    this(var bar : Int) : this(1, 1, 1) {
       bar = 1
       this.bar
       1 : Int
diff --git a/compiler/testData/codegen/functions/nothisnoclosure.jet b/compiler/testData/codegen/functions/nothisnoclosure.jet
index cb161d00ce0..a53afefb72e 100644
--- a/compiler/testData/codegen/functions/nothisnoclosure.jet
+++ b/compiler/testData/codegen/functions/nothisnoclosure.jet
@@ -1,4 +1,4 @@
-fun loop(times : Int) {
+fun loop(var times : Int) {
    while(times > 0) {
         val u : fun(value : Int) : Unit = {
             System.out?.println(it)
diff --git a/compiler/testData/codegen/objects/objectLiteral.jet b/compiler/testData/codegen/objects/objectLiteral.jet
index a457840fefc..ca3f96cf336 100644
--- a/compiler/testData/codegen/objects/objectLiteral.jet
+++ b/compiler/testData/codegen/objects/objectLiteral.jet
@@ -1,5 +1,5 @@
 class C(x: Int, val y : Int) {
-  fun initChild(x: Int) : java.lang.Object {
+  fun initChild(var x: Int) : java.lang.Object {
     return object : java.lang.Object() {
       override fun toString(): String? {
           x = x + y
diff --git a/compiler/testData/codegen/regressions/kt395.jet b/compiler/testData/codegen/regressions/kt395.jet
new file mode 100644
index 00000000000..1febc10ffc5
--- /dev/null
+++ b/compiler/testData/codegen/regressions/kt395.jet
@@ -0,0 +1,12 @@
+fun Any.with(operation : fun Any.() : Any) = operation().toString()
+
+val f = { (a : Int) :Unit => }
+
+fun box () : String {
+    return if(20.with {
+        this
+    } == "20")
+        "OK"
+    else
+        "fail"
+}
diff --git a/compiler/tests/org/jetbrains/jet/JetLightProjectDescriptor.java b/compiler/tests/org/jetbrains/jet/JetLightProjectDescriptor.java
deleted file mode 100644
index 09ba2a6de52..00000000000
--- a/compiler/tests/org/jetbrains/jet/JetLightProjectDescriptor.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.jetbrains.jet;
-
-import com.intellij.openapi.projectRoots.Sdk;
-import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor;
-
-/**
- * @author yole
- */
-public class JetLightProjectDescriptor extends DefaultLightProjectDescriptor {
-    public static JetLightProjectDescriptor INSTANCE = new JetLightProjectDescriptor();
-
-    @Override
-    public Sdk getSdk() {
-        return JetTestCaseBase.jdkFromIdeaHome();
-    }
-}
diff --git a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java
index 8cd3cf81437..1719cbf181d 100644
--- a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java
+++ b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java
@@ -14,6 +14,7 @@ import com.intellij.testFramework.LightVirtualFile;
 import com.intellij.testFramework.TestDataFile;
 import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NonNls;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.JetLanguage;
 
 import java.io.File;
@@ -25,7 +26,7 @@ import java.io.IOException;
 public abstract class JetLiteFixture extends UsefulTestCase {
     @NonNls
     protected final String myFullDataPath;
-    protected PsiFile myFile;
+    protected JetFile myFile;
     private JetCoreEnvironment myEnvironment;
 
     public JetLiteFixture(@NonNls String dataPath) {
@@ -37,7 +38,7 @@ public abstract class JetLiteFixture extends UsefulTestCase {
     }
 
     protected String getTestDataPath() {
-        return JetTestCaseBase.getTestDataPathBase();
+        return JetTestCaseBuilder.getTestDataPathBase();
     }
 
     public Project getProject() {
@@ -48,9 +49,9 @@ public abstract class JetLiteFixture extends UsefulTestCase {
     protected void setUp() throws Exception {
         super.setUp();
         myEnvironment = new JetCoreEnvironment(getTestRootDisposable());
-        final File rtJar = new File(JetTestCaseBase.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar");
+        final File rtJar = new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar");
         myEnvironment.addToClasspath(rtJar);
-        myEnvironment.addToClasspath(new File(JetTestCaseBase.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/annotations.jar"));
+        myEnvironment.addToClasspath(new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/annotations.jar"));
     }
 
     @Override
@@ -71,8 +72,16 @@ public abstract class JetLiteFixture extends UsefulTestCase {
         return text;
     }
 
-    protected PsiFile createPsiFile(String name, String text) {
-        return createFile(name + ".jet", text);
+    protected JetFile createPsiFile(String name, String text) {
+        return (JetFile) createFile(name + ".jet", text);
+    }
+
+    protected JetFile loadPsiFile(String name) {
+        try {
+            return createPsiFile(name, loadFile(name));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 
     protected PsiFile createFile(@NonNls String name, String text) {
diff --git a/compiler/tests/org/jetbrains/jet/JetTestCaseBase.java b/compiler/tests/org/jetbrains/jet/JetTestCaseBuilder.java
similarity index 63%
rename from compiler/tests/org/jetbrains/jet/JetTestCaseBase.java
rename to compiler/tests/org/jetbrains/jet/JetTestCaseBuilder.java
index e53d7077cdd..05e88fb44e6 100644
--- a/compiler/tests/org/jetbrains/jet/JetTestCaseBase.java
+++ b/compiler/tests/org/jetbrains/jet/JetTestCaseBuilder.java
@@ -1,9 +1,6 @@
 package org.jetbrains.jet;
 
-import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
 import com.intellij.openapi.application.PathManager;
-import com.intellij.openapi.projectRoots.Sdk;
-import com.intellij.openapi.projectRoots.impl.JavaSdkImpl;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 import org.jetbrains.annotations.NotNull;
@@ -18,72 +15,20 @@ import java.util.List;
 /**
  * @author abreslav
  */
-public abstract class JetTestCaseBase extends LightDaemonAnalyzerTestCase {
-
-    private static FilenameFilter emptyFilter;
-    private boolean checkInfos = false;
-    private String dataPath;
-    protected final String name;
-
-    public JetTestCaseBase(String dataPath, String name) {
-        this.dataPath = dataPath;
-        this.name = name;
-    }
-
-    public final JetTestCaseBase setCheckInfos(boolean checkInfos) {
-        this.checkInfos = checkInfos;
-        return this;
-    }
-
-    public static Sdk jdkFromIdeaHome() {
-        return new JavaSdkImpl().createJdk("JDK", "compiler/testData/mockJDK-1.7/jre", true);
-    }
-
-    @Override
-    protected String getTestDataPath() {
-        return getTestDataPathBase();
-    }
+public abstract class JetTestCaseBuilder {
+    private static FilenameFilter emptyFilter = new FilenameFilter() {
+        @Override
+        public boolean accept(File file, String name) {
+            return true;
+        }
+    };
 
     public static String getTestDataPathBase() {
         return getHomeDirectory() + "/compiler/testData";
     }
 
     public static String getHomeDirectory() {
-       return new File(PathManager.getResourceRoot(JetTestCaseBase.class, "/org/jetbrains/jet/JetTestCaseBase.class")).getParentFile().getParentFile().getParent();
-    }
-
-    @Override
-    protected Sdk getProjectJDK() {
-        return jdkFromIdeaHome();
-    }
-
-    @Override
-    public String getName() {
-        return "test" + name;
-    }
-
-    @Override
-    protected void runTest() throws Throwable {
-        doTest(getTestFilePath(), true, checkInfos);
-    }
-
-    @NotNull
-    protected String getTestFilePath() {
-        return dataPath + File.separator + name + ".jet";
-    }
-    
-    protected String getDataPath() {
-        return dataPath;
-    }
-
-    protected void setUp() throws Exception {
-        super.setUp();
-        emptyFilter = new FilenameFilter() {
-            @Override
-            public boolean accept(File file, String name) {
-                return true;
-            }
-        };
+       return new File(PathManager.getResourceRoot(JetTestCaseBuilder.class, "/org/jetbrains/jet/JetTestCaseBuilder.class")).getParentFile().getParentFile().getParent();
     }
 
     public interface NamedTestFactory {
diff --git a/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java b/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java
index b9efa562bcf..77dda242a64 100644
--- a/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java
+++ b/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java
@@ -8,7 +8,8 @@ import com.intellij.openapi.util.text.StringUtil;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.JetLiteFixture;
+import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.lang.cfg.LoopInfo;
 import org.jetbrains.jet.lang.cfg.pseudocode.*;
 import org.jetbrains.jet.lang.psi.*;
@@ -20,19 +21,25 @@ import java.io.IOException;
 import java.io.PrintStream;
 import java.util.*;
 
-public class JetControlFlowTest extends JetTestCaseBase {
+public class JetControlFlowTest extends JetLiteFixture {
     static {
         System.setProperty("idea.platform.prefix", "Idea");
     }
+    
+    private String myName;
 
     public JetControlFlowTest(String dataPath, String name) {
-        super(dataPath, name);
+        super(dataPath);
+        myName = name;
     }
-
+    
+    protected String getTestFilePath() {
+        return myFullDataPath + "/" + myName;
+    }
+    
     @Override
     protected void runTest() throws Throwable {
-        configureByFile(getTestFilePath());
-        JetFile file = (JetFile) getFile();
+        JetFile file = loadPsiFile(myName + ".jet");
 
         final Map<JetElement, Pseudocode> data = new LinkedHashMap<JetElement, Pseudocode>();
         final JetPseudocodeTrace pseudocodeTrace = new JetPseudocodeTrace() {
@@ -68,14 +75,14 @@ public class JetControlFlowTest extends JetTestCaseBase {
         });
 
         try {
-            processCFData(name, data);
+            processCFData(myName, data);
         }
         catch (IOException e) {
             throw new RuntimeException(e);
         }
         finally {
             if ("true".equals(System.getProperty("jet.control.flow.test.dump.graphs"))) {
-                dumpDot(name, data.values());
+                dumpDot(myName, data.values());
             }
         }
     }
@@ -120,7 +127,7 @@ public class JetControlFlowTest extends JetTestCaseBase {
             }
         }
 
-        String expectedInstructionsFileName = getTestDataPath() + "/" + getTestFilePath().replace(".jet", ".instructions");
+        String expectedInstructionsFileName = getTestFilePath() + ".instructions";
         File expectedInstructionsFile = new File(expectedInstructionsFileName);
         if (!expectedInstructionsFile.exists()) {
             FileUtil.writeToFile(expectedInstructionsFile, instructionDump.toString());
@@ -270,7 +277,6 @@ public class JetControlFlowTest extends JetTestCaseBase {
                 @Override
                 public void visitNondeterministicJump(NondeterministicJumpInstruction instruction) {
                     //todo print edges
-                    visitInstruction(instruction);
                     printEdge(out, nodeToName.get(instruction), nodeToName.get(instruction.getNext()), null);
                 }
 
@@ -352,7 +358,7 @@ public class JetControlFlowTest extends JetTestCaseBase {
     }
 
     private void dumpDot(String name, Collection<Pseudocode> pseudocodes) throws FileNotFoundException {
-        String graphFileName = getTestDataPath() + "/" + getTestFilePath().replace(".jet", ".dot");
+        String graphFileName = getTestDataPath() + "/" + getTestFilePath() + ".dot";
         File target = new File(graphFileName);
 
         PrintStream out = new PrintStream(target);
@@ -387,7 +393,7 @@ public class JetControlFlowTest extends JetTestCaseBase {
 
     public static TestSuite suite() {
         TestSuite suite = new TestSuite();
-        suite.addTest(JetTestCaseBase.suiteForDirectory(getTestDataPathBase(), "/cfg/", true, new JetTestCaseBase.NamedTestFactory() {
+        suite.addTest(JetTestCaseBuilder.suiteForDirectory(JetTestCaseBuilder.getTestDataPathBase(), "/cfg/", true, new JetTestCaseBuilder.NamedTestFactory() {
             @NotNull
             @Override
             public Test createTest(@NotNull String dataPath, @NotNull String name) {
diff --git a/compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java b/compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java
index d71414210c2..a5fdd26d6ac 100644
--- a/compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java
+++ b/compiler/tests/org/jetbrains/jet/checkers/FullJetPsiCheckerTest.java
@@ -2,39 +2,38 @@ 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 com.intellij.testFramework.LightPlatformCodeInsightTestCase;
 import junit.framework.Test;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.JetLiteFixture;
+import org.jetbrains.jet.JetTestCaseBuilder;
 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.lang.resolve.java.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 class FullJetPsiCheckerTest extends JetLiteFixture {
+    private final String myDataPath;
+    private String myName;
 
     public FullJetPsiCheckerTest(@NonNls String dataPath, String name) {
-        super(dataPath, name);
+        myDataPath = dataPath;
+        myName = name;
     }
 
+    @Override
+    public String getName() {
+        return "test" + myName;
+    }
 
     @Override
     public void runTest() throws Exception {
-        String fileName = name + ".jet";
-        String fullPath = getTestDataPath() + getTestFilePath();
+        String fileName = myName + ".jet";
+        String fullPath = myDataPath + "/" + fileName;
 
 
         String expectedText = loadFile(fullPath);
@@ -42,9 +41,8 @@ public class FullJetPsiCheckerTest extends JetTestCaseBase {
         List<CheckerTestUtil.DiagnosedRange> diagnosedRanges = Lists.newArrayList();
         String clearText = CheckerTestUtil.parseDiagnosedRanges(expectedText, diagnosedRanges);
 
-        configureFromFileText(fileName, clearText);
-        JetFile jetFile = (JetFile) myFile;
-        BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(jetFile);
+        myFile = createPsiFile(myName, clearText);
+        BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(myFile);
 
         CheckerTestUtil.diagnosticsDiff(diagnosedRanges, bindingContext.getDiagnostics(), new CheckerTestUtil.DiagnosticDiffCallbacks() {
             @Override
@@ -60,7 +58,7 @@ public class FullJetPsiCheckerTest extends JetTestCaseBase {
             }
         });
 
-        String actualText = CheckerTestUtil.addDiagnosticMarkersToText(jetFile, bindingContext).toString();
+        String actualText = CheckerTestUtil.addDiagnosticMarkersToText(myFile, bindingContext).toString();
 
         assertEquals(expectedText, actualText);
 
@@ -69,12 +67,7 @@ public class FullJetPsiCheckerTest extends JetTestCaseBase {
 //        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) {
@@ -105,9 +98,10 @@ public class FullJetPsiCheckerTest extends JetTestCaseBase {
             }
         }
     }
+*/
 
     public static Test suite() {
-        return JetTestCaseBase.suiteForDirectory(JetTestCaseBase.getTestDataPathBase(), "/checkerWithErrorTypes/full/", true, new JetTestCaseBase.NamedTestFactory() {
+        return JetTestCaseBuilder.suiteForDirectory(JetTestCaseBuilder.getTestDataPathBase(), "/checkerWithErrorTypes/full/", true, new JetTestCaseBuilder.NamedTestFactory() {
             @NotNull
             @Override
             public Test createTest(@NotNull String dataPath, @NotNull String name) {
diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java b/compiler/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java
deleted file mode 100644
index bdc6af855cd..00000000000
--- a/compiler/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package org.jetbrains.jet.checkers;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetTestCaseBase;
-
-/**
- * @author abreslav
- */
-public class JetPsiCheckerTest extends JetTestCaseBase {
-
-    public JetPsiCheckerTest(String dataPath, String name) {
-        super(dataPath, name);
-    }
-
-    public static Test suite() {
-        TestSuite suite = new TestSuite();
-        suite.addTest(JetTestCaseBase.suiteForDirectory(getTestDataPathBase(), "/checker/", false, new JetTestCaseBase.NamedTestFactory() {
-            @NotNull
-            @Override
-            public Test createTest(@NotNull String dataPath, @NotNull String name) {
-                return new JetPsiCheckerTest(dataPath, name);
-            }
-        }));
-        suite.addTest(JetTestCaseBase.suiteForDirectory(getTestDataPathBase(), "/checker/regression/", false, new JetTestCaseBase.NamedTestFactory() {
-            @NotNull
-            @Override
-            public Test createTest(@NotNull String dataPath, @NotNull String name) {
-                return new JetPsiCheckerTest(dataPath, name);
-            }
-        }));
-        suite.addTest(JetTestCaseBase.suiteForDirectory(getTestDataPathBase(), "/checker/infos/", false, new JetTestCaseBase.NamedTestFactory() {
-            @NotNull
-            @Override
-            public Test createTest(@NotNull String dataPath, @NotNull String name) {
-                return new JetPsiCheckerTest(dataPath, name).setCheckInfos(true);
-            }
-        }));
-        return suite;
-    }
-}
diff --git a/compiler/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java b/compiler/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java
index b76d37388c0..ebb5e91515e 100644
--- a/compiler/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java
+++ b/compiler/tests/org/jetbrains/jet/checkers/QuickJetPsiCheckerTest.java
@@ -6,7 +6,7 @@ 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.JetTestCaseBuilder;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
@@ -93,7 +93,7 @@ public class QuickJetPsiCheckerTest extends JetLiteFixture {
 //    }
 
     public static Test suite() {
-        return JetTestCaseBase.suiteForDirectory(JetTestCaseBase.getTestDataPathBase(), "/checkerWithErrorTypes/quick", true, new JetTestCaseBase.NamedTestFactory() {
+        return JetTestCaseBuilder.suiteForDirectory(JetTestCaseBuilder.getTestDataPathBase(), "/checkerWithErrorTypes/quick", true, new JetTestCaseBuilder.NamedTestFactory() {
             @NotNull
             @Override
             public Test createTest(@NotNull String dataPath, @NotNull String name) {
diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
index 405ba447af8..8b0bb54a270 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
@@ -20,7 +20,6 @@ import java.util.Map;
  */
 public abstract class CodegenTestCase extends JetLiteFixture {
     private MyClassLoader myClassLoader;
-    private JetFile myFile;
 
     protected static void assertThrows(Method foo, Class<? extends Throwable> exceptionClass, Object instance, Object... args) throws IllegalAccessException {
         boolean caught = false;
diff --git a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java
index da0ecc0dd4b..1bbef086700 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java
@@ -26,6 +26,41 @@ public class FunctionGenTest extends CodegenTestCase {
 
     }
 
+    public void testNullableAnyToString () throws InvocationTargetException, IllegalAccessException {
+        loadText("fun foo(x: Any?) = x.toString()");
+        System.out.println(generateToText());
+        Method foo = generateFunction();
+        assertEquals("something", foo.invoke(null, "something"));
+        assertEquals("null", foo.invoke(null, new Object[]{null}));
+
+    }
+
+    public void testNullableStringPlus () throws InvocationTargetException, IllegalAccessException {
+        loadText("fun foo(x: String?, y: Any?) = x + y");
+        String text = generateToText();
+        assertTrue(text.contains(".stringPlus"));
+        System.out.println(text);
+        Method foo = generateFunction();
+        assertEquals("something239", foo.invoke(null, "something", 239));
+        assertEquals("null239", foo.invoke(null, null, 239));
+        assertEquals("239null", foo.invoke(null, "239", null));
+        assertEquals("nullnull", foo.invoke(null, null, null));
+
+    }
+
+    public void testNonNullableStringPlus () throws InvocationTargetException, IllegalAccessException {
+        loadText("fun foo(x: String, y: Any?) = x + y + 120");
+        String text = generateToText();
+        assertFalse(text.contains(".stringPlus"));
+        System.out.println(text);
+        Method foo = generateFunction();
+        assertEquals("something239120", foo.invoke(null, "something", 239));
+        assertEquals("null239120", foo.invoke(null, null, 239));
+        assertEquals("239null120", foo.invoke(null, "239", null));
+        assertEquals("nullnull120", foo.invoke(null, null, null));
+
+    }
+
     public void testAnyEqualsNullable () throws InvocationTargetException, IllegalAccessException {
         loadText("fun foo(x: Any?) = x.equals(\"lala\")");
         System.out.println(generateToText());
@@ -41,4 +76,8 @@ public class FunctionGenTest extends CodegenTestCase {
         assertTrue((Boolean) foo.invoke(null, "lala"));
         assertFalse((Boolean) foo.invoke(null, "mama"));
     }
+
+    public void testKt395 () {
+        blackBoxFile("regressions/kt395.jet");
+    }
 }
diff --git a/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java b/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
index 389d6be3b04..c2365b7b71d 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
@@ -169,25 +169,25 @@ public class PrimitiveTypesTest extends CodegenTestCase {
     }
 
     public void testPreDecrement() throws Exception {
-        loadText("fun foo(a: Int): Int { return --a;}");
+        loadText("fun foo(var a: Int): Int { return --a;}");
         final Method main = generateFunction();
         assertEquals(9, main.invoke(null, 10));
     }
 
     public void testPreIncrementLong() throws Exception {
-        loadText("fun foo(a: Long): Long = ++a");
+        loadText("fun foo(var a: Long): Long = ++a");
         final Method main = generateFunction();
         assertEquals(11L, main.invoke(null, 10L));
     }
 
     public void testPreIncrementFloat() throws Exception {
-        loadText("fun foo(a: Float): Float = ++a");
+        loadText("fun foo(var a: Float): Float = ++a");
         final Method main = generateFunction();
         assertEquals(2.0f, main.invoke(null, 1.0f));
     }
 
     public void testPreIncrementDouble() throws Exception {
-        loadText("fun foo(a: Double): Double = ++a");
+        loadText("fun foo(var a: Double): Double = ++a");
         final Method main = generateFunction();
         assertEquals(2.0, main.invoke(null, 1.0));
     }
diff --git a/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java
index 6413d420c30..1a2dadff195 100644
--- a/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java
+++ b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java
@@ -13,7 +13,7 @@ import junit.framework.Test;
 import junit.framework.TestSuite;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.lang.parsing.JetParserDefinition;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetVisitorVoid;
@@ -101,7 +101,7 @@ public class JetParsingTest extends ParsingTestCase {
 
     public static TestSuite suite() {
         TestSuite suite = new TestSuite();
-        JetTestCaseBase.NamedTestFactory factory = new JetTestCaseBase.NamedTestFactory() {
+        JetTestCaseBuilder.NamedTestFactory factory = new JetTestCaseBuilder.NamedTestFactory() {
             @NotNull
             @Override
             public Test createTest(@NotNull String dataPath, @NotNull String name) {
@@ -109,8 +109,8 @@ public class JetParsingTest extends ParsingTestCase {
             }
         };
         String prefix = JetParsingTest.getTestDataDir() + "/psi/";
-        suite.addTest(JetTestCaseBase.suiteForDirectory(prefix, "/", false, factory));
-        suite.addTest(JetTestCaseBase.suiteForDirectory(prefix, "examples", true, factory));
+        suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "/", false, factory));
+        suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "examples", true, factory));
         return suite;
     }
 
diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
index 2a86bdc82d5..d71fe52d5fa 100644
--- a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
+++ b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
@@ -1,7 +1,5 @@
 package org.jetbrains.jet.resolve;
 
-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.jet.lang.JetSemanticServices;
@@ -48,17 +46,7 @@ public class ExpectedResolveData {
 //        this.nameToType = nameToType;
     }
 
-    public void extractData(final Document document) {
-        new WriteCommandAction.Simple(null) {
-          public void run() {
-              doExtractData(document);
-          }
-        }.execute().throwException();
-    }
-
-    private void doExtractData(Document document) {
-        String text = document.getText();
-
+    public String extractData(String text) {
         Pattern pattern = Pattern.compile("(~[^~]+~)|(`[^`]+`)");
         while (true) {
             Matcher matcher = pattern.matcher(text);
@@ -84,11 +72,11 @@ public class ExpectedResolveData {
                 throw new IllegalStateException();
             }
 
-            document.replaceString(start, matcher.end(), "");
-            text = document.getText();
+            text = text.substring(0, start) + text.substring(matcher.end());
         }
 
         System.out.println(text);
+        return text;
     }
 
     public void checkResult(JetFile file) {
diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java b/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java
index 90ec4c6bd51..92f87493622 100644
--- a/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java
+++ b/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java
@@ -1,108 +1,29 @@
 package org.jetbrains.jet.resolve;
 
-import com.intellij.codeHighlighting.Pass;
-import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
-import com.intellij.codeInsight.daemon.DaemonCodeAnalyzerSettings;
-import com.intellij.codeInsight.daemon.impl.DaemonCodeAnalyzerImpl;
-import com.intellij.codeInsight.daemon.impl.HighlightInfo;
-import com.intellij.injected.editor.EditorWindow;
-import com.intellij.openapi.command.CommandProcessor;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.vfs.VirtualFileFilter;
-import com.intellij.psi.PsiDocumentManager;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
-import com.intellij.testFramework.FileTreeAccessFilter;
-import com.intellij.testFramework.LightCodeInsightTestCase;
-import com.intellij.testFramework.fixtures.impl.CodeInsightTestFixtureImpl;
-import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.lang.psi.JetFile;
 
-import java.util.Collection;
-import java.util.List;
+import java.io.File;
 
 /**
  * @author abreslav
  */
-public abstract class ExtensibleResolveTestCase extends LightCodeInsightTestCase {
-    private final FileTreeAccessFilter myJavaFilesFilter = new FileTreeAccessFilter();
+public abstract class ExtensibleResolveTestCase extends JetLiteFixture {
     private ExpectedResolveData expectedResolveData;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         expectedResolveData = getExpectedResolveData();
-        ((DaemonCodeAnalyzerImpl) DaemonCodeAnalyzer.getInstance(getProject())).prepareForTest();
-        DaemonCodeAnalyzerSettings.getInstance().setImportHintEnabled(false);
     }
 
     protected abstract ExpectedResolveData getExpectedResolveData();
 
-    @Override
-    protected void tearDown() throws Exception {
-        ((DaemonCodeAnalyzerImpl) DaemonCodeAnalyzer.getInstance(getProject())).cleanupAfterTest(false); // has to cleanup by hand since light project does not get disposed any time soon
-        super.tearDown();
-    }
-
-    @Override
-    protected void runTest() throws Throwable {
-        final Throwable[] throwable = {null};
-        CommandProcessor.getInstance().executeCommand(getProject(), new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    doRunTest();
-                } catch (Throwable t) {
-                    throwable[0] = t;
-                }
-            }
-        }, "", null);
-        if (throwable[0] != null) {
-            throw throwable[0];
-        }
-    }
-
-    protected void doTest(@NonNls String filePath, boolean checkWarnings, boolean checkInfos) throws Exception {
-        configureByFile(filePath);
-        doTestConfiguredFile(checkWarnings, checkInfos);
-    }
-
-    protected void doTestConfiguredFile(boolean checkWarnings, boolean checkInfos) {
-        getJavaFacade().setAssertOnFileLoadingFilter(VirtualFileFilter.NONE);
-
-//        ExpectedHighlightingData expectedData = new ExpectedHighlightingData(getEditor().getDocument(), checkWarnings, checkInfos);
-        expectedResolveData.extractData(getEditor().getDocument());
-
-        PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
-        getFile().getText(); //to load text
-        myJavaFilesFilter.allowTreeAccessForFile(getVFile());
-        getJavaFacade().setAssertOnFileLoadingFilter(myJavaFilesFilter); // check repository work
-
-        Collection<HighlightInfo> infos = doHighlighting();
-
-        getJavaFacade().setAssertOnFileLoadingFilter(VirtualFileFilter.NONE);
-
-        expectedResolveData.checkResult((JetFile) getFile());
-    }
-
-    @NotNull
-    protected List<HighlightInfo> doHighlighting() {
-        PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
-
-        int[] toIgnore = doFolding() ? ArrayUtil.EMPTY_INT_ARRAY : new int[]{Pass.UPDATE_FOLDING};
-        Editor editor = getEditor();
-        PsiFile file = getFile();
-        if (editor instanceof EditorWindow) {
-            editor = ((EditorWindow) editor).getDelegate();
-            file = InjectedLanguageUtil.getTopLevelFile(file);
-        }
-
-        return CodeInsightTestFixtureImpl.instantiateAndRun(file, editor, toIgnore, false);
-    }
-
-    protected boolean doFolding() {
-        return false;
+    protected void doTest(@NonNls String filePath) throws Exception {
+        String text = loadFile(filePath);
+        text = expectedResolveData.extractData(text);
+        JetFile jetFile = createPsiFile(new File(filePath).getName(), text);
+        expectedResolveData.checkResult(jetFile);
     }
 }
diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java
index f93dda39119..ca206ae88c0 100644
--- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java
+++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java
@@ -2,7 +2,6 @@ package org.jetbrains.jet.resolve;
 
 import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.psi.JavaPsiFacade;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
@@ -10,7 +9,7 @@ import com.intellij.psi.PsiMethod;
 import com.intellij.psi.search.GlobalSearchScope;
 import junit.framework.Test;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
@@ -133,10 +132,12 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
         return getHomeDirectory() + "/compiler/testData";
     }
 
+/*
     @Override
     protected Sdk getProjectJDK() {
-        return JetTestCaseBase.jdkFromIdeaHome();
+        return PluginTestCaseBase.jdkFromIdeaHome();
     }
+*/
 
     private static String getHomeDirectory() {
         return new File(PathManager.getResourceRoot(JetParsingTest.class, "/org/jetbrains/jet/parsing/JetParsingTest.class")).getParentFile().getParentFile().getParent();
@@ -149,11 +150,11 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
 
     @Override
     protected void runTest() throws Throwable {
-        doTest(path, true, false);
+        doTest(path);
     }
 
     public static Test suite() {
-        return JetTestCaseBase.suiteForDirectory(getHomeDirectory() + "/compiler/testData/", "/resolve/", true, new JetTestCaseBase.NamedTestFactory() {
+        return JetTestCaseBuilder.suiteForDirectory(getHomeDirectory() + "/compiler/testData/", "/resolve/", true, new JetTestCaseBuilder.NamedTestFactory() {
             @NotNull
             @Override
             public Test createTest(@NotNull String dataPath, @NotNull String name) {
diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java
index 83896c8cfaa..4de8bd9a285 100644
--- a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java
+++ b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java
@@ -1,7 +1,7 @@
 package org.jetbrains.jet.types;
 
 import org.jetbrains.jet.JetLiteFixture;
-import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
@@ -32,7 +32,7 @@ public class JetOverridingTest extends JetLiteFixture {
 
     @Override
     protected String getTestDataPath() {
-        return JetTestCaseBase.getTestDataPathBase();
+        return JetTestCaseBuilder.getTestDataPathBase();
     }
 
     public void testBasic() throws Exception {
diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
index 22547f87bc3..aa914ef6bb3 100644
--- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
@@ -5,7 +5,7 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetLiteFixture;
-import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -51,7 +51,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
 
     @Override
     protected String getTestDataPath() {
-        return JetTestCaseBase.getTestDataPathBase();
+        return JetTestCaseBuilder.getTestDataPathBase();
     }
 
     public void testConstants() throws Exception {
diff --git a/idea/src/org/jetbrains/jet/plugin/JetFileFactory.java b/idea/src/org/jetbrains/jet/plugin/JetFileFactory.java
index 709364f0666..ca9f73eb3b2 100644
--- a/idea/src/org/jetbrains/jet/plugin/JetFileFactory.java
+++ b/idea/src/org/jetbrains/jet/plugin/JetFileFactory.java
@@ -10,6 +10,6 @@ import org.jetbrains.annotations.NotNull;
 public class JetFileFactory extends FileTypeFactory {
     @Override
     public void createFileTypes(@NotNull FileTypeConsumer consumer) {
-        consumer.consume(JetFileType.INSTANCE, "jet;jetl;jets;kt");
+        consumer.consume(JetFileType.INSTANCE, "jet;jetl;jets;kt;kts;ktm");
     }
 }
diff --git a/compiler/testData/checker/Abstract.jet b/idea/testData/checker/Abstract.jet
similarity index 100%
rename from compiler/testData/checker/Abstract.jet
rename to idea/testData/checker/Abstract.jet
diff --git a/compiler/testData/checker/AnonymousInitializers.jet b/idea/testData/checker/AnonymousInitializers.jet
similarity index 100%
rename from compiler/testData/checker/AnonymousInitializers.jet
rename to idea/testData/checker/AnonymousInitializers.jet
diff --git a/compiler/testData/checker/BinaryCallsOnNullableValues.jet b/idea/testData/checker/BinaryCallsOnNullableValues.jet
similarity index 100%
rename from compiler/testData/checker/BinaryCallsOnNullableValues.jet
rename to idea/testData/checker/BinaryCallsOnNullableValues.jet
diff --git a/compiler/testData/checker/Bounds.jet b/idea/testData/checker/Bounds.jet
similarity index 100%
rename from compiler/testData/checker/Bounds.jet
rename to idea/testData/checker/Bounds.jet
diff --git a/compiler/testData/checker/BreakContinue.jet b/idea/testData/checker/BreakContinue.jet
similarity index 100%
rename from compiler/testData/checker/BreakContinue.jet
rename to idea/testData/checker/BreakContinue.jet
diff --git a/compiler/testData/checker/Builders.jet b/idea/testData/checker/Builders.jet
similarity index 100%
rename from compiler/testData/checker/Builders.jet
rename to idea/testData/checker/Builders.jet
diff --git a/compiler/testData/checker/Casts.jet b/idea/testData/checker/Casts.jet
similarity index 100%
rename from compiler/testData/checker/Casts.jet
rename to idea/testData/checker/Casts.jet
diff --git a/compiler/testData/checker/ClassObjects.jet b/idea/testData/checker/ClassObjects.jet
similarity index 100%
rename from compiler/testData/checker/ClassObjects.jet
rename to idea/testData/checker/ClassObjects.jet
diff --git a/compiler/testData/checker/Constants.jet b/idea/testData/checker/Constants.jet
similarity index 100%
rename from compiler/testData/checker/Constants.jet
rename to idea/testData/checker/Constants.jet
diff --git a/compiler/testData/checker/Constructors.jet b/idea/testData/checker/Constructors.jet
similarity index 100%
rename from compiler/testData/checker/Constructors.jet
rename to idea/testData/checker/Constructors.jet
diff --git a/compiler/testData/checker/CyclicHierarchy.jet b/idea/testData/checker/CyclicHierarchy.jet
similarity index 100%
rename from compiler/testData/checker/CyclicHierarchy.jet
rename to idea/testData/checker/CyclicHierarchy.jet
diff --git a/compiler/testData/checker/Enums.jet b/idea/testData/checker/Enums.jet
similarity index 100%
rename from compiler/testData/checker/Enums.jet
rename to idea/testData/checker/Enums.jet
diff --git a/compiler/testData/checker/ExtensionFunctions.jet b/idea/testData/checker/ExtensionFunctions.jet
similarity index 100%
rename from compiler/testData/checker/ExtensionFunctions.jet
rename to idea/testData/checker/ExtensionFunctions.jet
diff --git a/compiler/testData/checker/ForRangeConventions.jet b/idea/testData/checker/ForRangeConventions.jet
similarity index 100%
rename from compiler/testData/checker/ForRangeConventions.jet
rename to idea/testData/checker/ForRangeConventions.jet
diff --git a/compiler/testData/checker/FunctionReturnTypes.jet b/idea/testData/checker/FunctionReturnTypes.jet
similarity index 100%
rename from compiler/testData/checker/FunctionReturnTypes.jet
rename to idea/testData/checker/FunctionReturnTypes.jet
diff --git a/compiler/testData/checker/GenericArgumentConsistency.jet b/idea/testData/checker/GenericArgumentConsistency.jet
similarity index 100%
rename from compiler/testData/checker/GenericArgumentConsistency.jet
rename to idea/testData/checker/GenericArgumentConsistency.jet
diff --git a/compiler/testData/checker/IncDec.jet b/idea/testData/checker/IncDec.jet
similarity index 100%
rename from compiler/testData/checker/IncDec.jet
rename to idea/testData/checker/IncDec.jet
diff --git a/compiler/testData/checker/IsExpressions.jet b/idea/testData/checker/IsExpressions.jet
similarity index 100%
rename from compiler/testData/checker/IsExpressions.jet
rename to idea/testData/checker/IsExpressions.jet
diff --git a/compiler/testData/checker/MultipleBounds.jet b/idea/testData/checker/MultipleBounds.jet
similarity index 100%
rename from compiler/testData/checker/MultipleBounds.jet
rename to idea/testData/checker/MultipleBounds.jet
diff --git a/compiler/testData/checker/NamespaceAsExpression.jet b/idea/testData/checker/NamespaceAsExpression.jet
similarity index 100%
rename from compiler/testData/checker/NamespaceAsExpression.jet
rename to idea/testData/checker/NamespaceAsExpression.jet
diff --git a/compiler/testData/checker/NamespaceQualified.jet b/idea/testData/checker/NamespaceQualified.jet
similarity index 96%
rename from compiler/testData/checker/NamespaceQualified.jet
rename to idea/testData/checker/NamespaceQualified.jet
index 120b3b73d34..7b63689a4f8 100644
--- a/compiler/testData/checker/NamespaceQualified.jet
+++ b/idea/testData/checker/NamespaceQualified.jet
@@ -52,7 +52,7 @@ abstract class Sum() : Iteratee<Int, Int> {
 }
 
 abstract class Collection<E> : Iterable<E> {
-  fun iterate<O>(iteratee : Iteratee<E, O>) : O {
+  fun iterate<O>(var iteratee : Iteratee<E, O>) : O {
       for (x in this) {
         val it = iteratee.process(x)
         if (it.isDone) return it.result
diff --git a/compiler/testData/checker/Nullability.jet b/idea/testData/checker/Nullability.jet
similarity index 100%
rename from compiler/testData/checker/Nullability.jet
rename to idea/testData/checker/Nullability.jet
diff --git a/compiler/testData/checker/Objects.jet b/idea/testData/checker/Objects.jet
similarity index 100%
rename from compiler/testData/checker/Objects.jet
rename to idea/testData/checker/Objects.jet
diff --git a/compiler/testData/checker/Override.jet b/idea/testData/checker/Override.jet
similarity index 100%
rename from compiler/testData/checker/Override.jet
rename to idea/testData/checker/Override.jet
diff --git a/compiler/testData/checker/PrimaryConstructors.jet b/idea/testData/checker/PrimaryConstructors.jet
similarity index 100%
rename from compiler/testData/checker/PrimaryConstructors.jet
rename to idea/testData/checker/PrimaryConstructors.jet
diff --git a/compiler/testData/checker/ProjectionsInSupertypes.jet b/idea/testData/checker/ProjectionsInSupertypes.jet
similarity index 100%
rename from compiler/testData/checker/ProjectionsInSupertypes.jet
rename to idea/testData/checker/ProjectionsInSupertypes.jet
diff --git a/compiler/testData/checker/Properties.jet b/idea/testData/checker/Properties.jet
similarity index 100%
rename from compiler/testData/checker/Properties.jet
rename to idea/testData/checker/Properties.jet
diff --git a/compiler/testData/checker/QualifiedExpressions.jet b/idea/testData/checker/QualifiedExpressions.jet
similarity index 100%
rename from compiler/testData/checker/QualifiedExpressions.jet
rename to idea/testData/checker/QualifiedExpressions.jet
diff --git a/compiler/testData/checker/QualifiedThis.jet b/idea/testData/checker/QualifiedThis.jet
similarity index 100%
rename from compiler/testData/checker/QualifiedThis.jet
rename to idea/testData/checker/QualifiedThis.jet
diff --git a/compiler/testData/checker/RecursiveTypeInference.jet b/idea/testData/checker/RecursiveTypeInference.jet
similarity index 100%
rename from compiler/testData/checker/RecursiveTypeInference.jet
rename to idea/testData/checker/RecursiveTypeInference.jet
diff --git a/compiler/testData/checker/Redeclarations.jet b/idea/testData/checker/Redeclarations.jet
similarity index 100%
rename from compiler/testData/checker/Redeclarations.jet
rename to idea/testData/checker/Redeclarations.jet
diff --git a/compiler/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet
similarity index 100%
rename from compiler/testData/checker/ResolveToJava.jet
rename to idea/testData/checker/ResolveToJava.jet
diff --git a/compiler/testData/checker/StringTemplates.jet b/idea/testData/checker/StringTemplates.jet
similarity index 100%
rename from compiler/testData/checker/StringTemplates.jet
rename to idea/testData/checker/StringTemplates.jet
diff --git a/compiler/testData/checker/SupertypeListChecks.jet b/idea/testData/checker/SupertypeListChecks.jet
similarity index 100%
rename from compiler/testData/checker/SupertypeListChecks.jet
rename to idea/testData/checker/SupertypeListChecks.jet
diff --git a/compiler/testData/checker/TraitSupertypeList.jet b/idea/testData/checker/TraitSupertypeList.jet
similarity index 100%
rename from compiler/testData/checker/TraitSupertypeList.jet
rename to idea/testData/checker/TraitSupertypeList.jet
diff --git a/compiler/testData/checker/UnreachableCode.jet b/idea/testData/checker/UnreachableCode.jet
similarity index 100%
rename from compiler/testData/checker/UnreachableCode.jet
rename to idea/testData/checker/UnreachableCode.jet
diff --git a/compiler/testData/checker/Unresolved.jet b/idea/testData/checker/Unresolved.jet
similarity index 100%
rename from compiler/testData/checker/Unresolved.jet
rename to idea/testData/checker/Unresolved.jet
diff --git a/compiler/testData/checker/Variance.jet b/idea/testData/checker/Variance.jet
similarity index 100%
rename from compiler/testData/checker/Variance.jet
rename to idea/testData/checker/Variance.jet
diff --git a/compiler/testData/checker/When.jet b/idea/testData/checker/When.jet
similarity index 100%
rename from compiler/testData/checker/When.jet
rename to idea/testData/checker/When.jet
diff --git a/compiler/testData/checker/infos/Autocasts.jet b/idea/testData/checker/infos/Autocasts.jet
similarity index 100%
rename from compiler/testData/checker/infos/Autocasts.jet
rename to idea/testData/checker/infos/Autocasts.jet
diff --git a/compiler/testData/checker/infos/PropertiesWithBackingFields.jet b/idea/testData/checker/infos/PropertiesWithBackingFields.jet
similarity index 100%
rename from compiler/testData/checker/infos/PropertiesWithBackingFields.jet
rename to idea/testData/checker/infos/PropertiesWithBackingFields.jet
diff --git a/compiler/testData/checker/infos/WrapIntoRef.jet b/idea/testData/checker/infos/WrapIntoRef.jet
similarity index 100%
rename from compiler/testData/checker/infos/WrapIntoRef.jet
rename to idea/testData/checker/infos/WrapIntoRef.jet
diff --git a/compiler/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet b/idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet
similarity index 100%
rename from compiler/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet
rename to idea/testData/checker/regression/AmbiguityOnLazyTypeComputation.jet
diff --git a/compiler/testData/checker/regression/AssignmentsUnderOperators.jet b/idea/testData/checker/regression/AssignmentsUnderOperators.jet
similarity index 100%
rename from compiler/testData/checker/regression/AssignmentsUnderOperators.jet
rename to idea/testData/checker/regression/AssignmentsUnderOperators.jet
diff --git a/compiler/testData/checker/regression/CoercionToUnit.jet b/idea/testData/checker/regression/CoercionToUnit.jet
similarity index 100%
rename from compiler/testData/checker/regression/CoercionToUnit.jet
rename to idea/testData/checker/regression/CoercionToUnit.jet
diff --git a/compiler/testData/checker/regression/DoubleDefine.jet b/idea/testData/checker/regression/DoubleDefine.jet
similarity index 100%
rename from compiler/testData/checker/regression/DoubleDefine.jet
rename to idea/testData/checker/regression/DoubleDefine.jet
diff --git a/compiler/testData/checker/regression/Jet11.jet b/idea/testData/checker/regression/Jet11.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet11.jet
rename to idea/testData/checker/regression/Jet11.jet
diff --git a/compiler/testData/checker/regression/Jet121.jet b/idea/testData/checker/regression/Jet121.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet121.jet
rename to idea/testData/checker/regression/Jet121.jet
diff --git a/compiler/testData/checker/regression/Jet124.jet b/idea/testData/checker/regression/Jet124.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet124.jet
rename to idea/testData/checker/regression/Jet124.jet
diff --git a/compiler/testData/checker/regression/Jet169.jet b/idea/testData/checker/regression/Jet169.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet169.jet
rename to idea/testData/checker/regression/Jet169.jet
diff --git a/compiler/testData/checker/regression/Jet17.jet b/idea/testData/checker/regression/Jet17.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet17.jet
rename to idea/testData/checker/regression/Jet17.jet
diff --git a/compiler/testData/checker/regression/Jet183-1.jet b/idea/testData/checker/regression/Jet183-1.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet183-1.jet
rename to idea/testData/checker/regression/Jet183-1.jet
diff --git a/compiler/testData/checker/regression/Jet183.jet b/idea/testData/checker/regression/Jet183.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet183.jet
rename to idea/testData/checker/regression/Jet183.jet
diff --git a/compiler/testData/checker/regression/Jet53.jet b/idea/testData/checker/regression/Jet53.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet53.jet
rename to idea/testData/checker/regression/Jet53.jet
diff --git a/compiler/testData/checker/regression/Jet67.jet b/idea/testData/checker/regression/Jet67.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet67.jet
rename to idea/testData/checker/regression/Jet67.jet
diff --git a/compiler/testData/checker/regression/Jet68.jet b/idea/testData/checker/regression/Jet68.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet68.jet
rename to idea/testData/checker/regression/Jet68.jet
diff --git a/compiler/testData/checker/regression/Jet69.jet b/idea/testData/checker/regression/Jet69.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet69.jet
rename to idea/testData/checker/regression/Jet69.jet
diff --git a/compiler/testData/checker/regression/Jet72.jet b/idea/testData/checker/regression/Jet72.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet72.jet
rename to idea/testData/checker/regression/Jet72.jet
diff --git a/compiler/testData/checker/regression/Jet81.jet b/idea/testData/checker/regression/Jet81.jet
similarity index 100%
rename from compiler/testData/checker/regression/Jet81.jet
rename to idea/testData/checker/regression/Jet81.jet
diff --git a/compiler/testData/checker/regression/OverrideResolution.jet b/idea/testData/checker/regression/OverrideResolution.jet
similarity index 100%
rename from compiler/testData/checker/regression/OverrideResolution.jet
rename to idea/testData/checker/regression/OverrideResolution.jet
diff --git a/compiler/testData/checker/regression/ScopeForSecondaryConstructors.jet b/idea/testData/checker/regression/ScopeForSecondaryConstructors.jet
similarity index 63%
rename from compiler/testData/checker/regression/ScopeForSecondaryConstructors.jet
rename to idea/testData/checker/regression/ScopeForSecondaryConstructors.jet
index 2cac1044074..80b5a321d89 100644
--- a/compiler/testData/checker/regression/ScopeForSecondaryConstructors.jet
+++ b/idea/testData/checker/regression/ScopeForSecondaryConstructors.jet
@@ -1,4 +1,4 @@
-  class Foo(var bar : Int, barr : Int, val barrr : Int) {
+  class Foo(var bar : Int, var barr : Int, var barrr : Int) {
     {
       bar = 1
       barr = 1
@@ -7,7 +7,7 @@
       this : Foo
     }
 
-    this(val bar : Int) : this(1, 1, 1) {
+    this(var bar : Int) : this(1, 1, 1) {
       bar = 1
       this.bar
       1 : Int
diff --git a/compiler/testData/checker/regression/SpecififcityByReceiver.jet b/idea/testData/checker/regression/SpecififcityByReceiver.jet
similarity index 100%
rename from compiler/testData/checker/regression/SpecififcityByReceiver.jet
rename to idea/testData/checker/regression/SpecififcityByReceiver.jet
diff --git a/compiler/testData/checker/regression/ThisConstructorInGenericClass.jet b/idea/testData/checker/regression/ThisConstructorInGenericClass.jet
similarity index 100%
rename from compiler/testData/checker/regression/ThisConstructorInGenericClass.jet
rename to idea/testData/checker/regression/ThisConstructorInGenericClass.jet
diff --git a/compiler/testData/checker/regression/WrongTraceInCallResolver.jet b/idea/testData/checker/regression/WrongTraceInCallResolver.jet
similarity index 100%
rename from compiler/testData/checker/regression/WrongTraceInCallResolver.jet
rename to idea/testData/checker/regression/WrongTraceInCallResolver.jet
diff --git a/compiler/testData/checker/regression/kt251.jet b/idea/testData/checker/regression/kt251.jet
similarity index 100%
rename from compiler/testData/checker/regression/kt251.jet
rename to idea/testData/checker/regression/kt251.jet
diff --git a/compiler/testData/checker/regression/kt303.jet b/idea/testData/checker/regression/kt303.jet
similarity index 100%
rename from compiler/testData/checker/regression/kt303.jet
rename to idea/testData/checker/regression/kt303.jet
diff --git a/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java b/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java
new file mode 100644
index 00000000000..608022b4a54
--- /dev/null
+++ b/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTest.java
@@ -0,0 +1,81 @@
+package org.jetbrains.jet.checkers;
+
+import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
+import com.intellij.openapi.projectRoots.Sdk;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetTestCaseBuilder;
+import org.jetbrains.jet.plugin.quickfix.PluginTestCaseBase;
+
+import java.io.File;
+
+/**
+ * @author abreslav
+ */
+public class JetPsiCheckerTest extends LightDaemonAnalyzerTestCase {
+    private boolean checkInfos = false;
+    private String myDataPath;
+    private String myName;
+
+    public JetPsiCheckerTest(String dataPath, String name) {
+        myDataPath = dataPath;
+        myName = name;
+    }
+
+    @Override
+    protected void runTest() throws Throwable {
+        doTest(getTestFilePath(), true, checkInfos);
+    }
+
+    @NotNull
+    protected String getTestFilePath() {
+        return myDataPath + File.separator + myName + ".jet";
+    }
+
+    public final JetPsiCheckerTest setCheckInfos(boolean checkInfos) {
+        this.checkInfos = checkInfos;
+        return this;
+    }
+    
+    @Override
+    protected String getTestDataPath() {
+        return PluginTestCaseBase.getTestDataPathBase();
+    }
+
+    @Override
+    protected Sdk getProjectJDK() {
+        return PluginTestCaseBase.jdkFromIdeaHome();
+    }
+
+    @Override
+    public String getName() {
+        return "test" + myName;
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite();
+        suite.addTest(JetTestCaseBuilder.suiteForDirectory(PluginTestCaseBase.getTestDataPathBase(), "/checker/", false, new JetTestCaseBuilder.NamedTestFactory() {
+            @NotNull
+            @Override
+            public Test createTest(@NotNull String dataPath, @NotNull String name) {
+                return new JetPsiCheckerTest(dataPath, name);
+            }
+        }));
+        suite.addTest(JetTestCaseBuilder.suiteForDirectory(PluginTestCaseBase.getTestDataPathBase(), "/checker/regression/", false, new JetTestCaseBuilder.NamedTestFactory() {
+            @NotNull
+            @Override
+            public Test createTest(@NotNull String dataPath, @NotNull String name) {
+                return new JetPsiCheckerTest(dataPath, name);
+            }
+        }));
+        suite.addTest(JetTestCaseBuilder.suiteForDirectory(PluginTestCaseBase.getTestDataPathBase(), "/checker/infos/", false, new JetTestCaseBuilder.NamedTestFactory() {
+            @NotNull
+            @Override
+            public Test createTest(@NotNull String dataPath, @NotNull String name) {
+                return new JetPsiCheckerTest(dataPath, name).setCheckInfos(true);
+            }
+        }));
+        return suite;
+    }
+}
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/JetQuickFixTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/JetQuickFixTest.java
index 85b900949db..fcf4fc91077 100644
--- a/idea/tests/org/jetbrains/jet/plugin/quickfix/JetQuickFixTest.java
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/JetQuickFixTest.java
@@ -6,7 +6,7 @@ import com.intellij.openapi.projectRoots.Sdk;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.JetTestCaseBuilder;
 
 import java.io.File;
 import java.io.FilenameFilter;
@@ -49,7 +49,7 @@ public class JetQuickFixTest  extends LightQuickFixTestCase {
                 return false;
             }
         };
-        JetTestCaseBase.NamedTestFactory namedTestFactory = new JetTestCaseBase.NamedTestFactory() {
+        JetTestCaseBuilder.NamedTestFactory namedTestFactory = new JetTestCaseBuilder.NamedTestFactory() {
             @NotNull
             @Override
             public Test createTest(@NotNull String dataPath, @NotNull String name) {
@@ -60,14 +60,14 @@ public class JetQuickFixTest  extends LightQuickFixTestCase {
         List<String> subDirs = Arrays.asList(quickFixTestsFilter != null ? dir.list(quickFixTestsFilter) : dir.list());
         Collections.sort(subDirs);
         for (String subDirName : subDirs) {
-            suite.addTest(JetTestCaseBase.suiteForDirectory(getTestDataPathBase(), subDirName, false, fileNameFilter, namedTestFactory));
+            suite.addTest(JetTestCaseBuilder.suiteForDirectory(getTestDataPathBase(), subDirName, false, fileNameFilter, namedTestFactory));
 
         }
         return suite;
     }
 
     public static String getTestDataPathBase() {
-        return JetTestCaseBase.getHomeDirectory() + "/idea/testData/quickfix/";
+        return JetTestCaseBuilder.getHomeDirectory() + "/idea/testData/quickfix/";
     }
 
     public String getName() {
@@ -91,6 +91,6 @@ public class JetQuickFixTest  extends LightQuickFixTestCase {
 
     @Override
     protected Sdk getProjectJDK() {
-        return JetTestCaseBase.jdkFromIdeaHome();
+        return PluginTestCaseBase.jdkFromIdeaHome();
     }
 }
diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/PluginTestCaseBase.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/PluginTestCaseBase.java
index c65a3ff5e3f..7a14d6e797c 100644
--- a/idea/tests/org/jetbrains/jet/plugin/quickfix/PluginTestCaseBase.java
+++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/PluginTestCaseBase.java
@@ -1,12 +1,18 @@
 package org.jetbrains.jet.plugin.quickfix;
 
-import org.jetbrains.jet.JetTestCaseBase;
+import com.intellij.openapi.projectRoots.Sdk;
+import com.intellij.openapi.projectRoots.impl.JavaSdkImpl;
+import org.jetbrains.jet.JetTestCaseBuilder;
 
 /**
  * @author yole
  */
 public class PluginTestCaseBase {
     public static String getTestDataPathBase() {
-        return JetTestCaseBase.getHomeDirectory() + "/idea/testData";
+        return JetTestCaseBuilder.getHomeDirectory() + "/idea/testData";
+    }
+
+    public static Sdk jdkFromIdeaHome() {
+        return new JavaSdkImpl().createJdk("JDK", "compiler/testData/mockJDK-1.7/jre", true);
     }
 }
diff --git a/stdlib/ktSrc/ModuleBuilder.kt b/stdlib/ktSrc/ModuleBuilder.kt
new file mode 100644
index 00000000000..f6e97a1cdf1
--- /dev/null
+++ b/stdlib/ktSrc/ModuleBuilder.kt
@@ -0,0 +1,47 @@
+namespace kotlin.modules
+
+import java.util.*
+import jet.modules.*
+
+class ModuleSetBuilder() {
+    val modules: ArrayList<ModuleBuilder> = ArrayList<ModuleBuilder>()
+
+    fun module(name: String, callback: fun ModuleBuilder.()) {
+        val builder = ModuleBuilder(name)
+        builder.callback()
+    }
+}
+
+class SourcesBuilder(val parent: ModuleBuilder) {
+    fun files(pattern: String) {
+        parent.addSourceFiles(pattern)
+    }
+}
+
+class ClasspathBuilder(val parent: ModuleBuilder) {
+    fun entry(name: String) {
+        parent.addClasspathEntry(name)
+    }
+}
+
+class ModuleBuilder(val name: String): IModuleBuilder {
+    val sourceFiles: ArrayList<String?> = ArrayList<String?>()
+    val classpathRoots: ArrayList<String?> = ArrayList<String?>()
+
+    val source: SourcesBuilder
+      get() = SourcesBuilder(this)
+
+    val classpath: ClasspathBuilder
+      get() = ClasspathBuilder(this)
+
+    fun addSourceFiles(pattern: String) {
+        sourceFiles.add(pattern)
+    }
+
+    fun addClasspathEntry(name: String) {
+        classpathRoots.add(name)
+    }
+
+    override fun getSourceFiles(): List<String?>? = sourceFiles
+    override fun getClasspathRoots(): List<String?>? = classpathRoots
+}
diff --git a/stdlib/src/jet/modules/IModuleBuilder.java b/stdlib/src/jet/modules/IModuleBuilder.java
new file mode 100644
index 00000000000..53ac51123c6
--- /dev/null
+++ b/stdlib/src/jet/modules/IModuleBuilder.java
@@ -0,0 +1,11 @@
+package jet.modules;
+
+import java.util.List;
+
+/**
+ * @author yole
+ */
+public interface IModuleBuilder {
+    List<String> getSourceFiles();
+    List<String> getClasspathRoots();
+}
diff --git a/stdlib/src/jet/runtime/Intrinsics.java b/stdlib/src/jet/runtime/Intrinsics.java
new file mode 100644
index 00000000000..9243275e611
--- /dev/null
+++ b/stdlib/src/jet/runtime/Intrinsics.java
@@ -0,0 +1,13 @@
+package jet.runtime;
+
+/**
+ * @author alex.tkachman
+ */
+public class Intrinsics {
+    private Intrinsics() {
+    }
+
+    public static String stringPlus(String self, Object other) {
+        return ((self == null) ? "null" : self) + ((other == null) ? "null" : other.toString());
+    }
+}
diff --git a/stdlib/src/jet/typeinfo/TypeInfo.java b/stdlib/src/jet/typeinfo/TypeInfo.java
index 57d13423562..309e35350e4 100644
--- a/stdlib/src/jet/typeinfo/TypeInfo.java
+++ b/stdlib/src/jet/typeinfo/TypeInfo.java
@@ -49,9 +49,7 @@ public abstract class TypeInfo<T> implements JetObject {
     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 abstract Object [] newArray(int length);
 
     public static <T> TypeInfoProjection invariantProjection(final TypeInfo<T> typeInfo) {
         return (TypeInfoProjection) typeInfo;
@@ -126,6 +124,11 @@ public abstract class TypeInfo<T> implements JetObject {
             this.varIndex = varIndex;
         }
 
+        @Override
+        public Object[] newArray(int length) {
+            throw new UnsupportedOperationException();
+        }
+
         @Override
         public Object getClassObject() {
             throw new UnsupportedOperationException("Abstract TypeInfo");
@@ -209,6 +212,11 @@ public abstract class TypeInfo<T> implements JetObject {
             return projections[index];
         }
 
+        @Override
+        public Object[] newArray(int length) {
+            return (Object[]) Array.newInstance(signature.klazz, length);
+        }
+
         public final Object getClassObject() {
             try {
                 final Class implClass = signature.klazz.getClassLoader().loadClass(signature.klazz.getCanonicalName());
diff --git a/stdlib/stdlib.iml b/stdlib/stdlib.iml
index d5c07432750..7140d09842b 100644
--- a/stdlib/stdlib.iml
+++ b/stdlib/stdlib.iml
@@ -4,6 +4,7 @@
     <exclude-output />
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/ktSrc" isTestSource="false" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />