}

            tasks.register('consumer', ConcatTask) {
                // Create a complex file collection chain involving `flatMap`, `map` and `filter`
                Provider<RegularFile> producerOutputFile = producer.flatMap { it.outputFile }
                Provider<List<RegularFile>> mappedOutputFile = producerOutputFile.map { [it] }

    }

    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

    }

    private static Map<AccessorKey, ReplacedAccessor> mapOldAccessorsOfUpgradedProperties(List<UpgradedProperty> upgradedProperties) {
        return upgradedProperties.stream()
            .flatMap(UpgradePropertiesRuleSetup::mapOldAccessorsOfUpgradedProperty)
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }

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

        ) {
            printer {
                val allBounds = symbol.typeParameters
                    .filter { declarationRenderer.typeParametersFilter.filter(analysisSession, it, symbol) }
                    .flatMap { typeParam ->
                        if (typeParam.upperBounds.size > 1) {
                            typeParam.upperBounds.map { bound -> typeParam to bound }
                        } else {

        String id = id(nonNull(artifact, "artifact"));
        if (session.getMavenSession().getAllProjects() != null) {
            session.getMavenSession().getAllProjects().stream()
                    .flatMap(this::getProjectArtifacts)
                    .filter(a -> Objects.equals(id, id(a)))
                    .forEach(a -> a.setFile(path != null ? path.toFile() : null));
        }
        if (path == null) {

     *
     * @return a stream containing this node and its descendant
     */
    @Nonnull
    default Stream<Node> stream() {
        return Stream.concat(Stream.of(this), getChildren().stream().flatMap(Node::stream));
    }

        val psiOfReferenceTarget = super.getResolvedToPsi(analysisSession, referenceTargetSymbols)
        if (psiOfReferenceTarget.isNotEmpty()) return psiOfReferenceTarget
        referenceTargetSymbols.flatMap { symbol ->
            when (symbol) {
                is KaFirSyntheticJavaPropertySymbol ->
                    if (isRead) {
                        listOfNotNull(symbol.javaGetterSymbol.psi)
                    } else {

        val checkFeatures = step.features.filterIsInstance<DocumentChecks>()
        val checkResults = stepContext.supportedDocumentChecks.filter { checkFeatures.any(it::shouldHandleFeature) }
            .flatMap { it.detectFailures(document, documentResolutionContainer) }

        if (checkResults.isNotEmpty()) {
            failureReasons += DocumentCheckFailures(checkResults)
        }

            val headerProto = parseModuleHeader(library.moduleHeaderData)

            val packageMetadataSequence = headerProto.packageFragmentNameList.asSequence().flatMap { packageFragmentName ->
                library.packageMetadataParts(packageFragmentName).asSequence().map { packageMetadataPart ->
                    library.packageMetadata(packageFragmentName, packageMetadataPart)