diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java
index 57d95ebadf3..eac2cd880fb 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java
@@ -302,7 +302,7 @@ public class PackageCodegen {
             }
             else if (declaration instanceof JetClassOrObject) {
                 JetClassOrObject classOrObject = (JetClassOrObject) declaration;
-                if (state.getGenerateDeclaredClassFilter().shouldProcessClass(classOrObject)) {
+                if (state.getGenerateDeclaredClassFilter().shouldGenerateClass(classOrObject)) {
                     generateClassOrObject(classOrObject);
                 }
             }
@@ -310,13 +310,13 @@ public class PackageCodegen {
                 JetScript script = (JetScript) declaration;
 
                // SCRIPT: generate script code, should be separate execution branch
-                if (state.getGenerateDeclaredClassFilter().shouldProcessScript(script)) {
+                if (state.getGenerateDeclaredClassFilter().shouldGenerateScript(script)) {
                     ScriptCodegen.createScriptCodegen(script, state, packagePartContext).generate();
                 }
             }
         }
 
-        if (!generatePackagePart) return null;
+        if (!generatePackagePart || !state.getGenerateDeclaredClassFilter().shouldGeneratePackagePart(file)) return null;
 
         ClassBuilder builder = state.getFactory().newVisitor(PackagePart(file, packageFragment), packagePartType, file);
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
index 2881660f6b7..8c18c194f6d 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
@@ -207,7 +207,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
     @Override
     public void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration) {
-        if (!filter.shouldProcessClass(declaration)) return;
+        if (!filter.shouldAnnotateClass(declaration)) return;
 
         ClassDescriptor classDescriptor = bindingContext.get(CLASS, declaration);
         // working around a problem with shallow analysis
@@ -225,7 +225,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
     @Override
     public void visitClass(@NotNull JetClass klass) {
-        if (!filter.shouldProcessClass(klass)) return;
+        if (!filter.shouldAnnotateClass(klass)) return;
 
         ClassDescriptor classDescriptor = bindingContext.get(CLASS, klass);
         // working around a problem with shallow analysis
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.java
index e89902f2c99..e3fdd38d09e 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.java
@@ -43,17 +43,29 @@ import java.util.List;
 
 public class GenerationState {
     public interface GenerateClassFilter {
-        boolean shouldProcessClass(JetClassOrObject classOrObject);
-        boolean shouldProcessScript(JetScript script);
+        boolean shouldAnnotateClass(JetClassOrObject classOrObject);
+        boolean shouldGenerateClass(JetClassOrObject classOrObject);
+        boolean shouldGeneratePackagePart(JetFile jetFile);
+        boolean shouldGenerateScript(JetScript script);
 
         GenerateClassFilter GENERATE_ALL = new GenerateClassFilter() {
             @Override
-            public boolean shouldProcessClass(JetClassOrObject classOrObject) {
+            public boolean shouldAnnotateClass(JetClassOrObject classOrObject) {
                 return true;
             }
 
             @Override
-            public boolean shouldProcessScript(JetScript script) {
+            public boolean shouldGenerateClass(JetClassOrObject classOrObject) {
+                return true;
+            }
+
+            @Override
+            public boolean shouldGenerateScript(JetScript script) {
+                return true;
+            }
+
+            @Override
+            public boolean shouldGeneratePackagePart(JetFile jetFile) {
                 return true;
             }
         };
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinJavaFileStubProvider.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinJavaFileStubProvider.java
index ca035e3bf93..25e836d50d0 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinJavaFileStubProvider.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinJavaFileStubProvider.java
@@ -110,15 +110,26 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                     @Override
                     public GenerationState.GenerateClassFilter getGenerateClassFilter() {
                         return new GenerationState.GenerateClassFilter() {
+
                             @Override
-                            public boolean shouldProcessClass(JetClassOrObject classOrObject) {
+                            public boolean shouldGeneratePackagePart(JetFile jetFile) {
+                                return true;
+                            }
+
+                            @Override
+                            public boolean shouldAnnotateClass(JetClassOrObject classOrObject) {
+                                return shouldGenerateClass(classOrObject);
+                            }
+
+                            @Override
+                            public boolean shouldGenerateClass(JetClassOrObject classOrObject) {
                                 // Top-level classes and such should not be generated for performance reasons.
                                 // Local classes in top-level functions must still be generated
                                 return JetPsiUtil.isLocal(classOrObject);
                             }
 
                             @Override
-                            public boolean shouldProcessScript(JetScript script) {
+                            public boolean shouldGenerateScript(JetScript script) {
                                 // Scripts yield top-level classes, and should not be generated
                                 return false;
                             }
@@ -221,8 +232,19 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                     @Override
                     public GenerationState.GenerateClassFilter getGenerateClassFilter() {
                         return new GenerationState.GenerateClassFilter() {
+
                             @Override
-                            public boolean shouldProcessClass(JetClassOrObject generatedClassOrObject) {
+                            public boolean shouldGeneratePackagePart(JetFile jetFile) {
+                                return true;
+                            }
+
+                            @Override
+                            public boolean shouldAnnotateClass(JetClassOrObject classOrObject) {
+                                return shouldGenerateClass(classOrObject);
+                            }
+
+                            @Override
+                            public boolean shouldGenerateClass(JetClassOrObject generatedClassOrObject) {
                                 // Trivial: generate and analyze class we are interested in.
                                 if (generatedClassOrObject == classOrObject) return true;
 
@@ -255,7 +277,7 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                             }
 
                             @Override
-                            public boolean shouldProcessScript(JetScript script) {
+                            public boolean shouldGenerateScript(JetScript script) {
                                 // We generate all enclosing classes
                                 return PsiTreeUtil.isAncestor(script, classOrObject, false);
                             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java b/idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java
index c8888995438..79579bce8ce 100644
--- a/idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java
+++ b/idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java
@@ -28,6 +28,7 @@ import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.wm.ToolWindow;
 import com.intellij.openapi.wm.ToolWindowFactory;
@@ -53,9 +54,7 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToDeclarationUtil;
 import org.jetbrains.kotlin.idea.util.InfinitePeriodicalTask;
 import org.jetbrains.kotlin.idea.util.LongRunningReadTask;
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
-import org.jetbrains.kotlin.psi.Call;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedSimpleFunctionDescriptor;
@@ -110,26 +109,58 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
         @NotNull
         @Override
         protected String processRequest(@NotNull Location location) {
-            JetFile jetFile = location.getJetFile();
+            final JetFile jetFile = location.getJetFile();
             assert jetFile != null;
 
             GenerationState state;
             try {
                 AnalysisResult result = ResolvePackage.analyzeFullyAndGetResult(jetFile);
                 boolean disableInline = !enableInline.isSelected();
-
+                Ref<Set<JetElement>> ref = new Ref();
                 if (!disableInline) {
-                    result = processInlinedDeclarations(jetFile.getProject(), result, Collections.<JetElement>singleton(jetFile), 1);
+                    result = processInlinedDeclarations(jetFile.getProject(), result, Collections.<JetElement>singleton(jetFile), 1, ref);
                 }
 
                 if (result.isError()) {
                     return printStackTraceToString(result.getError());
                 }
 
+                Set<JetFile> toProcess = new LinkedHashSet<JetFile>();
+                toProcess.add(jetFile);
+                if (ref.get() != null) {
+                    for (JetElement element: ref.get()) {
+                        JetFile file = element.getContainingJetFile();
+                        toProcess.add(file);
+                    }
+                }
+
+                GenerationState.GenerateClassFilter generateClassFilter = new GenerationState.GenerateClassFilter() {
+
+                    @Override
+                    public boolean shouldGeneratePackagePart(JetFile file) {
+                        return file == jetFile;
+                    }
+
+                    @Override
+                    public boolean shouldAnnotateClass(JetClassOrObject classOrObject) {
+                        return true;
+                    }
+
+                    @Override
+                    public boolean shouldGenerateClass(JetClassOrObject classOrObject) {
+                        return classOrObject.getContainingJetFile() == jetFile;
+                    }
+
+                    @Override
+                    public boolean shouldGenerateScript(JetScript script) {
+                        return script.getContainingJetFile() == jetFile;
+                    }
+                };
+
                 state = new GenerationState(jetFile.getProject(), ClassBuilderFactories.TEST, Progress.DEAF,
                                             result.getModuleDescriptor(), result.getBindingContext(),
-                                            Collections.singletonList(jetFile), !enableAssertions.isSelected(), !enableAssertions.isSelected(),
-                                            GenerationState.GenerateClassFilter.GENERATE_ALL,
+                                            new ArrayList<JetFile>(toProcess), !enableAssertions.isSelected(), !enableAssertions.isSelected(),
+                                            generateClassFilter,
                                             disableInline, !enableOptimization.isSelected(), null, null,
                                             DiagnosticSink.DO_NOTHING, null);
                 KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
@@ -154,8 +185,15 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
             return answer.toString();
         }
 
-        private AnalysisResult processInlinedDeclarations(Project project, AnalysisResult result, Set<JetElement> originalElements, int deep) {
+        private AnalysisResult processInlinedDeclarations(
+                @NotNull Project project,
+                @NotNull AnalysisResult result,
+                @NotNull Set<JetElement> originalElements,
+                int deep,
+                @NotNull Ref<Set<JetElement>> resultElements
+        ) {
             if (deep >= 10 || result.isError()) {
+                resultElements.set(originalElements);
                 return result;
             }
             Set<JetElement> collectedElements = new HashSet<JetElement>();
@@ -177,8 +215,10 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
             }
             if (collectedElements.size() != originalElements.size()) {
                 AnalysisResult newResult = KotlinCacheService.getInstance(project).getAnalysisResults(collectedElements);
-                return processInlinedDeclarations(project, newResult, collectedElements, deep + 1);
+                return processInlinedDeclarations(project, newResult, collectedElements, deep + 1, resultElements);
             }
+
+            resultElements.set(collectedElements);
             return result;
         }