Reintroduce random idents and remove double definition tests

Author: YuhanLiin

macros/Cargo.toml

@@ -16,6 +16,11 @@ proc-macro = true
 [dependencies]
 quote = "1.0.14"
 proc-macro2 = "1.0.36"
+rand_xoshiro = "0.6.0"
+
+[dependencies.rand]
+default-features = false
+version = "0.8.4"
 
 [dependencies.syn]
 features = ["extra-traits", "full"]

macros/src/lib.rs

@@ -1,13 +1,21 @@
 extern crate proc_macro;
 extern crate proc_macro2;
 extern crate quote;
+extern crate rand;
+extern crate rand_xoshiro;
 extern crate syn;
 
 use proc_macro::TokenStream;
-use std::collections::HashSet;
+use std::{
+    collections::HashSet,
+    sync::atomic::{AtomicUsize, Ordering},
+    time::{SystemTime, UNIX_EPOCH},
+};
 
 use proc_macro2::Span;
 use quote::{quote, quote_spanned};
+use rand::Rng;
+use rand_xoshiro::rand_core::SeedableRng;
 use syn::{
     parenthesized,
     parse::{self, Parse},
@@ -164,7 +172,6 @@ pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
             ReturnType::Type(_, ref ty) => matches!(**ty, Type::Never(_)),
         };
 
-    let fname = &f.sig.ident;
     let pair = match &interrupt_enable {
         Some(interrupt_enable) => interrupt_enable.extract_init_arg(&f.sig.inputs),
         None => extract_critical_section_arg(&f.sig.inputs),
@@ -174,6 +181,7 @@ pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
         // XXX should we blacklist other attributes?
         let attrs = f.attrs;
         let unsafety = f.sig.unsafety;
+        let hash = random_ident();
         let (statics, stmts) = match extract_static_muts(f.block.stmts) {
             Err(e) => return e.to_compile_error().into(),
             Ok(x) => x,
@@ -209,15 +217,15 @@ pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
             .map(|arg| quote_spanned!(Span::mixed_site()=> let arg = #arg; ));
 
         quote!(
-            #[no_mangle]
+            #[export_name = "main"]
             #(#attrs)*
-            pub #unsafety fn main() -> ! {
-                #unsafety fn #fname<'a>(#fn_param) -> ! {
+            pub #unsafety fn #hash() -> ! {
+                #unsafety fn #hash<'a>(#fn_param) -> ! {
                     #(#vars)*
                     #(#stmts)*
                 }
                 #arg_def
-                { #fname(#arg_ident) }
+                { #hash(#arg_ident) }
             }
         )
         .into()
@@ -282,15 +290,17 @@ impl Parse for EntryInterruptEnable {
 impl EntryInterruptEnable {
     fn extract_init_arg(&self, list: &Punctuated<FnArg, Token![,]>) -> Result<ParamArgPair, ()> {
         if let Some(fn_name) = &self.pre_interrupt {
+            let hash = random_ident();
             let fn_arg = Some(quote_spanned!(Span::mixed_site()=> {
                 let cs = unsafe { msp430::interrupt::CriticalSection::new() };
 
                 // This struct forces the lifetime of the CriticalSection to match the lifetime of
                 // the reference. Since the reference lifetime is restricted to this scope, the
                 // compiler has to constrain the lifetime of the CriticalSection as well,
                 // preventing the CriticalSection from being leaked as a return value.
-                mod inner { pub struct Cs<'a>(pub &'a msp430::interrupt::CriticalSection<'a>); }
-                let arg = #fn_name(*inner::Cs(&cs).0);
+                #[allow(non_camel_case_types)]
+                struct #hash<'a>(&'a msp430::interrupt::CriticalSection<'a>);
+                let arg = #fn_name(*#hash(&cs).0);
 
                 unsafe { msp430::interrupt::enable() };
                 arg
@@ -475,17 +485,19 @@ pub fn interrupt(args: TokenStream, input: TokenStream) -> TokenStream {
             .collect::<Vec<_>>();
 
         let output = f.sig.output;
+        let hash = random_ident();
+        let ident = ident.to_string();
         quote!(
-            #[no_mangle]
+            #[export_name = #ident]
             #(#attrs)*
-            #unsafety extern "msp430-interrupt" fn #ident() {
+            #unsafety extern "msp430-interrupt" fn #hash() {
                 #check
 
-                #unsafety fn #ident<'a>(#fn_param) #output {
+                #unsafety fn #hash<'a>(#fn_param) #output {
                     #(#vars)*
                     #(#stmts)*
                 }
-                { #ident(#fn_arg) }
+                { #hash(#fn_arg) }
             }
         )
         .into()
@@ -618,6 +630,41 @@ fn extract_critical_section_arg(list: &Punctuated<FnArg, Token![,]>) -> Result<P
     Err(())
 }
 
+// Creates a random identifier
+fn random_ident() -> Ident {
+    static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+    let secs = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+
+    let count: u64 = CALL_COUNT.fetch_add(1, Ordering::SeqCst) as u64;
+    let mut seed: [u8; 16] = [0; 16];
+
+    for (i, v) in seed.iter_mut().take(8).enumerate() {
+        *v = ((secs >> (i * 8)) & 0xFF) as u8
+    }
+
+    for (i, v) in seed.iter_mut().skip(8).enumerate() {
+        *v = ((count >> (i * 8)) & 0xFF) as u8
+    }
+
+    let mut rng = rand_xoshiro::Xoshiro128PlusPlus::from_seed(seed);
+    Ident::new(
+        &(0..16)
+            .map(|i| {
+                if i == 0 || rng.gen() {
+                    (b'a' + rng.gen::<u8>() % 25) as char
+                } else {
+                    (b'0' + rng.gen::<u8>() % 10) as char
+                }
+            })
+            .collect::<String>(),
+        Span::call_site(),
+    )
+}
+
 /// Extracts `static mut` vars from the beginning of the given statements
 fn extract_static_muts(stmts: Vec<Stmt>) -> Result<(Vec<ItemStatic>, Vec<Stmt>), parse::Error> {
     let mut istmts = stmts.into_iter();
@@ -653,24 +700,3 @@ fn extract_static_muts(stmts: Vec<Stmt>) -> Result<(Vec<ItemStatic>, Vec<Stmt>),
 
     Ok((statics, stmts))
 }
-
-/// ``` no_run
-/// #![no_main]
-/// use msp430_rt_macros::{entry, interrupt};
-/// use msp430::interrupt::CriticalSection;
-///
-/// fn arg(cs: CriticalSection) -> u32 {
-///     arg(cs)
-/// }
-///
-/// #[entry(interrupt_enable(pre_interrupt = arg))]
-/// fn main(i: u32) -> ! {
-///     main(i)
-/// }
-/// ```
-#[cfg(doctest)]
-#[doc(hidden)]
-#[proc_macro]
-pub fn recursive_doc_test(t: TokenStream) -> TokenStream {
-    t
-}