is KtFirNamedClassOrObjectSymbol -> firSymbol.fir
        is KtFirPsiJavaClassSymbol -> firSymbol.fir
        is KtFirAnonymousObjectSymbol -> firSymbol.fir
        else -> error(
            "`${this::class.qualifiedName}` needs to be specially handled by the scope provider or is an unknown" +
                    " ${KtSymbolWithDeclarations::class.simpleName} implementation."
        )
    }

                AnalysisSessionMode.Normal -> AnalysisApiFe10TestConfigurator
                AnalysisSessionMode.Dependent -> error("Unsupported AnalysisSessionMode.Dependent for fe10")
            }

            else -> {
                error("Unsupported non-source module for fe10")
            }
        }
    }

    override fun supportMode(data: AnalysisApiTestConfiguratorFactoryData): Boolean {
        return when {

internal fun FirNamedReference.getCandidateSymbols(): Collection<FirBasedSymbol<*>> = when (this) {
    is FirResolvedNamedReference -> listOf(resolvedSymbol)
    is FirErrorNamedReference -> getCandidateSymbols()
    else -> emptyList()
}

internal fun ConeDiagnostic.getCandidateSymbols(): Collection<FirBasedSymbol<*>> =
    when (this) {
        is ConeHiddenCandidateError -> {

        is Map<*, *> -> convertArgument(argument, firSymbolBuilder)
        is Collection<*> -> convertArgument(argument, firSymbolBuilder)
        is Pair<*, *> -> convertArgument(argument, firSymbolBuilder)
        else -> argument
    }
}

private fun convertArgument(argument: FirRegularClass, firSymbolBuilder: KtSymbolByFirBuilder): Any? {

        return fe10Annotations.mapIndexedNotNull { index, annotation ->
            if (annotation.classIdForAnnotation in annotationsToIgnore) {
                ignoredAnnotationsCounter++
                null
            } else {
                transformer(index - ignoredAnnotationsCounter, annotation)
            }
        }
    }

    companion object {
        fun create(
            fe10Annotations: Annotations,

    }

    private fun tryMapFirTypeToKtType(kClass: KClass<*>, nullable: Boolean): HLParameterConversion? {
        return if (nullable) {
            nullableTypeMapping[kClass] ?: typeMapping[kClass]
        } else {
            typeMapping[kClass]
        }
    }

    private fun tryMapAllowedType(kClass: KClass<*>): HLParameterConversion? {
        if (kClass in allowedTypesWithoutTypeParams) return HLIdParameterConversion

        val extension = when (pluginType) {
            CompilerPluginType.ASSIGNMENT -> AssignResolutionAltererExtension
            else -> return false
        }
        return extension.getInstances(module.project).isNotEmpty()
    }

        get() = withValidityAssertion { analysisContext.resolveSession.getFileAnnotations(file) }

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion { if (file.isCompiled) KtSymbolOrigin.LIBRARY else KtSymbolOrigin.SOURCE }

    override fun createPointer(): KtSymbolPointer<KtFileSymbol> = withValidityAssertion {
        KtPsiBasedSymbolPointer.createForSymbolFromSource<KtFileSymbol>(this) ?: KtFe10NeverRestoringSymbolPointer()

        get() = withValidityAssertion {
            val virtualFile = PsiUtilCore.getVirtualFile(psi)
            return if (virtualFile != null) {
                analysisContext.getOrigin(virtualFile)
            } else {
                KtSymbolOrigin.LIBRARY
            }
        }

    override fun hashCode(): Int {
        return packageName.hashCode()
    }

    override fun equals(other: Any?): Boolean {

        val result = ArrayList<KtType>(supertypes.size)
        val isNullable = fe10Type.isMarkedNullable
        for (supertype in supertypes) {
            val mappedSupertype = if (isNullable) supertype.makeNullable() else supertype
            result += mappedSupertype.toKtType(analysisContext)
        }
        return@cached result
    }

    override val nullability: KtTypeNullability