Move IC-related initialization logic to GenerationState

To further reduce number of parameters of GenerationState's constructor

compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt

@@ -33,7 +33,7 @@ fun List<PackageParts>.addCompiledPartsAndSort(state: GenerationState): List<Pac
         addCompiledParts(state).sortedBy { it.packageFqName }
 
 private fun List<PackageParts>.addCompiledParts(state: GenerationState): List<PackageParts> {
-    val incrementalCache = state.getIncrementalCacheForThisTarget() ?: return this
+    val incrementalCache = state.incrementalCacheForThisTarget ?: return this
     val moduleMappingData = incrementalCache.getModuleMappingData() ?: return this
 
     val mapping = ModuleMapping.create(moduleMappingData)

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

@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import java.io.File
 
 class GenerationState @JvmOverloads constructor(
@@ -55,9 +56,7 @@ class GenerationState @JvmOverloads constructor(
         val files: List<KtFile>,
         val configuration: CompilerConfiguration,
         val generateDeclaredClassFilter: GenerateClassFilter = GenerationState.GenerateClassFilter.GENERATE_ALL,
-        val packagesWithObsoleteParts: Collection<FqName> = emptySet(),
+        // For incremental compilation
-        val obsoleteMultifileClasses: Collection<FqName> = emptySet(),
-        // for PackageCodegen in incremental compilation mode
         val targetId: TargetId? = null,
         moduleName: String? = configuration.get(JVMConfigurationKeys.MODULE_NAME),
         // 'outDirectory' is a hack to correctly determine if a compiled class is from the same module as the callee during
@@ -88,10 +87,28 @@ class GenerationState @JvmOverloads constructor(
     val fileClassesProvider: CodegenFileClassesProvider = CodegenFileClassesProvider()
     val inlineCache: InlineCache = InlineCache()
 
-    fun getIncrementalCacheForThisTarget(): IncrementalCache? =
+    val incrementalCacheForThisTarget: IncrementalCache?
-            configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)?.let { components ->
+    val packagesWithObsoleteParts: Set<FqName>
-                targetId?.let { components.getIncrementalCache(it) }
+    val obsoleteMultifileClasses: List<FqName>
+
+    init {
+        val icComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)
+        if (icComponents != null) {
+            incrementalCacheForThisTarget =
+                    icComponents.getIncrementalCache(targetId ?: error("Target ID should be specified for incremental compilation"))
+            packagesWithObsoleteParts = incrementalCacheForThisTarget.getObsoletePackageParts().map {
+                JvmClassName.byInternalName(it).packageFqName
+            }.toSet()
+            obsoleteMultifileClasses = incrementalCacheForThisTarget.getObsoleteMultifileClasses().map {
+                JvmClassName.byInternalName(it).fqNameForClassNameWithoutDollars
             }
+        }
+        else {
+            incrementalCacheForThisTarget = null
+            packagesWithObsoleteParts = emptySet()
+            obsoleteMultifileClasses = emptyList()
+        }
+    }
 
     val extraJvmDiagnosticsTrace: BindingTrace = DelegatingBindingTrace(bindingContext, false, "For extra diagnostics in ${this.javaClass}")
     private val interceptedBuilderFactory: ClassBuilderFactory
@@ -108,7 +125,7 @@ class GenerationState @JvmOverloads constructor(
     val bindingTrace: BindingTrace = DelegatingBindingTrace(bindingContext, "trace in GenerationState")
     val bindingContext: BindingContext = bindingTrace.bindingContext
     val typeMapper: KotlinTypeMapper = KotlinTypeMapper(
-            this.bindingContext, classBuilderMode, fileClassesProvider, getIncrementalCacheForThisTarget(),
+            this.bindingContext, classBuilderMode, fileClassesProvider, incrementalCacheForThisTarget,
             IncompatibleClassTrackerImpl(extraJvmDiagnosticsTrace), this.moduleName
     )
     val intrinsics: IntrinsicMethods = IntrinsicMethods()
@@ -143,9 +160,8 @@ class GenerationState @JvmOverloads constructor(
                 .wrapWith(
                     { OptimizationClassBuilderFactory(it, configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false)) },
                     { BuilderFactoryForDuplicateSignatureDiagnostics(
-                            it, this.bindingContext, diagnostics, fileClassesProvider,
+                            it, this.bindingContext, diagnostics, fileClassesProvider, incrementalCacheForThisTarget, this.moduleName
-                            getIncrementalCacheForThisTarget(),
+                      ).apply { duplicateSignatureFactory = this } },
-                            this.moduleName).apply { duplicateSignatureFactory = this } },
                     { BuilderFactoryForDuplicateClassNameDiagnostics(it, diagnostics) },
                     { configuration.get(JVMConfigurationKeys.DECLARATIONS_JSON_PATH)
                               ?.let { destination -> SignatureDumpingBuilderFactory(it, File(destination)) } ?: it }

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

@@ -47,7 +47,6 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.isSubpackageOf
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.util.PerformanceCounter
 import org.jetbrains.kotlin.utils.KotlinPaths
@@ -139,13 +138,11 @@ object KotlinToJVMBytecodeCompiler {
             val ktFiles = CompileEnvironmentUtil.getKtFiles(
                     environment.project, getAbsolutePaths(directory, module), configuration) { s -> throw IllegalStateException("Should have been checked before: " + s) }
             if (!checkKotlinPackageUsage(environment, ktFiles)) return false
-            val moduleOutputDirectory = File(module.getOutputDirectory())
 
             val onIndependentPartCompilationEnd =
                     createOutputFilesFlushingCallbackIfPossible(configuration, File(module.getOutputDirectory()), jarPath)
 
-            val generationState = generate(environment, result, ktFiles, module, moduleOutputDirectory,
+            val generationState = generate(environment, result, ktFiles, module, onIndependentPartCompilationEnd)
-                                           module.getModuleName(),  onIndependentPartCompilationEnd)
 
             outputFiles.put(module, generationState.factory)
             generationStates.add(generationState)
@@ -311,7 +308,7 @@ object KotlinToJVMBytecodeCompiler {
 
         result.throwIfError()
 
-        return generate(environment, result, environment.getSourceFiles(), null, null, null, onIndependentPartCompilationEnd)
+        return generate(environment, result, environment.getSourceFiles(), null, onIndependentPartCompilationEnd)
     }
 
     private fun analyze(environment: KotlinCoreEnvironment, targetDescription: String?): AnalysisResult? {
@@ -368,42 +365,19 @@ object KotlinToJVMBytecodeCompiler {
             result: AnalysisResult,
             sourceFiles: List<KtFile>,
             module: Module?,
-            outputDirectory: File?,
-            moduleName: String?,
             onIndependentPartCompilationEnd: GenerationStateEventCallback
     ): GenerationState {
-        val configuration = environment.configuration
-        val incrementalCompilationComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)
-
-        val packagesWithObsoleteParts = hashSetOf<FqName>()
-        val obsoleteMultifileClasses = arrayListOf<FqName>()
-        var targetId: TargetId? = null
-
-        if (module != null && incrementalCompilationComponents != null) {
-            targetId = TargetId(module)
-            val incrementalCache = incrementalCompilationComponents.getIncrementalCache(targetId)
-
-            for (internalName in incrementalCache.getObsoletePackageParts()) {
-                packagesWithObsoleteParts.add(JvmClassName.byInternalName(internalName).packageFqName)
-            }
-
-            for (obsoleteFacadeInternalName in incrementalCache.getObsoleteMultifileClasses()) {
-                obsoleteMultifileClasses.add(JvmClassName.byInternalName(obsoleteFacadeInternalName).fqNameForClassNameWithoutDollars)
-            }
-        }
         val generationState = GenerationState(
                 environment.project,
                 ClassBuilderFactories.BINARIES,
                 result.moduleDescriptor,
                 result.bindingContext,
                 sourceFiles,
-                configuration,
+                environment.configuration,
                 GenerationState.GenerateClassFilter.GENERATE_ALL,
-                packagesWithObsoleteParts,
+                module?.let(::TargetId),
-                obsoleteMultifileClasses,
+                module?.let { it.getModuleName() },
-                targetId,
+                module?.let { File(it.getOutputDirectory()) },
-                moduleName,
-                outputDirectory,
                 onIndependentPartCompilationEnd
         )
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()