*
     * In the class scope of `B`, there is a callable symbol `foo` that takes a `String`. This symbol is derived from the original symbol
     * in `A` that takes the type parameter `T` (fake override). Given such a fake override symbol, [unwrapFakeOverrides] recovers the
     * original declared symbol.
     *
     * Such situation can also happen for intersection symbols (in case of multiple super types containing symbols with identical signature

            return KaSuperTypesFilter { analysisSession, superType, symbol -> predicate(analysisSession, superType, symbol) }
        }
    }
}

    override fun <S : KaFunctionLikeSymbol> asSignature(symbol: S): KaFunctionLikeSignature<S> {
        return KaFe10FunctionLikeSignature(symbol, symbol.returnType, symbol.receiverType, symbol.valueParameters.map { asSignature(it) })
    }

    override fun <S : KaVariableLikeSymbol> asSignature(symbol: S): KaVariableLikeSignature<S> {
        return KaFe10VariableLikeSignature(symbol, symbol.returnType, symbol.receiverType)
    }

                if (symbol is KaPossibleMultiplatformSymbol) {
                    if (symbol.isActual) add(KtTokens.ACTUAL_KEYWORD)
                    if (symbol.isExpect) add(KtTokens.EXPECT_KEYWORD)
                }

                if (symbol is KaFunctionSymbol) {
                    if (symbol.isExternal) add(KtTokens.EXTERNAL_KEYWORD)
                    if (symbol.isOverride) add(KtTokens.OVERRIDE_KEYWORD)

        val platform = getContainingModule(symbol).platform
        if (!platform.has<JvmPlatform>()) return null

        val containingSymbolOrSelf = when (symbol) {
            is KaValueParameterSymbol -> {
                getContainingDeclaration(symbol) as? KaFunctionLikeSymbol ?: symbol
            }
            is KaPropertyAccessorSymbol -> {

				err = pkgError
				return
			}
			panic(e)
		}()

		switch {
		case symbol == "":
			pkg.packageDoc() // The package exists, so we got some output.
			return
		case method == "":
			if pkg.symbolDoc(symbol) {
				return
			}
		case pkg.printMethodDoc(symbol, method):
			return
		case pkg.printFieldDoc(symbol, method):
			return
		}
	}
}

    override fun getDeprecation(symbol: KaSymbol): DeprecationInfo? {
        if (symbol is KaFirPackageSymbol || symbol is KaReceiverParameterSymbol) return null
        require(symbol is KaFirSymbol<*>) { "${this::class}" }

        // Optimization: Avoid building `firSymbol` of `KtFirPsiJavaClassSymbol` if it definitely isn't deprecated.
        if (symbol is KaFirPsiJavaClassSymbol && !symbol.mayHaveDeprecation()) {
            return null

            testServices.assertions.assertEquals(directlySubstituted, substitutedViaSignature)
            testServices.assertions.assertEquals(symbol, directlySubstituted.symbol)
            testServices.assertions.assertEquals(symbol, substitutedViaSignature.symbol)
        }
        when (symbol) {
            is KaFunctionLikeSymbol -> {

        }
        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 inline fun KaTypeCreatorMixIn.buildClassType(
    symbol: KaClassLikeSymbol,
    build: KaClassTypeBuilder.() -> Unit = {},
): KaType =
    analysisSession.typesCreator.buildClassType(KaClassTypeBuilder.BySymbol(symbol, token).apply(build))

public inline fun KaTypeCreatorMixIn.buildTypeParameterType(
    symbol: KaTypeParameterSymbol,
    build: KaTypeParameterTypeBuilder.() -> Unit = {},