KtTokens.PERCEQ -> KaCompoundAccess.CompoundAssign.Kind.REM_ASSIGN
            KtTokens.DIVEQ -> KaCompoundAccess.CompoundAssign.Kind.DIV_ASSIGN
            else -> error("unexpected operator $operationToken")
        }
        return compoundAssignKind
    }

    protected fun KtUnaryExpression.getInOrDecOperationKind(): KaCompoundAccess.IncOrDecOperation.Kind {

        val expression = testServices.expressionMarkerProvider.getSelectedElement(mainFile)
        expression as? KtExpression ?: error("unexpected expression kind ${expression::class}")

        val actual = executeOnPooledThreadInReadAction {
            analyze(expression) {

(161,162) SYNTAX Syntax error: Unexpected symbol....

        firSymbol.fir.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)

        val initializerExpression = firSymbol.fir.initializer
        check(initializerExpression is FirAnonymousObjectExpression) {
            "Unexpected enum entry initializer: ${initializerExpression?.javaClass}"
        }

        val classifierBuilder = analysisSession.firSymbolBuilder.classifierBuilder

        // represent Java classes viewed from Kotlin code, we shouldn't be able to encounter any local Java classes.
        require(!owner.isLocal) {
            "Unexpected local Java class in ${FirJavaDeclaredMembersOnlyScope::class.simpleName}."
        }
    }

    private fun FirCallableDeclaration.isDeclared(): Boolean =
        symbol.callableId.classId == owner.classId

            is KtExpression -> element
            is KtValueArgument -> element.getArgumentExpression()!!
            else -> error("Unexpected element: $element of ${element::class}")
        }

        val containingDeclaration = declarationAtCaret.parentOfType<KtDeclaration>()
            ?: error("Can't find containing declaration for $declarationAtCaret")

                    append("extension receiver with type ")
                    append(symbol.type.render(renderer.typeRenderer, position = Variance.INVARIANT))
                }
                else -> error("Unexpected symbol ${symbol::class}")
            }
            additionalInfo(symbol)?.let { append(" [$it]") }
        }
    }

    @Suppress("unused")// KaSession receiver

        val ktPropertySymbol = builder.variableLikeBuilder.buildPropertySymbol(propertySymbol)
        check(ktPropertySymbol is KaKotlinPropertySymbol) {
            "Unexpected symbol for primary constructor property ${ktPropertySymbol.javaClass} for fir: ${firSymbol.fir.renderWithType()}"
        }

        ktPropertySymbol
    }

     * the <code>Mojo</code> to communicate errors.
     *
     * @throws MojoExecutionException if an unexpected problem occurs.
     * Throwing this exception causes a "BUILD ERROR" message to be displayed.
     * @throws MojoFailureException if an expected problem (such as a compilation failure) occurs.
     * Throwing this exception causes a "BUILD FAILURE" message to be displayed.
     */

        nonNull(algorithms, "algorithms");
        try {
            return calculate(new ByteArrayInputStream(data), algorithms);
        } catch (IOException e) {
            throw new UncheckedIOException(e); // really unexpected
        }
    }

    @Override
    public Map<ChecksumAlgorithm, String> calculate(ByteBuffer data, Collection<ChecksumAlgorithm> algorithms) {
        nonNull(data, "data");