uefi: Add new cstr16 implementation

Instead of importing the `cstr16` proc macro from `uefi_macros`, add a new
declarative macro. This makes use of the new `ucs2::ucs2_cstr` declarative
macro, so bump the minimum version of `ucs2` to 0.3.3.

Author: nicholasbishop

uefi/Cargo.toml

@@ -30,7 +30,7 @@ log.workspace = true
 ptr_meta.workspace = true
 uguid.workspace = true
 cfg-if = "1.0.0"
-ucs2 = "0.3.2"
+ucs2 = "0.3.3"
 uefi-macros = "0.13.0"
 uefi-raw = "0.5.2"
 qemu-exit = { version = "3.0.2", optional = true }

uefi/src/lib.rs

@@ -100,6 +100,11 @@ extern crate alloc;
 // see https://github.com/rust-lang/rust/issues/54647
 extern crate self as uefi;
 
+/// Re-export ucs2_cstr so that it can be used in the implementation of the
+/// cstr16 macro. It is hidden since it's not intended to be used directly.
+#[doc(hidden)]
+pub use ucs2::ucs2_cstr;
+
 #[macro_use]
 extern crate uefi_raw;
 
@@ -108,7 +113,7 @@ pub mod data_types;
 #[cfg(feature = "alloc")]
 pub use data_types::CString16;
 pub use data_types::{CStr16, CStr8, Char16, Char8, Event, Guid, Handle, Identify};
-pub use uefi_macros::{cstr16, cstr8, entry};
+pub use uefi_macros::{cstr8, entry};
 pub use uguid::guid;
 
 mod result;
@@ -133,25 +138,19 @@ pub(crate) mod polyfill;
 
 pub mod helpers;
 
+mod macros;
 mod util;
 
 #[cfg(test)]
 // Crates that create procedural macros can't unit test the macros they export.
 // Therefore, we do some tests here.
 mod macro_tests {
-    use crate::{cstr16, cstr8};
+    use crate::cstr8;
 
     #[test]
     fn cstr8_macro_literal() {
         let _empty1 = cstr8!();
         let _empty2 = cstr8!("");
         let _regular = cstr8!("foobar");
     }
-
-    #[test]
-    fn cstr16_macro_literal() {
-        let _empty1 = cstr16!();
-        let _empty2 = cstr16!("");
-        let _regular = cstr16!("foobar");
-    }
 }

uefi/src/macros.rs

@@ -0,0 +1,36 @@
+/// Encode a string literal as a [`&CStr16`].
+///
+/// The encoding is done at compile time, so the result can be used in a
+/// `const` item.
+///
+/// An empty string containing just a null character can be created with either
+/// `cstr16!()` or `cstr16!("")`.
+///
+/// # Example
+///
+/// ```
+/// use uefi::{CStr16, cstr16};
+///
+/// const S: &CStr16 = cstr16!("abc");
+/// assert_eq!(S.to_u16_slice_with_nul(), [97, 98, 99, 0]);
+///
+/// const EMPTY: &CStr16 = cstr16!();
+/// assert_eq!(EMPTY.to_u16_slice_with_nul(), [0]);
+/// assert_eq!(cstr16!(""), EMPTY);
+/// ```
+///
+/// [`&CStr16`]: crate::CStr16
+#[macro_export]
+macro_rules! cstr16 {
+    () => {{
+        const S: &[u16] = &[0];
+        // SAFETY: `S` is a trivially correct UCS-2 C string.
+        unsafe { $crate::CStr16::from_u16_with_nul_unchecked(S) }
+    }};
+    ($s:literal) => {{
+        const S: &[u16] = &$crate::ucs2_cstr!($s);
+        // SAFETY: the ucs2_cstr macro always produces a valid UCS-2 string with
+        // a trailing null character.
+        unsafe { $crate::CStr16::from_u16_with_nul_unchecked(S) }
+    }};
+}