val sourceFile: String
        val testSourceFile: String
        val sourceFileTree: String
        val testSourceFileTree: String
        when {
            descriptor.language === Language.CPP -> {
                exampleClass = if (descriptor.componentType === ComponentType.LIBRARY) "Hello" else "Greeter"

                    enabled = branch.enableVcsTriggers
                    // https://www.jetbrains.com/help/teamcity/2022.04/configuring-schedule-triggers.html#general-syntax-1
                    // We want it to be triggered only when there're pending changes in the specific vcs root, i.e. GradleMaster/GradleRelease
                    triggerRules = "+:root=${VersionedSettingsBranch.fromDslContext().vcsRootId()}:."

        resolver("${prefix}TestSrcDistributionPath", "gradle-src-distribution-zip", srcDistribution)
        resolver("${prefix}TestAgentsClasspath", LibraryElements.JAR)
    }

    // do not attempt to find projects when the plugin is applied just to generate accessors
    if (project.name != "gradle-kotlin-dsl-accessors" && project.name != "test" /* remove once wrapper is updated */) {
        dependencies {

    taskFilter: (Task) -> Boolean,
    /* pass the collected information in build-logic and main build to build scan */
    buildScanAction: BuildScanConfiguration.(Any, Any) -> Unit
) {
    val gradleRootProject = when {
        project.name == "gradle" -> project.rootProject
        project.rootProject.name == "build-logic" -> rootProject.gradle.parent?.rootProject
        else -> project.gradle.parent?.rootProject
    }

            // TeamCity uses a dummy name when first running the DSL
            if (branch.contains("placeholder-1")) {
                return VersionedSettingsBranch(MASTER_BRANCH)
            }
            return VersionedSettingsBranch(branch)
        }

        private fun determineNightlyPromotionTriggerHour(branchName: String) = when (branchName) {
            MASTER_BRANCH -> 0

### Build session state

A "build session" represents a single invocation of Gradle, for example when you run `gradlew build`.
A session runs the build one or more times.
For example, when continuous build is enabled, the session may run the build many times, but when it is disabled, the session will run the build once only.

The build session state is managed by the `BuildSessionState` class.

        val ctDeclaringClass = ctMember.declaringClass
        when {
            ctMember is CtMethod && ctMember.isSynthetic -> true // synthetic members cannot have kdoc
            ctMember is CtClass -> ktFile.ktClassOf(ctMember)?.isDocumentedAsSince(version) == true
            ktFile.ktClassOf(ctDeclaringClass)?.isDocumentedAsSince(version) == true -> true
            else -> when (ctMember) {

- Click `Versioned Settings` on the left sidebar.
  - Select `Synchronization enabled` - `use settings from VCS` - `MyNewVcsRoot`(the one you just created) - `Settings format: Kotlin`, then `Apply`.
- At the popup window, click `Import Settings from VCS`. Wait a few seconds. 

fun Directory.parentOrRoot(): Directory = if (this.file("version.txt").asFile.exists()) {
    this
} else {
    val parent = dir("..")
    when {
        parent.file("version.txt").asFile.exists() -> parent
        this == parent -> throw IllegalStateException("Cannot find 'version.txt' file in root of repository")
        else -> parent.parentOrRoot()
    }
}

    permissions:
      issues: write
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
      - uses: actions/stale@v9
        with:
          operations-per-run: 50
          remove-stale-when-updated: false

          only-issue-labels: ':wave: team-triage'
          days-before-issue-stale: 14
          stale-issue-label: to-triage
          stale-issue-message: ""
          days-before-issue-close: -1