}
tasks.register<Consumer>("consumer") {
    // Connect the producer task output to the consumer task input
    // Don't need to add a task dependency to the consumer task. This is automatically added
    message = producer.flatMap { it.outputFile }.map { it.asFile.readText() }

        public fun provideExtensionsFor(module: KtModule): List<KaResolveExtension> {
            return EP_NAME.getExtensionList(module.project).flatMap { it.provideExtensionsFor(module) }
        }
    }
}

    }

    override fun getResolvedToPsi(
        analysisSession: KaSession,
        referenceTargetSymbols: Collection<KaSymbol>,
    ): Collection<PsiElement> = with(analysisSession) {
        referenceTargetSymbols.flatMap { symbol ->
            when (symbol) {
                is KaFirSyntheticJavaPropertySymbol -> listOfNotNull(symbol.javaGetterSymbol.psi, symbol.javaSetterSymbol?.psi)
                is KaFirSymbol<*> -> getPsiDeclarations(symbol)

        }

        val element = ktReferences.first().element
        val resolvedTo = analyseForTest(element) {
            val symbols = ktReferences.flatMap { it.resolveToSymbols() }
            val psiElements = symbols.mapNotNull { psiForTest(it, element.project) }
            psiElements.joinToString(separator = "\n") { TestPsiElementRenderer.render(it) }
        }

                // TODO:configuration should this `dependsOn` be necessary here?
                dependsOn 'producer'

                Provider<String> computedDirName = computeDirName.flatMap { it.dirName }.map { it.asFile.text }
                def file = layout.buildDirectory.$provider
                outputFile = file
                doLast {
                    println(file.get().asFile.text)
                }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val carets = testServices.expressionMarkerProvider.getAllCarets(mainFile)
        carets.flatMap { findReferencesAtCaret(mainFile, it.offset) }.forEach { reference ->
            val resolved = reference.resolve() ?: testServices.assertions.fail { "Could not resolve reference at caret" }

        override val content: Collection<DeclarativeDocument.DocumentNode>
            get() = document.content
                .filter { node -> isTopLevelConventionsCall(node, resolutionContainer) }
                .flatMap { (it as? ElementNode)?.content.orEmpty() }
                .filterIsInstance<ElementNode>()
                .filter { it.name in usedSoftwareTypes }

        override val sourceIdentifier: SourceIdentifier

        val discoveredCollectorDeclarations: List<DependencyCollectorDeclaration> = kClass.memberFunctions
            .filter { function -> hasDependencyCollectorGetterSignature(kClass, function) }
            .flatMap { function ->
                val name = dependencyCollectorNameFromGetterName(function.name)
                expandToOverloads { param ->
                    DependencyCollectorDeclaration(

consumer {
    // Connect the producer task output to the consumer task input
    // Don't need to add a task dependency to the consumer task. This is automatically added
    inputFile = producer.flatMap { it.outputFile }
}

producer {
    // Set values for the producer lazily
    // Don't need to update the consumer.inputFile property. This is automatically updated as producer.outputFile changes

public class FetchRootProjectsTasks implements BuildAction<List<Task>> {
    @Override
    public List<Task> execute(BuildController controller) {
        return controller.getBuildModel().getEditableBuilds().stream()
            .flatMap(build -> controller.getModel(build.getRootProject(), GradleProject.class).getTasks().stream())
            .collect(toList());
    }