//! Inline record fields can supply separate call-scoped borrows.

/// Two scalar fields with separate storage.
record Pair: Copy {
    /// First scalar.
    a: u32,
    /// Second scalar.
    b: u32,
}

/// Nested scalar storage.
record Nested: Copy {
    /// Borrowed record.
    pair: Pair,
}

/// Separate fixed buffers.
record Buffers: Copy {
    /// First buffer.
    a: [u8; 2],
    /// Second buffer.
    b: [u8; 2],
}

/// Accept two mutable scalar borrows.
fn mutablePair(a: &mut u32, b: &mut u32) {}

/// Accept a mutable borrow and a scalar value.
fn scalarPair(a: &mut u32, b: u32) {}

/// Accept mutable and shared scalar borrows.
fn sharedPair(a: &mut u32, b: &u32) {}

/// Accept two mutable buffer borrows.
fn buffers(a: &mut [u8], b: &mut [u8]) {}

/// Borrow two sibling fields mutably.
fn mutableFields(pair: &mut Pair) {
    mutablePair(&mut pair.a, &mut pair.b);
}

/// Read a sibling field while borrowing another field mutably.
fn scalarField(pair: &mut Pair) {
    scalarPair(&mut pair.a, pair.b);
}

/// Borrow sibling fields in a nested record.
fn nestedFields(value: &mut Nested) {
    sharedPair(&mut value.pair.a, &value.pair.b);
}

/// Borrow separate inline arrays as slices.
fn arrayFields(value: &mut Buffers) {
    buffers(&mut value.a[..], &mut value.b[..]);
}