)

    /**
     * Represents a local variable reassignment.
     */
    public class VariableReassignment(
        /** The reassignment expression. */
        public val expression: KtExpression,

        /** Reassigned variable symbol. */
        public val variable: KaVariableLikeSymbol,

        /** `true` if the variable is both read and set (as in `x += y` or `x++`). */

		// If lhs exists, declare a corresponding variable in the case-local scope.
		if lhs != nil {
			// spec: "The TypeSwitchGuard may include a short variable declaration.
			// When that form is used, the variable is declared at the beginning of
			// the implicit block in each clause. In clauses with a case listing
			// exactly one type, the variable has that type; otherwise, the variable

/**
 * A signature of a variable-like symbol. This includes properties, enum entries local variables, etc.
 */
public abstract class KaVariableLikeSignature<out S : KaVariableLikeSymbol> : KaCallableSignature<S>() {
    /**
     * A name of the variable with respect to the `@ParameterName` annotation. Can be different from the [KaVariableLikeSymbol.name].
     *

<!-- go.dev/issue/60905, CL 559555 -->
Go 1.23 introduces a new `GOARM64` environment variable, which specifies the minimum target version of the ARM64 architecture at compile time. Allowed values are `v8.{0-9}` and `v9.{0-5}`. This may be followed by an option specifying extensions implemented by target hardware. Valid options are `,lse` and `,crypto`.

The `GOARM64` environment variable defaults to `v8.0`.

### RISC-V {#riscv}

    override fun restoreSymbol(analysisSession: KaSession): KaKotlinPropertySymbol? =
        when (val variable = with(analysisSession) { variableSymbolPointer.restoreSymbol() }) {
            is KaKotlinPropertySymbol -> variable
            is KaValueParameterSymbol -> variable.generatedPrimaryConstructorProperty
            else -> null
        }

	typexpr                      // operand is a type
	constant_                    // operand is a constant; the operand's typ is a Basic type
	variable                     // operand is an addressable variable
	mapindex                     // operand is a map index expression (acts like a variable on lhs, commaok on rhs of an assignment)
	value                        // operand is a computed value

  valuedReturnExpressions = []
  variableReassignments = [
    VariableReassignment:
      expression = x++
      isAugmented = true
      variable = var x: kotlin.Int,
    VariableReassignment:
      expression = x++
      isAugmented = true
      variable = var x: kotlin.Int

// where a complete initialization (definition) of a variable begins.
// Since the liveness analysis can see initialization of single-word
// variables quite easy, OpVarDef is only needed for multi-word
// variables satisfying isfat(n.Type). For simplicity though, buildssa
// emits OpVarDef regardless of variable width.
//
// An 'OpVarDef x' annotation in the instruction stream tells the liveness

import org.jetbrains.kotlin.analysis.api.base.KaConstantValue
import org.jetbrains.kotlin.psi.KtExpression

/**
 * Value representing some property or variable initializer
 */
public sealed class KaInitializerValue {
    /**
     * [com.intellij.psi.PsiElement] of initializer. May be null if property/variable came from non-source file.
     */
    public abstract val initializerPsi: KtExpression?
}

/**

  jumpExpressions = []
  returnValueType = null
  valuedReturnExpressions = []
  variableReassignments = [
    VariableReassignment:
      expression = x = 1
      isAugmented = false
      variable = var x: kotlin.Int