Provider<Set<ResolvedArtifactResult>> resolvedArtifacts = resolvableDependencies.getArtifacts().getResolvedArtifacts();

                task.getArtifactFiles().from(resolvableDependencies.getArtifacts().getArtifactFiles());
                task.getArtifactIdentifiers().set(resolvedArtifacts.map(result -> result.stream().map(ResolvedArtifactResult::getId).collect(toList())));

    @Input
    public abstract ListProperty<ComponentArtifactIdentifier> getArtifactIdentifiers();

    @InputFiles
    public abstract ConfigurableFileCollection getArtifactFiles();

    @Input
    public abstract Property<ResolvedComponentResult> getRootComponent();

    @OutputFile
    public abstract RegularFileProperty getOutputFile();

    @TaskAction

// end::inputs[]

    @Input
    public abstract ListProperty<ResolvedVariantResult> getArtifactVariants();

    @InputFiles
    public abstract ListProperty<RegularFile> getArtifactFiles();

    @OutputFile
    public abstract RegularFileProperty getOutputFile();

    @TaskAction
    public void action() throws IOException {
        File outputFile = getOutputFile().getAsFile().get();

        return fileCollection.getResolutionHost();
    }

    @Override
    public boolean isLenient() {
        return lenient;
    }

    @Override
    public FileCollection getArtifactFiles() {
        return fileCollection;
    }

    @Override
    public Set<ResolvedArtifactResult> getArtifacts() {
        ensureResolved();
        return result.get().artifactResults;
    }

                @Internal
                ArtifactCollection artifacts

                @InputFiles
                FileCollection getArtifactFiles() {
                    return artifacts.getArtifactFiles()
                }

                @OutputFile File outputFile
            }
"""
    }

    def "artifact collection has resolved artifact files and metadata"() {

    /**
     * A file collection containing the files for all artifacts in this collection.
     * This is primarily useful to wire this artifact collection as a task input.
     */
    FileCollection getArtifactFiles();

    /**
     * Returns the resolved artifacts, performing the resolution if required.
     * This will resolve the artifact metadata and download the artifact files as required.
     *

                implementation("org.gradle.repro:lib@pom")
            }

            abstract class Resolve extends DefaultTask {
                @InputFiles
                abstract ConfigurableFileCollection getArtifactFiles()

                @TaskAction
                void printThem() {
                    assert artifactFiles.size() == 0
                }
            }
        """

            }

            abstract class TaskWithArtifactCollectionResultProviderInput extends DefaultTask {

                @InputFiles
                abstract ConfigurableFileCollection getArtifactFiles()

                @Internal
                abstract SetProperty<ResolvedArtifactResult> getResolvedArtifacts()

                @OutputFile
                abstract RegularFileProperty getOutputFile()

        });
    }

    private FileCollection filterArtifactsFromImplicitBuilds(Configuration configuration) {
        return configuration.getIncoming().artifactView(fromSourceDependency()).getArtifacts().getArtifactFiles();
    }

    private void configureXcodeForSwift(final Project project) {
        project.afterEvaluate(new Action<Project>() {
            @Override
            public void execute(final Project project) {

                Resolve() {
                    outputs.upToDateWhen { false }
                }

                @Optional
                @InputFiles
                FileCollection getArtifactFiles() {
                    return artifacts.get().artifactFiles
                }

                @TaskAction
                void run() {