import org.jetbrains.kotlin.analysis.api.symbols.KaCallableSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KaClassLikeSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KaFunctionSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol
import org.jetbrains.kotlin.analysis.api.symbols.markers.KaNamedSymbol

}

func (f *peFile) symbols() ([]Sym, error) {
	// Build sorted list of addresses of all symbols.
	// We infer the size of a symbol by looking at where the next symbol begins.
	var addrs []uint64

	imageBase, _ := f.imageBase()

	var syms []Sym
	for _, s := range f.pe.Symbols {
		const (
			N_UNDEF = 0  // An undefined (extern) symbol
			N_ABS   = -1 // An absolute symbol (e_value is a constant, not an address)

// Mimic [psiForUast] in FIR UAST
internal fun KaSession.psiForTest(symbol: KaSymbol, project: Project): PsiElement? {
    return when (symbol.origin) {
        KaSymbolOrigin.LIBRARY -> {
            findPsi(symbol, project) ?: symbol.psi
        }
        KaSymbolOrigin.SUBSTITUTION_OVERRIDE, KaSymbolOrigin.INTERSECTION_OVERRIDE -> {
            psiForTest((symbol as KaCallableSymbol).unwrapFakeOverrides, project)
        }

        }
        return null
    }
}

internal fun KaSession.getPsiDeclarations(symbol: KaFirSymbol<*>): Collection<PsiElement> {
    val intersectionOverriddenSymbolsOrSingle = when {
        symbol.origin == KaSymbolOrigin.INTERSECTION_OVERRIDE && symbol is KaCallableSymbol -> symbol.getIntersectionOverriddenSymbols()
        else -> listOf(symbol)
    }

    public abstract fun getDeprecation(symbol: KaSymbol): DeprecationInfo?
    public abstract fun getDeprecation(symbol: KaSymbol, annotationUseSiteTarget: AnnotationUseSiteTarget?): DeprecationInfo?
    public abstract fun getGetterDeprecation(symbol: KaPropertySymbol): DeprecationInfo?
    public abstract fun getSetterDeprecation(symbol: KaPropertySymbol): DeprecationInfo?

    public open fun <S : KaCallableSymbol> substitute(symbol: S, substitutor: KaSubstitutor): KaCallableSignature<S> = when (symbol) {
        is KaFunctionLikeSymbol -> substitute(symbol, substitutor)
        is KaVariableLikeSymbol -> substitute(symbol, substitutor)
        else -> unexpectedElementError("symbol", symbol)
    }

    public abstract fun <S : KaFunctionLikeSymbol> substitute(symbol: S, substitutor: KaSubstitutor): KaFunctionLikeSignature<S>

    }

    override fun getGetterDeprecation(symbol: KaPropertySymbol): DeprecationInfo? {
        return getAccessorDeprecation(symbol, symbol.getter) { it.getter }
    }

    override fun getSetterDeprecation(symbol: KaPropertySymbol): DeprecationInfo? {
        return getAccessorDeprecation(symbol, symbol.setter) { it.setter }
    }

    override fun getJavaGetterName(symbol: KaPropertySymbol): Name {

    ): Collection<PsiElement> = with(analysisSession) {
        referenceTargetSymbols.flatMap { symbol ->
            when (symbol) {
                is KaFirSyntheticJavaPropertySymbol -> listOfNotNull(symbol.javaGetterSymbol.psi, symbol.javaSetterSymbol?.psi)
                is KaFirSymbol<*> -> getPsiDeclarations(symbol)
                else -> listOfNotNull(symbol.psi)
            }
        }
    }

	// symbol reference in the object file.
	pkgIdx map[string]int32

	defs         []*LSym // list of defined symbols in the current package
	hashed64defs []*LSym // list of defined short (64-bit or less) hashed (content-addressable) symbols
	hasheddefs   []*LSym // list of defined hashed (content-addressable) symbols
	nonpkgdefs   []*LSym // list of defined non-package symbols

        return memberFir.symbol.getImplementationStatus(
            SessionHolderImpl(
                rootModuleSession,
                analysisSession.getScopeSessionFor(analysisSession.useSiteSession),
            ),
            parentClassFir.symbol
        )
    }

    override fun getOriginalContainingClassForOverride(symbol: KaCallableSymbol): KaClassOrObjectSymbol? {