public infix fun and(other: KaRendererAnnotationsFilter): KaRendererAnnotationsFilter =
        KaRendererAnnotationsFilter filter@{ annotation, owner ->
            val analysisSession = this@filter
            filter(analysisSession, annotation, owner) && other.filter(analysisSession, annotation, owner)
        }

    public infix fun or(other: KaRendererAnnotationsFilter): KaRendererAnnotationsFilter =

import org.jetbrains.kotlin.lexer.KtKeywordToken

public interface KaRendererKeywordFilter {
    public fun filter(analysisSession: KaSession, modifier: KtKeywordToken, annotated: KaAnnotated): Boolean

    public infix fun and(other: KaRendererKeywordFilter): KaRendererKeywordFilter {
        val self = this
        return KaRendererKeywordFilter filter@{ modifier, kaAnnotated ->
            val analysisSession = this@filter

    in '0'..'9' -> this - '0'
    in 'a'..'f' -> this - 'a' + 10
    in 'A'..'F' -> this - 'A' + 10
    else -> -1
  }

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

internal infix fun Short.and(mask: Int): Int = toInt() and mask

internal infix fun Int.and(mask: Long): Long = toLong() and mask

@Throws(IOException::class)
internal fun BufferedSink.writeMedium(medium: Int) {

import org.jetbrains.kotlin.types.Variance

public interface KaRendererOtherModifiersProvider {
    public fun getOtherModifiers(analysisSession: KaSession, symbol: KaDeclarationSymbol): List<KtModifierKeywordToken>

    public infix fun and(other: KaRendererOtherModifiersProvider): KaRendererOtherModifiersProvider {
        val self = this
        return object : KaRendererOtherModifiersProvider {

                    )
                ]
            )""".trimIndent()
        results.assert(expected)
    }

    @Test
    fun `parses infix call chain`() {
        val results = parse(
            """
            f(1) g "string" h true i 2L j 3.apply(4)
            """.trimIndent()
        )

        val expected = """

		"FAIL:\xff\x03",
		"FAIL:\xff\xd5",
		"FAIL:\xff\xff\xd5",
	}

	for _, tc := range testCases {
		want := tc[:5] == "PASS:"
		infix := tc[5:]

		data := []byte(nil)
		data = append(data, prefix...)
		data = append(data, infix...)
		data = append(data, suffix...)
		_, err := Decode(bytes.NewReader(data))
		got := err == nil

		if got != want {

        val firCall = infixCallExpression.getOrBuildFirSafe<FirFunctionCall>(firResolveSession) ?: return null

        // There is only one parameter for infix functions; get its type
        val argumentsToParameters = firCall.argumentsToSubstitutedValueParameters(substituteWithErrorTypes = false) ?: return null

- [`KT-65810`](https://youtrack.jetbrains.com/issue/KT-65810) PowerAssert: Infix transformation doesn't capture full context
- [`KT-65640`](https://youtrack.jetbrains.com/issue/KT-65640) PowerAssert: Infix function not aligned correctly