nameMapper = { ElementType.entries.firstOrNull { enumValue -> enumValue.name == it }?.name },
)

private fun <T> FirAnnotation.findFromRawArguments(expectedEnumClass: ClassId, transformer: (String) -> T?): Set<T> = buildSet {
    fun addIfMatching(arg: FirExpression) {
        if (arg !is FirQualifiedAccessExpression) return
        val callableSymbol = arg.calleeReference.toResolvedCallableSymbol() ?: return

            CallableCopyTypeCalculator.DoNothing,
            requiredMembersPhase = FirResolvePhase.STATUS,
        ) ?: return emptyList()

        return buildList {
            scope.processFunctionsByName(OperatorNameConventions.EQUALS) { functionSymbol ->
                val parameterSymbol = functionSymbol.valueParameterSymbols.singleOrNull()

        val graphIndex = ControlFlowGraphIndex {
            getControlFlowGraph(anchor = statements.first(), firStatements = firStatements)
        }

        val jumpExpressions = buildList {
            fun add(expressions: List<FirElement>) {
                expressions.mapNotNullTo(this) { it.psi as? KtExpression }
            }

            add(collector.firReturnExpressions)

        }

        val compilationPeerData = CompilationPeerCollector.process(mainFirFile)

        val filesToCompile = buildList {
            val dependencyFiles = buildSet {
                addAll(compilationPeerData.files)
                addAll(codeFragmentMappings?.capturedFiles.orEmpty())

    override fun getPossibleCallableNames(): Set<Name> = buildSet {
        addAll(firstWrappedScope.getPossibleCallableNames())
        addAll(secondWrappedScope.getPossibleCallableNames())
    }

    override fun getPossibleClassifierNames(): Set<Name> = buildSet {
        addAll(firstWrappedScope.getPossibleClassifierNames())

    protected abstract fun isTargetCallable(callable: FirCallableSymbol<*>): Boolean

    private val cachedCallableNames by lazy(LazyThreadSafetyMode.NONE) {
        buildSet {
            baseScope.processAllCallables { callable ->
                if (isTargetCallable(callable)) {
                    add(callable.name)
                }
            }
        }
    }

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

            buildList {
                nonInnerQualifiers.mapTo(this) {
                    KtClassTypeQualifier.KtResolvedClassTypeQualifier(
                        it.toKtClassSymbol(analysisContext),
                        emptyList(),

            }
            println()
        }
    }

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

    override val defaultImports = listOf(
        "org.jetbrains.kotlin.analysis.api.diagnostics.KtDiagnosticWithPsi",

        println()
        collectAndPrintImports(diagnosticList)
        println()
        printGeneratedMessage()
    }

    protected fun collectImports(diagnosticList: HLDiagnosticList): Collection<String> = buildSet {
        addAll(defaultImports)
        for (diagnostic in diagnosticList.diagnostics) {
            diagnostic.original.psiType.collectClassNamesTo(this)
            diagnostic.parameters.forEach { diagnosticParameter ->

            generateSingleConverter(type, converter)
        }
    }

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