* determine the coordinates which should be used in other published metadata to reference
 * the project component or its variant.
 *
 * TODO: This data should instead be exposed by dependency-management via a ResolutionResult.
 */
public interface ProjectDependencyPublicationResolver {
    /**
     * Determines the coordinates of the given type for the root component of the
     * project identified by {@code identityPath}.
     *

import java.util.List;

/**
 * The final representation of a component in the resolved dependency graph.
 * This is the type that is serialized on resolve and deserialized when we later need to build a `ResolutionResult`.
 */
public interface ResolvedGraphComponent {
    /**
     * Returns a simple id for this component, unique across components in the same graph.
     * This id cannot be used across graphs.
     */

                    configurations.compileClasspath.incoming.resolutionResult.allDependencies.collect {
                        it.toString()
                    } as Set
                }
                def incomingRuntimeClasspath = provider {
                    configurations.runtimeClasspath.incoming.resolutionResult.allDependencies.collect {
                        it.toString()
                    } as Set

import org.gradle.api.InvalidUserDataException
import org.gradle.api.artifacts.Configuration
import org.gradle.api.artifacts.ResolvableDependencies
import org.gradle.api.artifacts.result.ResolutionResult
import org.gradle.api.artifacts.result.ResolvedComponentResult
import org.gradle.api.artifacts.result.ResolvedVariantResult
import org.gradle.api.component.SoftwareComponentVariant

import org.gradle.internal.scan.UsedByScanPlugin;

/**
 * An edge in the dependency graph. Provides information about the origin of the dependency and the requested component.
 *
 * @see ResolutionResult
 */
@UsedByScanPlugin
public interface DependencyResult {
    /**
     * <p>Returns the requested component.
     *

            }
            project(':a') {
                apply plugin: 'java'
            }
            classes.doLast {
                def components = configurations.compileClasspath.incoming.resolutionResult.allComponents.id
                assert components.size() == 2
                assert components[0].build.buildPath == ':buildSrc'
                assert components[0].build.name == 'buildSrc'

import javax.annotation.Nullable;

/**
 * The final representation of a dependency in the resolved dependency graph.
 * This is the type that is serialized on resolve and deserialized when we later need to build a `ResolutionResult`.
 */
public interface ResolvedGraphDependency {

    ComponentSelector getRequested();

    @Nullable
    ModuleVersionResolveException getFailure();

    /**

            dependencies {
                conf("org:moduleA:1.0")
            }

            tasks.named("checkDeps") {
                doLast {
                    def result = configurations.conf.incoming.resolutionResult
                    boolean found = false
                    result.allComponents {
                        if (id instanceof ModuleComponentIdentifier && id.module == 'moduleA') {

            }
            dependencies {
                implementation project(':a')
            }
            classes.doLast {
                def components = configurations.compileClasspath.incoming.resolutionResult.allComponents.id
                assert components.size() == 2
                assert components[0].build.buildPath == ':buildB:buildSrc'
                assert components[0].build.name == 'buildSrc'

import org.gradle.internal.declarativedsl.language.FunctionCall
import org.gradle.internal.declarativedsl.language.LanguageTreeElement
import org.gradle.internal.declarativedsl.language.LocalValue


data class ResolutionResult(
    val topLevelReceiver: ObjectOrigin.TopLevelReceiver,
    val assignments: List<AssignmentRecord>,
    val additions: List<DataAdditionRecord>,
    val nestedObjectAccess: List<NestedObjectAccessRecord>,