println(sourceFragment.replaceIndent("    "))
        println()
    }
}


private
fun accessorSourceFragmentsFor(schema: TypedProjectSchema): Sequence<String> =
    accessorsFor(schema.map(::accessible)).flatMap { accessor ->
        val (_, fragments) = fragmentsFor(accessor)
        fragments
            .map { it.source }
            .filter { it.isNotBlank() }

    }

    @Override
    public Map<PerformanceExperimentOnOs, Long> getEstimatedExperimentDurationsInMillis() {
        return stores.stream()
            .flatMap(store -> store.getEstimatedExperimentDurationsInMillis().entrySet().stream())
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, Math::max, LinkedHashMap::new));
    }

            classFileManagerType = Optional.of(TransactionalManagerType.of(spec.getClassfileBackupDir(), new SbtLoggerAdapter()));
        }

        PreviousResult previousResult = analysisStore.flatMap(store -> store.get()
            .map(a -> PreviousResult.of(Optional.of(a.getAnalysis()), Optional.of(a.getMiniSetup()))))
            .orElse(PreviousResult.of(Optional.empty(), Optional.empty()));

    dirToArchive = layout.buildDirectory.dir("toArchive")
}

// tag::copy-single-file-example-with-task-properties[]
tasks.register<Copy>("copyReport2") {
    from(myReportTask.flatMap { it.outputFile })
    into(archiveReportsTask.flatMap { it.dirToArchive })
}
// end::copy-single-file-example-with-task-properties[]

// tag::copy-multiple-files-example[]
tasks.register<Copy>("copyReportsForArchiving") {

    val memberName: String,
    val pluginId: String,
    val implementationClass: String
)


private
fun pluginExtensionsFrom(jars: Iterable<File>): Sequence<PluginExtension> =
    jars.asSequence().flatMap(::pluginExtensionsFrom)


private
fun pluginExtensionsFrom(file: File): Sequence<PluginExtension> =
    pluginEntriesFrom(file)
        .asSequence()
        .map { (id, implementationClass) ->

        project.serviceOf<ModuleRegistry>().run {
            StandardKotlinBuildScriptTemplateModel(
                gradleModules
                    .map { getModule(it) }
                    .flatMap { it.allRequiredModules }
                    .fold(ClassPath.EMPTY) { classPath, module -> classPath + module.classpath }
                    .asFiles
            )
        }
}


internal

        if (os.isLinux()) {
            return Arrays.stream(roots)
                .map(root -> FileBasedInstallationFactory.fromDirectory(root, getSourceName(), InstallationLocation::autoDetected))
                .flatMap(Set::stream)
                .collect(Collectors.toSet());
        }
        return Collections.emptySet();
    }

    }

    public fun createFlattened(providers: List<P>): P =
        create(if (providers.size > 1) flatten(providers) else providers)

    public fun flatten(providers: List<P>): List<P> =
        providers.flatMap { provider ->
            // `KotlinCompositeProvider<P>` should always be a provider of type `P` itself, so the cast is legal. Still, suppressing the

        def compileTask = Mock(JavaCompile)
        def compileTaskProvider = Stub(TaskProvider) {
            configure(_) >> { it[0].execute(compileTask) }
            get() >> compileTask
            flatMap(_) >> objectFactory().directoryProperty()
        }
        def allJava = Mock(SourceDirectorySet)
        def allSource = Mock(SourceDirectorySet)
        def classesTask = Mock(Task)

    }

    internal val binaryModules: List<KtBinaryModule> by lazy {
        allKtModules
            .flatMap { it.allDirectDependencies() }
            .filterIsInstance<KtBinaryModule>()
    }

    override val allSourceFiles: List<PsiFileSystemItem> by lazy {
        buildList {