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

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

        }
    }

    public object ALL : KaRendererOtherModifiersProvider {
        override fun getOtherModifiers(analysisSession: KaSession, symbol: KaDeclarationSymbol): List<KtModifierKeywordToken> {
            return buildList {
                if (symbol is KaPossibleMultiplatformSymbol) {
                    if (symbol.isActual) add(KtTokens.ACTUAL_KEYWORD)
                    if (symbol.isExpect) add(KtTokens.EXPECT_KEYWORD)
                }

        val versionsByMinor = fetchVersionsFromMavenMetadata(mavenMetadataUrl)
            .groupBy { it.take(3) }
            .toSortedMap()
        val latests = buildList {
            versionsByMinor.entries.forEachIndexed { idx, entry ->
                add(entry.value.lastOrNull { !it.contains("-") })
                if (idx < versionsByMinor.size - 1) {

	if !ok {
		return "none"
	}
	return v
}

// BuildList returns the selected versions of all modules present in the Graph,
// beginning with the selected versions of each module path in the roots of g.
//
// The order of the remaining elements in the list is deterministic
// but arbitrary.
func (g *Graph) BuildList() []module.Version {
	seenRoot := make(map[string]bool, len(g.roots))

      .build()
  }

  @JvmStatic
  fun providers(
    client: OkHttpClient,
    http2Only: Boolean,
    workingOnly: Boolean,
    getOnly: Boolean,
  ): List<DnsOverHttps> {
    return buildList {
      add(buildGoogle(client))
      if (!getOnly) {
        add(buildGooglePost(client))
      }
      add(buildCloudflare(client))
      add(buildCloudflareIp(client))
      if (!getOnly) {