Merge #494

494: Resoures take 2 r=korken89 a=korken89



Co-authored-by: Emil Fresk <emil.fresk@gmail.com>

17 files changed, 605 insertions, 492 deletions

diff --git a/macros/src/codegen.rs b/macros/src/codegen.rs
index 113d17f9..6920031a 100644
--- a/macros/src/codegen.rs
+++ b/macros/src/codegen.rs
@@ -9,17 +9,17 @@ mod dispatchers;
 mod hardware_tasks;
 mod idle;
 mod init;
-mod locals;
+mod local_resources;
+mod local_resources_struct;
 mod module;
 mod post_init;
 mod pre_init;
-mod resources;
-mod resources_struct;
+mod shared_resources;
+mod shared_resources_struct;
 mod software_tasks;
 mod timer_queue;
 mod util;
 
-// TODO document the syntax here or in `rtic-syntax`
 pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
     let mut mod_app = vec![];
     let mut mains = vec![];
@@ -52,7 +52,7 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
     mod_app.push(quote!(
         #mod_app_init
 
-        #mod_app_idle
+        #(#mod_app_idle)*
     ));
 
     let main = util::suffixed("main");
@@ -83,7 +83,10 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
         }
     ));
 
-    let (mod_app_resources, mod_resources) = resources::codegen(app, analysis, extra);
+    let (mod_app_shared_resources, mod_shared_resources) =
+        shared_resources::codegen(app, analysis, extra);
+    let (mod_app_local_resources, mod_local_resources) =
+        local_resources::codegen(app, analysis, extra);
 
     let (mod_app_hardware_tasks, root_hardware_tasks, user_hardware_tasks) =
         hardware_tasks::codegen(app, analysis, extra);
@@ -185,7 +188,9 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
 
             #(#root)*
 
-            #mod_resources
+            #mod_shared_resources
+
+            #mod_local_resources
 
             #(#root_hardware_tasks)*
 
@@ -194,7 +199,9 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
             /// app module
             #(#mod_app)*
 
-            #(#mod_app_resources)*
+            #(#mod_app_shared_resources)*
+
+            #(#mod_app_local_resources)*
 
             #(#mod_app_hardware_tasks)*
 
diff --git a/macros/src/codegen/dispatchers.rs b/macros/src/codegen/dispatchers.rs
index 65a3f5f6..ac550036 100644
--- a/macros/src/codegen/dispatchers.rs
+++ b/macros/src/codegen/dispatchers.rs
@@ -76,12 +76,6 @@ pub fn codegen(app: &App, analysis: &Analysis, _extra: &Extra) -> Vec<TokenStrea
                 let inputs = util::mark_internal_ident(&inputs);
                 let (_, tupled, pats, _) = util::regroup_inputs(&task.inputs);
 
-                let locals_new = if task.locals.is_empty() {
-                    quote!()
-                } else {
-                    quote!(#name::Locals::new(),)
-                };
-
                 quote!(
                     #(#cfgs)*
                     #t::#name => {
@@ -94,7 +88,6 @@ pub fn codegen(app: &App, analysis: &Analysis, _extra: &Extra) -> Vec<TokenStrea
                         #fq.get_mut_unchecked().split().0.enqueue_unchecked(index);
                         let priority = &rtic::export::Priority::new(PRIORITY);
                         #name(
-                            #locals_new
                             #name::Context::new(priority)
                             #(,#pats)*
                         )
diff --git a/macros/src/codegen/hardware_tasks.rs b/macros/src/codegen/hardware_tasks.rs
index 003660c7..e6192e2c 100644
--- a/macros/src/codegen/hardware_tasks.rs
+++ b/macros/src/codegen/hardware_tasks.rs
@@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context};
 use crate::{
     analyze::Analysis,
     check::Extra,
-    codegen::{locals, module, resources_struct},
+    codegen::{local_resources_struct, module, shared_resources_struct},
 };
 
 /// Generate support code for hardware tasks (`#[exception]`s and `#[interrupt]`s)
@@ -29,12 +29,6 @@ pub fn codegen(
     let mut user_tasks = vec![];
 
     for (name, task) in &app.hardware_tasks {
-        let locals_new = if task.locals.is_empty() {
-            quote!()
-        } else {
-            quote!(#name::Locals::new(),)
-        };
-
         let symbol = task.args.binds.clone();
         let priority = task.args.priority;
         let cfgs = &task.cfgs;
@@ -50,19 +44,35 @@ pub fn codegen(
 
                 rtic::export::run(PRIORITY, || {
                     #name(
-                        #locals_new
                         #name::Context::new(&rtic::export::Priority::new(PRIORITY))
                     )
                 });
             }
         ));
 
-        let mut needs_lt = false;
+        let mut shared_needs_lt = false;
+        let mut local_needs_lt = false;
+
+        // `${task}Locals`
+        if !task.args.local_resources.is_empty() {
+            let (item, constructor) = local_resources_struct::codegen(
+                Context::HardwareTask(name),
+                &mut local_needs_lt,
+                app,
+            );
+
+            root.push(item);
+
+            mod_app.push(constructor);
+        }
 
         // `${task}Resources`
-        if !task.args.resources.is_empty() {
-            let (item, constructor) =
-                resources_struct::codegen(Context::HardwareTask(name), &mut needs_lt, app);
+        if !task.args.shared_resources.is_empty() {
+            let (item, constructor) = shared_resources_struct::codegen(
+                Context::HardwareTask(name),
+                &mut shared_needs_lt,
+                app,
+            );
 
             root.push(item);
 
@@ -71,30 +81,21 @@ pub fn codegen(
 
         root.push(module::codegen(
             Context::HardwareTask(name),
-            needs_lt,
+            shared_needs_lt,
+            local_needs_lt,
             app,
             analysis,
             extra,
         ));
 
-        // `${task}Locals`
-        let mut locals_pat = None;
-        if !task.locals.is_empty() {
-            let (struct_, pat) = locals::codegen(Context::HardwareTask(name), &task.locals, app);
-
-            root.push(struct_);
-            locals_pat = Some(pat);
-        }
-
-        if !&task.is_extern {
+        if !task.is_extern {
             let attrs = &task.attrs;
             let context = &task.context;
             let stmts = &task.stmts;
-            let locals_pat = locals_pat.iter();
             user_tasks.push(quote!(
                 #(#attrs)*
                 #[allow(non_snake_case)]
-                fn #name(#(#locals_pat,)* #context: #name::Context) {
+                fn #name(#context: #name::Context) {
                     use rtic::Mutex as _;
                     use rtic::mutex_prelude::*;
 
diff --git a/macros/src/codegen/idle.rs b/macros/src/codegen/idle.rs
index 4bc41c13..d6539316 100644
--- a/macros/src/codegen/idle.rs
+++ b/macros/src/codegen/idle.rs
@@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context};
 use crate::{
     analyze::Analysis,
     check::Extra,
-    codegen::{locals, module, resources_struct},
+    codegen::{local_resources_struct, module, shared_resources_struct},
 };
 
 /// Generates support code for `#[idle]` functions
@@ -15,7 +15,7 @@ pub fn codegen(
     extra: &Extra,
 ) -> (
     // mod_app_idle -- the `${idle}Resources` constructor
-    Option<TokenStream2>,
+    Vec<TokenStream2>,
     // root_idle -- items that must be placed in the root of the crate:
     // - the `${idle}Locals` struct
     // - the `${idle}Resources` struct
@@ -26,34 +26,35 @@ pub fn codegen(
     // call_idle
     TokenStream2,
 ) {
-    if !app.idles.is_empty() {
-        let idle = &app.idles.first().unwrap();
-        let mut needs_lt = false;
-        let mut mod_app = None;
+    if let Some(idle) = &app.idle {
+        let mut shared_needs_lt = false;
+        let mut local_needs_lt = false;
+        let mut mod_app = vec![];
         let mut root_idle = vec![];
-        let mut locals_pat = None;
-        let mut locals_new = None;
 
         let name = &idle.name;
 
-        if !idle.args.resources.is_empty() {
-            let (item, constructor) = resources_struct::codegen(Context::Idle, &mut needs_lt, app);
+        if !idle.args.shared_resources.is_empty() {
+            let (item, constructor) =
+                shared_resources_struct::codegen(Context::Idle, &mut shared_needs_lt, app);
 
             root_idle.push(item);
-            mod_app = Some(constructor);
+            mod_app.push(constructor);
         }
 
-        if !idle.locals.is_empty() {
-            let (locals, pat) = locals::codegen(Context::Idle, &idle.locals, app);
+        if !idle.args.local_resources.is_empty() {
+            let (item, constructor) =
+                local_resources_struct::codegen(Context::Idle, &mut local_needs_lt, app);
+
+            root_idle.push(item);
 
-            locals_new = Some(quote!(#name::Locals::new()));
-            locals_pat = Some(pat);
-            root_idle.push(locals);
+            mod_app.push(constructor);
         }
 
         root_idle.push(module::codegen(
             Context::Idle,
-            needs_lt,
+            shared_needs_lt,
+            local_needs_lt,
             app,
             analysis,
             extra,
@@ -62,11 +63,10 @@ pub fn codegen(
         let attrs = &idle.attrs;
         let context = &idle.context;
         let stmts = &idle.stmts;
-        let locals_pat = locals_pat.iter();
         let user_idle = Some(quote!(
             #(#attrs)*
             #[allow(non_snake_case)]
-            fn #name(#(#locals_pat,)* #context: #name::Context) -> ! {
+            fn #name(#context: #name::Context) -> ! {
                 use rtic::Mutex as _;
                 use rtic::mutex_prelude::*;
 
@@ -74,16 +74,14 @@ pub fn codegen(
             }
         ));
 
-        let locals_new = locals_new.iter();
         let call_idle = quote!(#name(
-            #(#locals_new,)*
             #name::Context::new(&rtic::export::Priority::new(0))
         ));
 
         (mod_app, root_idle, user_idle, call_idle)
     } else {
         (
-            None,
+            vec![],
             vec![],
             None,
             quote!(loop {
diff --git a/macros/src/codegen/init.rs b/macros/src/codegen/init.rs
index fe8a1263..b6d3f72e 100644
--- a/macros/src/codegen/init.rs
+++ b/macros/src/codegen/init.rs
@@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context};
 use crate::{
     analyze::Analysis,
     check::Extra,
-    codegen::{locals, module, resources_struct},
+    codegen::{local_resources_struct, module},
 };
 
 type CodegenResult = (
@@ -18,68 +18,96 @@ type CodegenResult = (
     // - the `${init}` module, which contains types like `${init}::Context`
     Vec<TokenStream2>,
     // user_init -- the `#[init]` function written by the user
-    Option<TokenStream2>,
-    // call_init -- the call to the user `#[init]` if there's one
-    Option<TokenStream2>,
+    TokenStream2,
+    // call_init -- the call to the user `#[init]`
+    TokenStream2,
 );
 
 /// Generates support code for `#[init]` functions
 pub fn codegen(app: &App, analysis: &Analysis, extra: &Extra) -> CodegenResult {
-    if !app.inits.is_empty() {
-        let init = &app.inits.first().unwrap();
-        let mut needs_lt = false;
-        let name = &init.name;
+    let init = &app.init;
+    let mut local_needs_lt = false;
+    let name = &init.name;
 
-        let mut root_init = vec![];
+    let mut root_init = vec![];
 
-        let mut locals_pat = None;
-        let mut locals_new = None;
-        if !init.locals.is_empty() {
-            let (struct_, pat) = locals::codegen(Context::Init, &init.locals, app);
+    let context = &init.context;
+    let attrs = &init.attrs;
+    let stmts = &init.stmts;
+    let shared = &init.user_shared_struct;
+    let local = &init.user_local_struct;
 
-            locals_new = Some(quote!(#name::Locals::new()));
-            locals_pat = Some(pat);
-            root_init.push(struct_);
+    let shared_resources: Vec<_> = app
+        .shared_resources
+        .iter()
+        .map(|(k, v)| {
+            let ty = &v.ty;
+            let cfgs = &v.cfgs;
+            quote!(
+                #(#cfgs)*
+                #k: #ty,
+            )
+        })
+        .collect();
+    let local_resources: Vec<_> = app
+        .local_resources
+        .iter()
+        .map(|(k, v)| {
+            let ty = &v.ty;
+            let cfgs = &v.cfgs;
+            quote!(
+                #(#cfgs)*
+                #k: #ty,
+            )
+        })
+        .collect();
+    root_init.push(quote! {
+        struct #shared {
+            #(#shared_resources)*
         }
 
-        let context = &init.context;
-        let attrs = &init.attrs;
-        let stmts = &init.stmts;
-        let locals_pat = locals_pat.iter();
-
-        let user_init_return = quote! {#name::LateResources, #name::Monotonics};
+        struct #local {
+            #(#local_resources)*
+        }
+    });
 
-        let user_init = Some(quote!(
-            #(#attrs)*
-            #[allow(non_snake_case)]
-            fn #name(#(#locals_pat,)* #context: #name::Context) -> (#user_init_return) {
-                #(#stmts)*
-            }
-        ));
+    // let locals_pat = locals_pat.iter();
 
-        let mut mod_app = None;
-        if !init.args.resources.is_empty() {
-            let (item, constructor) = resources_struct::codegen(Context::Init, &mut needs_lt, app);
+    let user_init_return = quote! {#shared, #local, #name::Monotonics};
 
-            root_init.push(item);
-            mod_app = Some(constructor);
+    let user_init = quote!(
+        #(#attrs)*
+        #[allow(non_snake_case)]
+        fn #name(#context: #name::Context) -> (#user_init_return) {
+            #(#stmts)*
         }
+    );
+
+    let mut mod_app = None;
 
-        let locals_new = locals_new.iter();
-        let call_init = Some(
-            quote!(let (late, mut monotonics) = #name(#(#locals_new,)* #name::Context::new(core.into()));),
-        );
-
-        root_init.push(module::codegen(
-            Context::Init,
-            needs_lt,
-            app,
-            analysis,
-            extra,
-        ));
-
-        (mod_app, root_init, user_init, call_init)
-    } else {
-        (None, vec![], None, None)
+    // `${task}Locals`
+    if !init.args.local_resources.is_empty() {
+        let (item, constructor) =
+            local_resources_struct::codegen(Context::Init, &mut local_needs_lt, app);
+
+        root_init.push(item);
+
+        mod_app = Some(constructor);
     }
+
+    // let locals_new = locals_new.iter();
+    let call_init = quote! {
+        let (shared_resources, local_resources, mut monotonics) = #name(#name::Context::new(core.into()));
+    };
+
+    root_init.push(module::codegen(
+        Context::Init,
+        false,
+        local_needs_lt,
+        app,
+        analysis,
+        extra,
+    ));
+
+    (mod_app, root_init, user_init, call_init)
 }
diff --git a/macros/src/codegen/local_resources.rs b/macros/src/codegen/local_resources.rs
new file mode 100644
index 00000000..a9ffa925
--- /dev/null
+++ b/macros/src/codegen/local_resources.rs
@@ -0,0 +1,71 @@
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use rtic_syntax::ast::App;
+
+use crate::{analyze::Analysis, check::Extra, codegen::util};
+
+/// Generates `local` variables and local resource proxies
+///
+/// I.e. the `static` variables and theirs proxies.
+pub fn codegen(
+    app: &App,
+    _analysis: &Analysis,
+    _extra: &Extra,
+) -> (
+    // mod_app -- the `static` variables behind the proxies
+    Vec<TokenStream2>,
+    // mod_resources -- the `resources` module
+    TokenStream2,
+) {
+    let mut mod_app = vec![];
+    // let mut mod_resources: _ = vec![];
+
+    // All local resources declared in the `#[local]' struct
+    for (name, res) in &app.local_resources {
+        let cfgs = &res.cfgs;
+        let ty = &res.ty;
+        let mangled_name = util::mark_internal_ident(&util::static_local_resource_ident(name));
+
+        let attrs = &res.attrs;
+        // late resources in `util::link_section_uninit`
+        let section = util::link_section_uninit();
+
+        // For future use
+        // let doc = format!(" RTIC internal: {}:{}", file!(), line!());
+        mod_app.push(quote!(
+            #[allow(non_upper_case_globals)]
+            // #[doc = #doc]
+            #[doc(hidden)]
+            #(#attrs)*
+            #(#cfgs)*
+            #section
+            static #mangled_name: rtic::RacyCell<core::mem::MaybeUninit<#ty>> = rtic::RacyCell::new(core::mem::MaybeUninit::uninit());
+        ));
+    }
+
+    // All declared `local = [NAME: TY = EXPR]` local resources
+    for (task_name, resource_name, task_local) in app.declared_local_resources() {
+        let cfgs = &task_local.cfgs;
+        let ty = &task_local.ty;
+        let expr = &task_local.expr;
+        let attrs = &task_local.attrs;
+
+        let mangled_name = util::mark_internal_ident(&util::declared_static_local_resource_ident(
+            resource_name,
+            &task_name,
+        ));
+
+        // For future use
+        // let doc = format!(" RTIC internal: {}:{}", file!(), line!());
+        mod_app.push(quote!(
+            #[allow(non_upper_case_globals)]
+            // #[doc = #doc]
+            #[doc(hidden)]
+            #(#attrs)*
+            #(#cfgs)*
+            static #mangled_name: rtic::RacyCell<#ty> = rtic::RacyCell::new(#expr);
+        ));
+    }
+
+    (mod_app, TokenStream2::new())
+}
diff --git a/macros/src/codegen/local_resources_struct.rs b/macros/src/codegen/local_resources_struct.rs
new file mode 100644
index 00000000..4bd9e2a4
--- /dev/null
+++ b/macros/src/codegen/local_resources_struct.rs
@@ -0,0 +1,110 @@
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use rtic_syntax::{
+    ast::{App, TaskLocal},
+    Context,
+};
+
+use crate::codegen::util;
+
+/// Generates local resources structs
+pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, TokenStream2) {
+    let mut lt = None;
+
+    let resources = match ctxt {
+        Context::Init => &app.init.args.local_resources,
+        Context::Idle => &app.idle.as_ref().unwrap().args.local_resources,
+        Context::HardwareTask(name) => &app.hardware_tasks[name].args.local_resources,
+        Context::SoftwareTask(name) => &app.software_tasks[name].args.local_resources,
+    };
+
+    let task_name = util::get_task_name(ctxt, app);
+
+    let mut fields = vec![];
+    let mut values = vec![];
+    let mut has_cfgs = false;
+
+    for (name, task_local) in resources {
+        let (cfgs, ty, is_declared) = match task_local {
+            TaskLocal::External => {
+                let r = app.local_resources.get(name).expect("UNREACHABLE");
+                (&r.cfgs, &r.ty, false)
+            }
+            TaskLocal::Declared(r) => (&r.cfgs, &r.ty, true),
+            _ => unreachable!(),
+        };
+
+        has_cfgs |= !cfgs.is_empty();
+
+        let lt = if ctxt.runs_once() {
+            quote!('static)
+        } else {
+            lt = Some(quote!('a));
+            quote!('a)
+        };
+
+        let mangled_name = if matches!(task_local, TaskLocal::External) {
+            util::mark_internal_ident(&util::static_local_resource_ident(name))
+        } else {
+            util::mark_internal_ident(&util::declared_static_local_resource_ident(
+                name, &task_name,
+            ))
+        };
+
+        fields.push(quote!(
+            #(#cfgs)*
+            pub #name: &#lt mut #ty
+        ));
+
+        let expr = if is_declared {
+            // If the local resources is already initialized, we only need to access its value and
+            // not go through an `MaybeUninit`
+            quote!(#mangled_name.get_mut_unchecked())
+        } else {
+            quote!(&mut *#mangled_name.get_mut_unchecked().as_mut_ptr())
+        };
+
+        values.push(quote!(
+            #(#cfgs)*
+            #name: #expr
+        ));
+    }
+
+    if lt.is_some() {
+        *needs_lt = true;
+
+        // The struct could end up empty due to `cfg`s leading to an error due to `'a` being unused
+        if has_cfgs {
+            fields.push(quote!(
+                #[doc(hidden)]
+                pub __marker__: core::marker::PhantomData<&'a ()>
+            ));
+
+            values.push(quote!(__marker__: core::marker::PhantomData))
+        }
+    }
+
+    let doc = format!("Local resources `{}` has access to", ctxt.ident(app));
+    let ident = util::local_resources_ident(ctxt, app);
+    let ident = util::mark_internal_ident(&ident);
+    let item = quote!(
+        #[allow(non_snake_case)]
+        #[doc = #doc]
+        pub struct #ident<#lt> {
+            #(#fields,)*
+        }
+    );
+
+    let constructor = quote!(
+        impl<#lt> #ident<#lt> {
+            #[inline(always)]
+            pub unsafe fn new() -> Self {
+                #ident {
+                    #(#values,)*
+                }
+            }
+        }
+    );
+
+    (item, constructor)
+}
diff --git a/macros/src/codegen/locals.rs b/macros/src/codegen/locals.rs
deleted file mode 100644
index 0fb8c6d2..00000000
--- a/macros/src/codegen/locals.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use proc_macro2::TokenStream as TokenStream2;
-use quote::quote;
-use rtic_syntax::{
-    ast::{App, Local},
-    Context, Map,
-};
-
-use crate::codegen::util;
-
-pub fn codegen(
-    ctxt: Context,
-    locals: &Map<Local>,
-    app: &App,
-) -> (
-    // locals
-    TokenStream2,
-    // pat
-    TokenStream2,
-) {
-    assert!(!locals.is_empty());
-
-    let runs_once = ctxt.runs_once();
-    let ident = util::locals_ident(ctxt, app);
-
-    let mut lt = None;
-    let mut fields = vec![];
-    let mut items = vec![];
-    let mut names = vec![];
-    let mut values = vec![];
-    let mut pats = vec![];
-    let mut has_cfgs = false;
-
-    for (name, local) in locals {
-        let lt = if runs_once {
-            quote!('static)
-        } else {
-            lt = Some(quote!('a));
-            quote!('a)
-        };
-
-        let cfgs = &local.cfgs;
-        has_cfgs |= !cfgs.is_empty();
-
-        let expr = &local.expr;
-        let ty = &local.ty;
-        fields.push(quote!(
-            #(#cfgs)*
-            #name: &#lt mut #ty
-        ));
-        items.push(quote!(
-            #(#cfgs)*
-            #[doc(hidden)]
-            static #name: rtic::RacyCell<#ty> = rtic::RacyCell::new(#expr)
-        ));
-        values.push(quote!(
-            #(#cfgs)*
-            #name: #name.get_mut_unchecked()
-        ));
-        names.push(name);
-        pats.push(quote!(
-            #(#cfgs)*
-            #name
-        ));
-    }
-
-    if lt.is_some() && has_cfgs {
-        fields.push(quote!(__marker__: core::marker::PhantomData<&'a ()>));
-        values.push(quote!(__marker__: core::marker::PhantomData));
-    }
-
-    let locals = quote!(
-        #[allow(non_snake_case)]
-        #[doc(hidden)]
-        pub struct #ident<#lt> {
-            #(#fields),*
-        }
-
-        impl<#lt> #ident<#lt> {
-            #[inline(always)]
-            unsafe fn new() -> Self {
-                #(#items;)*
-
-                #ident {
-                    #(#values),*
-                }
-            }
-        }
-    );
-
-    let ident = ctxt.ident(app);
-    (
-        locals,
-        quote!(#ident::Locals { #(#pats,)* .. }: #ident::Locals),
-    )
-}
diff --git a/macros/src/codegen/module.rs b/macros/src/codegen/module.rs
index a3d3fab2..a59d6628 100644
--- a/macros/src/codegen/module.rs
+++ b/macros/src/codegen/module.rs
@@ -5,7 +5,8 @@ use rtic_syntax::{ast::App, Context};
 
 pub fn codegen(
     ctxt: Context,
-    resources_tick: bool,
+    shared_resources_tick: bool,
+    local_resources_tick: bool,
     app: &App,
     analysis: &Analysis,
     extra: &Extra,
@@ -56,18 +57,41 @@ pub fn codegen(
         Context::SoftwareTask(_) => {}
     }
 
-    if ctxt.has_locals(app) {
-        let ident = util::locals_ident(ctxt, app);
+    // if ctxt.has_locals(app) {
+    //     let ident = util::locals_ident(ctxt, app);
+    //     module_items.push(quote!(
+    //         #[doc(inline)]
+    //         pub use super::#ident as Locals;
+    //     ));
+    // }
+
+    if ctxt.has_local_resources(app) {
+        let ident = util::local_resources_ident(ctxt, app);
+        let ident = util::mark_internal_ident(&ident);
+        let lt = if local_resources_tick {
+            lt = Some(quote!('a));
+            Some(quote!('a))
+        } else {
+            None
+        };
+
         module_items.push(quote!(
             #[doc(inline)]
-            pub use super::#ident as Locals;
+            pub use super::#ident as LocalResources;
+        ));
+
+        fields.push(quote!(
+            /// Local Resources this task has access to
+            pub local: #name::LocalResources<#lt>
         ));
+
+        values.push(quote!(local: #name::LocalResources::new()));
     }
 
-    if ctxt.has_resources(app) {
-        let ident = util::resources_ident(ctxt, app);
+    if ctxt.has_shared_resources(app) {
+        let ident = util::shared_resources_ident(ctxt, app);
         let ident = util::mark_internal_ident(&ident);
-        let lt = if resources_tick {
+        let lt = if shared_resources_tick {
             lt = Some(quote!('a));
             Some(quote!('a))
         } else {
@@ -76,12 +100,12 @@ pub fn codegen(
 
         module_items.push(quote!(
             #[doc(inline)]
-            pub use super::#ident as Resources;
+            pub use super::#ident as SharedResources;
         ));
 
         fields.push(quote!(
-            /// Resources this task has access to
-            pub resources: #name::Resources<#lt>
+            /// Shared Resources this task has access to
+            pub shared: #name::SharedResources<#lt>
         ));
 
         let priority = if ctxt.is_init() {
@@ -89,38 +113,10 @@ pub fn codegen(
         } else {
             Some(quote!(priority))
         };
-        values.push(quote!(resources: #name::Resources::new(#priority)));
+        values.push(quote!(shared: #name::SharedResources::new(#priority)));
     }
 
     if let Context::Init = ctxt {
-        let late_fields = analysis
-            .late_resources
-            .iter()
-            .flat_map(|resources| {
-                resources.iter().map(|name| {
-                    let ty = &app.late_resources[name].ty;
-                    let cfgs = &app.late_resources[name].cfgs;
-
-                    quote!(
-                        #(#cfgs)*
-                        pub #name: #ty
-                    )
-                })
-            })
-            .collect::<Vec<_>>();
-
-        let internal_late_ident = util::mark_internal_name("LateResources");
-        items.push(quote!(
-            /// Resources initialized at runtime
-            #[allow(non_snake_case)]
-            pub struct #internal_late_ident {
-                #(#late_fields),*
-            }
-        ));
-        module_items.push(quote!(
-            pub use super::#internal_late_ident as LateResources;
-        ));
-
         let monotonic_types: Vec<_> = app
             .monotonics
             .iter()
@@ -202,9 +198,6 @@ pub fn codegen(
         pub use super::#internal_context_name as Context;
     ));
 
-    // not sure if this is the right way, maybe its backwards,
-    // that spawn_module should put in in root
-
     if let Context::SoftwareTask(..) = ctxt {
         let spawnee = &app.software_tasks[name];
         let priority = spawnee.args.priority;
diff --git a/macros/src/codegen/post_init.rs b/macros/src/codegen/post_init.rs
index 78548bcd..161068d2 100644
--- a/macros/src/codegen/post_init.rs
+++ b/macros/src/codegen/post_init.rs
@@ -9,24 +9,39 @@ use crate::{analyze::Analysis, codegen::util};
 pub fn codegen(app: &App, analysis: &Analysis) -> Vec<TokenStream2> {
     let mut stmts = vec![];
 
-    // Initialize late resources
-    if !analysis.late_resources.is_empty() {
-        // BTreeSet wrapped in a vector
-        for name in analysis.late_resources.first().unwrap() {
-            let mangled_name = util::mark_internal_ident(&name);
-            // If it's live
-            let cfgs = app.late_resources[name].cfgs.clone();
-            if analysis.locations.get(name).is_some() {
-                stmts.push(quote!(
-                    // We include the cfgs
-                    #(#cfgs)*
-                    // Late resource is a RacyCell<MaybeUninit<T>>
-                    // - `get_mut_unchecked` to obtain `MaybeUninit<T>`
-                    // - `as_mut_ptr` to obtain a raw pointer to `MaybeUninit<T>`
-                    // - `write` the defined value for the late resource T
-                    #mangled_name.get_mut_unchecked().as_mut_ptr().write(late.#name);
-                ));
-            }
+    // Initialize shared resources
+    for (name, res) in &app.shared_resources {
+        let mangled_name = util::mark_internal_ident(&util::static_shared_resource_ident(name));
+        // If it's live
+        let cfgs = res.cfgs.clone();
+        if analysis.shared_resource_locations.get(name).is_some() {
+            stmts.push(quote!(
+                // We include the cfgs
+                #(#cfgs)*
+                // Resource is a RacyCell<MaybeUninit<T>>
+                // - `get_mut_unchecked` to obtain `MaybeUninit<T>`
+                // - `as_mut_ptr` to obtain a raw pointer to `MaybeUninit<T>`
+                // - `write` the defined value for the late resource T
+                #mangled_name.get_mut_unchecked().as_mut_ptr().write(shared_resources.#name);
+            ));
+        }
+    }
+
+    // Initialize local resources
+    for (name, res) in &app.local_resources {
+        let mangled_name = util::mark_internal_ident(&util::static_local_resource_ident(name));
+        // If it's live
+        let cfgs = res.cfgs.clone();
+        if analysis.local_resource_locations.get(name).is_some() {
+            stmts.push(quote!(
+                // We include the cfgs
+                #(#cfgs)*
+                // Resource is a RacyCell<MaybeUninit<T>>
+                // - `get_mut_unchecked` to obtain `MaybeUninit<T>`
+                // - `as_mut_ptr` to obtain a raw pointer to `MaybeUninit<T>`
+                // - `write` the defined value for the late resource T
+                #mangled_name.get_mut_unchecked().as_mut_ptr().write(local_resources.#name);
+            ));
         }
     }
 
diff --git a/macros/src/codegen/pre_init.rs b/macros/src/codegen/pre_init.rs
index 531debac..ae628f6e 100644
--- a/macros/src/codegen/pre_init.rs
+++ b/macros/src/codegen/pre_init.rs
@@ -126,7 +126,7 @@ pub fn codegen(app: &App, analysis: &Analysis, extra: &Extra) -> Vec<TokenStream
     }
 
     // If there's no user `#[idle]` then optimize returning from interrupt handlers
-    if app.idles.is_empty() {
+    if app.idle.is_none() {
         // Set SLEEPONEXIT bit to enter sleep mode when returning from ISR
         stmts.push(quote!(core.SCB.scr.modify(|r| r | 1 << 1);));
     }
diff --git a/macros/src/codegen/resources.rs b/macros/src/codegen/resources.rs
deleted file mode 100644
index a623ea60..00000000
--- a/macros/src/codegen/resources.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use proc_macro2::TokenStream as TokenStream2;
-use quote::quote;
-use rtic_syntax::{analyze::Ownership, ast::App};
-
-use crate::{analyze::Analysis, check::Extra, codegen::util};
-
-/// Generates `static` variables and resource proxies
-/// Early resources are stored in `RacyCell<T>`
-/// Late resource are stored in `RacyCell<MaybeUninit<T>>`
-///
-/// Safety:
-/// - RacyCell<T> access is `unsafe`.
-/// - RacyCell<MaybeUninit> is always written to before user access, thus
-//    the generated code for user access can safely `assume_init`.
-pub fn codegen(
-    app: &App,
-    analysis: &Analysis,
-    extra: &Extra,
-) -> (
-    // mod_app -- the `static` variables behind the proxies
-    Vec<TokenStream2>,
-    // mod_resources -- the `resources` module
-    TokenStream2,
-) {
-    let mut mod_app = vec![];
-    let mut mod_resources = vec![];
-
-    for (name, res, expr, _) in app.resources(analysis) {
-        let cfgs = &res.cfgs;
-        let ty = &res.ty;
-        let mangled_name = util::mark_internal_ident(&name);
-
-        {
-            // late resources in `util::link_section_uninit`
-            let section = if expr.is_none() {
-                util::link_section_uninit(true)
-            } else {
-                None
-            };
-
-            // resource type and assigned value
-            let (ty, expr) = if let Some(expr) = expr {
-                // early resource
-                (
-                    quote!(rtic::RacyCell<#ty>),
-                    quote!(rtic::RacyCell::new(#expr)),
-                )
-            } else {
-                // late resource
-                (
-                    quote!(rtic::RacyCell<core::mem::MaybeUninit<#ty>>),
-                    quote!(rtic::RacyCell::new(core::mem::MaybeUninit::uninit())),
-                )
-            };
-
-            let attrs = &res.attrs;
-
-            // For future use
-            // let doc = format!(" RTIC internal: {}:{}", file!(), line!());
-            mod_app.push(quote!(
-                #[allow(non_upper_case_globals)]
-                // #[doc = #doc]
-                #[doc(hidden)]
-                #(#attrs)*
-                #(#cfgs)*
-                #section
-                static #mangled_name: #ty = #expr;
-            ));
-        }
-
-        let r_prop = &res.properties;
-        // For future use
-        // let doc = format!(" RTIC internal: {}:{}", file!(), line!());
-
-        if !r_prop.task_local && !r_prop.lock_free {
-            mod_resources.push(quote!(
-                // #[doc = #doc]
-                #[doc(hidden)]
-                #[allow(non_camel_case_types)]
-                #(#cfgs)*
-                pub struct #name<'a> {
-                    priority: &'a Priority,
-                }
-
-                #(#cfgs)*
-                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
-                    }
-                }
-            ));
-
-            let (ptr, _doc) = if expr.is_none() {
-                // late resource
-                (
-                    quote!(
-                        #(#cfgs)*
-                        #mangled_name.get_mut_unchecked().as_mut_ptr()
-                    ),
-                    "late",
-                )
-            } else {
-                // early resource
-                (
-                    quote!(
-                        #(#cfgs)*
-                        #mangled_name.get_mut_unchecked()
-                    ),
-                    "early",
-                )
-            };
-
-            let ceiling = match analysis.ownerships.get(name) {
-                Some(Ownership::Owned { priority }) => *priority,
-                Some(Ownership::CoOwned { priority }) => *priority,
-                Some(Ownership::Contended { ceiling }) => *ceiling,
-                None => 0,
-            };
-
-            // For future use
-            // let doc = format!(" RTIC internal ({} resource): {}:{}", doc, file!(), line!());
-
-            mod_app.push(util::impl_mutex(
-                extra,
-                cfgs,
-                true,
-                name,
-                quote!(#ty),
-                ceiling,
-                ptr,
-            ));
-        }
-    }
-
-    let mod_resources = if mod_resources.is_empty() {
-        quote!()
-    } else {
-        quote!(mod resources {
-            use rtic::export::Priority;
-
-            #(#mod_resources)*
-        })
-    };
-
-    (mod_app, mod_resources)
-}
diff --git a/macros/src/codegen/shared_resources.rs b/macros/src/codegen/shared_resources.rs
new file mode 100644
index 00000000..181832fd
--- /dev/null
+++ b/macros/src/codegen/shared_resources.rs
@@ -0,0 +1,107 @@
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use rtic_syntax::{analyze::Ownership, ast::App};
+
+use crate::{analyze::Analysis, check::Extra, codegen::util};
+
+/// Generates `static` variables and shared resource proxies
+pub fn codegen(
+    app: &App,
+    analysis: &Analysis,
+    extra: &Extra,
+) -> (
+    // mod_app -- the `static` variables behind the proxies
+    Vec<TokenStream2>,
+    // mod_resources -- the `resources` module
+    TokenStream2,
+) {
+    let mut mod_app = vec![];
+    let mut mod_resources = vec![];
+
+    for (name, res) in &app.shared_resources {
+        let cfgs = &res.cfgs;
+        let ty = &res.ty;
+        let mangled_name = util::mark_internal_ident(&util::static_shared_resource_ident(&name));
+
+        // late resources in `util::link_section_uninit`
+        let section = util::link_section_uninit();
+        let attrs = &res.attrs;
+
+        // For future use
+        // let doc = format!(" RTIC internal: {}:{}", file!(), line!());
+        mod_app.push(quote!(
+            #[allow(non_upper_case_globals)]
+            // #[doc = #doc]
+            #[doc(hidden)]
+            #(#attrs)*
+            #(#cfgs)*
+            #section
+            static #mangled_name: rtic::RacyCell<core::mem::MaybeUninit<#ty>> = rtic::RacyCell::new(core::mem::MaybeUninit::uninit());
+        ));
+
+        // For future use
+        // let doc = format!(" RTIC internal: {}:{}", file!(), line!());
+
+        if !res.properties.lock_free {
+            mod_resources.push(quote!(
+                // #[doc = #doc]
+                #[doc(hidden)]
+                #[allow(non_camel_case_types)]
+                #(#cfgs)*
+                pub struct #name<'a> {
+                    priority: &'a Priority,
+                }
+
+                #(#cfgs)*
+                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
+                    }
+                }
+            ));
+
+            let ptr = quote!(
+                #(#cfgs)*
+                #mangled_name.get_mut_unchecked().as_mut_ptr()
+            );
+
+            let ceiling = match analysis.ownerships.get(name) {
+                Some(Ownership::Owned { priority }) => *priority,
+                Some(Ownership::CoOwned { priority }) => *priority,
+                Some(Ownership::Contended { ceiling }) => *ceiling,
+                None => 0,
+            };
+
+            // For future use
+            // let doc = format!(" RTIC internal ({} resource): {}:{}", doc, file!(), line!());
+
+            mod_app.push(util::impl_mutex(
+                extra,
+                cfgs,
+                true,
+                &name,
+                quote!(#ty),
+                ceiling,
+                ptr,
+            ));
+        }
+    }
+
+    let mod_resources = if mod_resources.is_empty() {
+        quote!()
+    } else {
+        quote!(mod shared_resources {
+            use rtic::export::Priority;
+
+            #(#mod_resources)*
+        })
+    };
+
+    (mod_app, mod_resources)
+}
diff --git a/macros/src/codegen/resources_struct.rs b/macros/src/codegen/shared_resources_struct.rs
index 6fe4678a..301bef73 100644
--- a/macros/src/codegen/resources_struct.rs
+++ b/macros/src/codegen/shared_resources_struct.rs
@@ -4,14 +4,15 @@ use rtic_syntax::{ast::App, Context};
 
 use crate::codegen::util;
 
+/// Generate shared resources structs
 pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, TokenStream2) {
     let mut lt = None;
 
     let resources = match ctxt {
-        Context::Init => &app.inits.first().unwrap().args.resources,
-        Context::Idle => &app.idles.first().unwrap().args.resources,
-        Context::HardwareTask(name) => &app.hardware_tasks[name].args.resources,
-        Context::SoftwareTask(name) => &app.software_tasks[name].args.resources,
+        Context::Init => unreachable!("Tried to generate shared resources struct for init"),
+        Context::Idle => &app.idle.as_ref().unwrap().args.shared_resources,
+        Context::HardwareTask(name) => &app.hardware_tasks[name].args.shared_resources,
+        Context::SoftwareTask(name) => &app.software_tasks[name].args.shared_resources,
     };
 
     let mut fields = vec![];
@@ -19,7 +20,7 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
     let mut has_cfgs = false;
 
     for (name, access) in resources {
-        let (res, expr) = app.resource(name).expect("UNREACHABLE");
+        let res = app.shared_resources.get(name).expect("UNREACHABLE");
 
         let cfgs = &res.cfgs;
         has_cfgs |= !cfgs.is_empty();
@@ -31,12 +32,9 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
             None
         };
         let ty = &res.ty;
-        let mangled_name = util::mark_internal_ident(&name);
+        let mangled_name = util::mark_internal_ident(&util::static_shared_resource_ident(&name));
 
-        // let ownership = &analysis.ownerships[name];
-        let r_prop = &res.properties;
-
-        if !r_prop.task_local && !r_prop.lock_free {
+        if !res.properties.lock_free {
             if access.is_shared() {
                 lt = Some(quote!('a));
 
@@ -50,12 +48,12 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
 
                 fields.push(quote!(
                     #(#cfgs)*
-                    pub #name: resources::#name<'a>
+                    pub #name: shared_resources::#name<'a>
                 ));
 
                 values.push(quote!(
                     #(#cfgs)*
-                    #name: resources::#name::new(priority)
+                    #name: shared_resources::#name::new(priority)
 
                 ));
 
@@ -76,24 +74,16 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
             ));
         }
 
-        let is_late = expr.is_none();
-        if is_late {
-            let expr = if access.is_exclusive() {
-                quote!(&mut *#mangled_name.get_mut_unchecked().as_mut_ptr())
-            } else {
-                quote!(&*#mangled_name.get_unchecked().as_ptr())
-            };
-
-            values.push(quote!(
-                #(#cfgs)*
-                #name: #expr
-            ));
+        let expr = if access.is_exclusive() {
+            quote!(&mut *#mangled_name.get_mut_unchecked().as_mut_ptr())
         } else {
-            values.push(quote!(
-                #(#cfgs)*
-                #name: #mangled_name.get_mut_unchecked()
-            ));
-        }
+            quote!(&*#mangled_name.get_unchecked().as_ptr())
+        };
+
+        values.push(quote!(
+            #(#cfgs)*
+            #name: #expr
+        ));
     }
 
     if lt.is_some() {
@@ -110,8 +100,8 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
         }
     }
 
-    let doc = format!("Resources `{}` has access to", ctxt.ident(app));
-    let ident = util::resources_ident(ctxt, app);
+    let doc = format!("Shared resources `{}` has access to", ctxt.ident(app));
+    let ident = util::shared_resources_ident(ctxt, app);
     let ident = util::mark_internal_ident(&ident);
     let item = quote!(
         #[allow(non_snake_case)]
diff --git a/macros/src/codegen/software_tasks.rs b/macros/src/codegen/software_tasks.rs
index 0372e8ec..cfd21e40 100644
--- a/macros/src/codegen/software_tasks.rs
+++ b/macros/src/codegen/software_tasks.rs
@@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context};
 use crate::{
     analyze::Analysis,
     check::Extra,
-    codegen::{locals, module, resources_struct, util},
+    codegen::{local_resources_struct, module, shared_resources_struct, util},
 };
 
 pub fn codegen(
@@ -45,7 +45,7 @@ pub fn codegen(
                 quote!(rtic::export::Queue(unsafe {
                     rtic::export::iQueue::u8_sc()
                 })),
-                Box::new(|| util::link_section_uninit(true)),
+                Box::new(|| util::link_section_uninit()),
             )
         };
         mod_app.push(quote!(
@@ -90,23 +90,32 @@ pub fn codegen(
         ));
 
         // `${task}Resources`
-        let mut needs_lt = false;
-        if !task.args.resources.is_empty() {
-            let (item, constructor) =
-                resources_struct::codegen(Context::SoftwareTask(name), &mut needs_lt, app);
+        let mut shared_needs_lt = false;
+        let mut local_needs_lt = false;
+
+        // `${task}Locals`
+        if !task.args.local_resources.is_empty() {
+            let (item, constructor) = local_resources_struct::codegen(
+                Context::SoftwareTask(name),
+                &mut local_needs_lt,
+                app,
+            );
 
             root.push(item);
 
             mod_app.push(constructor);
         }
 
-        // `${task}Locals`
-        let mut locals_pat = None;
-        if !task.locals.is_empty() {
-            let (struct_, pat) = locals::codegen(Context::SoftwareTask(name), &task.locals, app);
+        if !task.args.shared_resources.is_empty() {
+            let (item, constructor) = shared_resources_struct::codegen(
+                Context::SoftwareTask(name),
+                &mut shared_needs_lt,
+                app,
+            );
 
-            locals_pat = Some(pat);
-            root.push(struct_);
+            root.push(item);
+
+            mod_app.push(constructor);
         }
 
         if !&task.is_extern {
@@ -114,12 +123,11 @@ pub fn codegen(
             let attrs = &task.attrs;
             let cfgs = &task.cfgs;
             let stmts = &task.stmts;
-            let locals_pat = locals_pat.iter();
             user_tasks.push(quote!(
                 #(#attrs)*
                 #(#cfgs)*
                 #[allow(non_snake_case)]
-                fn #name(#(#locals_pat,)* #context: #name::Context #(,#inputs)*) {
+                fn #name(#context: #name::Context #(,#inputs)*) {
                     use rtic::Mutex as _;
                     use rtic::mutex_prelude::*;
 
@@ -130,7 +138,8 @@ pub fn codegen(
 
         root.push(module::codegen(
             Context::SoftwareTask(name),
-            needs_lt,
+            shared_needs_lt,
+            local_needs_lt,
             app,
             analysis,
             extra,
diff --git a/macros/src/codegen/util.rs b/macros/src/codegen/util.rs
index 3e42eda9..86bd6955 100644
--- a/macros/src/codegen/util.rs
+++ b/macros/src/codegen/util.rs
@@ -41,7 +41,7 @@ pub fn impl_mutex(
     ptr: TokenStream2,
 ) -> TokenStream2 {
     let (path, priority) = if resources_prefix {
-        (quote!(resources::#name), quote!(self.priority()))
+        (quote!(shared_resources::#name), quote!(self.priority()))
     } else {
         (quote!(#name), quote!(self.priority))
     };
@@ -152,30 +152,12 @@ fn link_section_index() -> usize {
 }
 
 // NOTE `None` means in shared memory
-pub fn link_section_uninit(empty_expr: bool) -> Option<TokenStream2> {
-    let section = if empty_expr {
-        let index = link_section_index();
-        format!(".uninit.rtic{}", index)
-    } else {
-        format!(".uninit.rtic{}", link_section_index())
-    };
+pub fn link_section_uninit() -> Option<TokenStream2> {
+    let section = format!(".uninit.rtic{}", link_section_index());
 
     Some(quote!(#[link_section = #section]))
 }
 
-/// Generates a pre-reexport identifier for the "locals" struct
-pub fn locals_ident(ctxt: Context, app: &App) -> Ident {
-    let mut s = match ctxt {
-        Context::Init => app.inits.first().unwrap().name.to_string(),
-        Context::Idle => app.idles.first().unwrap().name.to_string(),
-        Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(),
-    };
-
-    s.push_str("Locals");
-
-    Ident::new(&s, Span::call_site())
-}
-
 // Regroups the inputs of a task
 //
 // `inputs` could be &[`input: Foo`] OR &[`mut x: i32`, `ref y: i64`]
@@ -225,15 +207,39 @@ pub fn regroup_inputs(
     }
 }
 
-/// Generates a pre-reexport identifier for the "resources" struct
-pub fn resources_ident(ctxt: Context, app: &App) -> Ident {
+/// Get the ident for the name of the task
+pub fn get_task_name(ctxt: Context, app: &App) -> Ident {
+    let s = match ctxt {
+        Context::Init => app.init.name.to_string(),
+        Context::Idle => app.idle.as_ref().unwrap().name.to_string(),
+        Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(),
+    };
+
+    Ident::new(&s, Span::call_site())
+}
+
+/// Generates a pre-reexport identifier for the "shared resources" struct
+pub fn shared_resources_ident(ctxt: Context, app: &App) -> Ident {
     let mut s = match ctxt {
-        Context::Init => app.inits.first().unwrap().name.to_string(),
-        Context::Idle => app.idles.first().unwrap().name.to_string(),
+        Context::Init => app.init.name.to_string(),
+        Context::Idle => app.idle.as_ref().unwrap().name.to_string(),
         Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(),
     };
 
-    s.push_str("Resources");
+    s.push_str("SharedResources");
+
+    Ident::new(&s, Span::call_site())
+}
+
+/// Generates a pre-reexport identifier for the "local resources" struct
+pub fn local_resources_ident(ctxt: Context, app: &App) -> Ident {
+    let mut s = match ctxt {
+        Context::Init => app.init.name.to_string(),
+        Context::Idle => app.idle.as_ref().unwrap().name.to_string(),
+        Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(),
+    };
+
+    s.push_str("LocalResources");
 
     Ident::new(&s, Span::call_site())
 }
@@ -275,6 +281,27 @@ pub fn monotonic_ident(name: &str) -> Ident {
     Ident::new(&format!("MONOTONIC_STORAGE_{}", name), Span::call_site())
 }
 
+pub fn static_shared_resource_ident(name: &Ident) -> Ident {
+    Ident::new(
+        &format!("shared_resource_{}", name.to_string()),
+        Span::call_site(),
+    )
+}
+
+pub fn static_local_resource_ident(name: &Ident) -> Ident {
+    Ident::new(
+        &format!("local_resource_{}", name.to_string()),
+        Span::call_site(),
+    )
+}
+
+pub fn declared_static_local_resource_ident(name: &Ident, task_name: &Ident) -> Ident {
+    Ident::new(
+        &format!("local_{}_{}", task_name.to_string(), name.to_string()),
+        Span::call_site(),
+    )
+}
+
 /// The name to get better RT flag errors
 pub fn rt_err_ident() -> Ident {
     Ident::new(
diff --git a/macros/src/tests/single.rs b/macros/src/tests/single.rs
index 8c026e99..27118856 100644
--- a/macros/src/tests/single.rs
+++ b/macros/src/tests/single.rs
@@ -10,6 +10,17 @@ fn analyze() {
         quote!(device = pac, dispatchers = [B, A]),
         quote!(
             mod app {
+                #[shared]
+                struct Shared {}
+
+                #[local]
+                struct Local {}
+
+                #[init]
+                fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
+                    (Shared {}, Local {}, init::Monotonics {})
+                }
+
                 #[task(priority = 1)]
                 fn a(_: a::Context) {}