consumer.configure {
    // 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.configure {
    // Set values for the producer lazily
    // Don't need to update the consumer.inputFile property. This is automatically updated as producer.outputFile changes

                    task.getCompilerArgs().add("-parse-as-library");
                }
            });

            binary.getModuleFile().set(compile.flatMap(task -> task.getModuleFile()));
            binary.getCompileTask().set(compile);
            binary.getObjectsDir().set(compile.flatMap(task -> task.getObjectFileDir()));
        });

        project.getComponents().withType(ProductionSwiftComponent.class, component -> {

    }

    @Nullable
    @Override
    public HashCode hash(RegularFileSnapshotContext snapshotContext) throws IOException {
        return Optional.of(snapshotContext)
            .filter(this::filter)
            .flatMap(path -> tryHash(snapshotContext))
            .orElseGet(IoSupplier.wrap(() -> delegate.hash(snapshotContext)));
    }

    @Nullable
    @Override

        1 * sideEffect.execute(24)
        0 * _

        where:
        description               | wrap
        "Provider.map"            | { p, m -> p.map(m) }
        "Provider.flatMap"        | { p, m -> p.flatMap { Providers.of(m.call(it)) } }
        "TransformBackedProvider" | { p, m -> new TransformBackedProvider(null, p, m) }
        "MappingProvider"         | { p, m -> new MappingProvider(Integer, p, m) }
    }

    /**
     * All found class files bytes by Kotlin source name.
     */
    fun allClassesBytesBySourceName(): Sequence<Pair<String, ClassBytesSupplier>> =
        relevantClassPathFiles.asSequence()
            .flatMap { sourceNamesFrom(it) }
            .mapNotNull { sourceName ->
                classBytesSupplierForSourceName(sourceName)?.let { sourceName to it }
            }

    private

        return ExpectedActualResolver.findExpectedForActual(memberDescriptor).orEmpty().asSequence()
            .filter { it.key.isCompatibleOrWeaklyIncompatible }
            .flatMap { it.value }
            .map { it.toKtSymbol(analysisContext) as KaDeclarationSymbol }
            .toList()
    }

}
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) }
        }