* in the resolved dependency graph, and the dependencies between them.
 */
@UsedByScanPlugin
@HasInternalProtocol
public interface ResolutionResult {

    /**
     * Gives access to the root of resolved dependency graph.
     * You can walk the graph recursively from the root to obtain information about resolved dependencies.

    override fun processResolutionResult(resolutionResult: ResolutionResult): ResolutionResult {
        // Find all the software types that are referenced in the build file
        val referencedSoftwareTypes = findUsedSoftwareTypeNames(resolutionResult)
            .mapNotNull(softwareTypeConventionRepository::findConventions)

        with(ConventionTransformer(resolutionResult.topLevelReceiver)) {

    @Input
    abstract Property<ResolvableDependencies> getDependencies()

    @TaskAction
    void walk() {
        ResolutionResult resolutionResult = dependencies.get().resolutionResult
        ResolvedComponentResult root = resolutionResult.root
        traverseDependencies(0, root.dependencies)
    }

    private void traverseDependencies(int level, Set<? extends DependencyResult> results) {

    @get:Input
    abstract val dependencies: Property<ResolvableDependencies>

    @TaskAction
    fun walk() {
        val resolutionResult: ResolutionResult = dependencies.get().resolutionResult
        val root: ResolvedComponentResult = resolutionResult.root
        traverseDependencies(0, root.dependencies)
    }

    private fun traverseDependencies(level: Int, results: Set<DependencyResult>) {

import org.gradle.internal.declarativedsl.analysis.ResolutionResult


/**
 * Processes a resolution result to extract the Software Type convention operations it defines.
 */
internal
object ConventionsResolutionProcessor {
    fun process(resolutionResult: ResolutionResult): Map<String, SoftwareTypeConventionResolutionResults> {
        val assignments = resolutionResult.assignments.groupBy { assignment ->

import org.gradle.internal.declarativedsl.analysis.ResolutionResult
import org.gradle.internal.declarativedsl.objectGraph.AssignmentTraceElement.UnassignedValueUsed


class AssignmentTracer(
    val assignmentResolverFactory: () -> AssignmentResolver
) {
    fun produceAssignmentTrace(resolutionResult: ResolutionResult): AssignmentTrace {
        val assignmentResolver = assignmentResolverFactory()

        }

        def results1 = new DefaultVisitedGraphResults(resolutionResult, Collections.emptySet(), null)
        def results2 = new DefaultVisitedGraphResults(resolutionResult, Collections.singleton(unresolved), null)
        def results3 = new DefaultVisitedGraphResults(resolutionResult, Collections.emptySet(), resolveEx)
        def results4 = new DefaultVisitedGraphResults(resolutionResult, Collections.singleton(unresolved), resolveEx)

        expect:

import org.gradle.declarative.dsl.evaluation.InterpretationStepFeature
import org.gradle.internal.declarativedsl.analysis.ResolutionResult


interface ResolutionResultHandler : InterpretationStepFeatureHandler<InterpretationStepFeature.ResolutionResultPostprocessing> {
    fun processResolutionResult(resolutionResult: ResolutionResult): ResolutionResult

public class DefaultVisitedGraphResults implements VisitedGraphResults {

    private final MinimalResolutionResult resolutionResult;
    private final Set<UnresolvedDependency> unresolvedDependencies;
    private final ResolveException resolutionFailure;

    public DefaultVisitedGraphResults(
        MinimalResolutionResult resolutionResult,
        Set<UnresolvedDependency> unresolvedDependencies,
        @Nullable ResolveException resolutionFailure

) : StepContext


data class AnalysisStepResult(
    val evaluationSchema: EvaluationSchema,
    val languageTreeResult: LanguageTreeResult,
    val resolutionResult: ResolutionResult,
    val resolutionTrace: ResolutionTrace,
    val assignmentTrace: AssignmentTrace
) : StepResult