Simplified process of filtering out obsolete package parts and loading descriptors from incremental caches.

Now when file is deleted or dirty (compiled right now), its old package part is used. Current package of file doesn't matter.

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

@@ -62,8 +62,8 @@ public class KotlinCodegenFacade {
             packageFqNameToFiles.putValue(file.getPackageFqName(), file);
         }
 
-        Set<FqName> removedPackageFiles = new HashSet<FqName>(state.getPackagesWithRemovedFiles());
-        for (FqName fqName : Sets.union(removedPackageFiles, packageFqNameToFiles.keySet())) {
+        Set<FqName> packagesWithObsoleteParts = new HashSet<FqName>(state.getPackagesWithObsoleteParts());
+        for (FqName fqName : Sets.union(packagesWithObsoleteParts, packageFqNameToFiles.keySet())) {
             generatePackage(state, fqName, packageFqNameToFiles.get(fqName), errorHandler);
         }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.java

@@ -111,7 +111,7 @@ public class GenerationState {
     private final ModuleDescriptor module;
 
     @NotNull
-    private final Collection<FqName> packagesWithRemovedFiles;
+    private final Collection<FqName> packagesWithObsoleteParts;
 
     @Nullable
     private final String moduleId; // for PackageCodegen in incremental compilation mode
@@ -142,7 +142,7 @@ public class GenerationState {
             GenerateClassFilter generateClassFilter,
             boolean disableInline,
             boolean disableOptimization,
-            @Nullable Collection<FqName> packagesWithRemovedFiles,
+            @Nullable Collection<FqName> packagesWithObsoleteParts,
             @Nullable String moduleId,
             @NotNull DiagnosticSink diagnostics,
             @Nullable File outDirectory
@@ -152,7 +152,7 @@ public class GenerationState {
         this.module = module;
         this.files = files;
         this.moduleId = moduleId;
-        this.packagesWithRemovedFiles = packagesWithRemovedFiles == null ? Collections.<FqName>emptySet() : packagesWithRemovedFiles;
+        this.packagesWithObsoleteParts = packagesWithObsoleteParts == null ? Collections.<FqName>emptySet() : packagesWithObsoleteParts;
         this.classBuilderMode = builderFactory.getClassBuilderMode();
         this.disableInline = disableInline;
 
@@ -287,8 +287,8 @@ public class GenerationState {
     }
 
     @NotNull
-    public Collection<FqName> getPackagesWithRemovedFiles() {
-        return packagesWithRemovedFiles;
+    public Collection<FqName> getPackagesWithObsoleteParts() {
+        return packagesWithObsoleteParts;
     }
 
     @Nullable

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

@@ -338,13 +338,13 @@ public class KotlinToJVMBytecodeCompiler {
         CompilerConfiguration configuration = environment.getConfiguration();
         IncrementalCacheProvider incrementalCacheProvider = configuration.get(JVMConfigurationKeys.INCREMENTAL_CACHE_PROVIDER);
 
-        Collection<FqName> packagesWithRemovedFiles;
+        Collection<FqName> packagesWithObsoleteParts;
         if (moduleId == null || incrementalCacheProvider == null) {
-            packagesWithRemovedFiles = null;
+            packagesWithObsoleteParts = null;
         }
         else {
             IncrementalCache incrementalCache = incrementalCacheProvider.getIncrementalCache(moduleId);
-            packagesWithRemovedFiles = IncrementalPackage.getPackagesWithRemovedFiles(incrementalCache, environment.getSourceFiles());
+            packagesWithObsoleteParts = IncrementalPackage.getPackagesWithObsoleteParts(incrementalCache, environment.getSourceFiles());
         }
         BindingTraceContext diagnosticHolder = new BindingTraceContext();
         GenerationState generationState = new GenerationState(
@@ -359,7 +359,7 @@ public class KotlinToJVMBytecodeCompiler {
                 GenerationState.GenerateClassFilter.GENERATE_ALL,
                 configuration.get(JVMConfigurationKeys.DISABLE_INLINE, false),
                 configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false),
-                packagesWithRemovedFiles,
+                packagesWithObsoleteParts,
                 moduleId,
                 diagnosticHolder,
                 outputDirectory

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalCacheUtil.kt

@@ -24,21 +24,13 @@ import java.util.HashMap
 import java.io.File
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 
-public fun IncrementalCache.getPackagesWithRemovedFiles(sourceFilesToCompile: Collection<JetFile>): Collection<FqName> {
-    return getRemovedPackageParts(sourceFilesToCompile).map { it.getPackageFqName() }
+// TODO JetFiles are redundant
+public fun IncrementalCache.getPackagesWithObsoleteParts(sourceFilesToCompile: Collection<JetFile>): Collection<FqName> {
+    return getObsoletePackageParts(sourceFilesToCompile).map { it.getPackageFqName() }
 }
 
-public fun IncrementalCache.getRemovedPackageParts(sourceFilesToCompile: Collection<JetFile>): Collection<JvmClassName> {
-    val sourceFilesToFqName = HashMap<File, String?>()
-    for (sourceFile in sourceFilesToCompile) {
-        sourceFilesToFqName[File(sourceFile.getVirtualFile()!!.getPath())] =
-                if (PackagePartClassUtils.fileHasCallables(sourceFile))
-                    sourceFile.getPackageFqName().asString()
-                else
-                    null
-    }
-
-    return getRemovedPackageParts(sourceFilesToFqName).map { JvmClassName.byInternalName(it) }
+public fun IncrementalCache.getObsoletePackageParts(sourceFilesToCompile: Collection<JetFile>): Collection<JvmClassName> {
+    return getObsoletePackageParts(sourceFilesToCompile.map { File(it.getVirtualFile()!!.getPath()) }).map { JvmClassName.byInternalName(it) }
 }
 
 public fun IncrementalCache.getPackageData(fqName: FqName): ByteArray? {

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt

@@ -47,10 +47,7 @@ public class IncrementalPackageFragmentProvider(
         val moduleId: String
 ) : PackageFragmentProvider {
 
-    val packagePartsToNotLoadFromCache = (
-            sourceFiles.map { PackagePartClassUtils.getPackagePartInternalName(it) }
-                    + incrementalCache.getRemovedPackageParts(sourceFiles).map { it.getInternalName() }
-            ).toSet()
+    val obsoletePackageParts = incrementalCache.getObsoletePackageParts(sourceFiles).map { it.getInternalName() }.toSet()
     val fqNameToSubFqNames = MultiMap<FqName, FqName>()
     val fqNameToPackageFragment = HashMap<FqName, PackageFragmentDescriptor>()
     val fqNamesToLoad: Set<FqName>
@@ -70,10 +67,7 @@ public class IncrementalPackageFragmentProvider(
             fqNameToPackageFragment[fqName] = IncrementalPackageFragment(fqName)
         }
 
-        fqNamesToLoad = (
-                PackagePartClassUtils.getPackageFilesWithCallables(sourceFiles).map { it.getPackageFqName() }
-                + incrementalCache.getPackagesWithRemovedFiles(sourceFiles)
-        ).toSet()
+        fqNamesToLoad = incrementalCache.getPackagesWithObsoleteParts(sourceFiles).toSet()
 
         fqNamesToLoad.forEach { createPackageFragment(it) }
     }
@@ -119,7 +113,7 @@ public class IncrementalPackageFragmentProvider(
                             if (member.hasExtension(JvmProtoBuf.implClassName)) {
                                 val shortName = packageData.getNameResolver().getName(member.getExtension(JvmProtoBuf.implClassName)!!)
                                 val internalName = JvmClassName.byFqNameWithoutInnerClasses(fqName.child(shortName)).getInternalName()
-                                internalName !in packagePartsToNotLoadFromCache
+                                internalName !in obsoletePackageParts
                             }
                             else {
                                 true

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/cache/IncrementalCache.kt

@@ -19,10 +19,7 @@ package org.jetbrains.kotlin.load.kotlin.incremental.cache
 import java.io.File
 
 public trait IncrementalCache {
-    public fun getRemovedPackageParts(
-            // null value means source file has no top-level callables (won't produce package part)
-            sourceFilesToCompileAndFqNames: Map<File, String?>
-    ): Collection<String>
+    public fun getObsoletePackageParts(sourceFilesToCompile: Collection<File>): Collection<String>
 
     public fun getPackageData(fqName: String): ByteArray?