/// Result of resolving a place expression to a memory location.

    /// Byte offset of the value within the container.

    /// Type of the value held at that location.

/// Lower an assignment target that designates a memory location, and return

/// the address to store through. Returns `nil` without emitting anything for

/// targets that aren't memory-backed, such as locals tracked in SSA.

fn lowerPlace(self: *mut FnLowerer, target: *ast::Node) -> ?FieldRef throws (LowerError) {

    match target.value {

        case ast::NodeValue::FieldAccess(access) => {

            return try lowerFieldRef(self, access);

        }

        case ast::NodeValue::Deref(pointer) => {

            // Dereference: `*ptr` or `*r` on a single-field unlabeled record.

            // Both address offset 0 using the resolver-assigned type.

            let base = emitValToReg(self, try lowerExpr(self, pointer));

            return FieldRef { base, offset: 0, fieldType: try typeOf(self, target) };

        }

        case ast::NodeValue::Subscript { container, index } => {

            // Array or slice element: `arr[i]`.

            let elem = try lowerElemPtr(self, container, index);

            return FieldRef { base: elem.elemReg, offset: 0, fieldType: elem.elemType };

        }

        else => return nil,

    }

}

/// Lower a compound assignment whose target is memory-backed, and report

/// whether it was handled. Nothing is emitted when it isn't.

///

/// Compound assignments share their target node with the left operand of the

/// desugared binary expression. Resolve that place once so side effects in a

/// dereference, field parent, or subscript index are not repeated for the store.

fn lowerCompoundAssign(

    self: *mut FnLowerer, expr: *ast::Node, binop: ast::BinOp

) -> bool throws (LowerError) {

    let place = try lowerPlace(self, binop.left) else return false;

    let current = emitRead(self, place.base, place.offset, place.fieldType);

    let left = try applyCoercion(self, binop.left, current);

    let right = try lowerExpr(self, binop.right);

    let exprType = try typeOf(self, expr);

    let result = emitScalarBinOp(

        self, binop.op, ilType(self.low, exprType), left, right, isUnsignedType(exprType)

    );

    let assigned = try applyCoercion(self, expr, result);

    try emitStore(self, place.base, place.offset, place.fieldType, assigned);

    return true;

}

    // Compound assignments are represented as `target = target op rhs`, with

    // the exact same target node used in both places. Memory-backed targets

    // must be resolved once so calls in the target are evaluated once.

    if let case ast::NodeValue::BinOp(binop) = a.right.value {

        if binop.left == a.left and try lowerCompoundAssign(self, a.right, binop) {

            return;

        }

    }

        else => {

            let place = try lowerPlace(self, a.left) else {

                throw LowerError::UnexpectedNodeValue(a.left);

            };

            try emitStore(self, place.base, place.offset, place.fieldType, rhs);

//! returns: 0

//! Compound assignment evaluates a side-effecting lvalue exactly once.

fn nextIndex(calls: *mut u32) -> u32 {

    let index = *calls;

    set *calls += 1;

    return index;

}

@default fn main() -> i32 {

    let mut calls: u32 = 0;

    let mut values: [i32; 2] = [10, 20];

    set values[nextIndex(&mut calls)] += 5;

    assert calls == 1;

    assert values[0] == 15;

    assert values[1] == 20;

    return 0;

}

    store w32 %14 %12 0;

    sload w32 %17 %16 0;

    br.eq w32 %17 25 @assert.ok22 @assert.fail21;

    reserve %18 4 4;

    store w32 100 %18 0;

    sload w32 %19 %18 0;

    add w32 %20 %19 50;

    store w32 %20 %18 0;

    sload w32 %21 %18 0;

    br.eq w32 %21 150 @assert.ok24 @assert.fail23;

    add w32 %22 1 2;

    mul w32 %23 %22 3;

    sub w32 %24 %23 1;

    br.eq w32 %24 8 @assert.ok26 @assert.fail25;

    store w32 %7 %5 0;

  @guard#trap2