classLoaderName = ste.getClassLoaderName();
            moduleName = ste.getModuleName();
            moduleVersion = ste.getModuleVersion();
        } else {
            classLoaderName = null;
            moduleName = null;
            moduleVersion = null;
        }
        declaringClass = ste.getClassName();
        methodName = ste.getMethodName();
        fileName = ste.getFileName();

        DummyModuleVersionSelection moduleVersion = comp(module, reason)
        builder.startVisitComponent(moduleVersion.resultId, moduleVersion.selectionReason, "repo")
        builder.visitComponentDetails(moduleVersion.componentId, moduleVersion.moduleVersion)
        builder.visitSelectedVariant(moduleVersion.resultId, Stub(ResolvedVariantResult))
        builder.visitComponentVariants([])

        this.repoName = repoName;
    }

    @Override
    public void visitComponentDetails(ComponentIdentifier componentId, ModuleVersionIdentifier moduleVersion) {
        this.componentId = componentId;
        this.moduleVersion = moduleVersion;
    }

    @Override
    public void visitSelectedVariant(Long id, ResolvedVariantResult variant) {
        selectedVariants.put(id, variant);
    }

        args.add("-classpath");
        args.add(Joiner.on(File.pathSeparatorChar).join(classpath));

        if (!modulePath.isEmpty()) {
            if (moduleVersion != null) {
                args.add("--module-version");
                args.add(moduleVersion);
            }
            args.add("--module-path");
            args.add(Joiner.on(File.pathSeparatorChar).join(modulePath));
        }
    }

    // https://github.com/gradle/configuration-cache/issues/183
    val modules = provider {
        embeddedKotlinBaseDependencies.incoming.resolutionResult.allComponents
            .asSequence()
            .mapNotNull { it.moduleVersion }
            .filter { it.name !in skippedModules }
            .associate { "${it.group}:${it.name}" to it.version }
    }

    doLast {
        ReproduciblePropertiesWriter.store(
            modules.get(),

    public Collection<? extends ModuleVersionIdentifier> getAllVersions() {
        Collection<ComponentState> moduleVersions = module.getAllVersions();
        List<ModuleVersionIdentifier> out = Lists.newArrayListWithCapacity(moduleVersions.size());
        for (ComponentState moduleVersion : moduleVersions) {
            out.add(moduleVersion.id);
        }
        return out;
    }

    public boolean isSelected() {

        def result = deserialize(serialized)

        then:
        result.id == componentIdentifier
        result.selectionReason == ComponentSelectionReasons.requested()
        result.moduleVersion == newId('org', 'foo', '2.0')
        for (def variants : [result.selectedVariants, result.availableVariants]) {
            variants.size() == 2
            variants[0] == v1Result
            variants[1] == v2Result

        then:
        resolvedDependency.name == someGroup + ":" + someName + ":" + someVersion
        resolvedDependency.moduleGroup == someGroup
        resolvedDependency.moduleName == someName
        resolvedDependency.moduleVersion == someVersion
        resolvedDependency.configuration == someConfiguration
        resolvedDependency.moduleArtifacts.empty
        resolvedDependency.children.empty
        resolvedDependency.parents.empty
    }

        if (result.getId() instanceof ModuleComponentIdentifier) {
            ModuleVersionIdentifier moduleVersion = result.getModuleVersion();
            DefaultDependencyConstraint constraint = DefaultDependencyConstraint.strictly(
                moduleVersion.getGroup(),
                moduleVersion.getName(),
                moduleVersion.getVersion());
            constraint.because(consistentResolutionReason);
            return constraint;

        void start(RootGraphNode root) {
            this.root = root
        }

        @Override
        void visitNode(DependencyGraphNode node) {
            components.add(node.owner.moduleVersion)
        }

        @Override
        void visitEdges(DependencyGraphNode node) {
            node.outgoingEdges.each {
                if (it.failure) {