val function = assignment.operationReference.mainReference.resolve() as? KtNamedFunction ?: return null
        val name = function.name ?: return null
        return if (Name.identifier(name) in OperatorConventions.ASSIGNMENT_OPERATIONS.values)
            ReferenceAccess.READ to assignment
        else
            null
    }

    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.SpreadOperatorInDynamicCall

internal class WrongOperationWithDynamicImpl(
    override val operation: String,
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.WrongOperationWithDynamic

                firBinaryExpression.calleeReference.name in OperatorNameConventions.ASSIGNMENT_OPERATIONS
            ) {
                return null
            }
        }
        return binaryExpression
    }

    /**
     * For prefix and postfix `++` and `--`, the idea is the same because FIR represents it as several operations. For example, for `i++`,

                assignment.getCall(this)?.getResolvedCall(this) ?: return ReferenceAccess.READ_WRITE to assignment
            }
        }
        return if (resolvedCall.resultingDescriptor.name in OperatorConventions.ASSIGNMENT_OPERATIONS.values)
            ReferenceAccess.READ to assignment
        else
            ReferenceAccess.READ_WRITE to assignment
    }

            // - Labels themselves: `@label` in return`@label` or `label@`while...
            is KtLabelReferenceExpression ->
                false

            // - The operation symbol itself in binary and unary operations: `!!`, `+`...
            is KtOperationReferenceExpression ->
                false

            // All other expressions are used if their parent expression uses them.
            else ->

            if (unwrappedPsi is KtBinaryExpression &&
                (unwrappedPsi.operationToken in OperatorConventions.COMPARISON_OPERATIONS ||
                        unwrappedPsi.operationToken in OperatorConventions.EQUALS_OPERATIONS)
            ) {
                // TODO: Handle compound assignment
                handleAsFunctionCall(this, unwrappedPsi)?.toKtCallCandidateInfos()?.let { return@with it }

- [`KT-56023`](https://youtrack.jetbrains.com/issue/KT-56023) Constant operations (e.g. division) are not constant in K2 (JS, Native)
- [`KT-57354`](https://youtrack.jetbrains.com/issue/KT-57354) In suspend function default arguments are sometimes not deleted in IR

    }

    interface WrongOperationWithDynamic : KtFirDiagnostic<KtElement> {
        override val diagnosticClass get() = WrongOperationWithDynamic::class
        val operation: String
    }

    interface JsStaticNotInClassCompanion : KtFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = JsStaticNotInClassCompanion::class
    }

        SpreadOperatorInDynamicCallImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirJsErrors.WRONG_OPERATION_WITH_DYNAMIC) { firDiagnostic ->
        WrongOperationWithDynamicImpl(
            firDiagnostic.a,
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }

import org.jetbrains.kotlin.types.ConstantValueKind

/**
 * An evaluator that transform numeric operation, such as div, into compile-time constant iff involved operands, such as explicit receiver
 * and the argument, are compile-time constant as well.
 */
internal object FirCompileTimeConstantEvaluator {
    // TODO: Handle boolean operators, class reference, array, annotation values, etc.
    fun evaluate(
        fir: FirElement?,