classPathFiles: List<File>,
    classPathDependencies: List<File> = emptyList(),
) : Closeable {

    private
    val relevantClassPathFiles = classPathFiles.filter { it.isDirectory || (it.isFile && it.length() > 0) }

    private
    val openJars = mutableMapOf<File, JarFile>()

    private
    val classBytesIndex = (relevantClassPathFiles + classPathDependencies + platformClassLoader).map { classBytesIndexFor(it) }

    private val directoryFileTreeFactory: DirectoryFileTreeFactory,
    private val report: ConfigurationCacheReport,
    private val problemFactory: ProblemFactory,
    private val workExecutionTracker: WorkExecutionTracker,
    private val environmentChangeTracker: ConfigurationCacheEnvironmentChangeTracker,
    private val inputTrackingState: InputTrackingState,

}


internal
class ConfigurationCacheState(
    private val codecs: Codecs,
    private val stateFile: ConfigurationCacheStateFile,
    private val eventEmitter: BuildOperationProgressEventEmitter,
    private val host: DefaultConfigurationCache.Host
) {
    /**

class ConfigurationCacheProblemsSummary(

    private
    val maxCollectedProblems: Int = 4096

) {
    /**
     * Reported more problems than can be collected.
     */
    private
    var overflowed: Boolean = false

    private
    var problemCount: Int = 0

    private
    var failureCount: Int = 0

    private
    var suppressedCount: Int = 0

    private

            )
    }

    private
    fun lineNumber(location: CompilerMessageSourceLocation) =
        location.line.toString().padStart(maxLineNumberStringLength, '0')

    private
    fun prependIndent(it: String) = it.prependIndent(indent)

    private
    val errorPlural
        get() = if (errors.size > 1) "errors" else "error"

    private
    val maxLineNumberStringLength: Int by lazy {

@NonExtensible
@ServiceScope(Scope.Build::class)
open class BuildFlowScope @Inject internal constructor(
    private val flowScheduler: FlowScheduler,
    private val flowProviders: FlowProviders,
    private val flowParametersInstantiator: FlowParametersInstantiator,
    instantiatorFactory: InstantiatorFactory,
) : BuildAdapter(), FlowScope {

    private
    sealed class State {

        abstract val pendingActions: List<RegisteredFlowAction>

        collector.processThisReference(thisReference)
    }
}

private class ElementsToShortenCollector(
    private val shortenOptions: ShortenOptions,
    private val shorteningContext: FirShorteningContext,
    private val towerContextProvider: FirTowerDataContextProvider,
    private val containingFile: KtFile,
    private val selection: TextRange,
    private val classShortenStrategy: (FirClassLikeSymbol<*>) -> ShortenStrategy,

                return work
            }
    }

    private
    inner class DefaultConfigurationCacheBuild(
        override val state: BuildState,
        private val fileResolver: PathToFileResolver,
        private val buildStateRegistry: BuildStateRegistry,
        private val settingsFile: File?
    ) : ConfigurationCacheBuild {

        private
        val buildDirs = mutableMapOf<Path, File>()

        init {

    private val configurationTimeBarrier: ConfigurationTimeBarrier,
    private val buildActionModelRequirements: BuildActionModelRequirements,
    private val buildStateRegistry: BuildStateRegistry,
    private val virtualFileSystem: BuildLifecycleAwareVirtualFileSystem,
    private val buildOperationRunner: BuildOperationRunner,
    private val cacheFingerprintController: ConfigurationCacheFingerprintController,
    private val encryptionService: EncryptionService,

}


internal
class ScriptModelBase(
    private val rootProject: ProjectInternal
) {

    private
    val scriptClassPath: ClassPath by unsafeLazy {
        rootProject.gradle.baseScriptClassPath()
    }

    private
    val buildSrcSources: Collection<File> by unsafeLazy {
        SourcePathProvider.buildSrcRootsOf(rootProject.rootDir)
    }

    private