Even more cleanup

macros/src/codegen.rs

@@ -6,20 +6,17 @@ use crate::syntax::ast::App;
 
 mod assertions;
 mod async_dispatchers;
-// mod dispatchers;
 mod hardware_tasks;
 mod idle;
 mod init;
 mod local_resources;
 mod local_resources_struct;
 mod module;
-// mod monotonic;
 mod post_init;
 mod pre_init;
 mod shared_resources;
 mod shared_resources_struct;
 mod software_tasks;
-// mod timer_queue;
 mod util;
 
 #[allow(clippy::too_many_lines)]

macros/src/codegen/init.rs

@@ -76,7 +76,7 @@ pub fn codegen(app: &App, analysis: &Analysis) -> CodegenResult {
 
     // let locals_pat = locals_pat.iter();
 
-    let user_init_return = quote! {#shared, #local, #name::Monotonics};
+    let user_init_return = quote! {#shared, #local};
 
     let user_init = quote!(
         #(#attrs)*
@@ -99,9 +99,8 @@ pub fn codegen(app: &App, analysis: &Analysis) -> CodegenResult {
         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()));
+        let (shared_resources, local_resources) = #name(#name::Context::new(core.into()));
     };
 
     root_init.push(module::codegen(

macros/src/syntax/parse/init.rs

@@ -23,7 +23,7 @@ impl Init {
 
         if valid_signature {
             if let Ok((user_shared_struct, user_local_struct)) =
-                util::type_is_init_return(&item.sig.output, &name)
+                util::type_is_init_return(&item.sig.output)
             {
                 if let Some(context) = util::parse_inputs(item.sig.inputs, &name) {
                     return Ok(Init {
@@ -42,7 +42,7 @@ impl Init {
         Err(parse::Error::new(
             span,
             &format!(
-                "the `#[init]` function must have signature `fn({}::Context) -> (Shared resources struct, Local resources struct, {0}::Monotonics)`",
+                "the `#[init]` function must have signature `fn({}::Context) -> (Shared resources struct, Local resources struct)`",
                 name
             ),
         ))

macros/src/syntax/parse/monotonic.rs

@@ -1,42 +0,0 @@
-use proc_macro2::Span;
-use syn::Attribute;
-use syn::{parse, spanned::Spanned, ItemType, Visibility};
-
-use crate::syntax::parse::util::FilterAttrs;
-use crate::syntax::{
-    ast::{Monotonic, MonotonicArgs},
-    parse::util,
-};
-
-impl MonotonicArgs {
-    pub(crate) fn parse(attr: Attribute) -> parse::Result<Self> {
-        crate::syntax::parse::monotonic_args(attr.path, attr.tokens)
-    }
-}
-
-impl Monotonic {
-    pub(crate) fn parse(args: MonotonicArgs, item: &ItemType, span: Span) -> parse::Result<Self> {
-        if item.vis != Visibility::Inherited {
-            return Err(parse::Error::new(
-                span,
-                "this field must have inherited / private visibility",
-            ));
-        }
-
-        let FilterAttrs { cfgs, attrs, .. } = util::filter_attributes(item.attrs.clone());
-
-        if !attrs.is_empty() {
-            return Err(parse::Error::new(
-                attrs[0].path.span(),
-                "Monotonic does not support attributes other than `#[cfg]`",
-            ));
-        }
-
-        Ok(Monotonic {
-            cfgs,
-            ident: item.ident.clone(),
-            ty: item.ty.clone(),
-            args,
-        })
-    }
-}

macros/src/syntax/parse/util.rs

@@ -277,18 +277,18 @@ fn extract_init_resource_name_ident(ty: Type) -> Result<Ident, ()> {
 }
 
 /// Checks Init's return type, return the user provided types for analysis
-pub fn type_is_init_return(ty: &ReturnType, name: &str) -> Result<(Ident, Ident), ()> {
+pub fn type_is_init_return(ty: &ReturnType) -> Result<(Ident, Ident), ()> {
     match ty {
         ReturnType::Default => Err(()),
 
         ReturnType::Type(_, ty) => match &**ty {
             Type::Tuple(t) => {
                 // return should be:
-                // fn -> (User's #[shared] struct, User's #[local] struct, {name}::Monotonics)
+                // fn -> (User's #[shared] struct, User's #[local] struct)
                 //
                 // We check the length and the last one here, analysis checks that the user
                 // provided structs are correct.
-                if t.elems.len() == 3 && type_is_path(&t.elems[2], &[name, "Monotonics"]) {
+                if t.elems.len() == 2 {
                     return Ok((
                         extract_init_resource_name_ident(t.elems[0].clone())?,
                         extract_init_resource_name_ident(t.elems[1].clone())?,

src/export.rs

@@ -15,65 +15,6 @@ pub use cortex_m::{
     peripheral::{scb::SystemHandler, DWT, NVIC, SCB, SYST},
     Peripherals,
 };
-pub use heapless::sorted_linked_list::SortedLinkedList;
-pub use heapless::spsc::Queue;
-pub use heapless::BinaryHeap;
-pub use heapless::Vec;
-pub use rtic_monotonic as monotonic;
-
-pub mod idle_executor {
-    use core::{
-        future::Future,
-        pin::Pin,
-        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
-    };
-
-    fn no_op(_: *const ()) {}
-    fn no_op_clone(_: *const ()) -> RawWaker {
-        noop_raw_waker()
-    }
-
-    static IDLE_WAKER_TABLE: RawWakerVTable = RawWakerVTable::new(no_op_clone, no_op, no_op, no_op);
-
-    #[inline]
-    fn noop_raw_waker() -> RawWaker {
-        RawWaker::new(core::ptr::null(), &IDLE_WAKER_TABLE)
-    }
-
-    pub struct IdleExecutor<T>
-    where
-        T: Future,
-    {
-        idle: T,
-    }
-
-    impl<T> IdleExecutor<T>
-    where
-        T: Future,
-    {
-        #[inline(always)]
-        pub fn new(idle: T) -> Self {
-            Self { idle }
-        }
-
-        #[inline(always)]
-        pub fn run(&mut self) -> ! {
-            let w = unsafe { Waker::from_raw(noop_raw_waker()) };
-            let mut ctxt = Context::from_waker(&w);
-            loop {
-                match unsafe { Pin::new_unchecked(&mut self.idle) }.poll(&mut ctxt) {
-                    Poll::Pending => {
-                        // All ok!
-                    }
-                    Poll::Ready(_) => {
-                        // The idle executor will never return
-                        unreachable!()
-                    }
-                }
-            }
-        }
-    }
-}
 
 pub mod executor {
     use core::{
@@ -143,10 +84,6 @@ pub mod executor {
     }
 }
 
-pub type SCFQ<const N: usize> = Queue<u8, N>;
-pub type SCRQ<T, const N: usize> = Queue<(T, u8), N>;
-pub type ASYNCRQ<T, const N: usize> = Queue<T, N>;
-
 /// Mask is used to store interrupt masks on systems without a BASEPRI register (M0, M0+, M23).
 /// It needs to be large enough to cover all the relevant interrupts in use.
 /// For M0/M0+ there are only 32 interrupts so we only need one u32 value.
@@ -290,13 +227,6 @@ where
 {
 }
 
-#[inline(always)]
-pub fn assert_monotonic<T>()
-where
-    T: monotonic::Monotonic,
-{
-}
-
 /// Lock implementation using BASEPRI and global Critical Section (CS)
 ///
 /// # Safety