else -> userHome().resolve(".gradle-kotlin-dsl/log")
            }
        }

    private
    fun now() = GregorianCalendar.getInstance().time

    private
    const val cleanupAfterDays = 1

    private
    const val logFilesExpireAfterDays = 7

    private
    fun cleanupLogDirectory(logDir: File) =
        readyForCleanup(logDir) {

) : Closeable {
    override fun close() {
        // we synchronize access to all resources used by callbacks
        // in case there was still an event being dispatched at closing time.
        synchronized(writeContext) {
            unsafeWrite(null)
            writeContext.close()
        }
    }

    fun write(value: T, trace: PropertyTrace? = null) {
        synchronized(writeContext) {

        listOf(
            "org.gradle.kotlin.dsl.*",
            // TODO: let this be contributed by :plugins
            "org.gradle.kotlin.dsl.plugins.dsl.*",
            // TODO: infer list of types below at build time by inspecting the Gradle API
            "java.util.concurrent.Callable",
            "java.util.concurrent.TimeUnit",
            "java.math.BigDecimal",
            "java.math.BigInteger",
            "java.io.File",

    get() = settingsRoot.id.toString().substringAfter("Gradle")

data class VersionedSettingsBranch(val branchName: String) {
    /**
     * 0~23.
     * To avoid nightly promotion jobs running at the same time,
     * we run each branch on different hours.
     * master - 0:00
     * release - 1:00
     * release6x - 2:00
     * release7x - 3:00
     * ...
     * releaseNx - (N-4):00
     */

include("integration-testing")
include("jvm")
include("kotlin-dsl")
include("uber-plugins")
include("packaging")
include("performance-testing")
include("profiling")
include("publishing")

// Components used both at build time and GBT runtime, shipped in the distribution
include("kotlin-dsl-shared-runtime")

 * directly affect the configuration.
 * For example, accessing environment variable inside the `ValueSource` being obtained at
 * the configuration time is not really an input, because the value of the value source itself
 * becomes part of the configuration cache fingerprint.
 */
@ServiceScope(Scope.BuildTree::class)
class InputTrackingState {
    private

            // Restoration must consider properties that was overridden after store.
            // When property was loaded and stored then loaded value will be presented for execution time after restore.
            // This is a wrong behavior if property was overridden. Execution time must see overridden value instead of restored one.
            // Overridden properties keys are passed to be excluded from the restoration process.

        (buildRcNumber.isPresent && buildMilestoneNumber.isPresent)
    ) {
        throw InvalidUserDataException("Cannot set any combination of milestoneNumber, rcNumber and finalRelease at the same time")
    }

    val versionQualifier = buildVersionQualifier
    val isFinalRelease = finalRelease.isPresent

    val buildTimestamp = buildTimestamp()
    val versionNumber = when {
        isFinalRelease -> {

 * against a given [target][ProgramTarget].
 *
 * @see PartialEvaluator.reduce
 */
internal
sealed class ResidualProgram {

    /**
     * A static residue, can be compiled ahead of time.
     */
    data class Static(val instructions: List<Instruction>) : ResidualProgram() {

        constructor(vararg instructions: Instruction) :
            this(instructions.toList())
    }

    /**

import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath
import org.gradle.internal.resource.TextFileResourceLoader
import org.gradle.internal.time.Time.startTimer
import org.gradle.kotlin.dsl.*
import org.gradle.kotlin.dsl.accessors.AccessorsClassPath
import org.gradle.kotlin.dsl.accessors.ProjectAccessorsClassPathGenerator