listOf(
            kotlinDslImplicitImports to implicitImportsForPrecompiledScriptPlugins(implicitImports, classPathFingerprinter, classPathFiles)
        ) + precompiledScriptPluginImportsFrom(metadataDir.asFile)
    )
}


private
fun precompiledScriptPluginImportsFrom(metadataDirFile: File): List<Pair<String, List<String>>> =
    metadataDirFile.run {
        require(isDirectory)
        listFilesOrdered().map {

    @get:PathSensitive(PathSensitivity.RELATIVE)
    abstract val apiChangesDirectory: DirectoryProperty

    protected
    fun loadChanges(): Map<File, List<AcceptedApiChange>> {
        return apiChangesDirectory.get().asFile.listFiles()
            ?.filter {
                it.name.endsWith(".json")
            }?.associate {
                it to it.readAcceptedChanges()
            }?.filterValues {

    init {
        lowestTestedVersion = GradleVersion.version("3.0")
        lowestInterestingVersion = GradleVersion.version("0.8")

        val releasedVersions = releasedVersionsFile.asFile.reader().use {
            Gson().fromJson(it, ReleasedVersions::class.java)
        }

        val latestFinalRelease = releasedVersions.finalReleases.first()
        val latestRelease =

    @get:InputArtifact
    @get:Classpath
    abstract val inputArtifact: Provider<FileSystemLocation>

    override fun transform(outputs: TransformOutputs) {
        val jarFile = inputArtifact.get().asFile
        val zipFile = ZipFile(jarFile)
        val outputRoot = outputs.dir("public-api")
        zipFile.stream().forEach { entry ->
            if (entry.shouldInclude()) {

                @InputArtifact
                abstract Provider<FileSystemLocation> getInput()

                void transform(TransformOutputs outputs) {
                    def dir = input.get().asFile
                    assert dir.directory
                    println("transforming [\${dir.name}]")
                    outputs.file("\${dir.name}.size").text = 'ok'
                }
            }
        """

            succeeds 'verify'
        }

        where:
        [provider, configFromExtension] << [
            [
                'flatMap { it.output }.map { it.asFile.text }',
                'flatMap { it.output }.map { it.asFile }.map { it.text }',
            ],
            [false, true]
        ].combinations()
    }

    def "circular evaluation of map property is detected"() {
        buildFile """

                        dep.buildDependencies(sourceJar, javadocJar)
                        dep.publicationSourcePath = cp.fileReference(sourceJar.archiveFile.get().asFile)
                        dep.publicationJavadocPath = cp.fileReference(javadocJar.archiveFile.get().asFile)
                    }
                }
            }
        """
        }

        Task htmlReport = project.tasks.getByName(ProjectReportsPlugin.HTML_DEPENDENCY_REPORT);
        htmlReport instanceOf(HtmlDependencyReportTask.class)
        htmlReport.reports.html.outputLocation.get().asFile == new File(project.buildDir, "reports/project/dependencies")
        htmlReport.projects == [project] as Set

        Task projectReport = project.getTasks().getByName(ProjectReportsPlugin.PROJECT_REPORT);

            def copy1 = tasks.register("copy1", Copy) {
                destinationDir = layout.buildDirectory.dir("copy1").get().asFile
                from file("copy1source.txt")
            }

            def copy2 = tasks.register("copy2", Copy) {
                destinationDir = layout.buildDirectory.dir("copy2").get().asFile
                from file("copy2source.txt")
            }

            tasks.register("reader") {

                abstract ProjectLayout getLayout()

                @TaskAction
                void generate() {
                    layout.buildDirectory.dir("some-dir").get().asFile.mkdirs()
                    layout.buildDirectory.file("some-dir/output.txt").get().asFile.text = "output"
                }
            }

            task pluralOutputs(type: PluralOutputs)
        """
        when: