implement RFC #212

25 files changed, 332 insertions, 274 deletions

diff --git a/ci/expected/generics.run b/ci/expected/generics.run
index 7fa97758..fb31731e 100644
--- a/ci/expected/generics.run
+++ b/ci/expected/generics.run
@@ -1,6 +1,6 @@
 UART1(STATE = 0)
-SHARED: 0 -> 1
+shared: 0 -> 1
 UART0(STATE = 0)
-SHARED: 1 -> 2
+shared: 1 -> 2
 UART1(STATE = 1)
-SHARED: 2 -> 4
+shared: 2 -> 4
diff --git a/ci/expected/lock.run b/ci/expected/lock.run
index 156ac222..a987b372 100644
--- a/ci/expected/lock.run
+++ b/ci/expected/lock.run
@@ -1,5 +1,5 @@
 A
-B - SHARED = 1
+B - shared = 1
 C
-D - SHARED = 2
+D - shared = 2
 E
diff --git a/ci/expected/resource.run b/ci/expected/resource.run
index 9c70856a..a587a942 100644
--- a/ci/expected/resource.run
+++ b/ci/expected/resource.run
@@ -1,2 +1,2 @@
-UART0: SHARED = 1
-UART1: SHARED = 2
+UART0: shared = 1
+UART1: shared = 2
diff --git a/ci/expected/static.run b/ci/expected/static.run
index 2c295c99..1d4eed00 100644
--- a/ci/expected/static.run
+++ b/ci/expected/static.run
@@ -1,2 +1,2 @@
-UART1(KEY = 0xdeadbeef)
-UART0(KEY = 0xdeadbeef)
+UART1(key = 0xdeadbeef)
+UART0(key = 0xdeadbeef)
diff --git a/examples/cfg.rs b/examples/cfg.rs
index b1f65cfd..fb812cb0 100644
--- a/examples/cfg.rs
+++ b/examples/cfg.rs
@@ -11,25 +11,28 @@ use panic_semihosting as _;
 
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
-    #[cfg(debug_assertions)] // <- `true` when using the `dev` profile
-    static mut COUNT: u32 = 0;
+    struct Resources {
+        #[cfg(debug_assertions)] // <- `true` when using the `dev` profile
+        #[init(0)]
+        count: u32,
+    }
 
     #[init]
     fn init(_: init::Context) {
         // ..
     }
 
-    #[task(priority = 3, resources = [COUNT], spawn = [log])]
+    #[task(priority = 3, resources = [count], spawn = [log])]
     fn foo(_c: foo::Context) {
         #[cfg(debug_assertions)]
         {
-            *_c.resources.COUNT += 1;
+            *_c.resources.count += 1;
 
-            _c.spawn.log(*_c.resources.COUNT).ok();
+            _c.spawn.log(*_c.resources.count).ok();
         }
 
         // this wouldn't compile in `release` mode
-        // *resources.COUNT += 1;
+        // *resources.count += 1;
 
         // ..
     }
diff --git a/examples/generics.rs b/examples/generics.rs
index 562470d4..f0632d9a 100644
--- a/examples/generics.rs
+++ b/examples/generics.rs
@@ -12,7 +12,10 @@ use rtfm::{Exclusive, Mutex};
 
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
-    static mut SHARED: u32 = 0;
+    struct Resources {
+        #[init(0)]
+        shared: u32,
+    }
 
     #[init]
     fn init(_: init::Context) {
@@ -20,29 +23,29 @@ const APP: () = {
         rtfm::pend(Interrupt::UART1);
     }
 
-    #[task(binds = UART0, resources = [SHARED])]
+    #[task(binds = UART0, resources = [shared])]
     fn uart0(c: uart0::Context) {
         static mut STATE: u32 = 0;
 
         hprintln!("UART0(STATE = {})", *STATE).unwrap();
 
-        advance(STATE, c.resources.SHARED);
+        advance(STATE, c.resources.shared);
 
         rtfm::pend(Interrupt::UART1);
 
         debug::exit(debug::EXIT_SUCCESS);
     }
 
-    #[task(binds = UART1, priority = 2, resources = [SHARED])]
+    #[task(binds = UART1, priority = 2, resources = [shared])]
     fn uart1(c: uart1::Context) {
         static mut STATE: u32 = 0;
 
         hprintln!("UART1(STATE = {})", *STATE).unwrap();
 
-        // just to show that `SHARED` can be accessed directly
-        *c.resources.SHARED += 0;
+        // just to show that `shared` can be accessed directly
+        *c.resources.shared += 0;
 
-        advance(STATE, Exclusive(c.resources.SHARED));
+        advance(STATE, Exclusive(c.resources.shared));
     }
 };
 
@@ -55,5 +58,5 @@ fn advance(state: &mut u32, mut shared: impl Mutex<T = u32>) {
         (old, *shared)
     });
 
-    hprintln!("SHARED: {} -> {}", old, new).unwrap();
+    hprintln!("shared: {} -> {}", old, new).unwrap();
 }
diff --git a/examples/late.rs b/examples/late.rs
index 19807ff7..536d71aa 100644
--- a/examples/late.rs
+++ b/examples/late.rs
@@ -16,9 +16,9 @@ use panic_semihosting as _;
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
     // Late resources
-    extern "C" {
-        static mut P: Producer<'static, u32, U4>;
-        static mut C: Consumer<'static, u32, U4>;
+    struct Resources {
+        p: Producer<'static, u32, U4>,
+        c: Consumer<'static, u32, U4>,
     }
 
     #[init]
@@ -31,13 +31,13 @@ const APP: () = {
         let (p, c) = Q.as_mut().unwrap().split();
 
         // Initialization of late resources
-        init::LateResources { P: p, C: c }
+        init::LateResources { p, c }
     }
 
-    #[idle(resources = [C])]
+    #[idle(resources = [c])]
     fn idle(c: idle::Context) -> ! {
         loop {
-            if let Some(byte) = c.resources.C.dequeue() {
+            if let Some(byte) = c.resources.c.dequeue() {
                 hprintln!("received message: {}", byte).unwrap();
 
                 debug::exit(debug::EXIT_SUCCESS);
@@ -47,8 +47,8 @@ const APP: () = {
         }
     }
 
-    #[task(binds = UART0, resources = [P])]
+    #[task(binds = UART0, resources = [p])]
     fn uart0(c: uart0::Context) {
-        c.resources.P.enqueue(42).unwrap();
+        c.resources.p.enqueue(42).unwrap();
     }
 };
diff --git a/examples/lock.rs b/examples/lock.rs
index 17b6a58b..f33a60a4 100644
--- a/examples/lock.rs
+++ b/examples/lock.rs
@@ -11,7 +11,10 @@ use panic_semihosting as _;
 
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
-    static mut SHARED: u32 = 0;
+    struct Resources {
+        #[init(0)]
+        shared: u32,
+    }
 
     #[init]
     fn init(_: init::Context) {
@@ -19,21 +22,21 @@ const APP: () = {
     }
 
     // when omitted priority is assumed to be `1`
-    #[task(binds = GPIOA, resources = [SHARED])]
+    #[task(binds = GPIOA, resources = [shared])]
     fn gpioa(mut c: gpioa::Context) {
         hprintln!("A").unwrap();
 
         // the lower priority task requires a critical section to access the data
-        c.resources.SHARED.lock(|shared| {
+        c.resources.shared.lock(|shared| {
             // data can only be modified within this critical section (closure)
             *shared += 1;
 
             // GPIOB will *not* run right now due to the critical section
             rtfm::pend(Interrupt::GPIOB);
 
-            hprintln!("B - SHARED = {}", *shared).unwrap();
+            hprintln!("B - shared = {}", *shared).unwrap();
 
-            // GPIOC does not contend for `SHARED` so it's allowed to run now
+            // GPIOC does not contend for `shared` so it's allowed to run now
             rtfm::pend(Interrupt::GPIOC);
         });
 
@@ -44,12 +47,12 @@ const APP: () = {
         debug::exit(debug::EXIT_SUCCESS);
     }
 
-    #[task(binds = GPIOB, priority = 2, resources = [SHARED])]
+    #[task(binds = GPIOB, priority = 2, resources = [shared])]
     fn gpiob(c: gpiob::Context) {
         // the higher priority task does *not* need a critical section
-        *c.resources.SHARED += 1;
+        *c.resources.shared += 1;
 
-        hprintln!("D - SHARED = {}", *c.resources.SHARED).unwrap();
+        hprintln!("D - shared = {}", *c.resources.shared).unwrap();
     }
 
     #[task(binds = GPIOC, priority = 3)]
diff --git a/examples/not-send.rs b/examples/not-send.rs
index f240e511..d27cc82f 100644
--- a/examples/not-send.rs
+++ b/examples/not-send.rs
@@ -17,7 +17,10 @@ pub struct NotSend {
 
 #[app(device = lm3s6965)]
 const APP: () = {
-    static mut SHARED: Option<NotSend> = None;
+    struct Resources {
+        #[init(None)]
+        shared: Option<NotSend>,
+    }
 
     #[init(spawn = [baz, quux])]
     fn init(c: init::Context) {
@@ -36,16 +39,16 @@ const APP: () = {
         // scenario 1
     }
 
-    #[task(priority = 2, resources = [SHARED])]
+    #[task(priority = 2, resources = [shared])]
     fn baz(c: baz::Context) {
         // scenario 2: resource shared between tasks that run at the same priority
-        *c.resources.SHARED = Some(NotSend { _0: PhantomData });
+        *c.resources.shared = Some(NotSend { _0: PhantomData });
     }
 
-    #[task(priority = 2, resources = [SHARED])]
+    #[task(priority = 2, resources = [shared])]
     fn quux(c: quux::Context) {
         // scenario 2
-        let _not_send = c.resources.SHARED.take().unwrap();
+        let _not_send = c.resources.shared.take().unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
     }
diff --git a/examples/not-sync.rs b/examples/not-sync.rs
index 6b499111..f0f6075e 100644
--- a/examples/not-sync.rs
+++ b/examples/not-sync.rs
@@ -16,21 +16,24 @@ pub struct NotSync {
 
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
-    static SHARED: NotSync = NotSync { _0: PhantomData };
+    struct Resources {
+        #[init(NotSync { _0: PhantomData })]
+        shared: NotSync,
+    }
 
     #[init]
     fn init(_: init::Context) {
         debug::exit(debug::EXIT_SUCCESS);
     }
 
-    #[task(resources = [SHARED])]
+    #[task(resources = [shared])]
     fn foo(c: foo::Context) {
-        let _: &NotSync = c.resources.SHARED;
+        let _: &NotSync = c.resources.shared;
     }
 
-    #[task(resources = [SHARED])]
+    #[task(resources = [shared])]
     fn bar(c: bar::Context) {
-        let _: &NotSync = c.resources.SHARED;
+        let _: &NotSync = c.resources.shared;
     }
 
     extern "C" {
diff --git a/examples/resource.rs b/examples/resource.rs
index 661f8c35..2506a2cb 100644
--- a/examples/resource.rs
+++ b/examples/resource.rs
@@ -11,8 +11,11 @@ use panic_semihosting as _;
 
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
-    // A resource
-    static mut SHARED: u32 = 0;
+    struct Resources {
+        // A resource
+        #[init(0)]
+        shared: u32,
+    }
 
     #[init]
     fn init(_: init::Context) {
@@ -24,25 +27,25 @@ const APP: () = {
     fn idle(_: idle::Context) -> ! {
         debug::exit(debug::EXIT_SUCCESS);
 
-        // error: `SHARED` can't be accessed from this context
-        // SHARED += 1;
+        // error: `shared` can't be accessed from this context
+        // shared += 1;
 
         loop {}
     }
 
-    // `SHARED` can be access from this context
-    #[task(binds = UART0, resources = [SHARED])]
+    // `shared` can be access from this context
+    #[task(binds = UART0, resources = [shared])]
     fn uart0(c: uart0::Context) {
-        *c.resources.SHARED += 1;
+        *c.resources.shared += 1;
 
-        hprintln!("UART0: SHARED = {}", c.resources.SHARED).unwrap();
+        hprintln!("UART0: shared = {}", c.resources.shared).unwrap();
     }
 
-    // `SHARED` can be access from this context
-    #[task(binds = UART1, resources = [SHARED])]
+    // `shared` can be access from this context
+    #[task(binds = UART1, resources = [shared])]
     fn uart1(c: uart1::Context) {
-        *c.resources.SHARED += 1;
+        *c.resources.shared += 1;
 
-        hprintln!("UART1: SHARED = {}", c.resources.SHARED).unwrap();
+        hprintln!("UART1: shared = {}", c.resources.shared).unwrap();
     }
 };
diff --git a/examples/shared-with-init.rs b/examples/shared-with-init.rs
index ed73c8ba..14fa54b7 100644
--- a/examples/shared-with-init.rs
+++ b/examples/shared-with-init.rs
@@ -14,20 +14,23 @@ pub struct MustBeSend;
 
 #[app(device = lm3s6965)]
 const APP: () = {
-    static mut SHARED: Option<MustBeSend> = None;
+    struct Resources {
+        #[init(None)]
+        shared: Option<MustBeSend>,
+    }
 
-    #[init(resources = [SHARED])]
+    #[init(resources = [shared])]
     fn init(c: init::Context) {
         // this `message` will be sent to task `UART0`
         let message = MustBeSend;
-        *c.resources.SHARED = Some(message);
+        *c.resources.shared = Some(message);
 
         rtfm::pend(Interrupt::UART0);
     }
 
-    #[task(binds = UART0, resources = [SHARED])]
+    #[task(binds = UART0, resources = [shared])]
     fn uart0(c: uart0::Context) {
-        if let Some(message) = c.resources.SHARED.take() {
+        if let Some(message) = c.resources.shared.take() {
             // `message` has been received
             drop(message);
 
diff --git a/examples/static.rs b/examples/static.rs
index 5eb7b197..4af7ee67 100644
--- a/examples/static.rs
+++ b/examples/static.rs
@@ -11,8 +11,8 @@ use panic_semihosting as _;
 
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
-    extern "C" {
-        static KEY: u32;
+    struct Resources {
+        key: u32,
     }
 
     #[init]
@@ -20,18 +20,18 @@ const APP: () = {
         rtfm::pend(Interrupt::UART0);
         rtfm::pend(Interrupt::UART1);
 
-        init::LateResources { KEY: 0xdeadbeef }
+        init::LateResources { key: 0xdeadbeef }
     }
 
-    #[task(binds = UART0, resources = [KEY])]
+    #[task(binds = UART0, resources = [&key])]
     fn uart0(c: uart0::Context) {
-        hprintln!("UART0(KEY = {:#x})", c.resources.KEY).unwrap();
+        hprintln!("UART0(key = {:#x})", c.resources.key).unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
     }
 
-    #[task(binds = UART1, priority = 2, resources = [KEY])]
+    #[task(binds = UART1, priority = 2, resources = [&key])]
     fn uart1(c: uart1::Context) {
-        hprintln!("UART1(KEY = {:#x})", c.resources.KEY).unwrap();
+        hprintln!("UART1(key = {:#x})", c.resources.key).unwrap();
     }
 };
diff --git a/examples/t-cfg.rs b/examples/t-cfg.rs
index 158eef55..e61ec795 100644
--- a/examples/t-cfg.rs
+++ b/examples/t-cfg.rs
@@ -7,8 +7,11 @@ use panic_halt as _;
 
 #[rtfm::app(device = lm3s6965, monotonic = rtfm::cyccnt::CYCCNT)]
 const APP: () = {
-    #[cfg(never)]
-    static mut FOO: u32 = 0;
+    struct Resources {
+        #[cfg(never)]
+        #[init(0)]
+        foo: u32,
+    }
 
     #[init]
     fn init(_: init::Context) {
@@ -24,13 +27,13 @@ const APP: () = {
         loop {}
     }
 
-    #[task(resources = [FOO], schedule = [quux], spawn = [quux])]
+    #[task(resources = [foo], schedule = [quux], spawn = [quux])]
     fn foo(_: foo::Context) {
         #[cfg(never)]
         static mut BAR: u32 = 0;
     }
 
-    #[task(priority = 3, resources = [FOO], schedule = [quux], spawn = [quux])]
+    #[task(priority = 3, resources = [foo], schedule = [quux], spawn = [quux])]
     fn bar(_: bar::Context) {
         #[cfg(never)]
         static mut BAR: u32 = 0;
diff --git a/examples/t-late-not-send.rs b/examples/t-late-not-send.rs
index 55a053df..4fd3504e 100644
--- a/examples/t-late-not-send.rs
+++ b/examples/t-late-not-send.rs
@@ -13,23 +13,23 @@ pub struct NotSend {
 
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
-    extern "C" {
-        static mut X: NotSend;
+    struct Resources {
+        x: NotSend,
+        #[init(None)]
+        y: Option<NotSend>,
     }
 
-    static mut Y: Option<NotSend> = None;
-
-    #[init(resources = [Y])]
+    #[init(resources = [y])]
     fn init(c: init::Context) -> init::LateResources {
         // equivalent to late resource initialization
-        *c.resources.Y = Some(NotSend { _0: PhantomData });
+        *c.resources.y = Some(NotSend { _0: PhantomData });
 
         init::LateResources {
-            X: NotSend { _0: PhantomData },
+            x: NotSend { _0: PhantomData },
         }
     }
 
-    #[idle(resources = [X, Y])]
+    #[idle(resources = [x, y])]
     fn idle(_: idle::Context) -> ! {
         loop {}
     }
diff --git a/examples/t-resource.rs b/examples/t-resource.rs
index adcc04b3..303340ed 100644
--- a/examples/t-resource.rs
+++ b/examples/t-resource.rs
@@ -9,69 +9,79 @@ use panic_halt as _;
 
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
-    static mut O1: u32 = 0; // init
-    static mut O2: u32 = 0; // idle
-    static mut O3: u32 = 0; // EXTI0
-    static O4: u32 = 0; // idle
-    static O5: u32 = 0; // EXTI1
-    static O6: u32 = 0; // init
-
-    static mut S1: u32 = 0; // idle & EXTI0
-    static mut S2: u32 = 0; // EXTI0 & EXTI1
-    static S3: u32 = 0;
-
-    #[init(resources = [O1, O4, O5, O6, S3])]
+    struct Resources {
+        #[init(0)]
+        o1: u32, // init
+        #[init(0)]
+        o2: u32, // idle
+        #[init(0)]
+        o3: u32, // EXTI0
+        #[init(0)]
+        o4: u32, // idle
+        #[init(0)]
+        o5: u32, // EXTI1
+        #[init(0)]
+        o6: u32, // init
+        #[init(0)]
+        s1: u32, // idle & uart0
+        #[init(0)]
+        s2: u32, // uart0 & uart1
+        #[init(0)]
+        s3: u32, // idle & uart0
+    }
+
+    #[init(resources = [o1, o4, o5, o6, s3])]
     fn init(c: init::Context) {
         // owned by `init` == `&'static mut`
-        let _: &'static mut u32 = c.resources.O1;
+        let _: &'static mut u32 = c.resources.o1;
 
         // owned by `init` == `&'static` if read-only
-        let _: &'static u32 = c.resources.O6;
+        let _: &'static u32 = c.resources.o6;
 
         // `init` has exclusive access to all resources
-        let _: &mut u32 = c.resources.O4;
-        let _: &mut u32 = c.resources.O5;
-        let _: &mut u32 = c.resources.S3;
+        let _: &mut u32 = c.resources.o4;
+        let _: &mut u32 = c.resources.o5;
+        let _: &mut u32 = c.resources.s3;
     }
 
-    #[idle(resources = [O2, O4, S1, S3])]
+    #[idle(resources = [o2, &o4, s1, &s3])]
     fn idle(mut c: idle::Context) -> ! {
         // owned by `idle` == `&'static mut`
-        let _: &'static mut u32 = c.resources.O2;
+        let _: &'static mut u32 = c.resources.o2;
 
         // owned by `idle` == `&'static` if read-only
-        let _: &'static u32 = c.resources.O4;
+        let _: &'static u32 = c.resources.o4;
 
         // shared with `idle` == `Mutex`
-        c.resources.S1.lock(|_| {});
+        c.resources.s1.lock(|_| {});
 
         // `&` if read-only
-        let _: &u32 = c.resources.S3;
+        let _: &u32 = c.resources.s3;
 
         loop {}
     }
 
-    #[task(binds = UART0, resources = [O3, S1, S2, S3])]
+    #[task(binds = UART0, resources = [o3, s1, s2, &s3])]
     fn uart0(c: uart0::Context) {
         // owned by interrupt == `&mut`
-        let _: &mut u32 = c.resources.O3;
+        let _: &mut u32 = c.resources.o3;
 
         // no `Mutex` proxy when access from highest priority task
-        let _: &mut u32 = c.resources.S1;
+        let _: &mut u32 = c.resources.s1;
 
         // no `Mutex` proxy when co-owned by cooperative (same priority) tasks
-        let _: &mut u32 = c.resources.S2;
+        let _: &mut u32 = c.resources.s2;
 
         // `&` if read-only
-        let _: &u32 = c.resources.S3;
+        let _: &u32 = c.resources.s3;
     }
 
-    #[task(binds = UART1, resources = [S2, O5])]
+    #[task(binds = UART1, resources = [s2, &o5])]
     fn uart1(c: uart1::Context) {
         // owned by interrupt == `&` if read-only
-        let _: &u32 = c.resources.O5;
+        let _: &u32 = c.resources.o5;
 
         // no `Mutex` proxy when co-owned by cooperative (same priority) tasks
-        let _: &mut u32 = c.resources.S2;
+        let _: &mut u32 = c.resources.s2;
     }
 };
diff --git a/examples/types.rs b/examples/types.rs
index 3e9c7ea5..0c8097f3 100644
--- a/examples/types.rs
+++ b/examples/types.rs
@@ -11,7 +11,10 @@ use rtfm::cyccnt::Instant;
 
 #[rtfm::app(device = lm3s6965, peripherals = true, monotonic = rtfm::cyccnt::CYCCNT)]
 const APP: () = {
-    static mut SHARED: u32 = 0;
+    struct Resources {
+        #[init(0)]
+        shared: u32,
+    }
 
     #[init(schedule = [foo], spawn = [foo])]
     fn init(c: init::Context) {
@@ -31,18 +34,18 @@ const APP: () = {
         let _: svcall::Spawn = c.spawn;
     }
 
-    #[task(binds = UART0, resources = [SHARED], schedule = [foo], spawn = [foo])]
+    #[task(binds = UART0, resources = [shared], schedule = [foo], spawn = [foo])]
     fn uart0(c: uart0::Context) {
         let _: Instant = c.start;
-        let _: resources::SHARED = c.resources.SHARED;
+        let _: resources::shared = c.resources.shared;
         let _: uart0::Schedule = c.schedule;
         let _: uart0::Spawn = c.spawn;
     }
 
-    #[task(priority = 2, resources = [SHARED], schedule = [foo], spawn = [foo])]
+    #[task(priority = 2, resources = [shared], schedule = [foo], spawn = [foo])]
     fn foo(c: foo::Context) {
         let _: Instant = c.scheduled;
-        let _: &mut u32 = c.resources.SHARED;
+        let _: &mut u32 = c.resources.shared;
         let _: foo::Resources = c.resources;
         let _: foo::Schedule = c.schedule;
         let _: foo::Spawn = c.spawn;
diff --git a/heterogeneous/examples/x-init-2.rs b/heterogeneous/examples/x-init-2.rs
index b9c39197..033753c2 100644
--- a/heterogeneous/examples/x-init-2.rs
+++ b/heterogeneous/examples/x-init-2.rs
@@ -9,30 +9,30 @@ use panic_halt as _;
 
 #[rtfm::app(cores = 2, device = heterogeneous)]
 const APP: () = {
-    extern "C" {
+    struct Resources {
         // owned by core #1 but initialized by core #0
-        static mut X: u32;
+        x: u32,
 
         // owned by core #0 but initialized by core #1
-        static mut Y: u32;
+        y: u32,
     }
 
-    #[init(core = 0, late = [X])]
+    #[init(core = 0, late = [x])]
     fn a(_: a::Context) -> a::LateResources {
-        a::LateResources { X: 0 }
+        a::LateResources { x: 0 }
     }
 
-    #[idle(core = 0, resources = [Y])]
+    #[idle(core = 0, resources = [y])]
     fn b(_: b::Context) -> ! {
         loop {}
     }
 
     #[init(core = 1)]
     fn c(_: c::Context) -> c::LateResources {
-        c::LateResources { Y: 0 }
+        c::LateResources { y: 0 }
     }
 
-    #[idle(core = 1, resources = [X])]
+    #[idle(core = 1, resources = [x])]
     fn d(_: d::Context) -> ! {
         loop {}
     }
diff --git a/heterogeneous/examples/x-init.rs b/heterogeneous/examples/x-init.rs
index 53e73805..41837134 100644
--- a/heterogeneous/examples/x-init.rs
+++ b/heterogeneous/examples/x-init.rs
@@ -9,18 +9,18 @@ use panic_halt as _;
 
 #[rtfm::app(cores = 2, device = heterogeneous)]
 const APP: () = {
-    extern "C" {
-        static mut X: u32;
-        static mut Y: u32;
+    struct Resources {
+        x: u32,
+        y: u32,
     }
 
-    #[init(core = 0, late = [X])]
+    #[init(core = 0, late = [x])]
     fn a(_: a::Context) -> a::LateResources {
-        a::LateResources { X: 0 }
+        a::LateResources { x: 0 }
     }
 
     #[init(core = 1)]
     fn b(_: b::Context) -> b::LateResources {
-        b::LateResources { Y: 0 }
+        b::LateResources { y: 0 }
     }
 };
diff --git a/homogeneous/examples/x-init-2.rs b/homogeneous/examples/x-init-2.rs
index f51e2f6e..de35cf6f 100644
--- a/homogeneous/examples/x-init-2.rs
+++ b/homogeneous/examples/x-init-2.rs
@@ -9,30 +9,30 @@ use panic_halt as _;
 
 #[rtfm::app(cores = 2, device = homogeneous)]
 const APP: () = {
-    extern "C" {
+    struct Resources {
         // owned by core #1 but initialized by core #0
-        static mut X: u32;
+        x: u32,
 
         // owned by core #0 but initialized by core #1
-        static mut Y: u32;
+        y: u32,
     }
 
-    #[init(core = 0, late = [X])]
+    #[init(core = 0, late = [x])]
     fn a(_: a::Context) -> a::LateResources {
-        a::LateResources { X: 0 }
+        a::LateResources { x: 0 }
     }
 
-    #[idle(core = 0, resources = [Y])]
+    #[idle(core = 0, resources = [y])]
     fn b(_: b::Context) -> ! {
         loop {}
     }
 
     #[init(core = 1)]
     fn c(_: c::Context) -> c::LateResources {
-        c::LateResources { Y: 0 }
+        c::LateResources { y: 0 }
     }
 
-    #[idle(core = 1, resources = [X])]
+    #[idle(core = 1, resources = [x])]
     fn d(_: d::Context) -> ! {
         loop {}
     }
diff --git a/homogeneous/examples/x-init.rs b/homogeneous/examples/x-init.rs
index 5089e385..c359901c 100644
--- a/homogeneous/examples/x-init.rs
+++ b/homogeneous/examples/x-init.rs
@@ -9,18 +9,18 @@ use panic_halt as _;
 
 #[rtfm::app(cores = 2, device = homogeneous)]
 const APP: () = {
-    extern "C" {
-        static mut X: u32;
-        static mut Y: u32;
+    struct Resources {
+        x: u32,
+        y: u32,
     }
 
-    #[init(core = 0, late = [X])]
+    #[init(core = 0, late = [x])]
     fn a(_: a::Context) -> a::LateResources {
-        a::LateResources { X: 0 }
+        a::LateResources { x: 0 }
     }
 
     #[init(core = 1)]
     fn b(_: b::Context) -> b::LateResources {
-        b::LateResources { Y: 0 }
+        b::LateResources { y: 0 }
     }
 };
diff --git a/macros/src/codegen/resources.rs b/macros/src/codegen/resources.rs
index 1161a7a5..bec46020 100644
--- a/macros/src/codegen/resources.rs
+++ b/macros/src/codegen/resources.rs
@@ -57,6 +57,7 @@ pub fn codegen(
 
             let attrs = &res.attrs;
             const_app.push(quote!(
+                #[allow(non_upper_case_globals)]
                 #(#attrs)*
                 #(#cfgs)*
                 #loc_attr
@@ -65,50 +66,48 @@ pub fn codegen(
             ));
         }
 
-        // generate a resource proxy if needed
-        if res.mutability.is_some() {
-            if let Some(Ownership::Shared { ceiling }) = analysis.ownerships.get(name) {
-                let cfg_core = util::cfg_core(loc.core().expect("UNREACHABLE"), app.args.cores);
+        if let Some(Ownership::Contended { ceiling }) = analysis.ownerships.get(name) {
+            let cfg_core = util::cfg_core(loc.core().expect("UNREACHABLE"), app.args.cores);
 
-                mod_resources.push(quote!(
-                    #(#cfgs)*
-                    #cfg_core
-                    pub struct #name<'a> {
-                        priority: &'a Priority,
+            mod_resources.push(quote!(
+                #[allow(non_camel_case_types)]
+                #(#cfgs)*
+                #cfg_core
+                pub struct #name<'a> {
+                    priority: &'a Priority,
+                }
+
+                #(#cfgs)*
+                #cfg_core
+                impl<'a> #name<'a> {
+                    #[inline(always)]
+                    pub unsafe fn new(priority: &'a Priority) -> Self {
+                        #name { priority }
                     }
 
-                    #(#cfgs)*
-                    #cfg_core
-                    impl<'a> #name<'a> {
-                        #[inline(always)]
-                        pub unsafe fn new(priority: &'a Priority) -> Self {
-                            #name { priority }
-                        }
-
-                        #[inline(always)]
-                        pub unsafe fn priority(&self) -> &Priority {
-                            self.priority
-                        }
+                    #[inline(always)]
+                    pub unsafe fn priority(&self) -> &Priority {
+                        self.priority
                     }
-                ));
-
-                let ptr = if expr.is_none() {
-                    quote!(#name.as_mut_ptr())
-                } else {
-                    quote!(&mut #name)
-                };
-
-                const_app.push(util::impl_mutex(
-                    extra,
-                    cfgs,
-                    cfg_core.as_ref(),
-                    true,
-                    name,
-                    quote!(#ty),
-                    *ceiling,
-                    ptr,
-                ));
-            }
+                }
+            ));
+
+            let ptr = if expr.is_none() {
+                quote!(#name.as_mut_ptr())
+            } else {
+                quote!(&mut #name)
+            };
+
+            const_app.push(util::impl_mutex(
+                extra,
+                cfgs,
+                cfg_core.as_ref(),
+                true,
+                name,
+                quote!(#ty),
+                *ceiling,
+                ptr,
+            ));
         }
     }
 
diff --git a/macros/src/codegen/resources_struct.rs b/macros/src/codegen/resources_struct.rs
index 0248f199..07a60616 100644
--- a/macros/src/codegen/resources_struct.rs
+++ b/macros/src/codegen/resources_struct.rs
@@ -24,13 +24,17 @@ pub fn codegen(
     let mut values = vec![];
     let mut has_cfgs = false;
 
-    for name in resources {
+    for (name, access) in resources {
         let (res, expr) = app.resource(name).expect("UNREACHABLE");
 
         let cfgs = &res.cfgs;
         has_cfgs |= !cfgs.is_empty();
 
-        let mut_ = res.mutability;
+        let mut_ = if access.is_exclusive() {
+            Some(quote!(mut))
+        } else {
+            None
+        };
         let ty = &res.ty;
 
         if ctxt.is_init() {
diff --git a/ui/single/resources-cfg.rs b/ui/single/resources-cfg.rs
index 6f608fa4..906b3e25 100644
--- a/ui/single/resources-cfg.rs
+++ b/ui/single/resources-cfg.rs
@@ -2,56 +2,74 @@
 
 #[rtfm::app(device = lm3s6965)]
 const APP: () = {
-    #[cfg(never)]
-    static mut O1: u32 = 0; // init
-    #[cfg(never)]
-    static mut O2: u32 = 0; // idle
-    #[cfg(never)]
-    static mut O3: u32 = 0; // EXTI0
-    #[cfg(never)]
-    static O4: u32 = 0; // idle
-    #[cfg(never)]
-    static O5: u32 = 0; // EXTI1
-    #[cfg(never)]
-    static O6: u32 = 0; // init
-
-    #[cfg(never)]
-    static mut S1: u32 = 0; // idle & EXTI0
-    #[cfg(never)]
-    static mut S2: u32 = 0; // EXTI0 & EXTI1
-    #[cfg(never)]
-    static S3: u32 = 0;
-
-    #[init(resources = [O1, O4, O5, O6, S3])]
+    struct Resources {
+        #[cfg(never)]
+        #[init(0)]
+        o1: u32, // init
+
+        #[cfg(never)]
+        #[init(0)]
+        o2: u32, // idle
+
+        #[cfg(never)]
+        #[init(0)]
+        o3: u32, // EXTI0
+
+        #[cfg(never)]
+        #[init(0)]
+        o4: u32, // idle
+
+        #[cfg(never)]
+        #[init(0)]
+        o5: u32, // EXTI1
+
+        #[cfg(never)]
+        #[init(0)]
+        o6: u32, // init
+
+        #[cfg(never)]
+        #[init(0)]
+        s1: u32, // idle & EXTI0
+
+        #[cfg(never)]
+        #[init(0)]
+        s2: u32, // EXTI0 & EXTI1
+
+        #[cfg(never)]
+        #[init(0)]
+        s3: u32,
+    }
+
+    #[init(resources = [o1, o4, o5, o6, s3])]
     fn init(c: init::Context) {
-        c.resources.O1;
-        c.resources.O4;
-        c.resources.O5;
-        c.resources.O6;
-        c.resources.S3;
+        c.resources.o1;
+        c.resources.o4;
+        c.resources.o5;
+        c.resources.o6;
+        c.resources.s3;
     }
 
-    #[idle(resources = [O2, O4, S1, S3])]
+    #[idle(resources = [o2, &o4, s1, &s3])]
     fn idle(c: idle::Context) -> ! {
-        c.resources.O2;
-        c.resources.O4;
-        c.resources.S1;
-        c.resources.S3;
+        c.resources.o2;
+        c.resources.o4;
+        c.resources.s1;
+        c.resources.s3;
 
         loop {}
     }
 
-    #[task(binds = UART0, resources = [O3, S1, S2, S3])]
+    #[task(binds = UART0, resources = [o3, s1, s2, &s3])]
     fn uart0(c: uart0::Context) {
-        c.resources.O3;
-        c.resources.S1;
-        c.resources.S2;
-        c.resources.S3;
+        c.resources.o3;
+        c.resources.s1;
+        c.resources.s2;
+        c.resources.s3;
     }
 
-    #[task(binds = UART1, resources = [S2, O5])]
+    #[task(binds = UART1, resources = [s2, &o5])]
     fn uart1(c: uart1::Context) {
-        c.resources.S2;
-        c.resources.O5;
+        c.resources.s2;
+        c.resources.o5;
     }
 };
diff --git a/ui/single/resources-cfg.stderr b/ui/single/resources-cfg.stderr
index 55e7ee0e..a745e6e2 100644
--- a/ui/single/resources-cfg.stderr
+++ b/ui/single/resources-cfg.stderr
@@ -1,119 +1,119 @@
-error[E0609]: no field `O1` on type `initResources<'_>`
-  --> $DIR/resources-cfg.rs:27:21
+error[E0609]: no field `o1` on type `initResources<'_>`
+  --> $DIR/resources-cfg.rs:45:21
    |
-27 |         c.resources.O1;
+45 |         c.resources.o1;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `O4` on type `initResources<'_>`
-  --> $DIR/resources-cfg.rs:28:21
+error[E0609]: no field `o4` on type `initResources<'_>`
+  --> $DIR/resources-cfg.rs:46:21
    |
-28 |         c.resources.O4;
+46 |         c.resources.o4;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `O5` on type `initResources<'_>`
-  --> $DIR/resources-cfg.rs:29:21
+error[E0609]: no field `o5` on type `initResources<'_>`
+  --> $DIR/resources-cfg.rs:47:21
    |
-29 |         c.resources.O5;
+47 |         c.resources.o5;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `O6` on type `initResources<'_>`
-  --> $DIR/resources-cfg.rs:30:21
+error[E0609]: no field `o6` on type `initResources<'_>`
+  --> $DIR/resources-cfg.rs:48:21
    |
-30 |         c.resources.O6;
+48 |         c.resources.o6;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `S3` on type `initResources<'_>`
-  --> $DIR/resources-cfg.rs:31:21
+error[E0609]: no field `s3` on type `initResources<'_>`
+  --> $DIR/resources-cfg.rs:49:21
    |
-31 |         c.resources.S3;
+49 |         c.resources.s3;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `O2` on type `idleResources<'_>`
-  --> $DIR/resources-cfg.rs:36:21
+error[E0609]: no field `o2` on type `idleResources<'_>`
+  --> $DIR/resources-cfg.rs:54:21
    |
-36 |         c.resources.O2;
+54 |         c.resources.o2;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `O4` on type `idleResources<'_>`
-  --> $DIR/resources-cfg.rs:37:21
+error[E0609]: no field `o4` on type `idleResources<'_>`
+  --> $DIR/resources-cfg.rs:55:21
    |
-37 |         c.resources.O4;
+55 |         c.resources.o4;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `S1` on type `idleResources<'_>`
-  --> $DIR/resources-cfg.rs:38:21
+error[E0609]: no field `s1` on type `idleResources<'_>`
+  --> $DIR/resources-cfg.rs:56:21
    |
-38 |         c.resources.S1;
+56 |         c.resources.s1;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `S3` on type `idleResources<'_>`
-  --> $DIR/resources-cfg.rs:39:21
+error[E0609]: no field `s3` on type `idleResources<'_>`
+  --> $DIR/resources-cfg.rs:57:21
    |
-39 |         c.resources.S3;
+57 |         c.resources.s3;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `O3` on type `uart0Resources<'_>`
-  --> $DIR/resources-cfg.rs:46:21
+error[E0609]: no field `o3` on type `uart0Resources<'_>`
+  --> $DIR/resources-cfg.rs:64:21
    |
-46 |         c.resources.O3;
+64 |         c.resources.o3;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `S1` on type `uart0Resources<'_>`
-  --> $DIR/resources-cfg.rs:47:21
+error[E0609]: no field `s1` on type `uart0Resources<'_>`
+  --> $DIR/resources-cfg.rs:65:21
    |
-47 |         c.resources.S1;
+65 |         c.resources.s1;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `S2` on type `uart0Resources<'_>`
-  --> $DIR/resources-cfg.rs:48:21
+error[E0609]: no field `s2` on type `uart0Resources<'_>`
+  --> $DIR/resources-cfg.rs:66:21
    |
-48 |         c.resources.S2;
+66 |         c.resources.s2;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `S3` on type `uart0Resources<'_>`
-  --> $DIR/resources-cfg.rs:49:21
+error[E0609]: no field `s3` on type `uart0Resources<'_>`
+  --> $DIR/resources-cfg.rs:67:21
    |
-49 |         c.resources.S3;
+67 |         c.resources.s3;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `S2` on type `uart1Resources<'_>`
-  --> $DIR/resources-cfg.rs:54:21
+error[E0609]: no field `s2` on type `uart1Resources<'_>`
+  --> $DIR/resources-cfg.rs:72:21
    |
-54 |         c.resources.S2;
+72 |         c.resources.s2;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`
 
-error[E0609]: no field `O5` on type `uart1Resources<'_>`
-  --> $DIR/resources-cfg.rs:55:21
+error[E0609]: no field `o5` on type `uart1Resources<'_>`
+  --> $DIR/resources-cfg.rs:73:21
    |
-55 |         c.resources.O5;
+73 |         c.resources.o5;
    |                     ^^ unknown field
    |
    = note: available fields are: `__marker__`