macros: cleanup, make work in stable.

embassy-macros/src/util/ctxt.rs

@@ -0,0 +1,72 @@
+// nifty utility borrowed from serde :)
+// https://github.com/serde-rs/serde/blob/master/serde_derive/src/internals/ctxt.rs
+
+use proc_macro2::TokenStream;
+use quote::{quote, ToTokens};
+use std::cell::RefCell;
+use std::fmt::Display;
+use std::thread;
+use syn;
+
+/// A type to collect errors together and format them.
+///
+/// Dropping this object will cause a panic. It must be consumed using `check`.
+///
+/// References can be shared since this type uses run-time exclusive mut checking.
+#[derive(Default)]
+pub struct Ctxt {
+    // The contents will be set to `None` during checking. This is so that checking can be
+    // enforced.
+    errors: RefCell<Option<Vec<syn::Error>>>,
+}
+
+impl Ctxt {
+    /// Create a new context object.
+    ///
+    /// This object contains no errors, but will still trigger a panic if it is not `check`ed.
+    pub fn new() -> Self {
+        Ctxt {
+            errors: RefCell::new(Some(Vec::new())),
+        }
+    }
+
+    /// Add an error to the context object with a tokenenizable object.
+    ///
+    /// The object is used for spanning in error messages.
+    pub fn error_spanned_by<A: ToTokens, T: Display>(&self, obj: A, msg: T) {
+        self.errors
+            .borrow_mut()
+            .as_mut()
+            .unwrap()
+            // Curb monomorphization from generating too many identical methods.
+            .push(syn::Error::new_spanned(obj.into_token_stream(), msg));
+    }
+
+    /// Add one of Syn's parse errors.
+    #[allow(unused)]
+    pub fn syn_error(&self, err: syn::Error) {
+        self.errors.borrow_mut().as_mut().unwrap().push(err);
+    }
+
+    /// Consume this object, producing a formatted error string if there are errors.
+    pub fn check(self) -> Result<(), TokenStream> {
+        let errors = self.errors.borrow_mut().take().unwrap();
+        match errors.len() {
+            0 => Ok(()),
+            _ => Err(to_compile_errors(errors)),
+        }
+    }
+}
+
+fn to_compile_errors(errors: Vec<syn::Error>) -> proc_macro2::TokenStream {
+    let compile_errors = errors.iter().map(syn::Error::to_compile_error);
+    quote!(#(#compile_errors)*)
+}
+
+impl Drop for Ctxt {
+    fn drop(&mut self) {
+        if !thread::panicking() && self.errors.borrow().is_some() {
+            panic!("forgot to check for errors");
+        }
+    }
+}

embassy-macros/src/util/mod.rs

@@ -0,0 +1,2 @@
+pub mod ctxt;
+pub mod path;

embassy-macros/src/util/path.rs

@@ -0,0 +1,41 @@
+use darling::{FromMeta, Result};
+use proc_macro2::Span;
+use syn::{LitStr, Path};
+
+#[derive(Debug)]
+pub struct ModulePrefix {
+    literal: LitStr,
+}
+
+impl ModulePrefix {
+    pub fn new(path: &str) -> Self {
+        let literal = LitStr::new(path, Span::call_site());
+        Self { literal }
+    }
+
+    pub fn append(&self, component: &str) -> ModulePrefix {
+        let mut lit = self.literal().value();
+        lit.push_str(component);
+        Self::new(lit.as_str())
+    }
+
+    pub fn path(&self) -> Path {
+        self.literal.parse().unwrap()
+    }
+
+    pub fn literal(&self) -> &LitStr {
+        &self.literal
+    }
+}
+
+impl FromMeta for ModulePrefix {
+    fn from_string(value: &str) -> Result<Self> {
+        Ok(ModulePrefix::new(value))
+    }
+}
+
+impl Default for ModulePrefix {
+    fn default() -> ModulePrefix {
+        ModulePrefix::new("::")
+    }
+}