Jendrik Johannes <******@****.***> 1607501645 +0100

                fun visitClassFile(file: Path) {
                    try {
                        val reader = ClassReader(Files.newInputStream(file))
                        val details = classes[reader.className]
                        details.visited = true
                        val classWriter = ClassWriter(0)
                        reader.accept(
                            ClassRemapper(
                                classWriter,

    /**
     * Returns the header and footer of the html template as a pair.
     */
    fun load(): Pair<String, String> {
        val template = readHtmlTemplate()
        val headerEnd = template.indexOf(modelLine)
        require(headerEnd > 0) {
            "Invalid configuration cache report template!"
        }
        val header = template.substring(0, headerEnd)

        val superTypesFile = File(outputDir, DIRECT_SUPER_TYPES_FILE)
        if (superTypesFile.exists()) {
            // Load properties with reader to use UTF_8 Charset
            superTypesFile.reader().use { reader -> oldSuperTypes.load(reader) }
        }
        val instrumentedClassesFile = File(outputDir, INSTRUMENTED_CLASSES_FILE)
        val upgradedPropertiesFile = File(outputDir, UPGRADED_PROPERTIES_FILE)

        val writer = ValueStore.Writer<BuildTreeModelSideEffect> { encoder, value ->
            write(encoder, value)
        }
        val reader = ValueStore.Reader { decoder ->
            read(decoder)
        }
        store.createValueStore(StateType.ModelSideEffects, writer, reader)
    }

    fun collectSideEffects(): List<BlockAddress> = entries.toList()

    fun write(sideEffect: BuildTreeModelSideEffect) {

    val valuesStore by lazy {
        val writer = ValueStore.Writer<V> { encoder, value ->
            write(encoder, value)
        }
        val reader = ValueStore.Reader { decoder ->
            read(decoder)
        }
        store.createValueStore(stateType, writer, reader)
    }

    private
    val previousValues = ConcurrentHashMap<K, BlockAddress>()

    private

            )
        ),
        Stage(
            StageName.EXPERIMENTAL_VFS_RETENTION,
            trigger = Trigger.never,
            runsIndependent = true,
            flameGraphs = listOf(
                FlameGraphGeneration(
                    14, "File System Watching",

        // Technically, the relative order or entries is visible to the caller, so it might be considered when computing the hash.
        // However, the File.list spec leaves the order undefined, so no reasonable implementation should depend on it.
        // Making the hash order-independent by sorting the entries maximizes CC hits, even if the OS-returned order changes.
        Arrays.sort(entries)

            quietPeriod = 90
            triggerRules = triggerExcludes
            branchFilter = model.branch.branchFilter()
            enabled = enableTriggers
        }
    } else if (stage.trigger != Trigger.never) {
        triggers.schedule {
            if (stage.trigger == Trigger.weekly) {
                schedulingPolicy = weekly {
                    dayOfWeek = ScheduleTrigger.DAY.Saturday
                    hour = 1

    data class ExternalReassignment(val external: ObjectOrigin.External) : ErrorReason
    data class AssignmentTypeMismatch(val expected: DataType, val actual: DataType) : ErrorReason

    // TODO: these two are never reported for now, instead it is UnresolvedFunctionCallSignature
    data object UnusedConfigureLambda : ErrorReason
    data object MissingConfigureLambda : ErrorReason