Add local spawner - also seems to have broken some pac resolution thing

Author: usbalbin

rtic-macros/src/codegen/module.rs

@@ -1,3 +1,5 @@
+use std::marker::PhantomData;
+
 use crate::syntax::{ast::App, Context};
 use crate::{analyze::Analysis, codegen::bindings::interrupt_mod, codegen::util};
 use proc_macro2::TokenStream as TokenStream2;
@@ -112,36 +114,6 @@ pub fn codegen(ctxt: Context, app: &App, analysis: &Analysis) -> TokenStream2 {
     let internal_context_name = util::internal_task_ident(name, "Context");
     let exec_name = util::internal_task_ident(name, "EXEC");
 
-    items.push(quote!(
-        #(#cfgs)*
-        /// Execution context
-        #[allow(non_snake_case)]
-        #[allow(non_camel_case_types)]
-        pub struct #internal_context_name<'a> {
-            #[doc(hidden)]
-            __rtic_internal_p: ::core::marker::PhantomData<&'a ()>,
-            #(#fields,)*
-        }
-
-        #(#cfgs)*
-        impl<'a> #internal_context_name<'a> {
-            #[inline(always)]
-            #[allow(missing_docs)]
-            pub unsafe fn new(#core) -> Self {
-                #internal_context_name {
-                    __rtic_internal_p: ::core::marker::PhantomData,
-                    #(#values,)*
-                }
-            }
-        }
-    ));
-
-    module_items.push(quote!(
-        #(#cfgs)*
-        #[doc(inline)]
-        pub use super::#internal_context_name as Context;
-    ));
-
     if let Context::SoftwareTask(t) = ctxt {
         let spawnee = &app.software_tasks[name];
         let priority = spawnee.args.priority;
@@ -212,21 +184,112 @@ pub fn codegen(ctxt: Context, app: &App, analysis: &Analysis) -> TokenStream2 {
             }
         ));
 
-        if is_local_task {
+        if !is_local_task {
             module_items.push(quote!(
                 #(#cfgs)*
                 #[doc(inline)]
                 pub use super::#internal_spawn_ident as spawn;
             ));
         }
 
+        let local_tasks_on_same_executor: Vec<_> = app
+            .software_tasks
+            .iter()
+            //.filter(|(_, t)| t.args.is_local_task && t.args.priority == priority)
+            .map(|(_, t)| t)
+            .collect();
+
+        if !local_tasks_on_same_executor.is_empty() {
+            fields.push(quote! {
+                /// Used to spawn tasks on the same executor
+                ///
+                /// This is useful for tasks that take args which are !Send/!Sync.
+                ///
+                /// NOTE: This only works with tasks marked `is_local_task = true`
+                /// and which have the same priority and thus will run on the
+                /// same executor.
+                pub local_spawner: LocalSpawner
+            });
+            let tasks = local_tasks_on_same_executor
+                .iter()
+                .map(|task| {
+                    // Copied mostly from software_tasks.rs
+                    let context = &task.context;
+                    let attrs = &task.attrs;
+                    let cfgs = &task.cfgs;
+                    let inputs = &task.inputs;
+                    let lifetime = if task.is_bottom {
+                        quote!('static)
+                    } else {
+                        quote!('a)
+                    };
+                    let generics = if task.is_bottom {
+                        quote!()
+                    } else {
+                        quote!(<'a>)
+                    };
+                    let input_vals = inputs.iter().map(|i| &i.pat).collect::<Vec<_>>();
+                    quote! {
+                        #(#attrs)*
+                        #(#cfgs)*
+                        #[allow(non_snake_case)]
+                        fn #name #generics(&self #(,#inputs)*) {
+                            // SAFETY: This is safe to call since this can only be called
+                            // from the same executor
+                            unsafe { #internal_spawn_ident(#(#input_vals,)*) } // <-- TODO strip the types
+                        }
+                    }
+                })
+                .collect::<Vec<_>>();
+            values.push(quote!(local_spawner: LocalSpawner { _p: PhantomData }));
+            module_items.push(quote! {
+                struct LocalSpawner {
+                    _p: PhantomData<*mut ()>,
+                }
+
+                impl LocalSpawner {
+                    #(#tasks)*
+                }
+            });
+        }
+
         module_items.push(quote!(
             #(#cfgs)*
             #[doc(inline)]
             pub use super::#internal_waker_ident as waker;
         ));
     }
 
+    items.push(quote!(
+        #(#cfgs)*
+        /// Execution context
+        #[allow(non_snake_case)]
+        #[allow(non_camel_case_types)]
+        pub struct #internal_context_name<'a> {
+            #[doc(hidden)]
+            __rtic_internal_p: ::core::marker::PhantomData<&'a ()>,
+            #(#fields,)*
+        }
+
+        #(#cfgs)*
+        impl<'a> #internal_context_name<'a> {
+            #[inline(always)]
+            #[allow(missing_docs)]
+            pub unsafe fn new(#core) -> Self {
+                #internal_context_name {
+                    __rtic_internal_p: ::core::marker::PhantomData,
+                    #(#values,)*
+                }
+            }
+        }
+    ));
+
+    module_items.push(quote!(
+        #(#cfgs)*
+        #[doc(inline)]
+        pub use super::#internal_context_name as Context;
+    ));
+
     if items.is_empty() {
         quote!()
     } else {

rtic-macros/src/codegen/software_tasks.rs

@@ -37,8 +37,16 @@ pub fn codegen(app: &App, analysis: &Analysis) -> TokenStream2 {
             let cfgs = &task.cfgs;
             let stmts = &task.stmts;
             let inputs = &task.inputs;
-            let lifetime = if task.is_bottom { quote!('static) } else { quote!('a) };
-            let generics = if task.is_bottom { quote!() } else { quote!(<'a>) };
+            let lifetime = if task.is_bottom {
+                quote!('static)
+            } else {
+                quote!('a)
+            };
+            let generics = if task.is_bottom {
+                quote!()
+            } else {
+                quote!(<'a>)
+            };
 
             user_tasks.push(quote!(
                 #(#attrs)*
@@ -47,9 +55,6 @@ pub fn codegen(app: &App, analysis: &Analysis) -> TokenStream2 {
                 async fn #name #generics(#context: #name::Context<#lifetime> #(,#inputs)*) {
                     use rtic::Mutex as _;
                     use rtic::mutex::prelude::*;
-                    mod local_spawn {
-                        //#tasks_with_same_prio
-                    }
 
                     #(#stmts)*
                 }

rtic-macros/src/syntax.rs

@@ -7,7 +7,7 @@ use indexmap::{IndexMap, IndexSet};
 use proc_macro2::TokenStream as TokenStream2;
 use syn::Ident;
 
-use crate::syntax::ast::App;
+use crate::syntax::ast::{App, SoftwareTask};
 
 mod accessors;
 pub mod analyze;