xtask/uefi-raw: fix/improve check-raw

Author: phip1611

uefi-raw/src/lib.rs

@@ -71,7 +71,8 @@ pub type VirtualAddress = u64;
 /// The provided [`Boolean`] can't be converted to [`bool`] as it is neither
 /// `0` nor `1`.
 #[derive(Debug, Copy, Clone, PartialEq, Ord, PartialOrd, Eq)]
-pub struct InvalidBooleanError(u8);
+#[repr(transparent)]
+pub struct InvalidBooleanError(pub u8);
 
 impl Display for InvalidBooleanError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
@@ -89,7 +90,7 @@ impl Error for InvalidBooleanError {}
 /// respectively [`TryFrom`] implementations.
 #[derive(Copy, Clone, Debug, Default, PartialEq, Ord, PartialOrd, Eq, Hash)]
 #[repr(transparent)]
-pub struct Boolean(u8);
+pub struct Boolean(pub u8);
 
 impl Boolean {
     /// [`Boolean`] representing `true`.

xtask/src/check_raw.rs

@@ -31,6 +31,7 @@ enum ErrorKind {
     ForbiddenType,
     MalformedAttrs,
     MissingPub,
+    MissingRepr,
     MissingUnsafe,
     UnderscoreField,
     UnknownRepr,
@@ -49,6 +50,7 @@ impl Display for ErrorKind {
                 Self::ForbiddenType => "forbidden type",
                 Self::MalformedAttrs => "malformed attribute contents",
                 Self::MissingPub => "missing pub",
+                Self::MissingRepr => "missing repr",
                 Self::MissingUnsafe => "missing unsafe",
                 Self::UnderscoreField => "field name starts with `_`",
                 Self::UnknownRepr => "unknown repr",
@@ -105,17 +107,18 @@ fn is_pub(vis: &Visibility) -> bool {
 }
 
 /// Type repr. A type may have more than one of these (e.g. both `C` and `Packed`).
-#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
 enum Repr {
     Align(usize),
     C,
+    Rust,
     Packed,
     Transparent,
 }
 
 /// A restricted view of `Attribute`, limited to just the attributes that are
 /// expected in `uefi-raw`.
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 enum ParsedAttr {
     Derive,
     Doc,
@@ -137,6 +140,8 @@ fn parse_attrs(attrs: &[Attribute], src: &Path) -> Result<Vec<ParsedAttr>, Error
             attr.parse_nested_meta(|meta| {
                 if meta.path.is_ident("C") {
                     va.push(ParsedAttr::Repr(Repr::C));
+                } else if meta.path.is_ident("Rust") {
+                    va.push(ParsedAttr::Repr(Repr::Rust));
                 } else if meta.path.is_ident("packed") {
                     va.push(ParsedAttr::Repr(Repr::Packed));
                 } else if meta.path.is_ident("transparent") {
@@ -259,7 +264,9 @@ fn check_type_attrs(attrs: &[Attribute], spanned: &dyn Spanned, src: &Path) -> R
 
     let allowed_reprs: &[&[Repr]] = &[&[Repr::C], &[Repr::C, Repr::Packed], &[Repr::Transparent]];
 
-    if allowed_reprs.contains(&reprs.as_slice()) {
+    if reprs.is_empty() {
+        Err(Error::new(ErrorKind::MissingRepr, src, spanned))
+    } else if allowed_reprs.contains(&reprs.as_slice()) {
         Ok(())
     } else {
         Err(Error::new(ErrorKind::ForbiddenRepr, src, spanned))
@@ -408,6 +415,7 @@ mod tests {
         Path::new("test")
     }
 
+    #[track_caller]
     fn check_item_err(item: Item, expected_error: ErrorKind) {
         assert_eq!(check_item(&item, src()).unwrap_err().kind, expected_error);
     }
@@ -545,9 +553,20 @@ mod tests {
             ErrorKind::UnderscoreField,
         );
 
+        // Missing `repr`.
+        check_item_err(
+            parse_quote! {
+                pub struct S {
+                    pub f: u32,
+                }
+            },
+            ErrorKind::MissingRepr,
+        );
+
         // Forbidden `repr`.
         check_item_err(
             parse_quote! {
+                #[repr(Rust)]
                 pub struct S {
                     pub f: u32,
                 }
@@ -623,7 +642,7 @@ mod tests {
                     pub f: u32,
                 }
             },
-            ErrorKind::ForbiddenRepr,
+            ErrorKind::MissingRepr,
         );
     }
 }