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)) {

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

) : StepContext


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

}


class ResolverImpl(
    private val codeAnalyzer: CodeAnalyzer,
    private val errorCollector: ErrorCollector,
    private val generationId: OperationGenerationId
) : Resolver {
    override fun resolve(schema: AnalysisSchema, imports: List<Import>, topLevelBlock: Block): ResolutionResult {

        feature is InterpretationStepFeature.ResolutionResultPostprocessing.ConventionDefinition

    override fun processResolutionResult(resolutionResult: ResolutionResult): ResolutionResult {
        conventionRegistrar.registerConventions(ConventionsResolutionProcessor.process(resolutionResult))
        return resolutionResult
    }
}


interface ConventionDefinitionRegistrar {

            }
        }

        ProjectResolutionResult resolutionResult = resolveProject(selection, selection.getOriginalPath(), defaultBuild);
        return getSelectorForBuild(resolutionResult.build).getSelection(selection, resolutionResult.project, resolutionResult.taskName, resolutionResult.includeSubprojects);
    }

    @Override

        val allReceiverReferences = resolutionResult.conventionAdditions.map { it.container } +
            resolutionResult.conventionAssignments.map { it.lhs.receiverObject } +
            resolutionResult.conventionNestedObjectAccess.map { it.dataObject.accessor.access(it.container, it.dataObject) } +
            resolutionResult.additions.map { it.container } +
            resolutionResult.assignments.map { it.lhs.receiverObject } +