From 2068eae9280881e34b5cc2d76b0b1a61402223e7 Mon Sep 17 00:00:00 2001 From: Emil Fresk Date: Wed, 7 Apr 2021 11:06:57 +0200 Subject: [PATCH] Type aliases now work in the app module --- examples/t-schedule.rs | 33 ++++++++++++++++++---------- examples/type-usage.rs | 15 +++++++++++++ macros/Cargo.toml | 3 ++- macros/src/codegen.rs | 16 +++++++++++--- macros/src/codegen/hardware_tasks.rs | 4 ++++ macros/src/codegen/module.rs | 21 ++++++++++-------- 6 files changed, 67 insertions(+), 25 deletions(-) create mode 100644 examples/type-usage.rs diff --git a/examples/t-schedule.rs b/examples/t-schedule.rs index ef04c45180..5e38dbaf90 100644 --- a/examples/t-schedule.rs +++ b/examples/t-schedule.rs @@ -26,24 +26,27 @@ mod app { // Task without message passing // Not default - let _: Result = foo::MyMono::spawn_at(MyMono::now()); + let _: Result = + foo::MyMono::spawn_at(monotonics::MyMono::now()); let handle: Result = foo::MyMono::spawn_after(Seconds(1_u32)); let _: Result = handle.unwrap().reschedule_after(Seconds(1_u32)); let handle: Result = foo::MyMono::spawn_after(Seconds(1_u32)); - let _: Result = handle.unwrap().reschedule_at(MyMono::now()); + let _: Result = + handle.unwrap().reschedule_at(monotonics::MyMono::now()); let handle: Result = foo::MyMono::spawn_after(Seconds(1_u32)); let _: Result<(), ()> = handle.unwrap().cancel(); // Using default - let _: Result = foo::spawn_at(MyMono::now()); + let _: Result = foo::spawn_at(monotonics::MyMono::now()); let handle: Result = foo::spawn_after(Seconds(1_u32)); let _: Result = handle.unwrap().reschedule_after(Seconds(1_u32)); let handle: Result = foo::spawn_after(Seconds(1_u32)); - let _: Result = handle.unwrap().reschedule_at(MyMono::now()); + let _: Result = + handle.unwrap().reschedule_at(monotonics::MyMono::now()); let handle: Result = foo::spawn_after(Seconds(1_u32)); let _: Result<(), ()> = handle.unwrap().cancel(); @@ -51,7 +54,8 @@ mod app { // Task with single message passing // Not default - let _: Result = bar::MyMono::spawn_at(MyMono::now(), 0); + let _: Result = + bar::MyMono::spawn_at(monotonics::MyMono::now(), 0); let handle: Result = bar::MyMono::spawn_after(Seconds(1_u32), 0); let _: Result = @@ -59,19 +63,21 @@ mod app { let handle: Result = bar::MyMono::spawn_after(Seconds(1_u32), 0); - let _: Result = handle.unwrap().reschedule_at(MyMono::now()); + let _: Result = + handle.unwrap().reschedule_at(monotonics::MyMono::now()); let handle: Result = bar::MyMono::spawn_after(Seconds(1_u32), 0); let _: Result = handle.unwrap().cancel(); // Using default - let _: Result = bar::spawn_at(MyMono::now(), 0); + let _: Result = bar::spawn_at(monotonics::MyMono::now(), 0); let handle: Result = bar::spawn_after(Seconds(1_u32), 0); let _: Result = handle.unwrap().reschedule_after(Seconds(1_u32)); let handle: Result = bar::spawn_after(Seconds(1_u32), 0); - let _: Result = handle.unwrap().reschedule_at(MyMono::now()); + let _: Result = + handle.unwrap().reschedule_at(monotonics::MyMono::now()); let handle: Result = bar::spawn_after(Seconds(1_u32), 0); let _: Result = handle.unwrap().cancel(); @@ -80,7 +86,7 @@ mod app { // Not default let _: Result = - baz::MyMono::spawn_at(MyMono::now(), 0, 1); + baz::MyMono::spawn_at(monotonics::MyMono::now(), 0, 1); let handle: Result = baz::MyMono::spawn_after(Seconds(1_u32), 0, 1); let _: Result = @@ -88,19 +94,22 @@ mod app { let handle: Result = baz::MyMono::spawn_after(Seconds(1_u32), 0, 1); - let _: Result = handle.unwrap().reschedule_at(MyMono::now()); + let _: Result = + handle.unwrap().reschedule_at(monotonics::MyMono::now()); let handle: Result = baz::MyMono::spawn_after(Seconds(1_u32), 0, 1); let _: Result<(u32, u32), ()> = handle.unwrap().cancel(); // Using default - let _: Result = baz::spawn_at(MyMono::now(), 0, 1); + let _: Result = + baz::spawn_at(monotonics::MyMono::now(), 0, 1); let handle: Result = baz::spawn_after(Seconds(1_u32), 0, 1); let _: Result = handle.unwrap().reschedule_after(Seconds(1_u32)); let handle: Result = baz::spawn_after(Seconds(1_u32), 0, 1); - let _: Result = handle.unwrap().reschedule_at(MyMono::now()); + let _: Result = + handle.unwrap().reschedule_at(monotonics::MyMono::now()); let handle: Result = baz::spawn_after(Seconds(1_u32), 0, 1); let _: Result<(u32, u32), ()> = handle.unwrap().cancel(); diff --git a/examples/type-usage.rs b/examples/type-usage.rs new file mode 100644 index 0000000000..a7a0d41105 --- /dev/null +++ b/examples/type-usage.rs @@ -0,0 +1,15 @@ +//! examples/smallest.rs + +#![no_main] +#![no_std] + +use panic_semihosting as _; // panic handler +use rtic::app; + +#[app(device = lm3s6965, dispatchers = [SSI0])] +mod app { + type Test = u32; + + #[task] + fn t1(_: t1::Context, _val: Test) {} +} diff --git a/macros/Cargo.toml b/macros/Cargo.toml index f14b104655..8607ce55fd 100644 --- a/macros/Cargo.toml +++ b/macros/Cargo.toml @@ -22,5 +22,6 @@ proc-macro2 = "1" proc-macro-error = "1" quote = "1" syn = "1" -rtic-syntax = "0.5.0-alpha.1" +# rtic-syntax = "0.5.0-alpha.2" +rtic-syntax = { path = "../../rtic-syntax", version = "0.5.0-alpha.2" } diff --git a/macros/src/codegen.rs b/macros/src/codegen.rs index c5d956877b..cf728a7d3f 100644 --- a/macros/src/codegen.rs +++ b/macros/src/codegen.rs @@ -112,8 +112,6 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 { let user_imports = &app.user_imports; quote! { - pub use rtic::Monotonic as _; - #[doc = #doc] #[allow(non_snake_case)] pub mod #name { @@ -143,6 +141,18 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 { }) .collect(); + let monotonics = if !monotonic_parts.is_empty() { + quote!( + pub use rtic::Monotonic as _; + + /// Holds static methods for each monotonic. + pub mod monotonics { + #(#monotonic_parts)* + } + ) + } else { + quote!() + }; let rt_err = util::rt_err_ident(); quote!( @@ -151,7 +161,7 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 { /// Always include the device crate which contains the vector table use #device as #rt_err; - #(#monotonic_parts)* + #monotonics #(#user_imports)* diff --git a/macros/src/codegen/hardware_tasks.rs b/macros/src/codegen/hardware_tasks.rs index 4a1d7492f4..540b95e5a3 100644 --- a/macros/src/codegen/hardware_tasks.rs +++ b/macros/src/codegen/hardware_tasks.rs @@ -37,12 +37,16 @@ pub fn codegen( let symbol = task.args.binds.clone(); let priority = task.args.priority; + let cfgs = &task.cfgs; + let attrs = &task.attrs; let app_name = &app.name; let app_path = quote! {crate::#app_name}; mod_app.push(quote!( #[allow(non_snake_case)] #[no_mangle] + #(#attrs)* + #(#cfgs)* unsafe fn #symbol() { const PRIORITY: u8 = #priority; diff --git a/macros/src/codegen/module.rs b/macros/src/codegen/module.rs index e15aab1c83..ac69a80309 100644 --- a/macros/src/codegen/module.rs +++ b/macros/src/codegen/module.rs @@ -21,7 +21,7 @@ pub fn codegen( let app_name = &app.name; let app_path = quote! {crate::#app_name}; - let all_task_names: Vec<_> = app + let all_task_imports: Vec<_> = app .software_tasks .iter() .map(|(name, st)| { @@ -46,6 +46,13 @@ pub fn codegen( quote!() } })) + .chain(app.user_types.iter().map(|ty| { + let t = &ty.ident; + quote! { + #[allow(unused_imports)] + use super::#t; + } + })) .collect(); let mut lt = None; @@ -230,7 +237,7 @@ pub fn codegen( // Spawn caller items.push(quote!( - #(#all_task_names)* + #(#all_task_imports)* #(#cfgs)* /// Spawns the task directly @@ -268,7 +275,7 @@ pub fn codegen( let tq = util::mark_internal_ident(&tq); let t = util::schedule_t_ident(); let m = &monotonic.ident; - let mono_type = &monotonic.ty; + let mono_type = &monotonic.ident; let m_ident = util::monotonic_ident(&monotonic_name); let m_ident = util::mark_internal_ident(&m_ident); let m_isr = &monotonic.args.binds; @@ -300,10 +307,6 @@ pub fn codegen( items.push(quote!( /// Holds methods related to this monotonic pub mod #m { - // #( - // #[allow(unused_imports)] - // use #app_path::#all_task_names as #all_task_names; - // )* use super::*; #[allow(unused_imports)] use #app_path::#tq_marker; @@ -341,7 +344,7 @@ pub fn codegen( where D: rtic::time::duration::Duration + rtic::time::fixed_point::FixedPoint, D::T: Into<<#app_path::#mono_type as rtic::time::Clock>::T>, { - self.reschedule_at(#app_path::#m::now() + duration) + self.reschedule_at(#app_path::monotonics::#m::now() + duration) } pub fn reschedule_at(self, instant: rtic::time::Instant<#app_path::#mono_type>) -> Result @@ -373,7 +376,7 @@ pub fn codegen( let instant = if rtic::export::interrupt::free(|_| unsafe { #app_path::#m_ident.is_none() }) { rtic::time::Instant::new(0) } else { - #app_path::#m::now() + #app_path::monotonics::#m::now() }; spawn_at(instant + duration #(,#untupled)*)