Merge branch 'master' of git://github.com/jgl87/kotlin

#KT-3308 Can'tReproduce

.idea/dictionaries/geevee.xml

@@ -3,6 +3,7 @@
     <words>
       <w>builtins</w>
       <w>klass</w>
+      <w>proto</w>
       <w>protoc</w>
       <w>ubuntu</w>
     </words>

annotations/com/google/common/collect/annotations.xml

@@ -5,4 +5,8 @@
   <item name='com.google.common.collect.SetMultimap java.util.Map&lt;K,java.util.Collection&lt;V&gt;&gt; asMap()'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>
+  <item
+      name='com.google.common.collect.Sets com.google.common.collect.Sets.SetView&lt;E&gt; intersection(java.util.Set&lt;E&gt;, java.util.Set&lt;?&gt;)'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
 </root>

annotations/com/intellij/debugger/actions/annotations.xml

@@ -0,0 +1,12 @@
+<root>
+  <item
+      name='com.intellij.debugger.actions.JvmSmartStepIntoHandler java.util.List&lt;com.intellij.debugger.actions.SmartStepTarget&gt; findSmartStepTargets(com.intellij.debugger.SourcePosition)'>
+    <annotation name='kotlin.jvm.KotlinSignature'>
+      <val name="value" val="&quot;fun findSmartStepTargets(position: SourcePosition): List&lt;SmartStepTarget&gt;&quot;"/>
+    </annotation>
+  </item>
+  <item
+      name='com.intellij.debugger.actions.JvmSmartStepIntoHandler java.util.List&lt;com.intellij.debugger.actions.SmartStepTarget&gt; findSmartStepTargets(com.intellij.debugger.SourcePosition) 0'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>

annotations/com/intellij/debugger/annotations.xml

@@ -0,0 +1,6 @@
+<root>
+  <item
+      name='com.intellij.debugger.ExecutionWithDebuggerToolsTestCase void onBreakpoint(com.intellij.debugger.engine.SuspendContextRunnable) 0'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>

annotations/com/intellij/debugger/engine/annotations.xml

@@ -0,0 +1,16 @@
+<root>
+  <item
+      name='com.intellij.debugger.engine.MethodFilter boolean locationMatches(com.intellij.debugger.engine.DebugProcessImpl, com.sun.jdi.Location) 0'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item
+      name='com.intellij.debugger.engine.MethodFilter boolean locationMatches(com.intellij.debugger.engine.DebugProcessImpl, com.sun.jdi.Location) 1'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item name='com.intellij.debugger.engine.SuspendContextImpl'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item name='com.intellij.debugger.engine.SuspendContextRunnable void run(com.intellij.debugger.engine.SuspendContextImpl) 0'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>

annotations/com/intellij/debugger/impl/annotations.xml

@@ -0,0 +1,5 @@
+<root>
+  <item name='com.intellij.debugger.impl.OutputChecker'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>

annotations/com/intellij/execution/annotations.xml

@@ -0,0 +1,5 @@
+<root>
+  <item name='com.intellij.execution.ExecutionTestCase java.lang.String getTestAppPath()'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>

annotations/com/intellij/psi/stubs/annotations.xml

@@ -1,4 +1,11 @@
 <root>
+  <item name='com.intellij.psi.stubs.AbstractStubIndex java.util.Collection&lt;Key&gt; getAllKeys(com.intellij.openapi.project.Project)'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item
+      name='com.intellij.psi.stubs.AbstractStubIndex java.util.Collection&lt;Psi&gt; get(Key, com.intellij.openapi.project.Project, com.intellij.psi.search.GlobalSearchScope)'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
   <item
       name='com.intellij.psi.stubs.AbstractStubIndex java.util.Collection&lt;Psi&gt; get(Key, com.intellij.openapi.project.Project, com.intellij.psi.search.GlobalSearchScope) 2'>
     <annotation name='org.jetbrains.annotations.NotNull'/>

annotations/com/intellij/refactoring/rename/annotations.xml

@@ -14,4 +14,8 @@
       name='com.intellij.refactoring.rename.RenamePsiElementProcessor void prepareRenaming(com.intellij.psi.PsiElement, java.lang.String, java.util.Map<com.intellij.psi.PsiElement,java.lang.String>, com.intellij.psi.search.SearchScope) 3'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>
+  <item
+      name='com.intellij.refactoring.rename.RenamePsiElementProcessor void renameElement(com.intellij.psi.PsiElement, java.lang.String, com.intellij.usageView.UsageInfo[], com.intellij.refactoring.listeners.RefactoringElementListener) 2'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
 </root>

annotations/com/intellij/refactoring/rename/inplace/annotations.xml

@@ -0,0 +1,10 @@
+<root>
+  <item
+      name='com.intellij.refactoring.rename.inplace.VariableInplaceRenameHandler boolean isAvailable(com.intellij.psi.PsiElement, com.intellij.openapi.editor.Editor, com.intellij.psi.PsiFile) 1'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item
+      name='com.intellij.refactoring.rename.inplace.VariableInplaceRenameHandler boolean isAvailable(com.intellij.psi.PsiElement, com.intellij.openapi.editor.Editor, com.intellij.psi.PsiFile) 2'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>

annotations/com/intellij/usages/impl/annotations.xml

@@ -0,0 +1,6 @@
+<root>
+  <item
+      name='com.intellij.usages.impl.FileStructureGroupRuleProvider com.intellij.usages.rules.UsageGroupingRule getUsageGroupingRule(com.intellij.openapi.project.Project) 0'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>

annotations/com/intellij/util/annotations.xml

@@ -8,4 +8,10 @@
   <item name='com.intellij.util.QueryFactory com.intellij.util.Query&lt;Result&gt; createUniqueResultsQuery(Parameters)'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>
+  <item name='com.intellij.util.Range T getFrom()'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item name='com.intellij.util.Range T getTo()'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
 </root>

annotations/com/sun/jdi/annotations.xml

@@ -0,0 +1,5 @@
+<root>
+  <item name='com.sun.jdi.Location com.sun.jdi.Method method()'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+</root>

annotations/org/jetbrains/jps/builders/annotations.xml

@@ -1,10 +1,29 @@
 <root>
+  <item name='org.jetbrains.jps.builders.CompileScopeTestBuilder org.jetbrains.jps.builders.CompileScopeTestBuilder all()'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item name='org.jetbrains.jps.builders.CompileScopeTestBuilder org.jetbrains.jps.builders.CompileScopeTestBuilder allModules()'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item name='org.jetbrains.jps.builders.CompileScopeTestBuilder org.jetbrains.jps.builders.CompileScopeTestBuilder make()'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item name='org.jetbrains.jps.builders.CompileScopeTestBuilder org.jetbrains.jps.builders.CompileScopeTestBuilder rebuild()'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
   <item name='org.jetbrains.jps.builders.JpsBuildTestCase java.lang.String createFile(java.lang.String, java.lang.String)'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>
+  <item name='org.jetbrains.jps.builders.JpsBuildTestCase java.lang.String getAbsolutePath(java.lang.String)'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
   <item name='org.jetbrains.jps.builders.JpsBuildTestCase org.jetbrains.jps.builders.BuildResult makeAll()'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>
+  <item
+      name='org.jetbrains.jps.builders.JpsBuildTestCase org.jetbrains.jps.cmdline.ProjectDescriptor createProjectDescriptor(org.jetbrains.jps.builders.logging.BuildLoggingManager)'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
   <item
       name='org.jetbrains.jps.builders.JpsBuildTestCase org.jetbrains.jps.model.module.JpsModule addModule(java.lang.String, java.lang.String...)'>
     <annotation name='org.jetbrains.annotations.NotNull'/>

build.xml

@@ -611,38 +611,13 @@
         </jar>
     </target>
 
-    <target name="j2kConverter">
-        <taskdef resource="net/sf/antcontrib/antcontrib.properties" classpath="${dependencies.dir}/ant-contrib.jar"/>
-
-        <cleandir dir="${output}/classes/j2k"/>
-
-        <kotlinc output="${output}/classes/j2k">
-            <src path="${basedir}/j2k/src"/>
-            <classpath path="${kotlin-home}/lib/kotlin-compiler.jar"/>
-        </kotlinc>
-
-        <jar jarfile="${kotlin-home}/lib/tools/j2k.jar">
-            <fileset dir="${output}/classes/j2k" includes="org/jetbrains/jet/j2k/**"/>
-
-            <manifest>
-                <attribute name="Built-By" value="${manifest.impl.vendor}"/>
-
-                <attribute name="Implementation-Vendor" value="${manifest.impl.vendor}"/>
-                <attribute name="Implementation-Title" value="${manifest.impl.title.java2kotlin.converter}"/>
-                <attribute name="Implementation-Version" value="${build.number}"/>
-
-                <attribute name="Main-Class" value="org.jetbrains.jet.j2k.JavaToKotlinTranslator"/>
-            </manifest>
-        </jar>
-    </target>
-
     <!-- builds redistributables from sources -->
     <target name="dist"
-            depends="clean,init,prepareDist,preloader,builtins,compiler,compilerSources,antTools,jdkAnnotations,androidSdkAnnotations,runtime,runtime_sources,jslib,j2kConverter"/>
+            depends="clean,init,prepareDist,preloader,builtins,compiler,compilerSources,antTools,jdkAnnotations,androidSdkAnnotations,runtime,runtime_sources,jslib"/>
 
     <!-- builds everything, but classes are reused from project out dir, doesn't run proguard and javadoc -->
     <target name="dist_quick"
-            depends="clean,init,prepareDist,preloader,builtins,compiler_quick,antTools,jdkAnnotations,androidSdkAnnotations,runtime,runtime_sources,jslib,j2kConverter"/>
+            depends="clean,init,prepareDist,preloader,builtins,compiler_quick,antTools,jdkAnnotations,androidSdkAnnotations,runtime,runtime_sources,jslib"/>
 
     <!-- builds compiler jar from project out dir -->
     <target name="dist_quick_compiler_only"

compiler/backend/src/org/jetbrains/jet/codegen/AccessorForFunctionDescriptor.java

@@ -36,7 +36,7 @@ public class AccessorForFunctionDescriptor extends SimpleFunctionDescriptorImpl
             @NotNull DeclarationDescriptor containingDeclaration,
             int index
     ) {
-        super(containingDeclaration, Annotations.EMPTY,
+        super(containingDeclaration, null, Annotations.EMPTY,
               Name.identifier((descriptor instanceof ConstructorDescriptor ? "$init" : descriptor.getName()) + "$b$" + index),
               Kind.DECLARATION);
 

compiler/backend/src/org/jetbrains/jet/codegen/AccessorForPropertyDescriptor.java

@@ -43,7 +43,7 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl {
             @NotNull DeclarationDescriptor containingDeclaration,
             int index
     ) {
-        super(containingDeclaration, Annotations.EMPTY, Modality.FINAL, Visibilities.LOCAL,
+        super(containingDeclaration, null, Annotations.EMPTY, Modality.FINAL, Visibilities.LOCAL,
               original.isVar(), Name.identifier(original.getName() + "$b$" + index),
               Kind.DECLARATION);
 
@@ -55,16 +55,14 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl {
         public Getter(AccessorForPropertyDescriptor property) {
             super(property, Annotations.EMPTY, Modality.FINAL, Visibilities.LOCAL,
                   false,
-                  false, Kind.DECLARATION);
+                  false, Kind.DECLARATION, null);
             initialize(property.getType());
         }
     }
 
     public static class Setter extends PropertySetterDescriptorImpl {
         public Setter(AccessorForPropertyDescriptor property) {
-            super(property, Annotations.EMPTY, Modality.FINAL, Visibilities.LOCAL,
-                  false,
-                  false, Kind.DECLARATION);
+            super(property, Annotations.EMPTY, Modality.FINAL, Visibilities.LOCAL, false, false, Kind.DECLARATION, null);
             initializeDefault();
         }
     }

compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java

@@ -108,17 +108,17 @@ public abstract class ClassBodyCodegen extends MemberCodegen {
 
     protected void generateDeclaration(PropertyCodegen propertyCodegen, JetDeclaration declaration) {
         if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
-            genFunctionOrProperty(context, (JetTypeParameterListOwner) declaration, v);
+            genFunctionOrProperty((JetTypeParameterListOwner) declaration, v);
         }
         else if (declaration instanceof JetClassOrObject) {
             if (declaration instanceof JetEnumEntry && !enumEntryNeedSubclass(state.getBindingContext(), (JetEnumEntry) declaration)) {
                 return;
             }
 
-            genClassOrObject(context, (JetClassOrObject) declaration);
+            genClassOrObject((JetClassOrObject) declaration);
         }
         else if (declaration instanceof JetClassObject) {
-            genClassOrObject(context, ((JetClassObject) declaration).getObjectDeclaration());
+            genClassOrObject(((JetClassObject) declaration).getObjectDeclaration());
         }
     }
 
@@ -174,9 +174,9 @@ public abstract class ClassBodyCodegen extends MemberCodegen {
             MethodVisitor method = createOrGetClInitMethod();
             method.visitCode();
             SimpleFunctionDescriptorImpl clInit =
-                    new SimpleFunctionDescriptorImpl(descriptor, Annotations.EMPTY,
-                                                     Name.special("<clinit>"),
-                                                     CallableMemberDescriptor.Kind.SYNTHESIZED);
+                    SimpleFunctionDescriptorImpl.create(descriptor, Annotations.EMPTY,
+                                                        Name.special("<clinit>"),
+                                                        CallableMemberDescriptor.Kind.SYNTHESIZED);
             clInit.initialize(null, null, Collections.<TypeParameterDescriptor>emptyList(),
                               Collections.<ValueParameterDescriptor>emptyList(), null, null, Visibilities.PRIVATE);
 

compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java

@@ -159,7 +159,7 @@ public class ClosureCodegen extends ParentCodegenAwareImpl {
             v.anew(asmType);
             v.dup();
 
-            codegen.pushClosureOnStack(closure, false, codegen.defaulCallGenerator);
+            codegen.pushClosureOnStack(closure, false, codegen.defaultCallGenerator);
             v.invokespecial(asmType.getInternalName(), "<init>", constructor.getDescriptor());
         }
         return StackValue.onStack(asmType);

compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java

@@ -30,6 +30,7 @@ import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.context.MethodContext;
 import org.jetbrains.jet.codegen.context.PackageContext;
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
+import org.jetbrains.jet.config.IncrementalCompilation;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
@@ -73,12 +74,13 @@ public class CodegenUtil {
 
     public static SimpleFunctionDescriptor createInvoke(FunctionDescriptor fd) {
         int arity = fd.getValueParameters().size();
-        SimpleFunctionDescriptorImpl invokeDescriptor = new SimpleFunctionDescriptorImpl(
+        SimpleFunctionDescriptorImpl invokeDescriptor = SimpleFunctionDescriptorImpl.create(
                 fd.getExpectedThisObject() != null
                 ? KotlinBuiltIns.getInstance().getExtensionFunction(arity) : KotlinBuiltIns.getInstance().getFunction(arity),
                 Annotations.EMPTY,
                 Name.identifier("invoke"),
-                CallableMemberDescriptor.Kind.DECLARATION);
+                CallableMemberDescriptor.Kind.DECLARATION
+        );
 
         invokeDescriptor.initialize(DescriptorUtils.getReceiverParameterType(fd.getReceiverParameter()),
                                     fd.getExpectedThisObject(),
@@ -155,10 +157,30 @@ public class CodegenUtil {
 
         return !isFakeOverride && !isDelegate &&
                (((context.hasThisDescriptor() && containingDeclaration == context.getThisDescriptor()) ||
-                 (context.getParentContext() instanceof PackageContext && context.getParentContext().getContextDescriptor() == containingDeclaration))
+                 (context.getParentContext() instanceof PackageContext
+                  && isSamePackageInSameModule(context.getParentContext().getContextDescriptor(), containingDeclaration)))
                 && context.getContextKind() != OwnerKind.TRAIT_IMPL);
     }
 
+    private static boolean isSamePackageInSameModule(
+            @NotNull DeclarationDescriptor owner1,
+            @NotNull DeclarationDescriptor owner2
+    ) {
+        if (owner1 instanceof PackageFragmentDescriptor && owner2 instanceof PackageFragmentDescriptor) {
+            PackageFragmentDescriptor fragment1 = (PackageFragmentDescriptor) owner1;
+            PackageFragmentDescriptor fragment2 = (PackageFragmentDescriptor) owner2;
+
+            if (!IncrementalCompilation.ENABLED) {
+                return fragment1 == fragment2;
+            }
+
+            // backing field should be used directly within same module of same package
+            // TODO calls from other modules/libraries should use facade: KT-4590
+            return fragment1.getFqName().equals(fragment2.getFqName()) && DescriptorUtils.areInSameModule(fragment1, fragment2);
+        }
+        return false;
+    }
+
     public static boolean isCallInsideSameModuleAsDeclared(CallableMemberDescriptor declarationDescriptor, CodegenContext context) {
         if (context == CodegenContext.STATIC) {
             return true;

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -109,7 +109,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     @NotNull
     private final TailRecursionCodegen tailRecursionCodegen;
 
-    public final CallGenerator defaulCallGenerator;
+    public final CallGenerator defaultCallGenerator;
 
     public CalculatedClosure generateObjectLiteral(GenerationState state, JetObjectLiteralExpression literal) {
         JetObjectDeclaration objectDeclaration = literal.getObjectDeclaration();
@@ -180,7 +180,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         this.context = context;
         this.statementVisitor = new CodegenStatementVisitor(this);
         this.tailRecursionCodegen = new TailRecursionCodegen(context, this, this.v, state);
-        this.defaulCallGenerator = new CallGenerator.DefaultCallGenerator(this);
+        this.defaultCallGenerator = new CallGenerator.DefaultCallGenerator(this);
     }
 
     public GenerationState getState() {
@@ -1342,7 +1342,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         v.anew(type);
         v.dup();
 
-        pushClosureOnStack(closure, false, defaulCallGenerator);
+        pushClosureOnStack(closure, false, defaultCallGenerator);
 
         JetDelegatorToSuperCall superCall = closure.getSuperCall();
         if (superCall != null) {
@@ -1356,7 +1356,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             Type[] argumentTypes = superCallable.getAsmMethod().getArgumentTypes();
             ResolvedCall<?> resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, superCall.getCalleeExpression());
             assert resolvedCall != null;
-            pushMethodArguments(resolvedCall, Arrays.asList(argumentTypes), defaulCallGenerator);
+            pushMethodArgumentsWithoutCallReceiver(resolvedCall, Arrays.asList(argumentTypes), false, defaultCallGenerator);
         }
 
         v.invokespecial(type.getInternalName(), "<init>", constructor.getAsmMethod().getDescriptor());
@@ -1657,11 +1657,6 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             }
         }
 
-        int index = lookupLocalIndex(descriptor);
-        if (index >= 0) {
-            return stackValueForLocal(descriptor, index);
-        }
-
         if (descriptor instanceof PropertyDescriptor) {
             PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
 
@@ -1708,26 +1703,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             return StackValue.onStack(OBJECT_TYPE);
         }
 
-        StackValue value = context.lookupInContext(descriptor, StackValue.local(0, OBJECT_TYPE), state, false);
-        if (value != null) {
-            if (context.isSpecialStackValue(value)) {
-                return value;
-            }
-
-            if (value instanceof StackValue.Composed) {
-                StackValue.Composed composed = (StackValue.Composed) value;
-                composed.prefix.put(OBJECT_TYPE, v);
-                value = composed.suffix;
-            }
-
-            if (value instanceof StackValue.FieldForSharedVar) {
-                StackValue.FieldForSharedVar fieldForSharedVar = (StackValue.FieldForSharedVar) value;
-                Type sharedType = StackValue.sharedTypeForType(value.type);
-                v.visitFieldInsn(GETFIELD, fieldForSharedVar.owner.getInternalName(), fieldForSharedVar.name,
-                                 sharedType.getDescriptor());
-            }
-
-            return value;
+        StackValue localOrCaptured = findLocalOrCapturedValue(descriptor);
+        if (localOrCaptured != null) {
+            return localOrCaptured;
         }
 
         if (descriptor instanceof ValueParameterDescriptor && descriptor.getContainingDeclaration() instanceof ScriptDescriptor) {
@@ -1744,6 +1722,37 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         throw new UnsupportedOperationException("don't know how to generate reference " + descriptor);
     }
 
+    @Nullable
+    public StackValue findLocalOrCapturedValue(@NotNull DeclarationDescriptor descriptor) {
+        int index = lookupLocalIndex(descriptor);
+        if (index >= 0) {
+            return stackValueForLocal(descriptor, index);
+        }
+
+        StackValue value = context.lookupInContext(descriptor, StackValue.local(0, OBJECT_TYPE), state, false);
+        if (value == null) return null;
+
+        if (context.isSpecialStackValue(value)) {
+            return value;
+        }
+
+        if (value instanceof StackValue.Composed) {
+            StackValue.Composed composed = (StackValue.Composed) value;
+            composed.prefix.put(OBJECT_TYPE, v);
+            value = composed.suffix;
+        }
+
+        if (value instanceof StackValue.FieldForSharedVar) {
+            StackValue.FieldForSharedVar fieldForSharedVar = (StackValue.FieldForSharedVar) value;
+            Type sharedType = StackValue.sharedTypeForType(value.type);
+            v.visitFieldInsn(GETFIELD, fieldForSharedVar.owner.getInternalName(), fieldForSharedVar.name,
+                             sharedType.getDescriptor());
+        }
+
+        return value;
+    }
+
+
     private StackValue stackValueForLocal(DeclarationDescriptor descriptor, int index) {
         if (descriptor instanceof VariableDescriptor) {
             Type sharedVarType = typeMapper.getSharedVarType(descriptor);
@@ -1893,6 +1902,20 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         JetExpression callee = expression.getCalleeExpression();
         assert callee != null;
 
+        DottedCallInfo dottedCallInfo = bindingContext.get(BindingContext.DOTTED_CALL_INFO, expression);
+        if (dottedCallInfo != null) {
+            ResolvedCall<? extends FunctionDescriptor> resolvedDotCall = dottedCallInfo.getResolvedCall();
+            FunctionDescriptor dotFunDescriptor = accessibleFunctionDescriptor(resolvedDotCall.getResultingDescriptor());
+
+            JetType dotType = dotFunDescriptor.getReturnType();
+            assert dotType != null : "can't resolve type of dot operation: " + dotFunDescriptor;
+
+            StackValue newReceiver = invokeFunction(dottedCallInfo.getCall(), receiver, resolvedDotCall);
+            if (!KotlinBuiltIns.getInstance().isUnit(dotType)) {
+                receiver = newReceiver;
+            }
+        }
+
         ResolvedCall<?> resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, callee);
         if (resolvedCall == null) {
             throw new CompilationException("Cannot resolve: " + callee.getText(), null, expression);
@@ -2010,25 +2033,6 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
         Callable callable = resolveToCallable(accessibleFunctionDescriptor(fd), superCall);
 
-        if (callable instanceof CallableMethod) {
-            CallableMethod callableMethod = (CallableMethod) callable;
-            Type calleeType = callableMethod.getGenerateCalleeType();
-            if (calleeType != null) {
-                assert !callableMethod.isNeedsThis() : "Method should have a receiver: " + resolvedCall.getResultingDescriptor();
-                gen(call.getCalleeExpression(), calleeType);
-            }
-        }
-
-        return invokeFunctionWithCalleeOnStack(call, receiver, resolvedCall, callable);
-    }
-
-    @NotNull
-    private StackValue invokeFunctionWithCalleeOnStack(
-            @NotNull Call call,
-            @NotNull StackValue receiver,
-            @NotNull ResolvedCall<?> resolvedCall,
-            @NotNull Callable callable
-    ) {
         if (callable instanceof CallableMethod) {
             CallableMethod callableMethod = (CallableMethod) callable;
             invokeMethodWithArguments(call, callableMethod, resolvedCall, receiver);
@@ -2105,7 +2109,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                            descriptor instanceof SimpleFunctionDescriptor &&
                            ((SimpleFunctionDescriptor) descriptor).getInlineStrategy().isInline();
 
-        CallGenerator callGenerator = !isInline ? defaulCallGenerator :
+        CallGenerator callGenerator = !isInline ? defaultCallGenerator :
                           new InlineCodegen(this, state, (SimpleFunctionDescriptor) DescriptorUtils.unwrapFakeOverride(
                                   (CallableMemberDescriptor) descriptor.getOriginal()), call);
 
@@ -2113,33 +2117,17 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             resolvedCall = ((VariableAsFunctionResolvedCall) resolvedCall).getFunctionCall();
         }
 
-        if (!(descriptor instanceof ConstructorDescriptor)) { // otherwise already
-            receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod);
-            receiver.put(receiver.type, v);
-        }
-
-        assert callGenerator == defaulCallGenerator || !hasDefaultArguments(resolvedCall) && !tailRecursionCodegen.isTailRecursion(resolvedCall) :
+        assert callGenerator == defaultCallGenerator || !hasDefaultArguments(resolvedCall) && !tailRecursionCodegen.isTailRecursion(resolvedCall) :
                 "Method with defaults or tail recursive couldn't be inlined " + descriptor;
 
-        pushArgumentsAndInvoke(resolvedCall, callableMethod, callGenerator);
-    }
-
-    private void pushArgumentsAndInvoke(@NotNull ResolvedCall<?> resolvedCall, @NotNull CallableMethod callable, @NotNull CallGenerator callGenerator) {
-        callGenerator.putHiddenParams();
-
-        int mask = pushMethodArguments(resolvedCall, callable.getValueParameterTypes(), callGenerator);
+        int mask = pushMethodArgumentsWithCallReceiver(receiver, resolvedCall, callableMethod, false, callGenerator);
 
         if (tailRecursionCodegen.isTailRecursion(resolvedCall)) {
             tailRecursionCodegen.generateTailRecursion(resolvedCall);
             return;
         }
 
-        callGenerator.genCall(callable, resolvedCall, mask, this);
-    }
-
-    private void genThisAndReceiverFromResolvedCall(StackValue receiver, ResolvedCall<?> resolvedCall, CallableMethod callableMethod) {
-        receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod);
-        receiver.put(receiver.type, v);
+        callGenerator.genCall(callableMethod, resolvedCall, mask, this);
     }
 
     public void generateFromResolvedCall(@NotNull ReceiverValue descriptor, @NotNull Type type) {
@@ -2163,6 +2151,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             }
         }
         else if (descriptor instanceof ScriptReceiver) {
+            // SCRIPT: generate script
             generateScript((ScriptReceiver) descriptor);
         }
         else if (descriptor instanceof ExtensionReceiver) {
@@ -2196,6 +2185,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         return context.lookupInContext(provided, StackValue.local(0, OBJECT_TYPE), state, false);
     }
 
+    // SCRIPT: generate script, move to ScriptingUtil
     private void generateScript(@NotNull ScriptReceiver receiver) {
         CodegenContext cur = context;
         StackValue result = StackValue.local(0, OBJECT_TYPE);
@@ -2292,11 +2282,31 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         return false;
     }
 
-    public int pushMethodArguments(@NotNull ResolvedCall<?> resolvedCall, List<Type> valueParameterTypes, @NotNull CallGenerator callGenerator) {
-        return pushMethodArguments(resolvedCall, valueParameterTypes, false, callGenerator);
+    public int pushMethodArgumentsWithCallReceiver(
+            @Nullable StackValue receiver,
+            @NotNull ResolvedCall<?> resolvedCall,
+            @NotNull CallableMethod callableMethod,
+            boolean skipLast,
+            @NotNull CallGenerator callGenerator
+    ) {
+        CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
+
+        if (!(descriptor instanceof ConstructorDescriptor)) { // otherwise already
+            receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod);
+            receiver.put(receiver.type, v);
+        }
+
+        callGenerator.putHiddenParams();
+
+        return pushMethodArgumentsWithoutCallReceiver(resolvedCall, callableMethod.getValueParameterTypes(), skipLast, callGenerator);
     }
 
-    private int pushMethodArguments(@NotNull ResolvedCall<?> resolvedCall, List<Type> valueParameterTypes, boolean skipLast, @NotNull CallGenerator callGenerator) {
+    public int pushMethodArgumentsWithoutCallReceiver(
+            @NotNull ResolvedCall<?> resolvedCall,
+            List<Type> valueParameterTypes,
+            boolean skipLast,
+            @NotNull CallGenerator callGenerator
+    ) {
         List<ResolvedValueArgument> valueArguments = resolvedCall.getValueArgumentsByIndex();
         CallableDescriptor fd = resolvedCall.getResultingDescriptor();
         if (valueArguments == null) {
@@ -2524,12 +2534,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             }
             else {
                 Call call = CallMaker.makeCall(fakeExpression, NO_RECEIVER, null, fakeExpression, fakeArguments);
-                Callable callable = codegen.resolveToCallable(codegen.accessibleFunctionDescriptor(referencedFunction), false);
-                StackValue receiver = generateCallee(codegen, callable);
-                if (extensionReceiver.exists()) {
-                    receiver = StackValue.composed(receiver, receiverParameterStackValue(signature));
-                }
-                result = codegen.invokeFunctionWithCalleeOnStack(call, receiver, fakeResolvedCall, callable);
+                result = codegen.invokeFunction(call, StackValue.none(), fakeResolvedCall);
             }
 
             InstructionAdapter v = codegen.v;
@@ -2537,33 +2542,6 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             v.areturn(returnType);
         }
 
-        @NotNull
-        private StackValue generateCallee(@NotNull ExpressionCodegen codegen, @NotNull Callable callable) {
-            if (!(callable instanceof CallableMethod) || ((CallableMethod) callable).getGenerateCalleeType() == null) {
-                return StackValue.none();
-            }
-
-            // If referenced method is a CallableMethod with generateCalleeType != null, this means it's some kind of a closure
-            // (e.g. a local named function) and a non-trivial callee should be generated before calling invoke()
-
-            BindingContext bindingContext = codegen.bindingContext;
-            ClassDescriptor closureClassOfReferenced = bindingContext.get(CLASS_FOR_FUNCTION, referencedFunction);
-            MutableClosure closureOfReferenced = bindingContext.get(CLOSURE, closureClassOfReferenced);
-            assert closureOfReferenced != null :
-                    "Function mapped to CallableMethod with generateCalleeType != null must be a closure: " + referencedFunction;
-            if (isConst(closureOfReferenced)) {
-                // This is an optimization: we can obtain an instance of a const closure simply by GETSTATIC ...$instance
-                // (instead of passing this instance to the constructor and storing as a field)
-                Type asmType = asmTypeForAnonymousClass(bindingContext, referencedFunction);
-                codegen.v.getstatic(asmType.getInternalName(), JvmAbi.INSTANCE_FIELD, asmType.getDescriptor());
-                return StackValue.onStack(asmType);
-            }
-            else {
-                Type asmCallRefType = asmTypeForAnonymousClass(bindingContext, callableDescriptor);
-                return codegen.context.lookupInContext(referencedFunction, StackValue.local(0, asmCallRefType), state, false);
-            }
-        }
-
         @NotNull
         private JetCallExpression constructFakeFunctionCall() {
             StringBuilder fakeFunctionCall = new StringBuilder("callableReferenceFakeCall(");
@@ -3222,6 +3200,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
         Type varType = asmType(variableDescriptor.getType());
 
+        // SCRIPT: Variable at the top of the script is generated as field
         if (JetPsiUtil.isScriptDeclaration(variableDeclaration)) {
             generateInitializer.fun(variableDescriptor);
             JetScript scriptPsi = JetPsiUtil.getScript(variableDeclaration);
@@ -3267,15 +3246,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         ConstructorDescriptor constructorDescriptor = (ConstructorDescriptor) resolvedCall.getResultingDescriptor();
         MutableClosure closure = bindingContext.get(CLOSURE, constructorDescriptor.getContainingDeclaration());
 
-        ClassDescriptor descriptor = getExpectedThisObjectForConstructorCall(constructorDescriptor, closure);
-        if (receiver.type.getSort() != Type.VOID && descriptor == null) {
-            v.pop();
-        }
-
         //Resolved call to local class constructor doesn't have resolvedCall.getThisObject() and resolvedCall.getReceiverArgument()
         //so we need generate closure on stack
         //See StackValue.receiver for more info
-        pushClosureOnStack(closure, resolvedCall.getThisObject().exists() || resolvedCall.getReceiverArgument().exists(), defaulCallGenerator);
+        pushClosureOnStack(closure, resolvedCall.getThisObject().exists() || resolvedCall.getReceiverArgument().exists(),
+                           defaultCallGenerator);
 
         ConstructorDescriptor originalOfSamAdapter = (ConstructorDescriptor) SamCodegenUtil.getOriginalIfSamAdapter(constructorDescriptor);
         CallableMethod method = typeMapper.mapToCallableMethod(originalOfSamAdapter == null ? constructorDescriptor : originalOfSamAdapter);
@@ -3390,9 +3365,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             Type[] argumentTypes = asmMethod.getArgumentTypes();
 
             if (callable instanceof CallableMethod) {
-                genThisAndReceiverFromResolvedCall(receiver, resolvedCall, (CallableMethod) callable);
                 boolean skipLast = !isGetter;
-                pushMethodArguments(resolvedCall, ((CallableMethod) callable).getValueParameterTypes(), skipLast, defaulCallGenerator);
+                pushMethodArgumentsWithCallReceiver(receiver, resolvedCall, (CallableMethod) callable, skipLast, defaultCallGenerator);
             }
             else {
                 gen(array, arrayType); // intrinsic method

compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -157,8 +157,8 @@ public class FunctionCodegen extends ParentCodegenAwareImpl {
 
         for (int i = 0; i < kotlinParameterTypes.size(); i++) {
             JvmMethodParameterKind kind = kotlinParameterTypes.get(i).getKind();
-            if (kind == JvmMethodParameterKind.ENUM_NAME || kind == JvmMethodParameterKind.ENUM_ORDINAL) {
-                markEnumConstructorParameterAsSynthetic(mv, i);
+            if (kind.isSkippedInGenericSignature()) {
+                markEnumOrInnerConstructorParameterAsSynthetic(mv, i);
                 continue;
             }
 
@@ -181,8 +181,8 @@ public class FunctionCodegen extends ParentCodegenAwareImpl {
 
         for (int i = 0; i < kotlinParameterTypes.size(); i++) {
             JvmMethodParameterKind kind = kotlinParameterTypes.get(i).getKind();
-            if (kind == JvmMethodParameterKind.ENUM_NAME || kind == JvmMethodParameterKind.ENUM_ORDINAL) {
-                markEnumConstructorParameterAsSynthetic(mv, i);
+            if (kind.isSkippedInGenericSignature()) {
+                markEnumOrInnerConstructorParameterAsSynthetic(mv, i);
                 continue;
             }
 
@@ -223,7 +223,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl {
         }
     }
 
-    private void markEnumConstructorParameterAsSynthetic(MethodVisitor mv, int i) {
+    private void markEnumOrInnerConstructorParameterAsSynthetic(MethodVisitor mv, int i) {
         // IDEA's ClsPsi builder fails to annotate synthetic parameters
         if (state.getClassBuilderMode() == ClassBuilderMode.LIGHT_CLASSES) return;
 
@@ -367,7 +367,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl {
     }
 
     private static boolean needIndexForVar(JvmMethodParameterKind kind) {
-        return kind == JvmMethodParameterKind.SHARED_VAR || kind == JvmMethodParameterKind.SUPER_CALL_PARAM;
+        return kind == JvmMethodParameterKind.CAPTURED_LOCAL_VARIABLE || kind == JvmMethodParameterKind.SUPER_OF_ANONYMOUS_CALL_PARAM;
     }
 
     public static void endVisit(MethodVisitor mv, @Nullable String description, @Nullable PsiElement method) {

compiler/backend/src/org/jetbrains/jet/codegen/GeneratedClassLoader.java

@@ -21,6 +21,7 @@ import org.jetbrains.jet.OutputFile;
 
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.List;
 
 public class GeneratedClassLoader extends URLClassLoader {
     private ClassFileFactory state;
@@ -47,4 +48,9 @@ public class GeneratedClassLoader extends URLClassLoader {
     public void dispose() {
         state = null;
     }
+
+    @NotNull
+    public List<OutputFile> getAllGeneratedFiles() {
+        return state.asList();
+    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java

@@ -1024,9 +1024,15 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                     InstructionAdapter iv = codegen.v;
                     boolean forceField = AsmUtil.isPropertyWithBackingFieldInOuterClass(original) && !isClassObject(bridge.getContainingDeclaration());
                     StackValue property = codegen.intermediateValueForProperty(original, forceField, null, MethodKind.SYNTHETIC_ACCESSOR);
-                    if (!forceField) {
-                        iv.load(0, OBJECT_TYPE);
+
+                    Type[] argTypes = signature.getAsmMethod().getArgumentTypes();
+                    for (int i = 0, reg = 0; i < argTypes.length; i++) {
+                        Type argType = argTypes[i];
+                        iv.load(reg, argType);
+                        //noinspection AssignmentToForLoopParameter
+                        reg += argType.getSize();
                     }
+
                     property.put(property.type, iv);
                     iv.areturn(signature.getReturnType());
                 }
@@ -1577,7 +1583,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     private static int findFirstSuperArgument(@NotNull CallableMethod method) {
         int i = 0;
         for (JvmMethodParameterSignature type : method.getValueParameters()) {
-            if (type.getKind() == JvmMethodParameterKind.SUPER_CALL_PARAM) {
+            if (type.getKind() == JvmMethodParameterKind.SUPER_OF_ANONYMOUS_CALL_PARAM) {
                 return i + 1; // because of this
             }
             i += type.getAsmType().getSize();

compiler/backend/src/org/jetbrains/jet/codegen/JavaSerializerExtension.java

@@ -22,7 +22,10 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.Method;
 import org.jetbrains.jet.descriptors.serialization.*;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPropertyDescriptor;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedSimpleFunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.kotlin.SignatureDeserializer;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -64,10 +67,20 @@ public class JavaSerializerExtension extends SerializerExtension {
             @NotNull ProtoBuf.Callable.Builder proto,
             @NotNull NameTable nameTable
     ) {
+        SignatureSerializer signatureSerializer = new SignatureSerializer(nameTable);
         if (callable instanceof FunctionDescriptor) {
-            Method method = bindings.get(METHOD_FOR_FUNCTION, (FunctionDescriptor) callable);
-            if (method != null) {
-                proto.setExtension(JavaProtoBuf.methodSignature, new SignatureSerializer(nameTable).methodSignature(method));
+            JavaProtoBuf.JavaMethodSignature signature;
+            if (callable instanceof DeserializedSimpleFunctionDescriptor) {
+                DeserializedSimpleFunctionDescriptor deserialized = (DeserializedSimpleFunctionDescriptor) callable;
+                signature = signatureSerializer.copyMethodSignature(
+                        deserialized.getProto().getExtension(JavaProtoBuf.methodSignature), deserialized.getNameResolver());
+            }
+            else {
+                Method method = bindings.get(METHOD_FOR_FUNCTION, (FunctionDescriptor) callable);
+                signature = method != null ? signatureSerializer.methodSignature(method) : null;
+            }
+            if (signature != null) {
+                proto.setExtension(JavaProtoBuf.methodSignature, signature);
             }
         }
         else if (callable instanceof PropertyDescriptor) {
@@ -96,8 +109,18 @@ public class JavaSerializerExtension extends SerializerExtension {
                 syntheticMethod = bindings.get(SYNTHETIC_METHOD_FOR_PROPERTY, property);
             }
 
-            JavaProtoBuf.JavaPropertySignature signature = new SignatureSerializer(nameTable)
-                            .propertySignature(fieldType, fieldName, isStaticInOuter, syntheticMethod, getterMethod, setterMethod);
+            JavaProtoBuf.JavaPropertySignature signature;
+            if (callable instanceof DeserializedPropertyDescriptor) {
+                DeserializedPropertyDescriptor deserializedCallable = (DeserializedPropertyDescriptor) callable;
+                signature = signatureSerializer.copyPropertySignature(
+                        deserializedCallable.getProto().getExtension(JavaProtoBuf.propertySignature),
+                        deserializedCallable.getNameResolver()
+                );
+            }
+            else {
+                signature = signatureSerializer
+                        .propertySignature(fieldType, fieldName, isStaticInOuter, syntheticMethod, getterMethod, setterMethod);
+            }
             proto.setExtension(JavaProtoBuf.propertySignature, signature);
         }
     }
@@ -120,6 +143,15 @@ public class JavaSerializerExtension extends SerializerExtension {
             this.nameTable = nameTable;
         }
 
+        @NotNull
+        public JavaProtoBuf.JavaMethodSignature copyMethodSignature(
+                @NotNull JavaProtoBuf.JavaMethodSignature signature,
+                @NotNull NameResolver nameResolver
+        ) {
+            String method = new SignatureDeserializer(nameResolver).methodSignatureString(signature);
+            return methodSignature(getAsmMethod(method));
+        }
+
         @NotNull
         public JavaProtoBuf.JavaMethodSignature methodSignature(@NotNull Method method) {
             JavaProtoBuf.JavaMethodSignature.Builder signature = JavaProtoBuf.JavaMethodSignature.newBuilder();
@@ -135,6 +167,37 @@ public class JavaSerializerExtension extends SerializerExtension {
             return signature.build();
         }
 
+        @NotNull
+        public JavaProtoBuf.JavaPropertySignature copyPropertySignature(
+                @NotNull JavaProtoBuf.JavaPropertySignature signature,
+                @NotNull NameResolver nameResolver
+        ) {
+            Type fieldType;
+            String fieldName;
+            boolean isStaticInOuter;
+            SignatureDeserializer signatureDeserializer = new SignatureDeserializer(nameResolver);
+            if (signature.hasField()) {
+                JavaProtoBuf.JavaFieldSignature field = signature.getField();
+                fieldType = Type.getType(signatureDeserializer.typeDescriptor(field.getType()));
+                fieldName = nameResolver.getName(field.getName()).asString();
+                isStaticInOuter = field.getIsStaticInOuter();
+            }
+            else {
+                fieldType = null;
+                fieldName = null;
+                isStaticInOuter = false;
+            }
+
+            Method syntheticMethod = signature.hasSyntheticMethod()
+                    ? getAsmMethod(signatureDeserializer.methodSignatureString(signature.getSyntheticMethod()))
+                    : null;
+
+            Method getter = signature.hasGetter() ? getAsmMethod(signatureDeserializer.methodSignatureString(signature.getGetter())) : null;
+            Method setter = signature.hasSetter() ? getAsmMethod(signatureDeserializer.methodSignatureString(signature.getSetter())) : null;
+
+            return propertySignature(fieldType, fieldName, isStaticInOuter, syntheticMethod, getter, setter);
+        }
+
         @NotNull
         public JavaProtoBuf.JavaPropertySignature propertySignature(
                 @Nullable Type fieldType,
@@ -206,4 +269,10 @@ public class JavaSerializerExtension extends SerializerExtension {
             return FqName.fromSegments(Arrays.asList(internalName.split("/")));
         }
     }
+
+    @NotNull
+    private static Method getAsmMethod(@NotNull String nameAndDesc) {
+        int indexOf = nameAndDesc.indexOf('(');
+        return new Method(nameAndDesc.substring(0, indexOf), nameAndDesc.substring(indexOf));
+    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/KotlinCodegenFacade.java

@@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.psi.JetScript;
 import org.jetbrains.jet.lang.resolve.ScriptNameUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -38,10 +37,12 @@ public class KotlinCodegenFacade {
     ) {
         for (JetFile file : state.getFiles()) {
             if (file.isScript()) {
-                String name = ScriptNameUtil.classNameForScript(file);
+                // SCRIPT: register class name for scripting from this file, move outside of this function
+                FqName name = ScriptNameUtil.classNameForScript(file);
                 JetScript script = file.getScript();
                 assert script != null;
-                registerClassNameForScript(state.getBindingTrace(), script, Type.getObjectType(name));
+                Type type = AsmUtil.asmTypeByFqNameWithoutInnerClasses(name);
+                registerClassNameForScript(state.getBindingTrace(), script, type);
             }
         }
 
@@ -50,7 +51,7 @@ public class KotlinCodegenFacade {
         MultiMap<FqName, JetFile> packageFqNameToFiles = new MultiMap<FqName, JetFile>();
         for (JetFile file : state.getFiles()) {
             if (file == null) throw new IllegalArgumentException("A null file given for compilation");
-            packageFqNameToFiles.putValue(JetPsiUtil.getFQName(file), file);
+            packageFqNameToFiles.putValue(file.getPackageFqName(), file);
         }
 
         for (Map.Entry<FqName, Collection<JetFile>> entry : packageFqNameToFiles.entrySet()) {

compiler/backend/src/org/jetbrains/jet/codegen/MemberCodegen.java

@@ -52,7 +52,6 @@ public class MemberCodegen extends ParentCodegenAwareImpl {
     }
 
     public void genFunctionOrProperty(
-            @NotNull FieldOwnerContext context,
             @NotNull JetTypeParameterListOwner functionOrProperty,
             @NotNull ClassBuilder classBuilder
     ) {
@@ -127,8 +126,8 @@ public class MemberCodegen extends ParentCodegenAwareImpl {
         }
     }
 
-    public void genClassOrObject(CodegenContext parentContext, JetClassOrObject aClass) {
-        genClassOrObject(parentContext, aClass, state, this);
+    public void genClassOrObject(JetClassOrObject aClass) {
+        genClassOrObject(context, aClass, state, this);
     }
 
     @NotNull

compiler/backend/src/org/jetbrains/jet/codegen/PackageCodegen.java

@@ -16,7 +16,8 @@
 
 package org.jetbrains.jet.codegen;
 
-import com.google.common.collect.Sets;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Ordering;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.util.io.FileUtil;
@@ -24,26 +25,36 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiFile;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.PathUtil;
+import com.intellij.util.SmartList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
+import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.context.FieldOwnerContext;
+import org.jetbrains.jet.codegen.context.MethodContext;
 import org.jetbrains.jet.codegen.context.PackageContext;
+import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.GenerationStateAware;
-import org.jetbrains.jet.descriptors.serialization.BitEncoding;
-import org.jetbrains.jet.descriptors.serialization.DescriptorSerializer;
-import org.jetbrains.jet.descriptors.serialization.PackageData;
-import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.config.IncrementalCompilation;
+import org.jetbrains.jet.descriptors.serialization.*;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedCallableMemberDescriptor;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPropertyDescriptor;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedSimpleFunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.MemberComparator;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
+import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragmentScope;
+import org.jetbrains.jet.lang.resolve.kotlin.BaseDescriptorDeserializer;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -59,12 +70,10 @@ public class PackageCodegen extends GenerationStateAware {
     @NotNull
     private final ClassBuilderOnDemand v;
 
-    @NotNull
-    private final FqName name;
-
     @NotNull
     private final Collection<JetFile> files;
-    private final Set<PackageFragmentDescriptor> packageFragments;
+    private final PackageFragmentDescriptor packageFragment;
+    private final PackageFragmentDescriptor compiledPackageFragment;
 
     public PackageCodegen(
             @NotNull ClassBuilderOnDemand v,
@@ -73,18 +82,14 @@ public class PackageCodegen extends GenerationStateAware {
             @NotNull Collection<JetFile> packageFiles
     ) {
         super(state);
-        checkAllFilesHaveSamePackage(packageFiles);
 
         this.v = v;
-        name = fqName;
         this.files = packageFiles;
+        this.packageFragment = getOnlyPackageFragment();
+        this.compiledPackageFragment = getCompiledPackageFragment();
 
-        packageFragments = Sets.newHashSet();
-        for (JetFile file : packageFiles) {
-            packageFragments.add(getPackageFragment(file));
-        }
-
-        final PsiFile sourceFile = packageFiles.size() == 1 ? packageFiles.iterator().next().getContainingFile() : null;
+        final PsiFile sourceFile = packageFiles.size() == 1 && getPreviouslyCompiledCallables().isEmpty()
+                                   ? packageFiles.iterator().next().getContainingFile() : null;
 
         v.addOptionalDeclaration(new ClassBuilderOnDemand.ClassBuilderCallback() {
             @Override
@@ -104,6 +109,81 @@ public class PackageCodegen extends GenerationStateAware {
         });
     }
 
+    @Nullable
+    private PackageFragmentDescriptor getCompiledPackageFragment() {
+        if (!IncrementalCompilation.ENABLED) {
+            return null;
+        }
+
+        // TODO rewrite it to something more robust when module system is implemented
+        for (PackageFragmentDescriptor anotherFragment : packageFragment.getContainingDeclaration().getPackageFragmentProvider()
+                .getPackageFragments(packageFragment.getFqName())) {
+            if (anotherFragment.getMemberScope() instanceof LazyJavaPackageFragmentScope) {
+                return anotherFragment;
+            }
+        }
+        return null;
+    }
+
+    @NotNull
+    private List<DeserializedCallableMemberDescriptor> getPreviouslyCompiledCallables() {
+        List<DeserializedCallableMemberDescriptor> callables = Lists.newArrayList();
+        if (compiledPackageFragment != null) {
+            for (DeclarationDescriptor member : compiledPackageFragment.getMemberScope().getAllDescriptors()) {
+                if (member instanceof DeserializedCallableMemberDescriptor) {
+                    callables.add((DeserializedCallableMemberDescriptor) member);
+                }
+            }
+        }
+        return callables;
+    }
+
+    private void generateDelegationsToPreviouslyCompiled(Map<CallableMemberDescriptor, Runnable> generateCallableMemberTasks) {
+        for (final DeserializedCallableMemberDescriptor member : getPreviouslyCompiledCallables()) {
+            generateCallableMemberTasks.put(member, new Runnable() {
+                @Override
+                public void run() {
+                    FieldOwnerContext context = CodegenContext.STATIC.intoPackageFacade(
+                            Type.getObjectType(getPackagePartInternalName(member)),
+                            compiledPackageFragment);
+
+                    FunctionCodegen functionCodegen = new FunctionCodegen(
+                            context,
+                            v.getClassBuilder(),
+                            state,
+                            getMemberCodegen(context)
+                    );
+
+                    if (member instanceof DeserializedSimpleFunctionDescriptor) {
+                        DeserializedSimpleFunctionDescriptor function = (DeserializedSimpleFunctionDescriptor) member;
+                        JvmMethodSignature signature = typeMapper.mapSignature(function, OwnerKind.PACKAGE);
+                        functionCodegen.generateMethod(null, signature, function,
+                                                       new FunctionGenerationStrategy() {
+                                                           @Override
+                                                           public void generateBody(
+                                                                   @NotNull MethodVisitor mv,
+                                                                   @NotNull JvmMethodSignature signature,
+                                                                   @NotNull MethodContext context,
+                                                                   @Nullable MemberCodegen parentCodegen
+                                                           ) {
+                                                               throw new IllegalStateException("shouldn't be called");
+                                                           }
+                                                       }
+                        );
+                    }
+                    else if (member instanceof DeserializedPropertyDescriptor) {
+                        PropertyCodegen propertyCodegen = new PropertyCodegen(
+                                context, v.getClassBuilder(), functionCodegen, getMemberCodegen(context));
+                        propertyCodegen.generateInPackageFacade((DeserializedPropertyDescriptor) member);
+                    }
+                    else {
+                        throw new IllegalStateException("Unexpected member: " + member);
+                    }
+                }
+            });
+        }
+    }
+
     public void generate(@NotNull CompilationErrorHandler errorHandler) {
         List<JvmSerializationBindings> bindings = new ArrayList<JvmSerializationBindings>(files.size() + 1);
         boolean shouldGeneratePackageClass = shouldGeneratePackageClass(files);
@@ -111,9 +191,11 @@ public class PackageCodegen extends GenerationStateAware {
             bindings.add(v.getClassBuilder().getSerializationBindings());
         }
 
+        Map<CallableMemberDescriptor, Runnable> generateCallableMemberTasks = new HashMap<CallableMemberDescriptor, Runnable>();
+
         for (JetFile file : files) {
             try {
-                ClassBuilder builder = generate(file);
+                ClassBuilder builder = generate(file, generateCallableMemberTasks);
                 if (builder != null) {
                     bindings.add(builder.getSerializationBindings());
                 }
@@ -132,12 +214,21 @@ public class PackageCodegen extends GenerationStateAware {
             }
         }
 
+        if (shouldGeneratePackageClass) {
+            // Shouldn't generate delegations to previously compiled if we compile only "classes" part of a package.
+            generateDelegationsToPreviouslyCompiled(generateCallableMemberTasks);
+        }
+
+        for (CallableMemberDescriptor member : Ordering.from(MemberComparator.INSTANCE).sortedCopy(generateCallableMemberTasks.keySet())) {
+            generateCallableMemberTasks.get(member).run();
+        }
+
         if (shouldGeneratePackageClass) {
             writeKotlinPackageAnnotationIfNeeded(JvmSerializationBindings.union(bindings));
         }
 
         assert v.isActivated() == shouldGeneratePackageClass :
-                "Different algorithms for generating package class and for heuristics for: " + name.asString();
+                "Different algorithms for generating package class and for heuristics for: " + packageFragment;
     }
 
     private void writeKotlinPackageAnnotationIfNeeded(@NotNull JvmSerializationBindings bindings) {
@@ -145,11 +236,15 @@ public class PackageCodegen extends GenerationStateAware {
             return;
         }
 
+        // SCRIPT: Do not write annotations for scripts (if any is??)
         for (JetFile file : files) {
             if (file.isScript()) return;
         }
 
         DescriptorSerializer serializer = new DescriptorSerializer(new JavaSerializerExtension(bindings));
+        Collection<PackageFragmentDescriptor> packageFragments = compiledPackageFragment == null
+                                                                 ? Collections.singleton(packageFragment)
+                                                                 : Arrays.asList(packageFragment, compiledPackageFragment);
         ProtoBuf.Package packageProto = serializer.packageProto(packageFragments).build();
 
         if (packageProto.getMemberCount() == 0) return;
@@ -168,10 +263,10 @@ public class PackageCodegen extends GenerationStateAware {
     }
 
     @Nullable
-    private ClassBuilder generate(@NotNull JetFile file) {
+    private ClassBuilder generate(@NotNull JetFile file, @NotNull Map<CallableMemberDescriptor, Runnable> generateCallableMemberTasks) {
         boolean generateSrcClass = false;
-        Type packagePartType = getPackagePartType(getPackageClassFqName(name), file.getVirtualFile());
-        PackageContext packagePartContext = CodegenContext.STATIC.intoPackagePart(getPackageFragment(file), packagePartType);
+        Type packagePartType = getPackagePartType(getPackageClassFqName(packageFragment.getFqName()), file.getVirtualFile());
+        PackageContext packagePartContext = CodegenContext.STATIC.intoPackagePart(packageFragment, packagePartType);
 
         for (JetDeclaration declaration : file.getDeclarations()) {
             if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
@@ -184,6 +279,7 @@ public class PackageCodegen extends GenerationStateAware {
                 }
             }
             else if (declaration instanceof JetScript) {
+               // SCRIPT: generate script code, should be separate execution branch
                ScriptCodegen.createScriptCodegen((JetScript) declaration, state, packagePartContext).generate();
             }
         }
@@ -194,35 +290,63 @@ public class PackageCodegen extends GenerationStateAware {
 
         new PackagePartCodegen(builder, file, packagePartType, packagePartContext, state).generate();
 
-        FieldOwnerContext packageFacade = CodegenContext.STATIC.intoPackageFacade(packagePartType, getPackageFragment(file));
-        //TODO: FIX: Default method generated at facade without delegation
-        MemberCodegen memberCodegen = new MemberCodegen(state, null, packageFacade, null) {
-            @NotNull
-            @Override
-            public ClassBuilder getBuilder() {
-                return v.getClassBuilder();
-            }
-        };
-        for (JetDeclaration declaration : file.getDeclarations()) {
+        FieldOwnerContext packageFacade = CodegenContext.STATIC.intoPackageFacade(packagePartType, packageFragment);
+
+        final MemberCodegen memberCodegen = getMemberCodegen(packageFacade);
+
+        for (final JetDeclaration declaration : file.getDeclarations()) {
             if (declaration instanceof JetNamedFunction || declaration instanceof JetProperty) {
-                memberCodegen.genFunctionOrProperty(packageFacade, (JetTypeParameterListOwner) declaration, v.getClassBuilder());
+                DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration);
+                assert descriptor instanceof CallableMemberDescriptor :
+                        "Expected callable member, was " + descriptor + " for " + declaration.getText();
+                generateCallableMemberTasks.put(
+                        (CallableMemberDescriptor) descriptor,
+                        new Runnable() {
+                            @Override
+                            public void run() {
+                                memberCodegen.genFunctionOrProperty(
+                                        (JetTypeParameterListOwner) declaration, v.getClassBuilder());
+                            }
+                        }
+                );
             }
         }
 
         return builder;
     }
 
+    //TODO: FIX: Default method generated at facade without delegation
+    private MemberCodegen getMemberCodegen(@NotNull FieldOwnerContext packageFacade) {
+        return new MemberCodegen(state, null, packageFacade, null) {
+            @NotNull
+            @Override
+            public ClassBuilder getBuilder() {
+                return v.getClassBuilder();
+            }
+        };
+    }
+
     @NotNull
-    private PackageFragmentDescriptor getPackageFragment(@NotNull JetFile file) {
-        PackageFragmentDescriptor packageFragment = bindingContext.get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file);
-        assert packageFragment != null : "package fragment is null for " + file;
-        return packageFragment;
+    private PackageFragmentDescriptor getOnlyPackageFragment() {
+        SmartList<PackageFragmentDescriptor> fragments = new SmartList<PackageFragmentDescriptor>();
+        for (JetFile file : files) {
+            PackageFragmentDescriptor fragment = bindingContext.get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file);
+            assert fragment != null : "package fragment is null for " + file;
+
+            if (!fragments.contains(fragment)) {
+                fragments.add(fragment);
+            }
+        }
+        if (fragments.size() != 1) {
+            throw new IllegalStateException("More than one package fragment, files: " + files + " | fragments: " + fragments);
+        }
+        return fragments.get(0);
     }
 
     public void generateClassOrObject(@NotNull JetClassOrObject classOrObject) {
         JetFile file = (JetFile) classOrObject.getContainingFile();
-        Type packagePartType = getPackagePartType(getPackageClassFqName(name), file.getVirtualFile());
-        CodegenContext context = CodegenContext.STATIC.intoPackagePart(getPackageFragment(file), packagePartType);
+        Type packagePartType = getPackagePartType(getPackageClassFqName(packageFragment.getFqName()), file.getVirtualFile());
+        CodegenContext context = CodegenContext.STATIC.intoPackagePart(packageFragment, packagePartType);
         MemberCodegen.genClassOrObject(context, classOrObject, state, null);
     }
 
@@ -231,8 +355,6 @@ public class PackageCodegen extends GenerationStateAware {
      * @return
      */
     public static boolean shouldGeneratePackageClass(@NotNull Collection<JetFile> packageFiles) {
-        checkAllFilesHaveSamePackage(packageFiles);
-
         for (JetFile file : packageFiles) {
             for (JetDeclaration declaration : file.getDeclarations()) {
                 if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
@@ -244,21 +366,6 @@ public class PackageCodegen extends GenerationStateAware {
         return false;
     }
 
-    private static void checkAllFilesHaveSamePackage(Collection<JetFile> packageFiles) {
-        FqName commonFqName = null;
-        for (JetFile file : packageFiles) {
-            FqName fqName = JetPsiUtil.getFQName(file);
-            if (commonFqName != null) {
-                if (!commonFqName.equals(fqName)) {
-                    throw new IllegalArgumentException("All files should have same package name");
-                }
-            }
-            else {
-                commonFqName = JetPsiUtil.getFQName(file);
-            }
-        }
-    }
-
     public void done() {
         v.done();
     }
@@ -271,9 +378,7 @@ public class PackageCodegen extends GenerationStateAware {
         String srcName = facadeFqName.shortName().asString() + "-" + replaceSpecialSymbols(fileName) + "-" + Integer.toHexString(
                 CodegenUtil.getPathHashCode(file));
 
-        FqName srcFqName = facadeFqName.parent().child(Name.identifier(srcName));
-
-        return asmTypeByFqNameWithoutInnerClasses(srcFqName);
+        return asmTypeByFqNameWithoutInnerClasses(facadeFqName.parent().child(Name.identifier(srcName)));
     }
 
     @NotNull
@@ -283,7 +388,14 @@ public class PackageCodegen extends GenerationStateAware {
 
     @NotNull
     public static String getPackagePartInternalName(@NotNull JetFile file) {
-        FqName packageFqName = JetPsiUtil.getFQName(file);
+        FqName packageFqName = file.getPackageFqName();
         return getPackagePartType(getPackageClassFqName(packageFqName), file.getVirtualFile()).getInternalName();
     }
+
+    @NotNull
+    public static String getPackagePartInternalName(@NotNull DeserializedCallableMemberDescriptor callable) {
+        FqName packageFqName = ((PackageFragmentDescriptor) callable.getContainingDeclaration()).getFqName();
+        FqName packagePartFqName = packageFqName.child(BaseDescriptorDeserializer.getPackagePartClassName(callable));
+        return JvmClassName.byFqNameWithoutInnerClasses(packagePartFqName).getInternalName();
+    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/PackagePartCodegen.java

@@ -62,7 +62,7 @@ public class PackagePartCodegen extends MemberCodegen {
         this.packagePartName = packagePartName;
         this.context = context;
         descriptor = state.getBindingContext().get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, jetFile);
-        assert descriptor != null : "No package fragment found for jetFile " + jetFile + " declared package: " + jetFile.getPackageName();
+        assert descriptor != null : "No package fragment found for jetFile " + jetFile + " declared package: " + jetFile.getPackageFqName();
     }
 
     public void generate() {
@@ -79,7 +79,7 @@ public class PackagePartCodegen extends MemberCodegen {
 
         for (JetDeclaration declaration : jetFile.getDeclarations()) {
             if (declaration instanceof JetNamedFunction || declaration instanceof JetProperty) {
-                genFunctionOrProperty(context, (JetTypeParameterListOwner) declaration, v);
+                genFunctionOrProperty((JetTypeParameterListOwner) declaration, v);
             }
         }
 
@@ -99,9 +99,9 @@ public class PackagePartCodegen extends MemberCodegen {
             FrameMap frameMap = new FrameMap();
 
             SimpleFunctionDescriptorImpl clInit =
-                    new SimpleFunctionDescriptorImpl(this.descriptor, Annotations.EMPTY,
-                                                     Name.special("<clinit>"),
-                                                     CallableMemberDescriptor.Kind.SYNTHESIZED);
+                    SimpleFunctionDescriptorImpl.create(this.descriptor, Annotations.EMPTY,
+                                                        Name.special("<clinit>"),
+                                                        CallableMemberDescriptor.Kind.SYNTHESIZED);
             clInit.initialize(null, null, Collections.<TypeParameterDescriptor>emptyList(),
                               Collections.<ValueParameterDescriptor>emptyList(), null, null, Visibilities.PRIVATE);
 

compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * Copyright 2010-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,6 +31,7 @@ import org.jetbrains.jet.codegen.context.PackageFacadeContext;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.GenerationStateAware;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPropertyDescriptor;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -80,27 +81,43 @@ public class PropertyCodegen extends GenerationStateAware {
         this.kind = context.getContextKind();
     }
 
-    public void gen(JetProperty p) {
-        VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, p);
+    public void gen(@NotNull JetProperty property) {
+        VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, property);
         assert variableDescriptor instanceof PropertyDescriptor : "Property should have a property descriptor: " + variableDescriptor;
 
         PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variableDescriptor;
-        assert kind == OwnerKind.PACKAGE || kind == OwnerKind.IMPLEMENTATION || kind == OwnerKind.TRAIT_IMPL
-                : "Generating property with a wrong kind (" + kind + "): " + propertyDescriptor;
+        gen(property, propertyDescriptor, property.getGetter(), property.getSetter());
+    }
 
+    public void generateInPackageFacade(@NotNull DeserializedPropertyDescriptor deserializedProperty) {
+        assert context instanceof PackageFacadeContext : "should be called only for generating package facade: " + context;
+        gen(null, deserializedProperty, null, null);
+    }
+
+    private void gen(
+            @Nullable JetProperty declaration,
+            @NotNull PropertyDescriptor descriptor,
+            @Nullable JetPropertyAccessor getter,
+            @Nullable JetPropertyAccessor setter
+    ) {
+        assert kind == OwnerKind.PACKAGE || kind == OwnerKind.IMPLEMENTATION || kind == OwnerKind.TRAIT_IMPL
+                : "Generating property with a wrong kind (" + kind + "): " + descriptor;
 
         if (context instanceof PackageFacadeContext) {
             Type ownerType = ((PackageFacadeContext) context).getDelegateToClassType();
-            v.getSerializationBindings().put(IMPL_CLASS_NAME_FOR_CALLABLE, propertyDescriptor, shortNameByAsmType(ownerType));
+            v.getSerializationBindings().put(IMPL_CLASS_NAME_FOR_CALLABLE, descriptor, shortNameByAsmType(ownerType));
         }
-        else if (!generateBackingField(p, propertyDescriptor)) {
-            generateSyntheticMethodIfNeeded(propertyDescriptor);
+        else {
+            assert declaration != null : "Declaration is null for different context: " + context;
+            if (!generateBackingField(declaration, descriptor)) {
+                generateSyntheticMethodIfNeeded(descriptor);
+            }
         }
 
-        generateGetter(p, propertyDescriptor, p.getGetter());
-        generateSetter(p, propertyDescriptor, p.getSetter());
+        generateGetter(declaration, descriptor, getter);
+        generateSetter(declaration, descriptor, setter);
 
-        context.recordSyntheticAccessorIfNeeded(propertyDescriptor, bindingContext);
+        context.recordSyntheticAccessorIfNeeded(descriptor, bindingContext);
     }
 
     public void generatePrimaryConstructorProperty(JetParameter p, PropertyDescriptor descriptor) {
@@ -151,16 +168,12 @@ public class PropertyCodegen extends GenerationStateAware {
         if (descriptor.getAnnotations().isEmpty()) return;
 
         ReceiverParameterDescriptor receiver = descriptor.getReceiverParameter();
-        Type receiverAsmType = receiver == null ? null : typeMapper.mapType(receiver.getType());
-        Method method = JvmAbi.getSyntheticMethodSignatureForAnnotatedProperty(descriptor.getName(), receiverAsmType);
+        String name = JvmAbi.getSyntheticMethodNameForAnnotatedProperty(descriptor.getName());
+        String desc = receiver == null ? "()V" : "(" + typeMapper.mapType(receiver.getType()) + ")V";
 
         if (!isTrait(context.getContextDescriptor()) || kind == OwnerKind.TRAIT_IMPL) {
-            MethodVisitor mv = v.newMethod(null,
-                                           ACC_DEPRECATED | ACC_FINAL | ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC,
-                                           method.getName(),
-                                           method.getDescriptor(),
-                                           null,
-                                           null);
+            int flags = ACC_DEPRECATED | ACC_FINAL | ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC;
+            MethodVisitor mv = v.newMethod(null, flags, name, desc, null, null);
             AnnotationCodegen.forMethod(mv, typeMapper).genAnnotations(descriptor);
             mv.visitCode();
             mv.visitInsn(Opcodes.RETURN);
@@ -172,7 +185,7 @@ public class PropertyCodegen extends GenerationStateAware {
         }
 
         if (kind != OwnerKind.TRAIT_IMPL) {
-            v.getSerializationBindings().put(SYNTHETIC_METHOD_FOR_PROPERTY, descriptor, method);
+            v.getSerializationBindings().put(SYNTHETIC_METHOD_FOR_PROPERTY, descriptor, new Method(name, desc));
         }
     }
 
@@ -244,7 +257,7 @@ public class PropertyCodegen extends GenerationStateAware {
         return generateBackingField(p, propertyDescriptor, false, propertyDescriptor.getType(), value);
     }
 
-    private void generateGetter(JetNamedDeclaration p, PropertyDescriptor propertyDescriptor, JetPropertyAccessor getter) {
+    private void generateGetter(@Nullable JetNamedDeclaration p, @NotNull PropertyDescriptor propertyDescriptor, @Nullable JetPropertyAccessor getter) {
         boolean defaultGetter = getter == null || getter.getBodyExpression() == null;
 
         //TODO: Now it's not enough information to properly resolve property from bytecode without generated getter and setter
@@ -274,7 +287,7 @@ public class PropertyCodegen extends GenerationStateAware {
         //}
     }
 
-    private void generateSetter(JetNamedDeclaration p, PropertyDescriptor propertyDescriptor, JetPropertyAccessor setter) {
+    private void generateSetter(@Nullable JetNamedDeclaration p, @NotNull PropertyDescriptor propertyDescriptor, @Nullable JetPropertyAccessor setter) {
         boolean defaultSetter = setter == null || setter.getBodyExpression() == null;
 
         //TODO: Now it's not enough information to properly resolve property from bytecode without generated getter and setter
@@ -374,10 +387,12 @@ public class PropertyCodegen extends GenerationStateAware {
         }
     }
 
+    @NotNull
     public static String getterName(Name propertyName) {
         return JvmAbi.GETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName.asString());
     }
 
+    @NotNull
     public static String setterName(Name propertyName) {
         return JvmAbi.SETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName.asString());
     }

compiler/backend/src/org/jetbrains/jet/codegen/SamWrapperCodegen.java

@@ -26,7 +26,6 @@ import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
@@ -136,7 +135,7 @@ public class SamWrapperCodegen extends ParentCodegenAwareImpl {
     }
 
     private String getWrapperName(@NotNull JetFile containingFile) {
-        FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(JetPsiUtil.getFQName(containingFile));
+        FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(containingFile.getPackageFqName());
         String packageInternalName = JvmClassName.byFqNameWithoutInnerClasses(packageClassFqName).getInternalName();
         return packageInternalName + "$sam$" + samInterface.getName().asString() + "$" +
                Integer.toHexString(CodegenUtil.getPathHashCode(containingFile.getVirtualFile()) * 31 + DescriptorUtils.getFqNameSafe(

compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java

@@ -40,6 +40,7 @@ import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 import static org.jetbrains.jet.codegen.binding.CodegenBinding.*;
 import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE;
 
+// SCRIPT: script code generator
 public class ScriptCodegen extends MemberCodegen {
 
     public static ScriptCodegen createScriptCodegen(
@@ -203,7 +204,7 @@ public class ScriptCodegen extends MemberCodegen {
 
     private void genMembers(@NotNull FieldOwnerContext context, @NotNull ClassBuilder classBuilder) {
         for (JetDeclaration decl : scriptDeclaration.getDeclarations()) {
-            genFunctionOrProperty(context, (JetTypeParameterListOwner) decl, classBuilder);
+            genFunctionOrProperty((JetTypeParameterListOwner) decl, classBuilder);
         }
     }
 

compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java

@@ -330,12 +330,16 @@ public abstract class StackValue {
             ExpressionCodegen codegen,
             @Nullable CallableMethod callableMethod
     ) {
-        if (resolvedCall.getThisObject().exists() || resolvedCall.getReceiverArgument().exists()) {
+        if (resolvedCall.getThisObject().exists() || resolvedCall.getReceiverArgument().exists() || isLocalFunCall(callableMethod)) {
             return new CallReceiver(resolvedCall, receiver, codegen, callableMethod, true);
         }
         return receiver;
     }
 
+    private static boolean isLocalFunCall(@Nullable CallableMethod callableMethod) {
+        return callableMethod != null && callableMethod.getGenerateCalleeType() != null;
+    }
+
     public static StackValue receiverWithoutReceiverArgument(StackValue receiverWithParameter) {
         if (receiverWithParameter instanceof CallReceiver) {
             CallReceiver callReceiver = (CallReceiver) receiverWithParameter;
@@ -1125,37 +1129,26 @@ public abstract class StackValue {
 
             CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
 
-            if (thisObject.exists()) {
+            if (receiverArgument.exists()) {
                 if (callableMethod != null) {
-                    if (receiverArgument.exists()) {
-                        return callableMethod.getReceiverClass();
-                    }
-                    else {
-                        //noinspection ConstantConditions
-                        return callableMethod.getThisType();
-                    }
+                    return callableMethod.getReceiverClass();
                 }
                 else {
-                    if (receiverArgument.exists()) {
-                        return codegen.typeMapper.mapType(descriptor.getReceiverParameter().getType());
-                    }
-                    else {
-                        return codegen.typeMapper.mapType(descriptor.getExpectedThisObject().getType());
-                    }
+                    return codegen.typeMapper.mapType(descriptor.getReceiverParameter().getType());
+                }
+            } else if (thisObject.exists()) {
+                if (callableMethod != null) {
+                    return callableMethod.getThisType();
+                }
+                else {
+                    return codegen.typeMapper.mapType(descriptor.getExpectedThisObject().getType());
                 }
             }
+            else if (isLocalFunCall(callableMethod)) {
+                return callableMethod.getGenerateCalleeType();
+            }
             else {
-                if (receiverArgument.exists()) {
-                    if (callableMethod != null) {
-                        return callableMethod.getReceiverClass();
-                    }
-                    else {
-                        return codegen.typeMapper.mapType(descriptor.getReceiverParameter().getType());
-                    }
-                }
-                else {
-                    return Type.VOID_TYPE;
-                }
+                return Type.VOID_TYPE;
             }
         }
 
@@ -1165,27 +1158,33 @@ public abstract class StackValue {
 
             ReceiverValue thisObject = resolvedCall.getThisObject();
             ReceiverValue receiverArgument = resolvedCall.getReceiverArgument();
+            int depth;
             if (thisObject.exists()) {
                 if (receiverArgument.exists()) {
-                    if (callableMethod != null) {
-                        codegen.generateFromResolvedCall(thisObject, callableMethod.getOwner());
-                    }
-                    else {
-                        codegen.generateFromResolvedCall(thisObject, codegen.typeMapper
-                                .mapType(descriptor.getExpectedThisObject().getType()));
-                    }
-                    if (putReceiverArgumentOnStack) {
-                        genReceiver(v, receiverArgument, type, descriptor.getReceiverParameter(), 1);
-                    }
+                    Type resultType = callableMethod != null ? callableMethod.getOwner() : codegen.typeMapper
+                            .mapType(descriptor.getExpectedThisObject().getType());
+
+                    codegen.generateFromResolvedCall(thisObject, resultType);
                 }
                 else {
                     genReceiver(v, thisObject, type, null, 0);
                 }
+
+                depth = 1;
+            } else if (isLocalFunCall(callableMethod)) {
+                assert receiver == none() || receiverArgument.exists(): "Receiver should be present only for local extension function: " + callableMethod;
+                StackValue value = codegen.findLocalOrCapturedValue(descriptor.getOriginal());
+                assert value != null : "Local fun should be found in locals or in captured params: " + resolvedCall;
+                value.put(callableMethod.getGenerateCalleeType(), v);
+
+                depth = 1;
             }
             else {
-                if (putReceiverArgumentOnStack && receiverArgument.exists()) {
-                    genReceiver(v, receiverArgument, type, descriptor.getReceiverParameter(), 0);
-                }
+                depth = 0;
+            }
+
+            if (putReceiverArgumentOnStack && receiverArgument.exists()) {
+                genReceiver(v, receiverArgument, type, descriptor.getReceiverParameter(), depth);
             }
         }
 
@@ -1211,7 +1210,7 @@ public abstract class StackValue {
 
     public abstract static class StackValueWithSimpleReceiver extends StackValue {
 
-        protected final boolean isStatic;
+        public final boolean isStatic;
 
         public StackValueWithSimpleReceiver(@NotNull Type type, boolean isStatic) {
             super(type);

compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java

@@ -141,6 +141,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     @Override
     public void visitJetFile(@NotNull JetFile file) {
         if (file.isScript()) {
+            // SCRIPT: should be replaced with VisitScript override
             //noinspection ConstantConditions
             ClassDescriptor classDescriptor = bindingContext.get(CLASS_FOR_SCRIPT, bindingContext.get(SCRIPT, file.getScript()));
             pushClassDescriptor(classDescriptor);
@@ -148,7 +149,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
             nameStack.push(asmTypeForScriptPsi(bindingContext, file.getScript()).getInternalName());
         }
         else {
-            nameStack.push(JvmClassName.byFqNameWithoutInnerClasses(JetPsiUtil.getFQName(file)).getInternalName());
+            nameStack.push(JvmClassName.byFqNameWithoutInnerClasses(file.getPackageFqName()).getInternalName());
         }
         file.acceptChildren(this);
         nameStack.pop();

compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java

@@ -79,6 +79,7 @@ public class CodegenBinding {
         return Boolean.TRUE.equals(bindingContext.get(ENUM_ENTRY_CLASS_NEED_SUBCLASS, classDescriptor));
     }
 
+    // SCRIPT: Generate asmType for script, move to ScriptingUtil
     @NotNull
     public static Type asmTypeForScriptDescriptor(BindingContext bindingContext, @NotNull ScriptDescriptor scriptDescriptor) {
         ClassDescriptor classDescriptor = bindingContext.get(CLASS_FOR_SCRIPT, scriptDescriptor);
@@ -86,6 +87,7 @@ public class CodegenBinding {
         return asmType(bindingContext, classDescriptor);
     }
 
+    // SCRIPT: Generate asmType for script, move to ScriptingUtil
     @NotNull
     public static Type asmTypeForScriptPsi(BindingContext bindingContext, @NotNull JetScript script) {
         ScriptDescriptor scriptDescriptor = bindingContext.get(SCRIPT, script);
@@ -138,6 +140,7 @@ public class CodegenBinding {
         return asmType(bindingContext, classDescriptor);
     }
 
+    // SCRIPT: register asmType for script descriptor, move to ScriptingUtil
     public static void registerClassNameForScript(
             BindingTrace bindingTrace,
             @NotNull ScriptDescriptor scriptDescriptor,
@@ -217,6 +220,7 @@ public class CodegenBinding {
         innerClasses.add(inner);
     }
 
+    // SCRIPT: register asmType for script, move to ScriptingUtil
     public static void registerClassNameForScript(
             BindingTrace bindingTrace,
             @NotNull JetScript jetScript,
@@ -234,10 +238,11 @@ public class CodegenBinding {
         // todo: we use Set and add given files but ignoring other scripts because something non-clear kept in binding
         // for scripts especially in case of REPL
 
+        // SCRIPT: collect fq names for files that are not scripts
         HashSet<FqName> names = new HashSet<FqName>();
         for (JetFile file : files) {
             if (!file.isScript()) {
-                names.add(JetPsiUtil.getFQName(file));
+                names.add(file.getPackageFqName());
             }
         }
 

compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java

@@ -80,18 +80,15 @@ public final class PsiCodegenPredictor {
             }
         }
         else {
-            String packageName = ((JetFile) declaration.getContainingFile()).getPackageName();
-            if (packageName == null) {
-                return null;
-            }
+            FqName packageFqName = ((JetFile) declaration.getContainingFile()).getPackageFqName();
 
             if (declaration instanceof JetNamedFunction) {
-                JvmClassName packageClass = JvmClassName.byFqNameWithoutInnerClasses(getPackageClassFqName(new FqName(packageName)));
+                JvmClassName packageClass = JvmClassName.byFqNameWithoutInnerClasses(getPackageClassFqName(packageFqName));
                 Name name = ((JetNamedFunction) declaration).getNameAsName();
                 return name == null ? null : packageClass.getInternalName() + "$" + name.asString();
             }
 
-            parentInternalName = JvmClassName.byFqNameWithoutInnerClasses(packageName).getInternalName();
+            parentInternalName = JvmClassName.byFqNameWithoutInnerClasses(packageFqName).getInternalName();
         }
 
         if (declaration instanceof JetClassObject) {

compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java

@@ -39,6 +39,7 @@ import java.util.HashMap;
 import java.util.Map;
 
 import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PRIVATE;
+import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PROTECTED;
 import static org.jetbrains.jet.codegen.AsmUtil.CAPTURED_THIS_FIELD;
 import static org.jetbrains.jet.codegen.AsmUtil.getVisibilityAccessFlag;
 import static org.jetbrains.jet.codegen.binding.CodegenBinding.*;
@@ -190,13 +191,14 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     @NotNull
     public ConstructorContext intoConstructor(@Nullable ConstructorDescriptor descriptor, @Nullable MutableClosure closure) {
         if (descriptor == null) {
-            descriptor = new ConstructorDescriptorImpl(getThisDescriptor(), Annotations.EMPTY, true)
+            descriptor = ConstructorDescriptorImpl.create(getThisDescriptor(), Annotations.EMPTY, true)
                     .initialize(Collections.<TypeParameterDescriptor>emptyList(), Collections.<ValueParameterDescriptor>emptyList(),
-                                Visibilities.PUBLIC);
+                                Visibilities.PUBLIC, false);
         }
         return new ConstructorContext(descriptor, getContextKind(), this, closure);
     }
 
+    // SCRIPT: generate into script, move to ScriptingUtil
     @NotNull
     public ScriptContext intoScript(@NotNull ScriptDescriptor script, @NotNull ClassDescriptor classDescriptor) {
         return new ScriptContext(script, classDescriptor, OwnerKind.IMPLEMENTATION, this, closure);
@@ -332,7 +334,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
                         break;
                     }
                     else {
-                        return result == null ? innerValue : StackValue.composed(result, innerValue);
+                        return result == null ? innerValue : composedOrStatic(result, innerValue);
                     }
                 }
             }
@@ -348,7 +350,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
             resultValue = parentContext != null ? parentContext.lookupInContext(d, result, state, ignoreNoOuter) : null;
         }
 
-        if (myOuter != null && resultValue != null) {
+        if (myOuter != null && resultValue != null && !isStaticField(resultValue)) {
             closure.setCaptureThis();
         }
         return resultValue;
@@ -397,15 +399,16 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
             PropertyGetterDescriptor getter = propertyDescriptor.getGetter();
 
             flag |= (getter == null ? 0 : getVisibilityAccessFlag(getter)) |
-                    (setter == null ? 0 : getVisibilityAccessFlag(setter));
+                (setter == null ? 0 : getVisibilityAccessFlag(setter));
         }
         return flag;
     }
 
     @NotNull
     private MemberDescriptor accessibleDescriptorIfNeeded(CallableMemberDescriptor descriptor, boolean fromOutsideContext) {
-        int flag = getAccessFlags(descriptor);
-        if ((flag & ACC_PRIVATE) == 0) {
+        CallableMemberDescriptor unwrappedDescriptor = DescriptorUtils.unwrapFakeOverride(descriptor);
+        int flag = getAccessFlags(unwrappedDescriptor);
+        if ((flag & ACC_PRIVATE) == 0 && (flag & ACC_PROTECTED) == 0) {
             return descriptor;
         }
 
@@ -437,7 +440,24 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
             }
         }
 
-        return (MemberDescriptor) (descriptorContext != null ? descriptorContext.getAccessor(descriptor) : descriptor);
+        if (descriptorContext == null) {
+            return descriptor;
+        }
+
+        if ((flag & ACC_PROTECTED) != 0) {
+            PackageFragmentDescriptor unwrappedDescriptorPackage =
+                    DescriptorUtils.getParentOfType(unwrappedDescriptor, PackageFragmentDescriptor.class, false);
+            PackageFragmentDescriptor contextDescriptorPackage =
+                    DescriptorUtils.getParentOfType(descriptorContext.getContextDescriptor(), PackageFragmentDescriptor.class, false);
+
+            boolean inSamePackage = contextDescriptorPackage != null && unwrappedDescriptorPackage != null &&
+                                    unwrappedDescriptorPackage.getFqName().equals(contextDescriptorPackage.getFqName());
+            if (inSamePackage) {
+                return descriptor;
+            }
+        }
+
+        return (MemberDescriptor) descriptorContext.getAccessor(descriptor);
     }
 
     private void addChild(@NotNull CodegenContext child) {
@@ -454,7 +474,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
         DeclarationDescriptor childContextDescriptor = child.contextDescriptor;
         if (childContextDescriptor instanceof ClassDescriptor) {
             ClassKind kind = ((ClassDescriptor) childContextDescriptor).getKind();
-            return kind == ClassKind.CLASS_OBJECT;
+                return kind == ClassKind.CLASS_OBJECT;
         }
         return false;
     }
@@ -463,4 +483,16 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     public CodegenContext findChildContext(@NotNull DeclarationDescriptor child) {
         return childContexts == null ? null : childContexts.get(child);
     }
-}
+
+    @NotNull
+    private static StackValue composedOrStatic(@NotNull StackValue prefix, @NotNull StackValue suffix) {
+        if (isStaticField(suffix)) {
+            return suffix;
+        }
+        return StackValue.composed(prefix, suffix);
+    }
+
+    private static boolean isStaticField(@NotNull StackValue value) {
+        return value instanceof StackValue.Field && ((StackValue.Field) value).isStatic;
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/context/LocalLookup.java

@@ -16,17 +16,19 @@
 
 package org.jetbrains.jet.codegen.context;
 
+import org.jetbrains.org.objectweb.asm.Type;
+import org.jetbrains.jet.codegen.CodegenUtil;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.codegen.binding.MutableClosure;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.org.objectweb.asm.Type;
 
 import static org.jetbrains.jet.codegen.AsmUtil.CAPTURED_RECEIVER_FIELD;
-import static org.jetbrains.jet.codegen.binding.CodegenBinding.asmTypeForAnonymousClass;
-import static org.jetbrains.jet.codegen.binding.CodegenBinding.isLocalNamedFun;
+import static org.jetbrains.jet.codegen.binding.CodegenBinding.*;
 
 public interface LocalLookup {
     boolean lookupLocal(DeclarationDescriptor descriptor);
@@ -86,7 +88,15 @@ public interface LocalLookup {
                 boolean idx = localLookup != null && localLookup.lookupLocal(vd);
                 if (!idx) return null;
 
-                Type localType = asmTypeForAnonymousClass(state.getBindingContext(), vd);
+                BindingContext bindingContext = state.getBindingContext();
+                Type localType = asmTypeForAnonymousClass(bindingContext, vd);
+
+                MutableClosure localFunClosure = bindingContext.get(CLOSURE, bindingContext.get(CLASS_FOR_FUNCTION, vd));
+                if (localFunClosure != null && CodegenUtil.isConst(localFunClosure)) {
+                    // This is an optimization: we can obtain an instance of a const closure simply by GETSTATIC ...$instance
+                    // (instead of passing this instance to the constructor and storing as a field)
+                    return StackValue.field(localType, localType, JvmAbi.INSTANCE_FIELD, true);
+                }
 
                 String fieldName = "$" + vd.getName();
                 StackValue innerValue = StackValue.field(localType, classType, fieldName, false);

compiler/backend/src/org/jetbrains/jet/codegen/context/ScriptContext.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.codegen.binding.MutableClosure;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 
+// SCRIPT: script as field owner context
 public class ScriptContext extends FieldOwnerContext<ClassDescriptor> {
     @NotNull
     private final ScriptDescriptor scriptDescriptor;

compiler/backend/src/org/jetbrains/jet/codegen/inline/InlineCodegenUtil.java

@@ -85,7 +85,7 @@ public class InlineCodegenUtil {
         VirtualFile file;
         DeclarationDescriptor parentDeclaration = deserializedDescriptor.getContainingDeclaration();
         if (parentDeclaration instanceof PackageFragmentDescriptor) {
-            ProtoBuf.Callable proto = deserializedDescriptor.getFunctionProto();
+            ProtoBuf.Callable proto = deserializedDescriptor.getProto();
             if (!proto.hasExtension(JavaProtoBuf.implClassName)) {
                 throw new IllegalStateException("Function in namespace should have implClassName property in proto: " + deserializedDescriptor);
             }

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java

@@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.jet.lang.resolve.CompileTimeConstantUtils;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
-import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -59,8 +59,8 @@ public class IntrinsicMethods {
     private static final EnumValueOf ENUM_VALUE_OF = new EnumValueOf();
     private static final ToString TO_STRING = new ToString();
 
-    private static final FqName KOTLIN_ANY_FQ_NAME = DescriptorUtils.getFqNameSafe(KotlinBuiltIns.getInstance().getAny());
-    private static final FqName KOTLIN_STRING_FQ_NAME = DescriptorUtils.getFqNameSafe(KotlinBuiltIns.getInstance().getString());
+    private static final FqNameUnsafe KOTLIN_ANY_FQ_NAME = DescriptorUtils.getFqName(KotlinBuiltIns.getInstance().getAny());
+    private static final FqNameUnsafe KOTLIN_STRING_FQ_NAME = DescriptorUtils.getFqName(KotlinBuiltIns.getInstance().getString());
 
     private final Map<String, IntrinsicMethod> namedMethods = new HashMap<String, IntrinsicMethod>();
     private static final IntrinsicMethod ARRAY_ITERATOR = new ArrayIterator();

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicsMap.java

@@ -32,11 +32,11 @@ import java.util.Map;
 class IntrinsicsMap {
     private static final class Key {
         private final FqNameUnsafe owner;
-        private final FqName receiverParameter;
+        private final FqNameUnsafe receiverParameter;
         private final String name;
         private final int valueParameterCount;
 
-        private Key(@NotNull FqNameUnsafe owner, @Nullable FqName receiverParameter, @NotNull String name, int valueParameterCount) {
+        private Key(@NotNull FqNameUnsafe owner, @Nullable FqNameUnsafe receiverParameter, @NotNull String name, int valueParameterCount) {
             this.owner = owner;
             this.receiverParameter = receiverParameter;
             this.name = name;
@@ -85,7 +85,7 @@ class IntrinsicsMap {
      */
     public void registerIntrinsic(
             @NotNull FqName owner,
-            @Nullable FqName receiverParameter,
+            @Nullable FqNameUnsafe receiverParameter,
             @NotNull String name,
             int valueParameterCount,
             @NotNull IntrinsicMethod impl
@@ -105,13 +105,13 @@ class IntrinsicsMap {
     }
 
     @Nullable
-    private static FqName getReceiverParameterFqName(@NotNull CallableMemberDescriptor descriptor) {
+    private static FqNameUnsafe getReceiverParameterFqName(@NotNull CallableMemberDescriptor descriptor) {
         ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
         if (receiverParameter == null) return null;
 
         ClassifierDescriptor classifier = receiverParameter.getType().getConstructor().getDeclarationDescriptor();
         if (classifier == null) return null;
 
-        return DescriptorUtils.getFqNameSafe(classifier);
+        return DescriptorUtils.getFqName(classifier);
     }
 }

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StupidSync.java

@@ -43,7 +43,7 @@ public class StupidSync extends IntrinsicMethod {
             @NotNull Type returnType,
             @Nullable PsiElement element,
             @Nullable List<JetExpression> arguments,
-            StackValue receiver
+            @Nullable StackValue receiver
     ) {
         assert element != null : "Element should not be null";
         ResolvedCall<?> resolvedCall =
@@ -51,7 +51,7 @@ public class StupidSync extends IntrinsicMethod {
 
         assert resolvedCall != null : "Resolved call for " + element.getText() + " should be not null";
 
-        codegen.pushMethodArguments(resolvedCall, Arrays.asList(OBJECT_TYPE, FUNCTION0_TYPE), codegen.defaulCallGenerator);
+        codegen.pushMethodArgumentsWithoutCallReceiver(resolvedCall, Arrays.asList(OBJECT_TYPE, FUNCTION0_TYPE), false, codegen.defaultCallGenerator);
         v.invokestatic("kotlin/jvm/internal/Intrinsics", "stupidSync", Type.getMethodDescriptor(OBJECT_TYPE, OBJECT_TYPE, FUNCTION0_TYPE));
         return OBJECT_TYPE;
     }

compiler/backend/src/org/jetbrains/jet/codegen/signature/BothSignatureWriter.java

@@ -183,8 +183,8 @@ public class BothSignatureWriter {
 
     public void writeParameterType(JvmMethodParameterKind parameterKind) {
         // This magic mimics the behavior of javac that enum constructor have these synthetic parameters in erased signature, but doesn't
-        // have them in generic signature. IDEA relies on this behavior.
-        if (parameterKind == JvmMethodParameterKind.ENUM_NAME || parameterKind == JvmMethodParameterKind.ENUM_ORDINAL) {
+        // have them in generic signature. IDEA, javac and their friends rely on this behavior.
+        if (parameterKind.isSkippedInGenericSignature()) {
             generic = true;
 
             // pushing dummy visitor, because we don't want these parameters to appear in generic JVM signature

compiler/backend/src/org/jetbrains/jet/codegen/signature/JvmMethodParameterKind.java

@@ -16,13 +16,21 @@
 
 package org.jetbrains.jet.codegen.signature;
 
+import java.util.EnumSet;
+
 public enum JvmMethodParameterKind {
     VALUE,
     THIS,
     OUTER,
     RECEIVER,
-    SHARED_VAR,
+    CAPTURED_LOCAL_VARIABLE,
     ENUM_NAME,
     ENUM_ORDINAL,
-    SUPER_CALL_PARAM
+    SUPER_OF_ANONYMOUS_CALL_PARAM;
+
+    private static final EnumSet<JvmMethodParameterKind> SKIPPED_IN_GENERIC_SIGNATURE = EnumSet.of(OUTER, ENUM_NAME, ENUM_ORDINAL);
+
+    public boolean isSkippedInGenericSignature() {
+        return SKIPPED_IN_GENERIC_SIGNATURE.contains(this);
+    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java

@@ -29,6 +29,8 @@ import org.jetbrains.jet.codegen.signature.BothSignatureWriter;
 import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind;
 import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
+import org.jetbrains.jet.config.IncrementalCompilation;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedCallableMemberDescriptor;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.jet.lang.psi.JetDelegatorToSuperCall;
@@ -126,13 +128,18 @@ public class JetTypeMapper extends BindingTraceAware {
         }
 
         // It's not a package created for Java class statics
-        JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor);
-        if (insideModule && file != null) {
-            return PackageCodegen.getPackagePartInternalName(file);
-        }
-        else {
-            return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/');
+        if (insideModule) {
+            JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor);
+            if (file != null) {
+                return PackageCodegen.getPackagePartInternalName(file);
+            }
+            if (descriptor instanceof DeserializedCallableMemberDescriptor && IncrementalCompilation.ENABLED) {
+                //
+                // TODO calls from other modules/libraries should use facade: KT-4590
+                return PackageCodegen.getPackagePartInternalName((DeserializedCallableMemberDescriptor) descriptor);
+            }
         }
+        return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/');
     }
 
     @NotNull
@@ -762,7 +769,7 @@ public class JetTypeMapper extends BindingTraceAware {
             }
 
             if (type != null) {
-                signatureWriter.writeParameterType(JvmMethodParameterKind.SHARED_VAR);
+                signatureWriter.writeParameterType(JvmMethodParameterKind.CAPTURED_LOCAL_VARIABLE);
                 signatureWriter.writeAsmType(type);
                 signatureWriter.writeParameterTypeEnd();
             }
@@ -775,7 +782,7 @@ public class JetTypeMapper extends BindingTraceAware {
 
             if (superDescriptor instanceof ConstructorDescriptor && isAnonymousObject(descriptor.getContainingDeclaration())) {
                 for (JvmMethodParameterSignature parameter : mapSignature((ConstructorDescriptor) superDescriptor).getValueParameters()) {
-                    signatureWriter.writeParameterType(JvmMethodParameterKind.SUPER_CALL_PARAM);
+                    signatureWriter.writeParameterType(JvmMethodParameterKind.SUPER_OF_ANONYMOUS_CALL_PARAM);
                     signatureWriter.writeAsmType(parameter.getAsmType());
                     signatureWriter.writeParameterTypeEnd();
                 }

compiler/builtins-serializer/src/BuiltInsSerializer.kt

@@ -40,7 +40,6 @@ import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM
 import org.jetbrains.jet.lang.resolve.BindingTraceContext
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 import org.jetbrains.jet.lang.resolve.name.FqName
-import com.intellij.util.containers.ContainerUtil
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import org.jetbrains.jet.utils.recursePostOrder
 
@@ -67,11 +66,9 @@ public class BuiltInsSerializer(val out: PrintStream?) {
 
         val environment = JetCoreEnvironment.createForTests(disposable, configuration)
 
-        val files = environment.getSourceFiles() ?: error("No source files in $sourceRoots")
+        val files = environment.getSourceFiles()
 
-        val project = environment.getProject()
-
-        val session = AnalyzerFacadeForJVM.createLazyResolveSession(project, files, BindingTraceContext(), false)
+        val session = AnalyzerFacadeForJVM.createLazyResolveSession(environment.getProject(), files, BindingTraceContext(), false)
         val module = session.getModuleDescriptor()
 
         // We don't use FileUtil because it spawns JNA initialization, which fails because we don't have (and don't want to have) its
@@ -82,8 +79,9 @@ public class BuiltInsSerializer(val out: PrintStream?) {
             System.err.println("Could not make directories: " + destDir)
         }
 
-        for (fqName in ContainerUtil.mapNotNull(files) { it?.getPackageName() }.toSet()) {
-            serializePackage(module, FqName(fqName), destDir)
+        files.map { it.getPackageFqName() }.toSet().forEach {
+            fqName ->
+            serializePackage(module, fqName, destDir)
         }
 
         out?.println("Total bytes written: $totalSize to $totalFiles files")

compiler/builtins-serializer/src/ClassSerializationUtil.kt

@@ -52,7 +52,7 @@ public object ClassSerializationUtil {
     public fun getClassId(classDescriptor: ClassDescriptor): ClassId {
         val owner = classDescriptor.getContainingDeclaration()
         if (owner is PackageFragmentDescriptor) {
-            return ClassId(owner.getFqName(), FqNameUnsafe.topLevel(classDescriptor.getName()))
+            return ClassId(owner.fqName, FqNameUnsafe.topLevel(classDescriptor.getName()))
         }
         return getClassId(owner as ClassDescriptor).createNestedClassId(classDescriptor.getName())
     }

compiler/cli/cli.iml

@@ -18,6 +18,8 @@
     <orderEntry type="module" module-name="descriptor.loader.java" />
     <orderEntry type="module" module-name="util" />
     <orderEntry type="module" module-name="backend-common" />
+    <orderEntry type="module" module-name="serialization" />
+    <orderEntry type="module" module-name="serialization.java" />
   </component>
 </module>
 

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliSourcesMemberFilter.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.cli.jvm.compiler
+
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf
+import org.jetbrains.jet.codegen.PackageCodegen.getPackagePartInternalName
+import org.jetbrains.jet.descriptors.serialization.NameResolver
+import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
+import org.jetbrains.jet.lang.resolve.java.JvmClassName
+
+public class CliSourcesMemberFilter(environment: JetCoreEnvironment): MemberFilter {
+    val packagePartClassNames = environment.getSourceFiles().map { getPackagePartInternalName(it) }.toSet()
+
+    override fun acceptPackagePartClass(container: PackageFragmentDescriptor, member: ProtoBuf.Callable, nameResolver: NameResolver): Boolean {
+        if (member.hasExtension(JavaProtoBuf.implClassName)) {
+            val shortName = nameResolver.getName(member.getExtension(JavaProtoBuf.implClassName)!!)
+            val fqName = container.fqName.child(shortName)
+            val internalName = JvmClassName.byFqNameWithoutInnerClasses(fqName).getInternalName()
+            return internalName !in packagePartClassNames
+        }
+        return true
+    }
+}

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java

@@ -74,7 +74,7 @@ public class CompileEnvironmentUtil {
             return ModuleChunk.EMPTY;
         }
         String extension = FileUtilRt.getExtension(moduleDefinitionFile);
-        if ("kts".equalsIgnoreCase(extension)) {
+        if ("ktm".equalsIgnoreCase(extension)) {
             return new ModuleChunk(loadModuleScript(paths, moduleDefinitionFile, messageCollector));
         }
         if ("xml".equalsIgnoreCase(extension)) {

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java

@@ -57,6 +57,8 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinBinaryClassCache;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
+import org.jetbrains.jet.lang.resolve.lazy.declarations.CliDeclarationProviderFactoryService;
+import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService;
 import org.jetbrains.jet.plugin.JetFileType;
 import org.jetbrains.jet.utils.PathUtil;
 
@@ -75,7 +77,10 @@ public class JetCoreEnvironment {
     private static int ourProjectCount = 0;
 
     @NotNull
-    public static JetCoreEnvironment createForProduction(@NotNull Disposable parentDisposable, @NotNull CompilerConfiguration configuration) {
+    public static JetCoreEnvironment createForProduction(
+            @NotNull Disposable parentDisposable,
+            @NotNull CompilerConfiguration configuration
+    ) {
         // JPS may run many instances of the compiler in parallel (there's an option for compiling independent modules in parallel in IntelliJ)
         // All projects share the same ApplicationEnvironment, and when the last project is disposed, the ApplicationEnvironment is disposed as well
         Disposer.register(parentDisposable, new Disposable() {
@@ -88,7 +93,8 @@ public class JetCoreEnvironment {
                 }
             }
         });
-        JetCoreEnvironment environment = new JetCoreEnvironment(parentDisposable, getOrCreateApplicationEnvironmentForProduction(), configuration);
+        JetCoreEnvironment environment =
+                new JetCoreEnvironment(parentDisposable, getOrCreateApplicationEnvironmentForProduction(), configuration);
         synchronized (APPLICATION_LOCK) {
             ourProjectCount++;
         }
@@ -138,14 +144,15 @@ public class JetCoreEnvironment {
         applicationEnvironment.registerFileType(PlainTextFileType.INSTANCE, "xml");
 
         applicationEnvironment.registerFileType(JetFileType.INSTANCE, "kt");
-        applicationEnvironment.registerFileType(JetFileType.INSTANCE, "kts");
         applicationEnvironment.registerFileType(JetFileType.INSTANCE, "ktm");
-        applicationEnvironment.registerFileType(JetFileType.INSTANCE, JetParserDefinition.KTSCRIPT_FILE_SUFFIX); // should be renamed to kts
+        applicationEnvironment.registerFileType(JetFileType.INSTANCE, JetParserDefinition.STD_SCRIPT_SUFFIX); // should be renamed to kts
         applicationEnvironment.registerParserDefinition(new JavaParserDefinition());
         applicationEnvironment.registerParserDefinition(new JetParserDefinition());
 
         applicationEnvironment.getApplication().registerService(OperationModeProvider.class, new CompilerModeProvider());
         applicationEnvironment.getApplication().registerService(KotlinBinaryClassCache.class, new KotlinBinaryClassCache());
+        applicationEnvironment.getApplication().registerService(DeclarationProviderFactoryService.class,
+                                                                new CliDeclarationProviderFactoryService());
 
         return applicationEnvironment;
     }
@@ -185,7 +192,7 @@ public class JetCoreEnvironment {
         CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClsCustomNavigationPolicy.EP_NAME,
                                                           ClsCustomNavigationPolicy.class);
         CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClassFileDecompilers.EP_NAME,
-                                                            ClassFileDecompilers.Decompiler.class);
+                                                          ClassFileDecompilers.Decompiler.class);
 
         annotationsManager = new CoreExternalAnnotationsManager(project.getComponent(PsiManager.class));
         project.registerService(ExternalAnnotationsManager.class, annotationsManager);
@@ -294,6 +301,7 @@ public class JetCoreEnvironment {
         }
     }
 
+    @NotNull
     public List<JetFile> getSourceFiles() {
         return sourceFiles;
     }

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java

@@ -42,7 +42,6 @@ import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.ScriptNameUtil;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -170,7 +169,7 @@ public class KotlinToJVMBytecodeCompiler {
                     // more than one main
                     return null;
                 }
-                FqName fqName = JetPsiUtil.getFQName(file);
+                FqName fqName = file.getPackageFqName();
                 mainClass = PackageClassUtils.getPackageClassFqName(fqName);
             }
         }
@@ -227,7 +226,7 @@ public class KotlinToJVMBytecodeCompiler {
             return null;
         }
 
-        GeneratedClassLoader classLoader = null;
+        GeneratedClassLoader classLoader;
         try {
             classLoader = new GeneratedClassLoader(state.getFactory(),
                                                    new URLClassLoader(new URL[] {
@@ -236,17 +235,12 @@ public class KotlinToJVMBytecodeCompiler {
                                                    }, AllModules.class.getClassLoader())
             );
 
-            return classLoader.loadClass(ScriptNameUtil.classNameForScript(environment.getSourceFiles().get(0)));
+            FqName nameForScript = ScriptNameUtil.classNameForScript(environment.getSourceFiles().get(0));
+            return classLoader.loadClass(nameForScript.asString());
         }
         catch (Exception e) {
             throw new RuntimeException("Failed to evaluate script: " + e, e);
         }
-        finally {
-            if (classLoader != null) {
-                classLoader.dispose();
-            }
-            state.destroy();
-        }
     }
 
     @Nullable
@@ -281,8 +275,8 @@ public class KotlinToJVMBytecodeCompiler {
                                 environment.getConfiguration().getList(JVMConfigurationKeys.SCRIPT_PARAMETERS),
                                 Predicates.<PsiFile>alwaysTrue(),
                                 false,
-                                sharedModule
-                        );
+                                sharedModule,
+                                new CliSourcesMemberFilter(environment));
                     }
                 }, environment.getSourceFiles()
         );

compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java

@@ -43,12 +43,13 @@ import org.jetbrains.jet.codegen.CompilationErrorHandler;
 import org.jetbrains.jet.codegen.KotlinCodegenFacade;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.PackageLikeBuilderDummy;
+import org.jetbrains.jet.lang.parsing.JetParserDefinition;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.psi.JetScript;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -75,9 +76,7 @@ import java.util.List;
 
 import static org.jetbrains.jet.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
 import static org.jetbrains.jet.codegen.binding.CodegenBinding.registerClassNameForScript;
-import static org.jetbrains.jet.lang.descriptors.DependencyKind.BINARIES;
-import static org.jetbrains.jet.lang.descriptors.DependencyKind.BUILT_INS;
-import static org.jetbrains.jet.lang.descriptors.DependencyKind.SOURCES;
+import static org.jetbrains.jet.lang.descriptors.DependencyKind.*;
 
 public class ReplInterpreter {
 
@@ -111,7 +110,7 @@ public class ReplInterpreter {
                 false,
                 true,
                 Collections.<AnalyzerScriptParameter>emptyList());
-        injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
+        injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module, MemberFilter.ALWAYS_TRUE);
         topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters);
         module.addFragmentProvider(SOURCES, injector.getTopDownAnalyzer().getPackageFragmentProvider());
         module.addFragmentProvider(BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
@@ -210,7 +209,7 @@ public class ReplInterpreter {
         }
         fullText.append(line);
 
-        LightVirtualFile virtualFile = new LightVirtualFile("line" + lineNumber + ".ktscript", JetLanguage.INSTANCE, fullText.toString());
+        LightVirtualFile virtualFile = new LightVirtualFile("line" + lineNumber + JetParserDefinition.STD_SCRIPT_EXT, JetLanguage.INSTANCE, fullText.toString());
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
         JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
 
@@ -362,7 +361,7 @@ public class ReplInterpreter {
         state.beforeCompile();
         KotlinCodegenFacade.generatePackage(
                 state,
-                JetPsiUtil.getFQName((JetFile) script.getContainingFile()),
+                ((JetFile) script.getContainingFile()).getPackageFqName(),
                 Collections.singleton((JetFile) script.getContainingFile()),
                 errorHandler);
     }

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
@@ -56,6 +57,7 @@ public class InjectorForJavaDescriptorResolver {
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final VirtualFileFinder virtualFileFinder;
+    private final MemberFilter memberFilter;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
@@ -84,6 +86,7 @@ public class InjectorForJavaDescriptorResolver {
         this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.memberFilter = org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter.ALWAYS_TRUE;
         this.descriptorDeserializers = new DescriptorDeserializers();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
@@ -101,10 +104,11 @@ public class InjectorForJavaDescriptorResolver {
         psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
-        deserializedDescriptorResolver.setAnnotationDeserializer(descriptorDeserializers);
+        deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
+        deserializedDescriptorResolver.setMemberFilter(memberFilter);
         deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
         descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.LazyResolveBasedCache;
@@ -73,6 +74,7 @@ public class InjectorForLazyResolveWithJava {
     private final ResolveSession resolveSession;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final VirtualFileFinder virtualFileFinder;
+    private final MemberFilter memberFilter;
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final LazyResolveBasedCache lazyResolveBasedCache;
@@ -129,6 +131,7 @@ public class InjectorForLazyResolveWithJava {
         this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.memberFilter = org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter.ALWAYS_TRUE;
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -171,7 +174,8 @@ public class InjectorForLazyResolveWithJava {
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
         annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setExpressionTypingServices(expressionTypingServices);
+        annotationResolver.setStorageManager(lockBasedStorageManager);
+        annotationResolver.setTypeResolver(typeResolver);
 
         callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);
@@ -220,10 +224,11 @@ public class InjectorForLazyResolveWithJava {
 
         jetImportsFactory.setProject(project);
 
-        deserializedDescriptorResolver.setAnnotationDeserializer(descriptorDeserializers);
+        deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
+        deserializedDescriptorResolver.setMemberFilter(memberFilter);
         deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
         descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
@@ -81,6 +82,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final TopDownAnalyzer topDownAnalyzer;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
+    private final MemberFilter memberFilter;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
@@ -128,7 +130,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         @NotNull Project project,
         @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl moduleDescriptor
+        @NotNull ModuleDescriptorImpl moduleDescriptor,
+        @NotNull MemberFilter memberFilter
     ) {
         this.project = project;
         this.globalContext = globalContext;
@@ -138,6 +141,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
+        this.memberFilter = memberFilter;
         this.javaClassFinder = new JavaClassFinderImpl();
         this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
@@ -187,6 +191,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.topDownAnalyzer.setOverloadResolver(overloadResolver);
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        this.topDownAnalyzer.setProject(project);
         this.topDownAnalyzer.setScriptHeaderResolver(scriptHeaderResolver);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
@@ -214,7 +219,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         bodyResolver.setTrace(bindingTrace);
 
         annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setExpressionTypingServices(expressionTypingServices);
+        annotationResolver.setStorageManager(storageManager);
+        annotationResolver.setTypeResolver(typeResolver);
 
         callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);
@@ -298,10 +304,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
         typeHierarchyResolver.setTrace(bindingTrace);
 
-        deserializedDescriptorResolver.setAnnotationDeserializer(descriptorDeserializers);
+        deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
+        deserializedDescriptorResolver.setMemberFilter(memberFilter);
         deserializedDescriptorResolver.setStorageManager(storageManager);
 
         descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.context.GlobalContextImpl;
+import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.di.InjectorForLazyResolveWithJava;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.DependencyKind;
@@ -37,7 +38,8 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
-import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
@@ -59,21 +61,24 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
 
     @Override
     @NotNull
-    public AnalyzeExhaust analyzeFiles(@NotNull Project project,
+    public AnalyzeExhaust analyzeFiles(
+            @NotNull Project project,
             @NotNull Collection<JetFile> files,
             @NotNull List<AnalyzerScriptParameter> scriptParameters,
-            @NotNull Predicate<PsiFile> filesToAnalyzeCompletely) {
+            @NotNull Predicate<PsiFile> filesToAnalyzeCompletely
+    ) {
         return analyzeFilesWithJavaIntegration(project, files, scriptParameters, filesToAnalyzeCompletely, true);
     }
 
     @NotNull
     @Override
-    public AnalyzeExhaust analyzeBodiesInFiles(@NotNull Project project,
-                                               @NotNull List<AnalyzerScriptParameter> scriptParameters,
-                                               @NotNull Predicate<PsiFile> filesForBodiesResolve,
-                                               @NotNull BindingTrace headersTraceContext,
-                                               @NotNull BodiesResolveContext bodiesResolveContext,
-                                               @NotNull ModuleDescriptor module
+    public AnalyzeExhaust analyzeBodiesInFiles(
+            @NotNull Project project,
+            @NotNull List<AnalyzerScriptParameter> scriptParameters,
+            @NotNull Predicate<PsiFile> filesForBodiesResolve,
+            @NotNull BindingTrace headersTraceContext,
+            @NotNull BodiesResolveContext bodiesResolveContext,
+            @NotNull ModuleDescriptor module
     ) {
         return AnalyzerFacadeForEverything.analyzeBodiesInFilesWithJavaIntegration(
                 project, scriptParameters, filesForBodiesResolve,
@@ -95,10 +100,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
     ) {
         GlobalContextImpl globalContext = ContextPackage.GlobalContext();
 
-        // TODO: Replace with stub declaration provider
-        FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
-                globalContext.getStorageManager(),
-                files);
+        DeclarationProviderFactory declarationProviderFactory =
+                DeclarationProviderFactoryService.createDeclarationProviderFactory(project, globalContext.getStorageManager(), files);
 
         InjectorForLazyResolveWithJava resolveWithJava = new InjectorForLazyResolveWithJava(
                 project,
@@ -120,7 +123,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
 
     @NotNull
     public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(
-            JetFile file, List<AnalyzerScriptParameter> scriptParameters) {
+            JetFile file, List<AnalyzerScriptParameter> scriptParameters
+    ) {
         AnalyzingUtils.checkForSyntacticErrors(file);
 
         AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file, scriptParameters);
@@ -132,7 +136,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
 
     @NotNull
     public static AnalyzeExhaust analyzeOneFileWithJavaIntegration(
-            JetFile file, List<AnalyzerScriptParameter> scriptParameters) {
+            JetFile file, List<AnalyzerScriptParameter> scriptParameters
+    ) {
         return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), scriptParameters,
                                                Predicates.<PsiFile>alwaysTrue());
     }
@@ -169,8 +174,12 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
 
     @NotNull
     public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
-            Project project, Collection<JetFile> files, List<AnalyzerScriptParameter> scriptParameters, Predicate<PsiFile> filesToAnalyzeCompletely,
-            boolean storeContextForBodiesResolve) {
+            Project project,
+            Collection<JetFile> files,
+            List<AnalyzerScriptParameter> scriptParameters,
+            Predicate<PsiFile> filesToAnalyzeCompletely,
+            boolean storeContextForBodiesResolve
+    ) {
         BindingTraceContext bindingTraceContext = new BindingTraceContext();
 
         return analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, scriptParameters, filesToAnalyzeCompletely,
@@ -187,7 +196,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             boolean storeContextForBodiesResolve
     ) {
         return analyzeFilesWithJavaIntegration(project, files, trace, scriptParameters, filesToAnalyzeCompletely,
-                                               storeContextForBodiesResolve, createJavaModule("<module>"));
+                                               storeContextForBodiesResolve, createJavaModule("<module>"), MemberFilter.ALWAYS_TRUE);
     }
 
     @NotNull
@@ -198,11 +207,12 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             List<AnalyzerScriptParameter> scriptParameters,
             Predicate<PsiFile> filesToAnalyzeCompletely,
             boolean storeContextForBodiesResolve,
-            ModuleDescriptorImpl module
+            ModuleDescriptorImpl module,
+            MemberFilter memberFilter
     ) {
         GlobalContext globalContext = ContextPackage.GlobalContext();
         return analyzeFilesWithJavaIntegrationInGlobalContext(project, files, trace, scriptParameters, filesToAnalyzeCompletely,
-                                                              storeContextForBodiesResolve, module, globalContext);
+                                                              storeContextForBodiesResolve, module, globalContext, memberFilter);
     }
 
     @NotNull
@@ -214,7 +224,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             Predicate<PsiFile> filesToAnalyzeCompletely,
             boolean storeContextForBodiesResolve,
             ModuleDescriptorImpl module,
-            GlobalContext globalContext
+            GlobalContext globalContext,
+            MemberFilter memberFilter
     ) {
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 globalContext.getStorageManager(),
@@ -225,7 +236,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                 scriptParameters
         );
 
-        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
+        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module,
+                                                                                         memberFilter);
         try {
             module.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
             TopDownAnalysisContext topDownAnalysisContext = injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetFilesProvider.java

@@ -25,7 +25,6 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.util.Collection;
@@ -53,12 +52,12 @@ public abstract class JetFilesProvider {
         private final FqName name;
 
         public SameJetFilePredicate(JetFile file) {
-            this.name = JetPsiUtil.getFQName(file);
+            this.name = file.getPackageFqName();
         }
 
         @Override
         public boolean apply(PsiFile psiFile) {
-            return JetPsiUtil.getFQName((JetFile) psiFile).equals(name);
+            return ((JetFile) psiFile).getPackageFqName().equals(name);
         }
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java

@@ -207,6 +207,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
 
             altParamDescriptors.add(new ValueParameterDescriptorImpl(
                     originalParameterDescriptor.getContainingDeclaration(),
+                    null,
                     originalParameterDescriptor.getIndex(),
                     originalParameterDescriptor.getAnnotations(),
                     altName != null ? altName : originalParameterDescriptor.getName(),

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java

@@ -222,6 +222,7 @@ public class SignaturesPropagationData {
 
                 resultParameters.add(new ValueParameterDescriptorImpl(
                         originalParam.getContainingDeclaration(),
+                        null,
                         shouldBeExtension ? originalIndex - 1 : originalIndex,
                         originalParam.getAnnotations(),
                         stableName != null ? stableName : originalParam.getName(),

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java

@@ -76,7 +76,9 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
             throw new AlternativeSignatureMismatchException("Auto type '%s' is not-null, while type in alternative signature is nullable: '%s'",
                  DescriptorRenderer.TEXT.renderType(originalType), nullableType.getText());
         }
-        return TypeUtils.makeNullable(computeType(nullableType.getInnerType(), originalType, originalToAltTypeParameters, typeUsage));
+        JetTypeElement innerType = nullableType.getInnerType();
+        assert innerType != null : "Syntax error: " + nullableType.getText();
+        return TypeUtils.makeNullable(computeType(innerType, originalType, originalToAltTypeParameters, typeUsage));
     }
 
     @Override

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/LazyResolveBasedCache.kt

@@ -58,7 +58,7 @@ public class LazyResolveBasedCache() : JavaResolverCache {
         return resolveSession.findInPackageFragments(fqName) { packageFragmentDescriptor ->
             ResolveSessionUtils.findByQualifiedName(
                     packageFragmentDescriptor.getMemberScope(),
-                    fqName.tail(packageFragmentDescriptor.getFqName()))
+                    fqName.tail(packageFragmentDescriptor.fqName))
         }
     }
 

compiler/frontend/serialization/serialization.iml

@@ -10,7 +10,6 @@
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" exported="" name="protobuf-java" level="project" />
     <orderEntry type="library" name="trove4j" level="project" />
-    <orderEntry type="library" name="intellij-core" level="project" />
     <orderEntry type="module" module-name="util.runtime" exported="" />
     <orderEntry type="module" module-name="descriptors" exported="" />
   </component>

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java

@@ -46,12 +46,12 @@ public class DescriptorDeserializer {
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull NameResolver nameResolver,
             @NotNull DescriptorFinder descriptorFinder,
-            @NotNull Deserializers annotationDeserializer
+            @NotNull Deserializers deserializers
     ) {
         return new DescriptorDeserializer(storageManager,
                 new TypeDeserializer(storageManager, null, nameResolver, descriptorFinder,
                                      "Deserializer for " + containingDeclaration.getName(), NONE),
-                containingDeclaration, nameResolver, annotationDeserializer);
+                containingDeclaration, nameResolver, deserializers);
     }
 
     @NotNull
@@ -60,9 +60,9 @@ public class DescriptorDeserializer {
             @NotNull TypeDeserializer typeDeserializer,
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull NameResolver nameResolver,
-            @NotNull Deserializers annotationDeserializer
+            @NotNull Deserializers deserializers
     ) {
-        return new DescriptorDeserializer(storageManager, typeDeserializer, containingDeclaration, nameResolver, annotationDeserializer);
+        return new DescriptorDeserializer(storageManager, typeDeserializer, containingDeclaration, nameResolver, deserializers);
     }
 
     private final DeclarationDescriptor containingDeclaration;
@@ -136,14 +136,17 @@ public class DescriptorDeserializer {
     private PropertyDescriptor loadProperty(@NotNull final Callable proto) {
         final int flags = proto.getFlags();
 
-        PropertyDescriptorImpl property = new PropertyDescriptorImpl(
+        DeserializedPropertyDescriptor property = new DeserializedPropertyDescriptor(
                 containingDeclaration,
+                null,
                 getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY),
                 modality(Flags.MODALITY.get(flags)),
                 visibility(Flags.VISIBILITY.get(flags)),
                 Flags.CALLABLE_KIND.get(flags) == Callable.CallableKind.VAR,
                 nameResolver.getName(proto.getName()),
-                memberKind(Flags.MEMBER_KIND.get(flags))
+                memberKind(Flags.MEMBER_KIND.get(flags)),
+                proto,
+                nameResolver
         );
 
         List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(proto.getTypeParameterCount());
@@ -162,11 +165,11 @@ public class DescriptorDeserializer {
             int getterFlags = proto.getGetterFlags();
             boolean isNotDefault = proto.hasGetterFlags() && Flags.IS_NOT_DEFAULT.get(getterFlags);
             if (isNotDefault) {
-                getter = new PropertyGetterDescriptorImpl(
-                        property, getAnnotations(proto, getterFlags, AnnotatedCallableKind.PROPERTY_GETTER),
-                        modality(Flags.MODALITY.get(getterFlags)), visibility(Flags.VISIBILITY.get(getterFlags)),
-                        isNotDefault, !isNotDefault, property.getKind()
-                );
+                getter = new PropertyGetterDescriptorImpl(property,
+                                                          getAnnotations(proto, getterFlags, AnnotatedCallableKind.PROPERTY_GETTER),
+                                                          modality(Flags.MODALITY.get(getterFlags)),
+                                                          visibility(Flags.VISIBILITY.get(getterFlags)), isNotDefault, !isNotDefault,
+                                                          property.getKind(), null);
             }
             else {
                 getter = DescriptorFactory.createDefaultGetter(property);
@@ -178,11 +181,11 @@ public class DescriptorDeserializer {
             int setterFlags = proto.getSetterFlags();
             boolean isNotDefault = proto.hasSetterFlags() && Flags.IS_NOT_DEFAULT.get(setterFlags);
             if (isNotDefault) {
-                setter = new PropertySetterDescriptorImpl(
-                        property, getAnnotations(proto, setterFlags, AnnotatedCallableKind.PROPERTY_SETTER),
-                        modality(Flags.MODALITY.get(setterFlags)), visibility(Flags.VISIBILITY.get(setterFlags)),
-                        isNotDefault, !isNotDefault, property.getKind()
-                );
+                setter = new PropertySetterDescriptorImpl(property,
+                                                          getAnnotations(proto, setterFlags, AnnotatedCallableKind.PROPERTY_SETTER),
+                                                          modality(Flags.MODALITY.get(setterFlags)),
+                                                          visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault, !isNotDefault,
+                                                          property.getKind(), null);
                 DescriptorDeserializer setterLocal = local.createChildDeserializer(setter, Collections.<TypeParameter>emptyList(),
                                                                                    Collections.<TypeParameterDescriptor>emptyList());
                 List<ValueParameterDescriptor> valueParameters = setterLocal.valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER);
@@ -219,7 +222,7 @@ public class DescriptorDeserializer {
     @NotNull
     private CallableMemberDescriptor loadFunction(@NotNull Callable proto) {
         int flags = proto.getFlags();
-        DeserializedSimpleFunctionDescriptor function = new DeserializedSimpleFunctionDescriptor(
+        DeserializedSimpleFunctionDescriptor function = DeserializedSimpleFunctionDescriptor.create(
                 containingDeclaration, proto,
                 deserializers,
                 nameResolver
@@ -247,7 +250,7 @@ public class DescriptorDeserializer {
     @NotNull
     private CallableMemberDescriptor loadConstructor(@NotNull Callable proto) {
         ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
-        ConstructorDescriptorImpl descriptor = new ConstructorDescriptorImpl(
+        ConstructorDescriptorImpl descriptor = ConstructorDescriptorImpl.create(
                 classDescriptor,
                 getAnnotations(proto, proto.getFlags(), AnnotatedCallableKind.FUNCTION),
                 // TODO: primary
@@ -398,6 +401,7 @@ public class DescriptorDeserializer {
             Callable.ValueParameter proto = protos.get(i);
             result.add(new ValueParameterDescriptorImpl(
                     containingDeclaration,
+                    null,
                     i,
                     getAnnotations(classOrPackage, callable, kind, proto),
                     nameResolver.getName(proto.getName()),

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java

@@ -16,12 +16,10 @@
 
 package org.jetbrains.jet.descriptors.serialization;
 
-import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
 import org.jetbrains.jet.lang.resolve.DescriptorFactory;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
 import org.jetbrains.jet.lang.types.TypeProjection;
@@ -400,7 +398,7 @@ public class DescriptorSerializer {
     public ProtoBuf.Package.Builder packageProto(@NotNull Collection<PackageFragmentDescriptor> fragments) {
         ProtoBuf.Package.Builder builder = ProtoBuf.Package.newBuilder();
 
-        Collection<DeclarationDescriptor> members = Lists.newArrayList();
+        Collection<DeclarationDescriptor> members = new ArrayList<DeclarationDescriptor>();
         for (PackageFragmentDescriptor fragment : fragments) {
             members.addAll(fragment.getMemberScope().getAllDescriptors());
         }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedCallableMemberDescriptor.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.descriptors.serialization.descriptors
+
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf
+import org.jetbrains.jet.descriptors.serialization.NameResolver
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor
+
+public trait DeserializedCallableMemberDescriptor: CallableMemberDescriptor {
+    public val proto: ProtoBuf.Callable
+    public val nameResolver: NameResolver
+}

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java

@@ -60,11 +60,11 @@ public abstract class DeserializedMemberScope implements JetScope {
     private final MemoizedFunctionToNotNull<Name, Collection<VariableDescriptor>> properties;
     private final NotNullLazyValue<Collection<DeclarationDescriptor>> allDescriptors;
 
-    public DeserializedMemberScope(
+    protected DeserializedMemberScope(
             @NotNull StorageManager storageManager,
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull DescriptorDeserializer deserializer,
-            @NotNull List<ProtoBuf.Callable> membersList
+            @NotNull Collection<ProtoBuf.Callable> membersList
     ) {
         this.containingDeclaration = containingDeclaration;
         this.deserializer = deserializer;
@@ -245,4 +245,4 @@ public abstract class DeserializedMemberScope implements JetScope {
         p.popIndent();
         p.println("}");
     }
-}
+}

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java

@@ -19,13 +19,18 @@ package org.jetbrains.jet.descriptors.serialization.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.storage.StorageManager;
 
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
 
 public class DeserializedPackageMemberScope extends DeserializedMemberScope {
     private final DescriptorFinder descriptorFinder;
@@ -36,13 +41,14 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
             @NotNull StorageManager storageManager,
             @NotNull PackageFragmentDescriptor packageDescriptor,
             @NotNull Deserializers deserializers,
+            @NotNull MemberFilter memberFilter,
             @NotNull DescriptorFinder descriptorFinder,
             @NotNull ProtoBuf.Package proto,
             @NotNull NameResolver nameResolver
     ) {
         super(storageManager, packageDescriptor,
               DescriptorDeserializer.create(storageManager, packageDescriptor, nameResolver, descriptorFinder, deserializers),
-              proto.getMemberList());
+              getFilteredMembers(packageDescriptor, proto, memberFilter, nameResolver));
         this.descriptorFinder = descriptorFinder;
         this.packageFqName = packageDescriptor.getFqName();
     }
@@ -51,10 +57,11 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
             @NotNull StorageManager storageManager,
             @NotNull PackageFragmentDescriptor packageDescriptor,
             @NotNull Deserializers deserializers,
+            @NotNull MemberFilter memberFilter,
             @NotNull DescriptorFinder descriptorFinder,
             @NotNull PackageData packageData
     ) {
-        this(storageManager, packageDescriptor, deserializers, descriptorFinder, packageData.getPackageProto(),
+        this(storageManager, packageDescriptor, deserializers, memberFilter, descriptorFinder, packageData.getPackageProto(),
              packageData.getNameResolver());
     }
 
@@ -85,4 +92,20 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
     protected ReceiverParameterDescriptor getImplicitReceiver() {
         return null;
     }
+
+    @NotNull
+    private static Collection<ProtoBuf.Callable> getFilteredMembers(
+            @NotNull PackageFragmentDescriptor packageDescriptor,
+            @NotNull ProtoBuf.Package packageProto,
+            @NotNull MemberFilter memberFilter,
+            @NotNull NameResolver nameResolver
+    ) {
+        List<ProtoBuf.Callable> result = new ArrayList<ProtoBuf.Callable>();
+        for (ProtoBuf.Callable member : packageProto.getMemberList()) {
+            if (memberFilter.acceptPackagePartClass(packageDescriptor, member, nameResolver)) {
+                result.add(member);
+            }
+        }
+        return result;
+    }
 }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPropertyDescriptor.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.descriptors.serialization.descriptors
+
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import org.jetbrains.jet.lang.descriptors.Modality
+import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations
+import org.jetbrains.jet.lang.descriptors.Visibility
+import org.jetbrains.jet.descriptors.serialization.NameResolver
+import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind
+
+public class DeserializedPropertyDescriptor(
+        containingDeclaration: DeclarationDescriptor,
+        original: PropertyDescriptor?,
+        annotations: Annotations,
+        modality: Modality,
+        visibility: Visibility,
+        isVar: Boolean,
+        name: Name,
+        kind: Kind,
+        override public val proto: ProtoBuf.Callable,
+        override public val nameResolver: NameResolver
+) : DeserializedCallableMemberDescriptor,
+    PropertyDescriptorImpl(containingDeclaration, original, annotations, modality, visibility, isVar, name, kind) {
+
+    override fun createSubstitutedCopy(
+            newOwner: DeclarationDescriptor,
+            newModality: Modality,
+            newVisibility: Visibility,
+            original: PropertyDescriptor?,
+            kind: Kind
+    ): PropertyDescriptorImpl {
+        return DeserializedPropertyDescriptor(
+                newOwner, original, getAnnotations(), newModality, newVisibility, isVar(), getName(), kind, proto, nameResolver)
+    }
+}

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java

@@ -17,87 +17,53 @@
 package org.jetbrains.jet.descriptors.serialization.descriptors;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer;
 import org.jetbrains.jet.descriptors.serialization.Flags;
 import org.jetbrains.jet.descriptors.serialization.NameResolver;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescriptorImpl {
+public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescriptorImpl implements DeserializedCallableMemberDescriptor {
 
-    private final ProtoBuf.Callable functionProto;
+    private final ProtoBuf.Callable proto;
     private final NameResolver nameResolver;
 
     private DeserializedSimpleFunctionDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
+            @Nullable SimpleFunctionDescriptor original,
             @NotNull Annotations annotations,
             @NotNull Name name,
             @NotNull Kind kind,
-            @NotNull ProtoBuf.Callable functionProto,
-            @NotNull NameResolver nameResolver
-    ) {
-        super(containingDeclaration, annotations, name, kind);
-        this.functionProto = functionProto;
-        this.nameResolver = nameResolver;
-    }
-
-    private DeserializedSimpleFunctionDescriptor(
-            @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull SimpleFunctionDescriptor original,
-            @NotNull Annotations annotations,
-            @NotNull Name name,
-            @NotNull Kind kind,
-            @NotNull ProtoBuf.Callable functionProto,
+            @NotNull ProtoBuf.Callable proto,
             @NotNull NameResolver nameResolver) {
         super(containingDeclaration, original, annotations, name, kind);
-        this.functionProto = functionProto;
+        this.proto = proto;
         this.nameResolver = nameResolver;
     }
 
-    public DeserializedSimpleFunctionDescriptor(
-            @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull ProtoBuf.Callable functionProto,
-            @NotNull Deserializers deserializers,
-            @NotNull NameResolver nameResolver
-    ) {
-        this(containingDeclaration,
-             DescriptorDeserializer.getAnnotations(containingDeclaration, functionProto, functionProto.getFlags(),
-                                                   Deserializers.AnnotatedCallableKind.FUNCTION, deserializers.getAnnotationDeserializer(),
-                                                   nameResolver),
-             nameResolver.getName(functionProto.getName()),
-             DescriptorDeserializer.memberKind(Flags.MEMBER_KIND.get(functionProto.getFlags())),
-             functionProto,
-             nameResolver);
-    }
-
+    @NotNull
     @Override
-    protected FunctionDescriptorImpl createSubstitutedCopy(DeclarationDescriptor newOwner, boolean preserveOriginal, Kind kind) {
-        if (preserveOriginal) {
-            return new DeserializedSimpleFunctionDescriptor(
-                    newOwner,
-                    getOriginal(),
-                    getAnnotations(),
-                    getName(),
-                    kind,
-                    functionProto,
-                    nameResolver
-            );
-        }
-        else {
-            return new DeserializedSimpleFunctionDescriptor(
-                    newOwner,
-                    getAnnotations(),
-                    getName(),
-                    kind,
-                    functionProto,
-                    nameResolver
-            );
-        }
+    protected FunctionDescriptorImpl createSubstitutedCopy(
+            @NotNull DeclarationDescriptor newOwner,
+            @Nullable FunctionDescriptor original,
+            @NotNull Kind kind
+    ) {
+        return new DeserializedSimpleFunctionDescriptor(
+                newOwner,
+                (DeserializedSimpleFunctionDescriptor) original,
+                getAnnotations(),
+                getName(),
+                kind,
+                proto,
+                nameResolver
+        );
     }
 
     @NotNull
@@ -106,11 +72,35 @@ public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescript
         return (DeserializedSimpleFunctionDescriptor) super.getOriginal();
     }
 
-    public ProtoBuf.Callable getFunctionProto() {
-        return functionProto;
+    @NotNull
+    @Override
+    public ProtoBuf.Callable getProto() {
+        return proto;
     }
 
+    @NotNull
+    @Override
     public NameResolver getNameResolver() {
         return nameResolver;
     }
+
+    public static DeserializedSimpleFunctionDescriptor create(
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull ProtoBuf.Callable proto,
+            @NotNull Deserializers deserializers,
+            @NotNull NameResolver nameResolver
+    ) {
+        Annotations annotations = DescriptorDeserializer.getAnnotations(containingDeclaration, proto, proto.getFlags(),
+                                                                        Deserializers.AnnotatedCallableKind.FUNCTION,
+                                                                        deserializers.getAnnotationDeserializer(),
+                                                                        nameResolver);
+        return new DeserializedSimpleFunctionDescriptor(
+                containingDeclaration,
+                null,
+                annotations,
+                nameResolver.getName(proto.getName()),
+                DescriptorDeserializer.memberKind(Flags.MEMBER_KIND.get(proto.getFlags())),
+                proto,
+                nameResolver);
+    }
 }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/MemberFilter.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.descriptors.serialization.descriptors
+
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf
+import org.jetbrains.jet.descriptors.serialization.NameResolver
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
+
+public trait MemberFilter {
+    fun acceptPackagePartClass(container: PackageFragmentDescriptor, member: ProtoBuf.Callable, nameResolver: NameResolver): Boolean
+
+    class object {
+        public val ALWAYS_TRUE: MemberFilter = object : MemberFilter {
+            override fun acceptPackagePartClass(container: PackageFragmentDescriptor, member: ProtoBuf.Callable, nameResolver: NameResolver): Boolean = true
+        }
+    }
+}

compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java

@@ -50,7 +50,7 @@ public interface JetNodeTypes {
     IElementType VALUE_PARAMETER_LIST               = JetStubElementTypes.VALUE_PARAMETER_LIST;
     IElementType VALUE_PARAMETER                    = JetStubElementTypes.VALUE_PARAMETER;
 
-    JetNodeType CLASS_BODY                          = new JetNodeType("CLASS_BODY", JetClassBody.class);
+    IElementType CLASS_BODY                         = JetStubElementTypes.CLASS_BODY;
     JetNodeType IMPORT_LIST                         = new JetNodeType("IMPORT_LIST", JetImportList.class);
     JetNodeType IMPORT_DIRECTIVE                    = new JetNodeType("IMPORT_DIRECTIVE", JetImportDirective.class);
     JetNodeType MODIFIER_LIST                       = new JetNodeType("MODIFIER_LIST", JetModifierList.class);
@@ -108,7 +108,6 @@ public interface JetNodeTypes {
     JetNodeType FOR                       = new JetNodeType("FOR", JetForExpression.class);
     JetNodeType WHILE                     = new JetNodeType("WHILE", JetWhileExpression.class);
     JetNodeType DO_WHILE                  = new JetNodeType("DO_WHILE", JetDoWhileExpression.class);
-    JetNodeType LOOP_PARAMETER            = new JetNodeType("LOOP_PARAMETER", JetParameter.class); // TODO: Do we need separate type?
     JetNodeType LOOP_RANGE                = new JetNodeType("LOOP_RANGE", JetContainerNode.class);
     JetNodeType BODY                      = new JetNodeType("BODY", JetContainerNode.class);
     JetNodeType BLOCK                     = new JetNodeType("BLOCK", JetBlockExpression.class);
@@ -147,6 +146,8 @@ public interface JetNodeTypes {
     JetNodeType WHEN_CONDITION_EXPRESSION = new JetNodeType("WHEN_CONDITION_WITH_EXPRESSION", JetWhenConditionWithExpression.class);
 
     JetNodeType PACKAGE_DIRECTIVE = new JetNodeType("PACKAGE_DIRECTIVE", JetPackageDirective.class);
+
+    // SCRIPT: script node type
     JetNodeType SCRIPT = new JetNodeType("SCRIPT", JetScript.class);
 
     IFileElementType TYPE_CODE_FRAGMENT = new JetTypeCodeFragmentType();

compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java

@@ -120,7 +120,8 @@ public class InjectorForBodyResolve {
         this.bodyResolver.setTrace(bindingTrace);
 
         annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setExpressionTypingServices(expressionTypingServices);
+        annotationResolver.setStorageManager(storageManager);
+        annotationResolver.setTypeResolver(typeResolver);
 
         callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java

@@ -115,7 +115,8 @@ public class InjectorForLazyResolve {
         this.resolveSession.setTypeResolver(typeResolver);
 
         annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setExpressionTypingServices(expressionTypingServices);
+        annotationResolver.setStorageManager(lockBasedStorageManager);
+        annotationResolver.setTypeResolver(typeResolver);
 
         callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java

@@ -21,14 +21,12 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents;
+import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
-import org.jetbrains.jet.lang.resolve.calls.CallResolver;
-import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
-import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver;
@@ -36,6 +34,8 @@ import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
 import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.jet.lang.types.expressions.ForLoopConventionsChecker;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
+import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -48,14 +48,12 @@ public class InjectorForMacros {
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final ExpressionTypingServices expressionTypingServices;
     private final ExpressionTypingComponents expressionTypingComponents;
+    private final CallResolver callResolver;
     private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
     private final TypeResolver typeResolver;
     private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final CandidateResolver candidateResolver;
     private final CallExpressionResolver callExpressionResolver;
     private final DescriptorResolver descriptorResolver;
     private final DelegatedPropertyResolver delegatedPropertyResolver;
@@ -63,6 +61,8 @@ public class InjectorForMacros {
     private final ControlStructureTypingUtils controlStructureTypingUtils;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
+    private final ArgumentTypeResolver argumentTypeResolver;
+    private final CandidateResolver candidateResolver;
     
     public InjectorForMacros(
         @NotNull Project project,
@@ -73,21 +73,21 @@ public class InjectorForMacros {
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.expressionTypingComponents = new ExpressionTypingComponents();
         this.expressionTypingServices = new ExpressionTypingServices(getExpressionTypingComponents());
+        this.callResolver = new CallResolver();
         this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext();
         this.storageManager = globalContext.getStorageManager();
         this.annotationResolver = new AnnotationResolver();
-        this.callResolver = new CallResolver();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.candidateResolver = new CandidateResolver();
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
         this.delegatedPropertyResolver = new DelegatedPropertyResolver();
         this.callResolverExtensionProvider = new CallResolverExtensionProvider();
         this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices());
-        this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), callResolver);
+        this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), getCallResolver());
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
+        this.candidateResolver = new CandidateResolver();
 
         this.expressionTypingServices.setAnnotationResolver(annotationResolver);
         this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
@@ -105,23 +105,19 @@ public class InjectorForMacros {
         this.expressionTypingComponents.setGlobalContext(globalContext);
         this.expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
 
+        this.callResolver.setArgumentTypeResolver(argumentTypeResolver);
+        this.callResolver.setCandidateResolver(candidateResolver);
+        this.callResolver.setExpressionTypingServices(expressionTypingServices);
+        this.callResolver.setTypeResolver(typeResolver);
+
         annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setExpressionTypingServices(expressionTypingServices);
-
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
+        annotationResolver.setStorageManager(storageManager);
+        annotationResolver.setTypeResolver(typeResolver);
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setModuleDescriptor(moduleDescriptor);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
         callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
 
         descriptorResolver.setAnnotationResolver(annotationResolver);
@@ -137,6 +133,11 @@ public class InjectorForMacros {
         forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
         forLoopConventionsChecker.setProject(project);
 
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setTypeResolver(typeResolver);
+
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
+
     }
     
     @PreDestroy
@@ -151,4 +152,8 @@ public class InjectorForMacros {
         return this.expressionTypingComponents;
     }
     
+    public CallResolver getCallResolver() {
+        return this.callResolver;
+    }
+    
 }

compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java

@@ -145,6 +145,7 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalyzer.setOverloadResolver(overloadResolver);
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        this.topDownAnalyzer.setProject(project);
         this.topDownAnalyzer.setScriptHeaderResolver(scriptHeaderResolver);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
@@ -160,7 +161,8 @@ public class InjectorForTopDownAnalyzerBasic {
         bodyResolver.setTrace(bindingTrace);
 
         annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setExpressionTypingServices(expressionTypingServices);
+        annotationResolver.setStorageManager(storageManager);
+        annotationResolver.setTypeResolver(typeResolver);
 
         callResolver.setArgumentTypeResolver(argumentTypeResolver);
         callResolver.setCandidateResolver(candidateResolver);

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java

@@ -31,6 +31,7 @@ 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.CompileTimeConstantUtils;
+import org.jetbrains.jet.lang.resolve.calls.model.DottedCallInfo;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall;
@@ -784,6 +785,11 @@ public class JetControlFlowProcessor {
 
             generateInstructions(selectorExpression, NOT_IN_CONDITION);
 
+            DottedCallInfo dottedCallInfo = trace.get(BindingContext.DOTTED_CALL_INFO, selectorExpression);
+            if (dottedCallInfo != null) {
+                generateInstructions((JetCallExpression) dottedCallInfo.getCall().getCallElement(), NOT_IN_CONDITION);
+            }
+
             // receiver was generated for resolvedCall
             JetExpression calleeExpression = JetPsiUtil.getCalleeExpressionIfAny(selectorExpression);
             if (calleeExpression == null || getResolvedCall(calleeExpression) == null) {

compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt

@@ -16,14 +16,12 @@
 
 package org.jetbrains.jet.lang.evaluate
 
-import com.intellij.psi.tree.IElementType
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptorImpl
 import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.psi.*
 import org.jetbrains.jet.lang.resolve.*
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall
 import org.jetbrains.jet.lang.resolve.constants.*
-import org.jetbrains.jet.lang.resolve.name.Name
 import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
@@ -36,7 +34,6 @@ import java.math.BigInteger
 import org.jetbrains.jet.lang.diagnostics.Errors
 import com.intellij.psi.util.PsiTreeUtil
 
-[suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE")]
 public class ConstantExpressionEvaluator private (val trace: BindingTrace) : JetVisitor<CompileTimeConstant<*>, JetType>() {
 
     class object {
@@ -166,16 +163,15 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
             return createCompileTimeConstant(result, expectedType)
         }
         else {
-            return evaluateCall(expression, expression.getOperationReference(), leftExpression, expectedType)
+            return evaluateCall(expression.getOperationReference(), leftExpression, expectedType)
         }
     }
 
-    private fun evaluateCall(fullExpression: JetExpression, callExpression: JetExpression, receiverExpression: JetExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    private fun evaluateCall(callExpression: JetExpression, receiverExpression: JetExpression, expectedType: JetType?): CompileTimeConstant<*>? {
         val resolvedCall = trace.getBindingContext().get(BindingContext.RESOLVED_CALL, callExpression)
         if (resolvedCall == null) return null
 
-        val resultingDescriptorName = resolvedCall.getResultingDescriptor()?.getName()
-        if (resultingDescriptorName == null) return null
+        val resultingDescriptorName = resolvedCall.getResultingDescriptor().getName()
 
         val argumentForReceiver = createOperationArgumentForReceiver(resolvedCall, receiverExpression)
         if (argumentForReceiver == null) return null
@@ -285,7 +281,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
         val leftExpression = expression.getBaseExpression()
         if (leftExpression == null) return null
 
-        return evaluateCall(expression, expression.getOperationReference(), leftExpression, expectedType)
+        return evaluateCall(expression.getOperationReference(), leftExpression, expectedType)
     }
 
     override fun visitSimpleNameExpression(expression: JetSimpleNameExpression, expectedType: JetType?): CompileTimeConstant<*>? {
@@ -323,7 +319,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
             }
 
             val receiverExpression = expression.getReceiverExpression()
-            return evaluateCall(expression, calleeExpression, receiverExpression, expectedType)
+            return evaluateCall(calleeExpression, receiverExpression, expectedType)
         }
 
         // MyEnum.A, Integer.MAX_VALUE
@@ -339,7 +335,6 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
         if (call == null) return null
 
         val resultingDescriptor = call.getResultingDescriptor()
-        if (resultingDescriptor == null) return null
 
         // array()
         if (CompileTimeConstantUtils.isArrayMethodCall(call)) {
@@ -355,7 +350,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
             if (DescriptorUtils.isAnnotationClass(classDescriptor)) {
                 val descriptor = AnnotationDescriptorImpl()
                 descriptor.setAnnotationType(classDescriptor.getDefaultType())
-                AnnotationResolver.resolveAnnotationArgument(descriptor, call, trace)
+                AnnotationResolver.resolveAnnotationArguments(descriptor, call, trace)
                 return AnnotationValue(descriptor)
             }
         }

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java

@@ -1374,7 +1374,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
                 advance(); // COLON
                 myJetParsing.parseTypeRef(TokenSet.create(IN_KEYWORD));
             }
-            parameter.done(LOOP_PARAMETER);
+            parameter.done(VALUE_PARAMETER);
         }
 
         expect(IN_KEYWORD, "Expecting 'in'", TokenSet.create(LPAR, LBRACE));

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParser.java

@@ -26,7 +26,6 @@ import org.jetbrains.annotations.NotNull;
 
 public class JetParser implements PsiParser {
 
-    public static final String STD_SCRIPT_EXT = "." + JetParserDefinition.KTSCRIPT_FILE_SUFFIX;
     private final JetScriptDefinitionProvider scriptDefinitionProvider;
 
     public JetParser(Project project) {
@@ -43,7 +42,8 @@ public class JetParser implements PsiParser {
     @NotNull
     public ASTNode parse(IElementType iElementType, PsiBuilder psiBuilder, PsiFile psiFile) {
         JetParsing jetParsing = JetParsing.createForTopLevel(new SemanticWhitespaceAwarePsiBuilderImpl(psiBuilder));
-        if (scriptDefinitionProvider != null && scriptDefinitionProvider.isScript(psiFile) || psiFile.getName().endsWith(STD_SCRIPT_EXT)) {
+        if (scriptDefinitionProvider != null && scriptDefinitionProvider.isScript(psiFile)
+            || psiFile.getName().endsWith(JetParserDefinition.STD_SCRIPT_EXT)) {
             jetParsing.parseScript();
         }
         else {

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParserDefinition.java

@@ -40,7 +40,8 @@ import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.JetLanguage;
 
 public class JetParserDefinition implements ParserDefinition {
-    public static final String KTSCRIPT_FILE_SUFFIX = "ktscript";
+    public static final String STD_SCRIPT_SUFFIX = "kts";
+    public static final String STD_SCRIPT_EXT = "." + STD_SCRIPT_SUFFIX;
 
     public JetParserDefinition() {
         //todo: ApplicationManager.getApplication() is null during JetParsingTest setting up

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java

@@ -50,7 +50,8 @@ public class JetParsing extends AbstractJetParsing {
     private static final TokenSet IMPORT_RECOVERY_SET = TokenSet.create(AS_KEYWORD, DOT, EOL_OR_SEMICOLON);
     /*package*/ static final TokenSet TYPE_REF_FIRST = TokenSet.create(LBRACKET, IDENTIFIER, FUN_KEYWORD, LPAR, CAPITALIZED_THIS_KEYWORD, HASH);
     private static final TokenSet RECEIVER_TYPE_TERMINATORS = TokenSet.create(DOT, SAFE_ACCESS);
-    private static final TokenSet VALUE_PARAMETER_FIRST = TokenSet.orSet(TokenSet.create(IDENTIFIER, LBRACKET), MODIFIER_KEYWORDS);
+    private static final TokenSet VALUE_PARAMETER_FIRST =
+            TokenSet.orSet(TokenSet.create(IDENTIFIER, LBRACKET, VAL_KEYWORD, VAR_KEYWORD), MODIFIER_KEYWORDS);
 
     static JetParsing createForTopLevel(SemanticWhitespaceAwarePsiBuilder builder) {
         JetParsing jetParsing = new JetParsing(builder);

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetScriptDefinitionProvider.java

@@ -29,10 +29,10 @@ public class JetScriptDefinitionProvider {
     private final HashMap<String,JetScriptDefinition> scripts = new HashMap<String, JetScriptDefinition>();
     private final HashSet<PsiFile> scriptsFiles = new HashSet<PsiFile>();
 
-    private static final JetScriptDefinition standardScript = new JetScriptDefinition(".ktscript", Collections.<AnalyzerScriptParameter>emptyList());
+    private static final JetScriptDefinition standardScript = new JetScriptDefinition(JetParserDefinition.STD_SCRIPT_EXT, Collections.<AnalyzerScriptParameter>emptyList());
 
     public JetScriptDefinitionProvider() {
-        // .ktscript will take analyzer parameters explicitly specified on compilation
+        // .kts will take analyzer parameters explicitly specified on compilation
         addScriptDefinition(standardScript);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotationEntry.java

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
-import com.intellij.psi.stubs.IStubElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
@@ -32,12 +31,6 @@ public class JetAnnotationEntry extends JetElementImplStub<PsiJetAnnotationStub>
         super(node);
     }
 
-    @NotNull
-    @Override
-    public IStubElementType getElementType() {
-        return JetStubElementTypes.ANNOTATION_ENTRY;
-    }
-
     public JetAnnotationEntry(@NotNull PsiJetAnnotationStub stub) {
         super(stub, JetStubElementTypes.ANNOTATION_ENTRY);
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClass.java

@@ -22,7 +22,6 @@ import com.intellij.navigation.ItemPresentationProviders;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
-import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
@@ -165,12 +164,6 @@ public class JetClass extends JetTypeParameterListOwnerStub<PsiJetClassStub> imp
         return hasModifier(JetTokens.INNER_KEYWORD);
     }
 
-    @NotNull
-    @Override
-    public IStubElementType getElementType() {
-        return JetStubElementTypes.CLASS;
-    }
-
     @Override
     public void delete() throws IncorrectOperationException {
         JetPsiUtil.deleteClass(this);
@@ -205,7 +198,7 @@ public class JetClass extends JetTypeParameterListOwnerStub<PsiJetClassStub> imp
         }
         PsiFile file = getContainingFile();
         if (!(file instanceof JetFile)) return null;
-        String fileQualifiedName = ((JetFile) file).getPackageDirective().getQualifiedName();
+        String fileQualifiedName = ((JetFile) file).getPackageFqName().asString();
         if (!fileQualifiedName.isEmpty()) {
             parts.add(fileQualifiedName);
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassBody.java

@@ -18,20 +18,27 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.tree.TokenSet;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
+import org.jetbrains.jet.lang.psi.stubs.PsiJetClassBodyStub;
+import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.List;
 
-public class JetClassBody extends JetElementImpl implements JetDeclarationContainer {
+public class JetClassBody extends JetElementImplStub<PsiJetClassBodyStub> implements JetDeclarationContainer {
     public JetClassBody(@NotNull ASTNode node) {
         super(node);
     }
 
+    public JetClassBody(@NotNull PsiJetClassBodyStub stub) {
+        super(stub, JetStubElementTypes.CLASS_BODY);
+    }
+
     @Override
     @NotNull
     public List<JetDeclaration> getDeclarations() {

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetElementImplStub.java

@@ -45,7 +45,7 @@ public class JetElementImplStub<T extends StubElement> extends StubBasedPsiEleme
 
     @Override
     public String toString() {
-        return getNode().getElementType().toString();
+        return getElementType().toString();
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetEnumEntry.java

@@ -18,13 +18,11 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lang.psi.stubs.PsiJetClassStub;
-import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
@@ -55,12 +53,6 @@ public class JetEnumEntry extends JetClass {
         return nameAsDeclaration == null ? null : nameAsDeclaration.getNameIdentifier();
     }
 
-    @NotNull
-    @Override
-    public IStubElementType getElementType() {
-        return JetStubElementTypes.ENUM_ENTRY;
-    }
-
     @Override
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
         JetObjectDeclarationName nameAsDeclaration = getNameAsDeclaration();

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFile.java

@@ -25,11 +25,11 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiClassOwner;
 import com.intellij.psi.PsiElementVisitor;
 import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lang.psi.stubs.PsiJetFileStub;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.plugin.JetFileType;
 import org.jetbrains.jet.plugin.JetLanguage;
 
@@ -92,23 +92,32 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
         return null;
     }
 
-    // scripts have no package directive
+    // scripts have no package directive, all other files must have package directives
     @Nullable
     public JetPackageDirective getPackageDirective() {
         ASTNode ast = getNode().findChildByType(JetNodeTypes.PACKAGE_DIRECTIVE);
         return ast != null ? (JetPackageDirective) ast.getPsi() : null;
     }
 
+    @Deprecated // getPackageFqName should be used instead
     @Override
-    @Nullable
+    @NotNull
     public String getPackageName() {
+        return getPackageFqName().asString();
+    }
+
+    @NotNull
+    public FqName getPackageFqName() {
         PsiJetFileStub stub = (PsiJetFileStub) getStub();
         if (stub != null) {
-            return stub.getPackageName();
+            return stub.getPackageFqName();
         }
 
-        JetPackageDirective directive = getPackageDirective();
-        return directive != null ? directive.getQualifiedName() : null;
+        JetPackageDirective packageDirective = getPackageDirective();
+        if (packageDirective == null) {
+            return FqName.ROOT;
+        }
+        return packageDirective.getFqName();
     }
 
     @NotNull
@@ -120,6 +129,7 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
     @Override
     public void setPackageName(String packageName) { }
 
+    // SCRIPT: find script in file
     @Nullable
     public JetScript getScript() {
         return PsiTreeUtil.getChildOfType(this, JetScript.class);

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetForExpression.java

@@ -34,7 +34,7 @@ public class JetForExpression extends JetLoopExpression {
 
     @Nullable
     public JetParameter getLoopParameter() {
-        return (JetParameter) findChildByType(JetNodeTypes.LOOP_PARAMETER);
+        return (JetParameter) findChildByType(JetNodeTypes.VALUE_PARAMETER);
     }
 
     @Nullable

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionLiteral.java

@@ -20,6 +20,7 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lexer.JetTokens;
 
 public class JetFunctionLiteral extends JetFunctionNotStubbed {
@@ -66,4 +67,10 @@ public class JetFunctionLiteral extends JetFunctionNotStubbed {
     public ASTNode getArrowNode() {
         return getNode().findChildByType(JetTokens.ARROW);
     }
+
+    @Nullable
+    @Override
+    public FqName getFqName() {
+        return null;
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetMultiDeclarationEntry.java

@@ -21,6 +21,7 @@ import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import static org.jetbrains.jet.lexer.JetTokens.VAL_KEYWORD;
@@ -63,4 +64,10 @@ public class JetMultiDeclarationEntry extends JetNamedDeclarationNotStubbed impl
     public ASTNode getValOrVarNode() {
         return getParentNode().findChildByType(TokenSet.create(VAL_KEYWORD, VAR_KEYWORD));
     }
+
+    @Nullable
+    @Override
+    public FqName getFqName() {
+        return null;
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclaration.java

@@ -19,9 +19,12 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.psi.PsiNameIdentifierOwner;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 public interface JetNamedDeclaration extends JetDeclaration, PsiNameIdentifierOwner, JetStatementExpression, JetNamed {
     @NotNull
     Name getNameAsSafeName();
+    @Nullable
+    FqName getFqName();
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationStub.java

@@ -21,14 +21,16 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.search.LocalSearchScope;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.stubs.IStubElementType;
-import com.intellij.psi.stubs.NamedStub;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.psi.stubs.PsiJetStubWithFqName;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lexer.JetTokens;
 
-abstract class JetNamedDeclarationStub<T extends NamedStub> extends JetDeclarationStub<T> implements JetNamedDeclaration {
+abstract class JetNamedDeclarationStub<T extends PsiJetStubWithFqName> extends JetDeclarationStub<T> implements JetNamedDeclaration {
     public JetNamedDeclarationStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }
@@ -92,4 +94,14 @@ abstract class JetNamedDeclarationStub<T extends NamedStub> extends JetDeclarati
 
         return super.getUseScope();
     }
+
+    @Nullable
+    @Override
+    public FqName getFqName() {
+        T stub = getStub();
+        if (stub != null) {
+            return stub.getFqName();
+        }
+        return JetNamedDeclarationUtil.getFQName(this);
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationUtil.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.util.PsiTreeUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+public final class JetNamedDeclarationUtil {
+    @Nullable
+    public static FqNameUnsafe getUnsafeFQName(@NotNull JetNamedDeclaration namedDeclaration) {
+        FqName fqName = namedDeclaration.getFqName();
+        return fqName != null ? fqName.toUnsafe() : null;
+    }
+
+    @Nullable
+    //NOTE: use JetNamedDeclaration#getFqName instead
+    /*package private*/ static FqName getFQName(@NotNull JetNamedDeclaration namedDeclaration) {
+        Name name = namedDeclaration.getNameAsName();
+        if (name == null) {
+            return null;
+        }
+
+        FqName parentFqName = getParentFqName(namedDeclaration);
+
+        if (parentFqName == null) {
+            return null;
+        }
+
+        return parentFqName.child(name);
+    }
+
+    @Nullable
+    public static FqName getParentFqName(@NotNull JetNamedDeclaration namedDeclaration) {
+        PsiElement parent = namedDeclaration.getParent();
+        if (parent instanceof JetClassBody) {
+            // One nesting to JetClassBody doesn't affect to qualified name
+            parent = parent.getParent();
+        }
+
+        if (parent instanceof JetFile) {
+            return ((JetFile) parent).getPackageFqName();
+        }
+        else if (parent instanceof JetNamedFunction || parent instanceof JetClass) {
+            return getFQName((JetNamedDeclaration) parent);
+        }
+        else if (namedDeclaration instanceof JetParameter) {
+            JetClass constructorClass = JetPsiUtil.getClassIfParameterIsProperty((JetParameter) namedDeclaration);
+            if (constructorClass != null) {
+                return getFQName(constructorClass);
+            }
+        }
+        else if (parent instanceof JetObjectDeclaration) {
+            if (parent.getParent() instanceof JetClassObject) {
+                JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(parent, JetClassOrObject.class);
+                if (classOrObject != null) {
+                    return getFQName(classOrObject);
+                }
+            }
+            else {
+                return getFQName((JetNamedDeclaration) parent);
+            }
+        }
+        return null;
+    }
+
+    private JetNamedDeclarationUtil() {
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedFunction.java

@@ -20,7 +20,6 @@ import com.intellij.lang.ASTNode;
 import com.intellij.navigation.ItemPresentation;
 import com.intellij.navigation.ItemPresentationProviders;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
@@ -28,8 +27,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lang.psi.stubs.PsiJetFunctionStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collections;
@@ -77,41 +74,6 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<PsiJetFuncti
         return PsiTreeUtil.getNextSiblingOfType(getEqualsToken(), JetExpression.class);
     }
 
-    /**
-    * Returns full qualified name for function "package_fqn.function_name"
-    * Not null for top level functions unless syntax errors are present.
-    * @return
-    */
-    @Nullable
-    public FqName getFqName() {
-        PsiJetFunctionStub stub = getStub();
-        if (stub != null) {
-            return stub.getTopFQName();
-        }
-
-        PsiElement parent = getParent();
-        if (parent instanceof JetFile) {
-            // fqname is different in scripts
-            if (((JetFile) parent).getPackageDirective() == null) {
-                return null;
-            }
-            JetFile jetFile = (JetFile) parent;
-            FqName fileFQN = JetPsiUtil.getFQName(jetFile);
-            Name nameAsName = getNameAsName();
-            if (nameAsName != null) {
-                return fileFQN.child(nameAsName);
-            }
-        }
-
-        return null;
-    }
-
-    @NotNull
-    @Override
-    public IStubElementType getElementType() {
-        return JetStubElementTypes.FUNCTION;
-    }
-    
     @Override
     public ItemPresentation getPresentation() {
         return ItemPresentationProviders.getItemPresentation(this);

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNullableType.java

@@ -18,8 +18,10 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lexer.JetTokens;
 
+import java.util.Collections;
 import java.util.List;
 
 public class JetNullableType extends JetTypeElement {
@@ -35,7 +37,8 @@ public class JetNullableType extends JetTypeElement {
     @NotNull
     @Override
     public List<JetTypeReference> getTypeArgumentsAsTypes() {
-        return getInnerType().getTypeArgumentsAsTypes();
+        JetTypeElement innerType = getInnerType();
+        return innerType == null ? Collections.<JetTypeReference>emptyList() : innerType.getTypeArgumentsAsTypes();
     }
 
     @Override
@@ -43,7 +46,8 @@ public class JetNullableType extends JetTypeElement {
         return visitor.visitNullableType(this, data);
     }
 
-    @NotNull
+    @Nullable
+    @IfNotParsed
     public JetTypeElement getInnerType() {
         return findChildByClass(JetTypeElement.class);
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java

@@ -20,7 +20,6 @@ import com.intellij.lang.ASTNode;
 import com.intellij.navigation.ItemPresentation;
 import com.intellij.navigation.ItemPresentationProviders;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
@@ -44,12 +43,6 @@ public class JetObjectDeclaration extends JetNamedDeclarationStub<PsiJetObjectSt
         super(stub, JetStubElementTypes.OBJECT_DECLARATION);
     }
 
-    @NotNull
-    @Override
-    public IStubElementType getElementType() {
-        return JetStubElementTypes.OBJECT_DECLARATION;
-    }
-
     @Override
     public String getName() {
         PsiJetObjectStub stub = getStub();
@@ -61,19 +54,6 @@ public class JetObjectDeclaration extends JetNamedDeclarationStub<PsiJetObjectSt
         return nameAsDeclaration == null ? null : nameAsDeclaration.getName();
     }
 
-    /**
-     * Could be null for anonymous objects and object declared inside functions
-     * @return
-     */
-    public FqName getFqName() {
-        PsiJetObjectStub stub = getStub();
-        if (stub != null) {
-            return stub.getFqName();
-        }
-
-        return JetPsiUtil.getFQName(this);
-    }
-
     public boolean isTopLevel() {
         PsiJetObjectStub stub = getStub();
         if (stub != null) {

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameter.java

@@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import com.intellij.navigation.ItemPresentation;
 import com.intellij.navigation.ItemPresentationProviders;
-import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.util.ArrayFactory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -42,14 +41,8 @@ public class JetParameter extends JetNamedDeclarationStub<PsiJetParameterStub> {
         super(node);
     }
 
-    public JetParameter(@NotNull PsiJetParameterStub stub, @NotNull IStubElementType nodeType) {
-        super(stub, nodeType);
-    }
-
-    @NotNull
-    @Override
-    public IStubElementType getElementType() {
-        return JetStubElementTypes.VALUE_PARAMETER;
+    public JetParameter(@NotNull PsiJetParameterStub stub) {
+        super(stub, JetStubElementTypes.VALUE_PARAMETER);
     }
 
     @Override
@@ -108,4 +101,8 @@ public class JetParameter extends JetNamedDeclarationStub<PsiJetParameterStub> {
     public ItemPresentation getPresentation() {
         return ItemPresentationProviders.getItemPresentation(this);
     }
+
+    public boolean isLoopParameter() {
+        return getParent() instanceof JetForExpression;
+    }
 }