default:
			return n.Pos()
		}
	}
}

// EndPos returns the approximate end position of n in the source.
// For some nodes (*Name, *BasicLit) it returns the position immediately
// following the node; for others (*BlockStmt, *SwitchStmt, etc.) it
// returns the position of the closing '}'; and for some (*ParenExpr)
// the returned position is the end position of the last enclosed
// expression.

The Gradle team is excited to announce Gradle @version@.

This release features [1](), [2](), ... [n](), and more.

<!-- 
Include only their name, impactful features should be called out separately below.
 [Some person](https://github.com/some-person)

 THIS LIST SHOULD BE ALPHABETIZED BY [PERSON NAME] - the docs:updateContributorsInReleaseNotes task will enforce this ordering, which is case-insensitive.
-->

/**
 * Collects, flattens and resolves dependencies.
 */
@Experimental
public interface DependencyResolver extends Service {

    /**
     * Collects the transitive dependencies of some artifacts and builds a dependency graph. Note that this operation is
     * only concerned about determining the coordinates of the transitive dependencies and does not actually resolve the
     * artifact files.
     *

dependencies {
    // All dependencies should be compileOnly, since this project is added also to worker classpath, so we don't pollute it.
    // If we need some dependency also at runtime we need to build a separate classpath and add it to :launcher project or :distributions-core project directly.
    compileOnly(project(":core"))
    compileOnly(projects.stdlibJavaExtensions)

    }
    integTestDistributionRuntimeOnly(project(":distributions-core"))
}

strictCompile {
    ignoreRawTypes() // raw types used in public API
}

packageCycles {
    // Some cycles have been inherited from the time these classes were in :core
    excludePatterns.add("org/gradle/api/internal/file/collections/**")

    implementation(project(":serialization"))
    implementation(project(":testing-base"))

    implementation(libs.guava)

    compileOnly(libs.groovy) {
        because("some used APIs (e.g. FileTree.visit) provide methods taking Groovy closures which causes compile errors")
    }

    testImplementation(project(":resources"))

    integTestImplementation(project(":internal-testing"))

package org.gradle.internal.cc.impl.cacheentry

import org.gradle.cache.internal.streams.BlockAddress
import org.gradle.util.Path
import java.io.File


/**
 * Data stored in the "entry details" file. Provides some metadata about the cache entry.
 */
internal
class EntryDetails(
    val rootDirs: List<File>,
    val intermediateModels: Map<ModelKey, BlockAddress>,
    val projectMetadata: Map<Path, BlockAddress>,

import org.gradle.internal.service.scopes.Scope


@EventScope(Scope.Build::class)
interface CoupledProjectsListener {
    /**
     * Notified when the build logic for a [referrer] project accesses the mutable state of some other [target] project.
     *
     * The [referrer] and [target] might represent the same project, and the listener implementation

    api(project(":logging-api"))
    api(project(":serialization"))
    api(project(":logging"))
    api(project(":stdlib-java-extensions"))

    // The client should not depend on core or core-api, but core still contains some types that are shared between the client and daemon
    api(project(":core-api"))
    api(project(":core"))

    implementation(libs.guava)
    implementation(libs.slf4jApi)
    implementation(project(":io"))

/**
 * Attached to a service implementation to indicate that the instance should be registered as a listener.
 *
 * <p>Generally, it is better to use {@link StatefulListener}, which is lazy and applies some validation to ensure no events are missed.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface ListenerService {