uefi-macros: Drop the unsafe_guid and Protocol macros

These are no longer used anywhere.

Author: nicholasbishop

uefi-macros/src/lib.rs

@@ -7,37 +7,10 @@ use proc_macro::TokenStream;
 use proc_macro2::{TokenStream as TokenStream2, TokenTree};
 use quote::{quote, ToTokens, TokenStreamExt};
 use syn::{
-    parse::{Parse, ParseStream},
-    parse_macro_input, parse_quote,
-    spanned::Spanned,
-    DeriveInput, Error, Fields, FnArg, Generics, Ident, ItemFn, ItemStruct, ItemType, LitStr, Pat,
-    Visibility,
+    parse_macro_input, parse_quote, spanned::Spanned, Error, Fields, FnArg, Ident, ItemFn,
+    ItemStruct, LitStr, Pat, Visibility,
 };
 
-/// Parses a type definition, extracts its identifier and generic parameters
-struct TypeDefinition {
-    ident: Ident,
-    generics: Generics,
-}
-
-impl Parse for TypeDefinition {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        if let Ok(d) = DeriveInput::parse(input) {
-            Ok(Self {
-                ident: d.ident,
-                generics: d.generics,
-            })
-        } else if let Ok(t) = ItemType::parse(input) {
-            Ok(Self {
-                ident: t.ident,
-                generics: t.generics,
-            })
-        } else {
-            Err(input.error("Input is not an alias, enum, struct or union definition"))
-        }
-    }
-}
-
 macro_rules! err {
     ($span:expr, $message:expr $(,)?) => {
         Error::new($span.span(), $message).to_compile_error()
@@ -47,40 +20,6 @@ macro_rules! err {
     };
 }
 
-/// `unsafe_guid` attribute macro, implements the `Identify` trait for any type
-/// (mostly works like a custom derive, but also supports type aliases)
-#[proc_macro_attribute]
-pub fn unsafe_guid(args: TokenStream, input: TokenStream) -> TokenStream {
-    // Parse the arguments and input using Syn
-    let (time_low, time_mid, time_high_and_version, clock_seq_and_variant, node) =
-        match parse_guid(parse_macro_input!(args as LitStr)) {
-            Ok(data) => data,
-            Err(tokens) => return tokens.into(),
-        };
-
-    let mut result: TokenStream2 = input.clone().into();
-
-    let type_definition = parse_macro_input!(input as TypeDefinition);
-
-    // At this point, we know everything we need to implement Identify
-    let ident = &type_definition.ident;
-    let (impl_generics, ty_generics, where_clause) = type_definition.generics.split_for_impl();
-
-    result.append_all(quote! {
-        unsafe impl #impl_generics ::uefi::Identify for #ident #ty_generics #where_clause {
-            #[doc(hidden)]
-            const GUID: ::uefi::Guid = ::uefi::Guid::from_values(
-                #time_low,
-                #time_mid,
-                #time_high_and_version,
-                #clock_seq_and_variant,
-                #node,
-            );
-        }
-    });
-    result.into()
-}
-
 /// Attribute macro for marking structs as UEFI protocols.
 ///
 /// The macro takes one argument, a GUID string.
@@ -243,28 +182,6 @@ fn parse_guid(guid_lit: LitStr) -> Result<(u32, u16, u16, u16, u64), TokenStream
     ))
 }
 
-/// Custom derive for the `Protocol` trait
-#[proc_macro_derive(Protocol)]
-pub fn derive_protocol(item: TokenStream) -> TokenStream {
-    // Parse the input using Syn
-    let item = parse_macro_input!(item as DeriveInput);
-
-    // Then implement Protocol
-    let ident = item.ident.clone();
-    let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
-    let result = quote! {
-        // Mark this as a `Protocol` implementation
-        impl #impl_generics ::uefi::proto::Protocol for #ident #ty_generics #where_clause {}
-
-        // Most UEFI functions expect to be called on the bootstrap processor.
-        impl #impl_generics !Send for #ident #ty_generics #where_clause {}
-
-        // Most UEFI functions do not support multithreaded access.
-        impl #impl_generics !Sync for #ident #ty_generics #where_clause {}
-    };
-    result.into()
-}
-
 /// Get the name of a function's argument at `arg_index`.
 fn get_function_arg_name(f: &ItemFn, arg_index: usize, errors: &mut TokenStream2) -> Option<Ident> {
     if let Some(FnArg::Typed(arg)) = f.sig.inputs.iter().nth(arg_index) {

uefi/src/data_types/guid.rs

@@ -133,12 +133,10 @@ pub unsafe trait Identify {
     const GUID: Guid;
 }
 
-pub use uefi_macros::unsafe_guid;
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use uefi::{guid, unsafe_guid};
+    use uefi::guid;
 
     #[test]
     fn test_guid_display() {
@@ -159,17 +157,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_unsafe_guid_macro() {
-        #[unsafe_guid("12345678-9abc-def0-1234-56789abcdef0")]
-        struct X;
-
-        assert_eq!(
-            X::GUID,
-            Guid::from_values(0x12345678, 0x9abc, 0xdef0, 0x1234, 0x56789abcdef0)
-        );
-    }
-
     #[test]
     fn test_to_from_bytes() {
         #[rustfmt::skip]

uefi/src/data_types/mod.rs

@@ -121,7 +121,7 @@ pub type VirtualAddress = u64;
 
 mod guid;
 pub use self::guid::Guid;
-pub use self::guid::{unsafe_guid, Identify};
+pub use self::guid::Identify;
 
 pub mod chars;
 pub use self::chars::{Char16, Char8};

uefi/src/lib.rs

@@ -85,7 +85,7 @@ extern crate self as uefi;
 pub mod data_types;
 #[cfg(feature = "alloc")]
 pub use self::data_types::CString16;
-pub use self::data_types::{unsafe_guid, Identify};
+pub use self::data_types::Identify;
 pub use self::data_types::{CStr16, CStr8, Char16, Char8, Event, Guid, Handle};
 pub use uefi_macros::guid;