diagnosticList.containsClashingBySimpleNameType(it)
        }
        println(",")
    }

    override fun collectImportsForDiagnosticParameter(diagnosticParameter: HLDiagnosticParameter): Collection<String> = buildSet {
        diagnosticParameter.type.collectClassNamesTo(this)
    }

    override val defaultImports = listOf(
        "org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic",

        builder: KtSymbolByFirBuilder,
    ): Pair<Collection<KtAnnotationValue>, KtElement?> {
        var representativePsi: KtElement? = null
        val flattenedVarargs = buildList {
            for (expr in this@convertVarargsExpression) {
                val converted = expr.convertConstantExpression(builder) ?: continue

                }
            }

            private fun toImportableFqNames(symbol: KtSymbol, qualifiedNameAsFqName: FqName): List<FqName> =
                buildList {
                    when (symbol) {
                        is KtCallableSymbol -> {
                            val callableId = symbol.callableIdIfNonLocal ?: return emptyList()

    init {
        extensionTools = buildList {
            addIfNotNull(useSiteSession.llResolveExtensionTool)
            useSiteModule.allDirectDependencies().mapNotNullTo(this) { dependency ->
                firResolveSession.getSessionFor(dependency).llResolveExtensionTool
            }
        }

        val shadowedScope = GlobalSearchScope.union(
            buildSet {

    }

    private fun KtAnalysisSession.getNonImportedSymbolsByFullyQualifiedName(fqName: FqName): Collection<KtSymbol> = buildSet {
        generateNameInterpretations(fqName).forEach { interpretation ->
            collectSymbolsByFqNameInterpretation(interpretation, this@buildSet)
        }
    }

    private fun KtAnalysisSession.collectSymbolsByFqNameInterpretation(
        interpretation: FqNameInterpretation,

            }
        }
    }

    class NestedType(val root: PossiblyInnerType, val nested: List<PossiblyInnerType>) {
        val allInnerTypes: List<PossiblyInnerType>
            get() = buildList {
                add(root)
                addAll(nested)
            }
    }

    override val typeContext = KtFe10TypeSystemCommonBackendContextForTypeMapping(resolveSession)

            ?: errorWithAttachment("Cannot find enclosing declaration for ${nameExpression::class}") {
                withPsiEntry("fakeNameExpression", nameExpression)
            }

        return buildList {
            addAll(towerDataContext.implicitReceiverStack)
            for (towerDataElement in towerDataContext.towerDataElements) {
                addAll(towerDataElement.contextReceiverGroup.orEmpty())
            }

        } finally {
            state.destroy()
        }
    }

    private fun computeErrors(diagnostics: Diagnostics, allowedErrorFilter: (KtDiagnostic) -> Boolean): List<KtDiagnostic> {
        return buildList {
            for (diagnostic in diagnostics.all()) {
                if (diagnostic.severity == Severity.ERROR) {
                    val ktDiagnostic = KtFe10Diagnostic(diagnostic, token)

    overriddenDescriptor: CallableMemberDescriptor
): Boolean {
    val containingClass = (descriptor.containingDeclaration as? ClassifierDescriptorWithTypeParameters)
    val typeParametersFromOuterClass = buildList { containingClass?.let { collectTypeParameters(it) } }
    val allowedTypeParameters = (overriddenDescriptor.typeParameters + typeParametersFromOuterClass).toSet()

    firScope: FirAbstractSimpleImportingScope,
    builder: KtSymbolByFirBuilder,
) : KtFirBasedScope<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 ->