Remove heuristic from PackageCodegen

Implement the logic in a more straightforward way, move the heuristic to
JavaElementFinder where it was also used

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

@@ -34,12 +34,8 @@ public class ClassBuilderOnDemand {
     }
 
     public void done() {
-        if (isActivated()) {
+        if (classBuilder.isComputed()) {
             classBuilder.invoke().done();
         }
     }
-
-    public boolean isActivated() {
-        return classBuilder.isComputed();
-    }
 }

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

@@ -186,10 +186,6 @@ public class PackageCodegen {
 
     public void generate(@NotNull CompilationErrorHandler errorHandler) {
         List<JvmSerializationBindings> bindings = new ArrayList<JvmSerializationBindings>(files.size() + 1);
-        boolean shouldGeneratePackageClass = shouldGeneratePackageClass(files);
-        if (shouldGeneratePackageClass) {
-            bindings.add(v.getClassBuilder().getSerializationBindings());
-        }
 
         Map<CallableMemberDescriptor, Runnable> generateCallableMemberTasks = new HashMap<CallableMemberDescriptor, Runnable>();
 
@@ -214,21 +210,16 @@ public class PackageCodegen {
             }
         }
 
-        if (shouldGeneratePackageClass) {
-            // Shouldn't generate delegations to previously compiled if we compile only "classes" part of a package.
-            generateDelegationsToPreviouslyCompiled(generateCallableMemberTasks);
-        }
+        if (generateCallableMemberTasks.isEmpty()) return;
+
+        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: " + packageFragment;
+        bindings.add(v.getClassBuilder().getSerializationBindings());
+        writeKotlinPackageAnnotationIfNeeded(JvmSerializationBindings.union(bindings));
     }
 
     private void writeKotlinPackageAnnotationIfNeeded(@NotNull JvmSerializationBindings bindings) {
@@ -357,22 +348,6 @@ public class PackageCodegen {
         MemberCodegen.genClassOrObject(context, classOrObject, state, null);
     }
 
-    /**
-     * @param packageFiles all files should have same package name
-     * @return
-     */
-    public static boolean shouldGeneratePackageClass(@NotNull Collection<JetFile> packageFiles) {
-        for (JetFile file : packageFiles) {
-            for (JetDeclaration declaration : file.getDeclarations()) {
-                if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-
     public void done() {
         v.done();
     }

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

@@ -34,10 +34,7 @@ import com.intellij.util.SmartList;
 import com.intellij.util.containers.SLRUCache;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.codegen.PackageCodegen;
-import org.jetbrains.jet.lang.psi.JetClassOrObject;
-import org.jetbrains.jet.lang.psi.JetEnumEntry;
-import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.java.JavaPsiFacadeKotlinHacks;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -144,20 +141,30 @@ public class JavaElementFinder extends PsiElementFinder implements JavaPsiFacade
 
     private void findPackageClass(FqName qualifiedName, GlobalSearchScope scope, List<PsiClass> answer) {
         Collection<JetFile> filesForPackage = lightClassGenerationSupport.findFilesForPackage(qualifiedName, scope);
+        if (!shouldGeneratePackageClass(filesForPackage)) return;
 
-        if (!filesForPackage.isEmpty() && PackageCodegen.shouldGeneratePackageClass(filesForPackage)) {
-            KotlinLightClassForPackage lightClass = KotlinLightClassForPackage.create(psiManager, qualifiedName, scope, filesForPackage);
-            if (lightClass != null) {
-                answer.add(lightClass);
+        KotlinLightClassForPackage lightClass = KotlinLightClassForPackage.create(psiManager, qualifiedName, scope, filesForPackage);
+        if (lightClass == null) return;
 
-                if (filesForPackage.size() > 1) {
-                    for (JetFile file : filesForPackage) {
-                        FakeLightClassForFileOfPackage fakeLightClass = new FakeLightClassForFileOfPackage(psiManager, lightClass, file);
-                        answer.add(fakeLightClass);
-                    }
+        answer.add(lightClass);
+
+        if (filesForPackage.size() > 1) {
+            for (JetFile file : filesForPackage) {
+                answer.add(new FakeLightClassForFileOfPackage(psiManager, lightClass, file));
+            }
+        }
+    }
+
+    private static boolean shouldGeneratePackageClass(@NotNull Collection<JetFile> packageFiles) {
+        for (JetFile file : packageFiles) {
+            for (JetDeclaration declaration : file.getDeclarations()) {
+                if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
+                    return true;
                 }
             }
         }
+
+        return false;
     }
 
     @NotNull