Cargo fmt

macros/src/analyze.rs

@@ -28,15 +28,12 @@ pub fn app(analysis: P<analyze::Analysis>, app: &App) -> P<Analysis> {
     let priorities = app
         .software_tasks
         .values()
-            .filter_map(|task| {
+        .filter_map(|task| Some(task.args.priority))
-                    Some(task.args.priority)
-            })
         .chain(analysis.timer_queues.first().map(|tq| tq.priority))
         .collect::<BTreeSet<_>>();
 
     if !priorities.is_empty() {
-            interrupts =
+        interrupts = priorities
-                priorities
             .iter()
             .cloned()
             .rev()

macros/src/check.rs

@@ -4,7 +4,6 @@ use proc_macro2::Span;
 use rtic_syntax::{
     analyze::Analysis,
     ast::{App, CustomArg},
-
 };
 use syn::{parse, Path};
 
@@ -51,9 +50,7 @@ pub fn app<'a>(app: &'a App, analysis: &Analysis) -> parse::Result<Extra<'a>> {
 
     // check that external (device-specific) interrupts are not named after known (Cortex-M)
     // exceptions
-    for name in app
+    for name in app.extern_interrupts.keys() {
-        .extern_interrupts.keys()
-    {
         let name_s = name.to_string();
 
         match &*name_s {
@@ -83,8 +80,7 @@ pub fn app<'a>(app: &'a App, analysis: &Analysis) -> parse::Result<Extra<'a>> {
         .collect::<HashSet<_>>();
 
     let need = priorities.len();
-    let given = app
+    let given = app.extern_interrupts.len();
-        .extern_interrupts.len();
     if need > given {
         let s = {
             format!(
@@ -131,9 +127,7 @@ pub fn app<'a>(app: &'a App, analysis: &Analysis) -> parse::Result<Extra<'a>> {
             },
 
             "peripherals" => match v {
-                CustomArg::Bool(x) => {
+                CustomArg::Bool(x) => peripherals = if *x { true } else { false },
-                    peripherals = if *x { true } else { false }
-                }
 
                 /*
                 CustomArg::UInt(s) if app.args.cores != 1 => {
@@ -152,7 +146,6 @@ pub fn app<'a>(app: &'a App, analysis: &Analysis) -> parse::Result<Extra<'a>> {
                     }
                 }
                 */
-
                 _ => {
                     return Err(parse::Error::new(
                         k.span(),

macros/src/codegen.rs

@@ -35,14 +35,11 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
 
     let pre_init_stmts = pre_init::codegen(&app, analysis, extra);
 
-    let (const_app_init, root_init, user_init, call_init) =
+    let (const_app_init, root_init, user_init, call_init) = init::codegen(app, analysis, extra);
-        init::codegen(app, analysis, extra);
 
-    let (const_app_post_init, post_init_stmts) =
+    let (const_app_post_init, post_init_stmts) = post_init::codegen(&app, analysis);
-        post_init::codegen(&app, analysis);
 
-    let (const_app_idle, root_idle, user_idle, call_idle) =
+    let (const_app_idle, root_idle, user_idle, call_idle) = idle::codegen(app, analysis, extra);
-        idle::codegen(app, analysis, extra);
 
     user.push(quote!(
         #user_init
@@ -84,7 +81,6 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
         }
     ));
 
-
     let (const_app_resources, mod_resources) = resources::codegen(app, analysis, extra);
 
     let (const_app_hardware_tasks, root_hardware_tasks, user_hardware_tasks) =

macros/src/codegen/hardware_tasks.rs

@@ -29,7 +29,6 @@ pub fn codegen(
     let mut user_tasks = vec![];
 
     for (name, task) in &app.hardware_tasks {
-
         let (let_instant, instant) = if app.uses_schedule() {
             let m = extra.monotonic();
 
@@ -96,8 +95,7 @@ pub fn codegen(
         // `${task}Locals`
         let mut locals_pat = None;
         if !task.locals.is_empty() {
-            let (struct_, pat) =
+            let (struct_, pat) = locals::codegen(Context::HardwareTask(name), &task.locals, app);
-                locals::codegen(Context::HardwareTask(name), &task.locals, app);
 
             root.push(struct_);
             locals_pat = Some(pat);

macros/src/codegen/init.rs

@@ -40,9 +40,7 @@ pub fn codegen(
                 .late_resources
                 .iter()
                 .flat_map(|resources| {
-                    resources
+                    resources.iter().map(|name| {
-                        .iter()
-                        .map(|name| {
                         let ty = &app.late_resources[name].ty;
                         let cfgs = &app.late_resources[name].cfgs;
 

macros/src/codegen/post_init.rs

@@ -5,10 +5,7 @@ use rtic_syntax::ast::App;
 use crate::analyze::Analysis;
 
 /// Generates code that runs after `#[init]` returns
-pub fn codegen(
+pub fn codegen(app: &App, analysis: &Analysis) -> (Vec<TokenStream2>, Vec<TokenStream2>) {
-    app: &App,
-    analysis: &Analysis,
-) -> (Vec<TokenStream2>, Vec<TokenStream2>) {
     //#TODO remove
     let const_app = vec![];
     let mut stmts = vec![];

macros/src/codegen/pre_init.rs

@@ -5,14 +5,7 @@ use rtic_syntax::ast::App;
 use crate::{analyze::Analysis, check::Extra, codegen::util};
 
 /// Generates code that runs before `#[init]`
-pub fn codegen(
+pub fn codegen(app: &App, analysis: &Analysis, extra: &Extra) -> Vec<TokenStream2> {
-    app: &App,
-    analysis: &Analysis,
-    extra: &Extra,
-) ->
-    // `pre_init_stmts`
-    Vec<TokenStream2>
-{
     let mut stmts = vec![];
 
     // disable interrupts -- `init` must run with interrupts disabled

macros/src/codegen/resources.rs

@@ -1,9 +1,6 @@
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
-use rtic_syntax::{
+use rtic_syntax::{analyze::Ownership, ast::App};
-    analyze::Ownership,
-    ast::App,
-};
 
 use crate::{analyze::Analysis, check::Extra, codegen::util};
 
@@ -66,7 +63,6 @@ pub fn codegen(
         }
 
         if let Some(Ownership::Contended { ceiling }) = analysis.ownerships.get(name) {
-
             mod_resources.push(quote!(
                 #[allow(non_camel_case_types)]
                 #(#cfgs)*

macros/src/codegen/spawn_body.rs

@@ -45,7 +45,8 @@ pub fn codegen(
     let device = extra.device;
     let enum_ = util::interrupt_ident();
     let interrupt = &analysis.interrupts.get(&priority);
-    let pend = {quote!(
+    let pend = {
+        quote!(
             rtic::pend(#device::#enum_::#interrupt);
         )
     };

macros/src/codegen/util.rs

@@ -44,10 +44,7 @@ pub fn cfg_core(core: Core, cores: u8) -> Option<TokenStream2> {
 /// There may be more than one free queue per task because we need one for each sender core so we
 /// include the sender (e.g. `S0`) in the name
 pub fn fq_ident(task: &Ident) -> Ident {
-    Ident::new(
+    Ident::new(&format!("{}_FQ", task.to_string()), Span::call_site())
-        &format!("{}_FQ", task.to_string()),
-        Span::call_site(),
-    )
 }
 
 /// Generates a `Mutex` implementation
@@ -253,10 +250,7 @@ pub fn resources_ident(ctxt: Context, app: &App) -> Ident {
 /// in turn may use more than one ready queue because the queues are SPSC queues so one is needed
 /// per sender core.
 pub fn rq_ident(priority: u8) -> Ident {
-    Ident::new(
+    Ident::new(&format!("P{}_RQ", priority), Span::call_site())
-        &format!("P{}_RQ", priority),
-        Span::call_site(),
-    )
 }
 
 /// Generates an identifier for a "schedule" function
@@ -264,10 +258,7 @@ pub fn rq_ident(priority: u8) -> Ident {
 /// The methods of the `Schedule` structs invoke these functions. As one task may be `schedule`-ed
 /// by different cores we need one "schedule" function per possible task-sender pair
 pub fn schedule_ident(name: &Ident) -> Ident {
-    Ident::new(
+    Ident::new(&format!("schedule_{}", name.to_string()), Span::call_site())
-        &format!("schedule_{}", name.to_string()),
-        Span::call_site(),
-    )
 }
 
 /// Generates an identifier for the `enum` of `schedule`-able tasks
@@ -287,10 +278,7 @@ pub fn spawn_barrier() -> Ident {
 /// The methods of the `Spawn` structs invoke these functions. As one task may be `spawn`-ed by
 /// different cores we need one "spawn" function per possible task-sender pair
 pub fn spawn_ident(name: &Ident) -> Ident {
-    Ident::new(
+    Ident::new(&format!("spawn_{}", name.to_string()), Span::call_site())
-        &format!("spawn_{}", name.to_string()),
-        Span::call_site(),
-    )
 }
 
 /// Generates an identifier for the `enum` of `spawn`-able tasks
@@ -298,10 +286,7 @@ pub fn spawn_ident(name: &Ident) -> Ident {
 /// This identifier needs the same structure as the `RQ` identifier because there's one ready queue
 /// for each of these `T` enums
 pub fn spawn_t_ident(priority: u8) -> Ident {
-    Ident::new(
+    Ident::new(&format!("P{}_T", priority), Span::call_site())
-        &format!("P{}_T", priority),
-        Span::call_site(),
-    )
 }
 
 pub fn suffixed(name: &str) -> Ident {