Don't create namespace class for file if codegen won't do so

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

@@ -28,7 +28,7 @@ public abstract class ClassBuilderOnDemand {
 
     private ClassBuilder classBuilder;
 
-    private List<ClassBuilderCallback> optionalDeclarations = Lists.newArrayList();
+    private final List<ClassBuilderCallback> optionalDeclarations = Lists.newArrayList();
 
     interface ClassBuilderCallback {
         void doSomething(@NotNull ClassBuilder classBuilder);
@@ -60,4 +60,8 @@ public abstract class ClassBuilderOnDemand {
             classBuilder.done();
         }
     }
+
+    public boolean isActivated() {
+        return classBuilder != null;
+    }
 }

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

@@ -131,8 +131,8 @@ public class GenerationState {
         return Pair.create(className, getFactory().forAnonymousSubclass(className));
     }
 
-    public NamespaceCodegen forNamespace(FqName fqName, Collection<JetFile> namespace) {
+    public NamespaceCodegen forNamespace(FqName fqName, Collection<JetFile> jetFiles) {
-        return getFactory().forNamespace(fqName, namespace);
+        return getFactory().forNamespace(fqName, jetFiles);
     }
 
     private void beforeCompile() {
@@ -181,8 +181,8 @@ public class GenerationState {
                 progress);
     }
 
-    protected void generateNamespace(FqName fqName, Collection<JetFile> namespace, CompilationErrorHandler errorHandler, Progress progress) {
+    protected void generateNamespace(FqName fqName, Collection<JetFile> jetFiles, CompilationErrorHandler errorHandler, Progress progress) {
-        NamespaceCodegen codegen = forNamespace(fqName, namespace);
+        NamespaceCodegen codegen = forNamespace(fqName, jetFiles);
         codegen.generate(errorHandler, progress);
     }
 

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

@@ -27,9 +27,9 @@ import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
 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.name.FqName;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.utils.Progress;
 import org.objectweb.asm.MethodVisitor;
@@ -120,6 +120,8 @@ public class NamespaceCodegen {
             }
         }
 
+        assert v.isActivated() == shouldGenerateNSClass(files) : "Different algorithms for generating namespace class and for heuristics";
+
         if (hasNonConstantPropertyInitializers()) {
             generateStaticInitializers();
         }
@@ -193,6 +195,18 @@ public class NamespaceCodegen {
         }
     }
 
+    public static boolean shouldGenerateNSClass(Collection<JetFile> files) {
+        for (JetFile file : files) {
+            for (JetDeclaration declaration : file.getDeclarations()) {
+                if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     private void generateStaticInitializers() {
         final JetFile namespace = files.iterator().next(); // @todo: hack
 

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JavaElementFinder.java

@@ -30,6 +30,7 @@ import com.intellij.util.SmartList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.codegen.JetTypeMapper;
+import org.jetbrains.jet.codegen.NamespaceCodegen;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.java.JavaPsiFacadeKotlinHacks;
 import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
@@ -38,10 +39,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.util.QualifiedNamesUtil;
 
-import java.util.HashSet;
+import java.util.*;
-import java.util.List;
-import java.util.Set;
-import java.util.WeakHashMap;
 
 public class JavaElementFinder extends PsiElementFinder implements JavaPsiFacadeKotlinHacks.KotlinFinderMarker {
     private final Project project;
@@ -118,7 +116,8 @@ public class JavaElementFinder extends PsiElementFinder implements JavaPsiFacade
         for (JetFile file : filesInScope) {
             final FqName packageName = JetPsiUtil.getFQName(file);
             if (packageName != null && qualifiedName.getFqName().startsWith(packageName.getFqName())) {
-                if (qualifiedName.equals(QualifiedNamesUtil.combine(packageName, Name.identifier(JvmAbi.PACKAGE_CLASS)))) {
+                if (qualifiedName.equals(QualifiedNamesUtil.combine(packageName, Name.identifier(JvmAbi.PACKAGE_CLASS))) &&
+                        NamespaceCodegen.shouldGenerateNSClass(Arrays.asList(file))) {
                     answer.add(new JetLightClass(psiManager, file, qualifiedName));
                 }
                 else {

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java

@@ -34,22 +34,19 @@ import com.intellij.psi.impl.java.stubs.PsiJavaFileStub;
 import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl;
 import com.intellij.psi.impl.light.AbstractLightClass;
 import com.intellij.psi.stubs.PsiClassHolderFileStub;
+import com.intellij.psi.stubs.PsiFileStub;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.util.*;
 import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
-import org.jetbrains.jet.codegen.ClassBuilder;
+import org.jetbrains.jet.codegen.*;
-import org.jetbrains.jet.codegen.ClassBuilderFactory;
-import org.jetbrains.jet.codegen.ClassBuilderMode;
-import org.jetbrains.jet.codegen.CompilationErrorHandler;
-import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetFunction;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
-import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.plugin.JetLanguage;
 import org.jetbrains.jet.util.QualifiedNamesUtil;
 import org.jetbrains.jet.utils.Progress;
@@ -104,9 +101,11 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
             return (PsiClass)stub.getPsi();
         }
 
-        for (StubElement child : stub.getChildrenStubs()) {
+        if (stub instanceof PsiClassStub || stub instanceof PsiFileStub) {
-            PsiClass answer = findClass(fqn, child);
+            for (StubElement child : stub.getChildrenStubs()) {
-            if (answer != null) return answer;
+                PsiClass answer = findClass(fqn, child);
+                if (answer != null) return answer;
+            }
         }
 
         return null;
@@ -205,7 +204,6 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
             }
         };
 
-
         state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
         state.getFactory().files();
 
@@ -213,13 +211,13 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
     }
 
     @Override
-    public ItemPresentation getPresentation() {
+    public boolean isEquivalentTo(PsiElement another) {
-        return ItemPresentationProviders.getItemPresentation(this);
+        return another instanceof PsiClass && Comparing.equal(((PsiClass)another).getQualifiedName(), getQualifiedName());
     }
 
     @Override
-    public boolean isEquivalentTo(PsiElement another) {
+    public ItemPresentation getPresentation() {
-        return another instanceof PsiClass && Comparing.equal(((PsiClass)another).getQualifiedName(), getQualifiedName());
+        return ItemPresentationProviders.getItemPresentation(this);
     }
 
     @Override