}
        }

        return null
    }
}

private fun FqName.dropFakeRootPrefixIfPresent(): FqName =
    tail(FqName(ROOT_PREFIX_FOR_IDE_RESOLUTION_MODE))

private data class AdditionalImports(val simpleImports: Set<FqName>, val starImports: Set<FqName>)

private inline fun <reified T : KtElement> KtFile.findSmallestElementOfTypeContainingSelection(selection: TextRange): T? =

        renderer: KaDeclarationRenderer,
        additionalInfo: KaSession.(KaSymbol) -> String?
    ): String {
        return buildString {
            symbolContainerFqName(symbol)?.let { fqName ->
                append("(in $fqName) ")
            }
            when (symbol) {
                is KaDeclarationSymbol -> {
                    append(symbol.render(renderer))
                    if (renderPsiClassName) {

                            }
                        }
                        is KaClassLikeSymbol -> {
                            val fqName = symbol.classId?.asSingleFqName()
                            if (fqName != null && fqName != qualifiedNameAsFqName) {
                                this += fqName
                            }
                        }
                    }
                }
        })

    DataTypeRef.Name::class
])
sealed interface DataTypeRef : Serializable {
    interface Type : DataTypeRef {
        val dataType: DataType
    }

    interface Name : DataTypeRef {
        val fqName: FqName
    }

                else -> error("Invalid symbol kind, expected one of: $identifiers")
            }
        }
    }
}

private fun extractPackageFqName(data: String): FqName = FqName.fromSegments(data.split('.'))

private fun extractCallableId(fullName: String): CallableId {
    val name = if ('.' in fullName) fullName.substringAfterLast(".") else fullName.substringAfterLast('/')

import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds

object KaFirArrayOfSymbolProvider {
    internal fun KaFirSession.arrayOfSymbol(identifier: Name): KaFirFunctionSymbol? {

	if err == nil {
		klog.V(3).InfoS("TimingRatioHistogramVec.NewForLabelValuesSafe hit the efficient case", "fqName", v.FQName(), "labelValues", labelValues)
		return tro
	}
	if !compbasemetrics.ErrIsNotRegistered(err) {
		klog.ErrorS(err, "Failed to extract TimingRatioHistogramVec member, using noop instead", "vectorname", v.FQName(), "labelValues", labelValues)
		return tro
	}

package org.gradle.internal.declarativedsl.analysis

import org.gradle.declarative.dsl.evaluation.OperationGenerationId
import org.gradle.declarative.dsl.schema.AnalysisSchema
import org.gradle.declarative.dsl.schema.FqName
import org.gradle.internal.declarativedsl.language.Block
import org.gradle.internal.declarativedsl.language.Import


interface Resolver {
    fun resolve(schema: AnalysisSchema, imports: List<Import>, topLevelBlock: Block): ResolutionResult

                return CallableId(
                    packageName = current.fqName,
                    className = if (className.isNotEmpty()) FqName.fromSegments(className.asReversed()) else null,
                    callableName = name,
                    pathToLocal = if (localName.isNotEmpty()) FqName.fromSegments(localName.asReversed()) else null
                )
            }

MODULE_FRAGMENT
  FILE fqName:<root> fileName:context.kt
    FUN name:call visibility:local modality:FINAL <> () returnType:kotlin.Unit
    FUN name:test visibility:public modality:FINAL <> () returnType:kotlin.Unit
      BLOCK_BODY
        VAR name:x type:kotlin.Int [var]
          CONST Int type=kotlin.Int value=0
        FUN LOCAL_FUNCTION name:call visibility:local modality:FINAL <> () returnType:kotlin.Unit
          BLOCK_BODY