Use AsMut/AsRef-like deref instead of unions

[Emilgardis]

Currently, svd2rust supports overlapping registers via the cli flag --nightly. This will generate an union of all registers that overlap each other.

Since it is not expected that non-Copy fields in unions will be stabilized soon (see tracking issue rust-lang/rust#32836), another system for access would prove beneficial for library maintainers and users wanting to access overlapping registers using stable rust.

cc @wez @japaric

related #16

[wez]

Yeah, makes sense. Referencing this example from atsamd21:

https://docs.rs/atsamd21g18a/0.2.1/atsamd21g18a/tc3/union.RegisterBlock.html

instead of the union generate something like this:

pub struct RegisterBlock {}

impl RegisterBlock {
    fn as_count8_mut(&mut self) -> &mut COUNT8 {
        unsafe {
            &mut *((self as *mut Self) as *mut COUNT8)
        }
    }

    fn as_count8_ref(&self) -> &COUNT8 {
        unsafe {
            &*((self as *const Self) as *const COUNT8)
        }
    }

    fn as_count16_mut(&mut self) -> &mut COUNT16 {
        unsafe {
            &mut *((self as *mut Self) as *mut COUNT16)
        }
    }

   // as_count16_ref(), as_count32_mut(), as_count32_ref() here
}

I've found that in atsamd21-hal I'd often make a safe accessor for the union anyway, so this removes some boilerplate for me.

[wez]

(caffeine kicks in) or are you suggesting that we literally implement AsMut/AsRef? That would avoid figuring out naming for accessor methods

[wez]

I can play around with this, since I think I'm the only person currently with a crate that requires and is using this :)

[Emilgardis]

I'm pretty sure having functions providing the variants is the most ergonomic instead of using AsRef/AsMut (as those doesn't take a type in the function).

// Definition of register block
struct RegisterBlock {
    reg1: CCMR,
    ...
}

struct CCMR {
    ...
}

struct CCMR_INPUT {
    ...
}

struct CCMR_OUTPUT {
    ...
}

assert!(reg.is::<CCMR>());

// using AsRef and AsMut for CCMR_*
let input: &mut CCMR_INPUT = reg.as_mut();
input.write(...);

// using functions in CCMR
reg.as_input().write(...);

However, another approach, which I find the most convincing, would be to have traits that are syntactic sugar for the AsRef and AsMut route and possible define it in bare-metal. That would make the following possible:

use bare_metal::AsMutRegister; // TODO: better trait and fn name

reg.as_mut_register::<CCMR_INPUT>().write(...);

// and

fn foo<I: AsMut<CCMR_INPUT>>(mut input: I) {
    input.as_mut().write(...);
}

foo(reg);

EDIT:: fixed some mistakes in fn foo

[wez]

I have some WIP in https://github.com/wez/svd2rust/tree/no_unions
It happens to look like the suggestion in #230

[adamgreig]

I believe this is now solved by #318.