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)

                // 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(

    isTransitive = false
    extendsFrom(manifestClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

tasks.jar.configure {
    val classpath = resolveManifestClasspath.flatMap { configuration ->
        configuration.elements.map { classpathDependency ->
            classpathDependency.joinToString(" ") { it.asFile.name }
        }
    }
    manifest.attributes("Class-Path" to classpath)

        )
}

tasks.withType<IntegrationTest>() {
    val argument = objects.newInstance(IntegTestCommandLineArgumentProvider::class.java).apply {
        repoLocation.fileProvider(resolveTestRepo.flatMap { it.elements }.map { it.first().asFile })
        kotlinVersion = libs.kotlinVersion
    }
    jvmArgumentProviders.add(argument)

        public fun resolveKdocFqName(analysisSession: KaSession, fqName: FqName, contextElement: KtElement): Collection<KaSymbol> =
            EP_NAME.extensions.flatMap { it.resolveKdocFqName(analysisSession, fqName, contextElement) }
    }

        it.stageName in listOf(
            StageName.QUICK_FEEDBACK_LINUX_ONLY,
            StageName.QUICK_FEEDBACK,
            StageName.PULL_REQUEST_FEEDBACK,
            StageName.READY_FOR_NIGHTLY,
        )
    }.flatMap { it.functionalTests }.filter { it.os == os }

    if (os == Os.LINUX) {
        steps {
            script {