public NoDepsResolvedArtifactSet(ResolvedArtifactSet selectedArtifacts) {
            this.selectedArtifacts = selectedArtifacts;
        }

        @Override
        public void visit(Visitor visitor) {
            selectedArtifacts.visit(visitor);
        }

        @Override
        public void visitTransformSources(TransformSourceVisitor visitor) {

        formatter.node("contains: " + getDisplayName());
    }

    SelectedArtifactSet getSelectedArtifacts() {
        if (selectedArtifacts == null) {
            selectedArtifacts = resultProvider.getValue();
        }
        return selectedArtifacts;
    }

    return if (transformStep.requiresDependencies()) {
        TransformStepSpec.FileDependencies(transformStep, upstreamDependencies.selectedArtifacts(), upstreamDependencies.configurationIdentity!!)
    } else {
        TransformStepSpec.NoDependencies(transformStep)
    }
}

        public abstract FileCollection selectedArtifacts();

        @Override
        public TransformDependencies calculateValue(NodeExecutionContext context) {
            FileCollection files = selectedArtifacts();
            // Trigger resolution, including any failures
            files.getFiles();

    override suspend fun WriteContext.encode(value: DefaultTransformUpstreamDependenciesResolver.FinalizeTransformDependencies) {
        write(value.selectedArtifacts())
    }

    override suspend fun ReadContext.decode(): DefaultTransformUpstreamDependenciesResolver.FinalizeTransformDependencies {
        val artifacts = readNonNull<FileCollectionInternal>()

    @Nullable
    ConfigurationIdentity getConfigurationIdentity();

    /**
     * Returns a collection containing the future artifacts for the given transform step.
     */
    FileCollection selectedArtifacts();

    /**
     * Computes the finalized dependency artifacts for the given transform step.
     */
    Try<TransformDependencies> computeArtifacts();

    void finalizeIfNotAlready();

            selectedArtifacts.add(variantSelector.select(variant, getRequestAttributes(), allowNoMatchingVariants, this));
        }
        CompositeResolvedArtifactSet.of(selectedArtifacts.build()).visit(listener);
    }

    @Override

        def visitedArtifactSet = Stub(VisitedArtifactSet) {
            select(_) >> selectedArtifacts(failure)
        }

        def legacyResults = DefaultResolverResults.DefaultLegacyResolverResults.graphResolved(
            depSpec -> selectedArtifacts(failure),
            Mock(ResolvedConfiguration) {
                hasError() >> true
            }
        )

        return this
    }

    override fun visitDependencies(context: TaskDependencyResolveContext) {
        throw UnsupportedOperationException("Should not be called")
    }

    override fun selectedArtifacts(): FileCollection {
        throw UnsupportedOperationException("Should not be called")
    }

    override fun finalizeIfNotAlready() {
    }

                                    <div class="card-body">
                                        <div class="form-group row">
                                            <la:errors property="selectedArtifact"/>
                                            <la:select styleId="artifacts" property="id" styleClass="form-control">
                                                <c:forEach var="item" varStatus="s"