analysisSession: KaSession,
            symbol: KaDeclarationSymbol,
            declarationModifiersRenderer: KaDeclarationModifiersRenderer,
        ): List<KtModifierKeywordToken> {
            return buildList {
                if (symbol is KaSymbolWithVisibility) {
                    declarationModifiersRenderer.visibilityProvider.getVisibilityModifier(analysisSession, symbol)?.let(::add)
                }

) {
    fun produceAssignmentTrace(resolutionResult: ResolutionResult): AssignmentTrace {
        val assignmentResolver = assignmentResolverFactory()
        val elementResults = buildList {
            val assignments = resolutionResult.conventionAssignments + resolutionResult.assignments
            assignments.forEach { (lhs, rhs, callId, method) ->
                add(

            val nonInnerQualifiers =
                generateSequence(nestedType.root.classifierDescriptor.containingDeclaration as? ClassDescriptor) { it.containingDeclaration as? ClassDescriptor }

            buildList {
                nonInnerQualifiers.mapTo(this) {
                    KaClassTypeQualifier.KaResolvedClassTypeQualifier(
                        it.toKaClassSymbol(analysisContext),
                        emptyList(),

    firScope: FirAbstractSimpleImportingScope,
    builder: KaSymbolByFirBuilder,
) : KaFirBasedScope<FirAbstractSimpleImportingScope>(firScope, builder) {

    private val imports: List<NonStarImport> by cached {
        buildList {
            firScope.simpleImports.values.forEach { imports ->
                imports.forEach { import ->
                    val importedClassId = import.importedName?.let { importedName ->

            }
        }
    }

private suspend inline fun <T> SequenceScope<T>.yieldList(listBuilder: MutableList<T>.() -> Unit) {
    yieldAll(buildList(listBuilder))

            generateSingleConverter(type, converter)
        }
    }

    private fun SmartPrinter.collectAndPrintImports(convertersMap: Map<KClass<*>, HLParameterConversion>) {
        val imports = buildList {
            add("org.jetbrains.kotlin.analysis.api.fir.KaSymbolByFirBuilder")
            add("org.jetbrains.kotlin.analysis.api.fir.KaFirSession")
            convertersMap.values.flatMapTo(this) { it.importsToAdd }

            psiFiles,
        )
    }

    private fun collectVirtualFilesByRoots(): List<VirtualFile> {
        val localFileSystem = kotlinCoreProjectEnvironment.environment.localFileSystem
        return buildList {
            for (root in sourceRoots) {
                val files = when {
                    root.isDirectory() -> collectSourceFilePaths(root)
                    root.hasSuitableExtensionToAnalyse() -> listOf(root)

import org.gradle.internal.declarativedsl.language.SingleFailureResult
import org.gradle.internal.declarativedsl.language.This


internal
fun collectFailures(results: Iterable<ElementResult<*>>): List<SingleFailureResult> = buildList {
    fun addExpanded(failingResult: FailingResult) {
        when (failingResult) {
            is SingleFailureResult -> add(failingResult)
            is MultipleFailuresResult -> failingResult.failures.forEach(::addExpanded)

        allKtModules
            .flatMap { it.allDirectDependencies() }
            .filterIsInstance<KtBinaryModule>()
    }

    override val allSourceFiles: List<PsiFileSystemItem> by lazy {
        buildList {
            val files = allKtModules.mapNotNull { (it as? KtSourceModuleImpl)?.sourceRoots }.flatten()
            addAll(files)
            addAll(findJvmRootsForJavaFiles(files.filterIsInstance<PsiJavaFile>()))
        }

        if (kotlinFile.packageFqName != packageFqName) {
            return emptyList()
        }

        return buildList {
            for (declaration in topLevelDeclarations) {
                if (declaration is T && declaration.nameAsName == name) {
                    add(declaration)
                }
            }
        }