}
        }
    }

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

		toolchain.SwitchOrFatal(ctx, err)
	}

	buildList := mg.BuildList()
	initialVersion := make(map[string]string, len(buildList))
	for _, m := range buildList {
		initialVersion[m.Path] = m.Version
	}

	r := &resolver{
		work:             par.NewQueue(runtime.GOMAXPROCS(0)),
		resolvedVersion:  map[string]versionReason{},
		buildList:        buildList,
		buildListVersion: initialVersion,

        context: AnalysisContext
    ): List<FunctionResolutionAndBinding> {
        var hasErrorInReceiverResolution = false
        val overloads: List<FunctionResolutionAndBinding> = buildList {
            when (functionCall.receiver) {
                is Expr -> {
                    val receiver = expressionResolver.doResolveExpression(context, functionCall.receiver)
                    if (receiver != null) {

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

                    StandardNames.getFunctionClassId(parametersCount)
                }
                buildString {
                    append(classId.asSingleFqName().toString())
                    val parameters = buildList {
                        receiverTypeRef?.let(::add)
                        parameters.mapTo(this) { it.returnTypeRef }
                        returnTypeRef.let(::add)
                    }

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

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

            val diagnosticsInFile =
                ktFile.collectDiagnosticsForFile(KaDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS).map { it.getKey() }.sorted()
            val diagnosticsFromElements = buildList {
                ktFile.accept(object : KtTreeVisitorVoid() {
                    override fun visitKtElement(element: KtElement) {