xtask/uefi-raw: improve check-raw error messages

This helps to better identify why the check-raw step fails.

Author: phip1611

xtask/src/check_raw.rs

@@ -33,6 +33,7 @@ enum ErrorKind {
     ForbiddenType,
     MalformedAttrs,
     MissingPub,
+    MissingRepr,
     MissingUnsafe,
     UnderscoreField,
     UnknownRepr,
@@ -51,6 +52,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",
@@ -107,17 +109,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,
     Packed,
+    Rust,
     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,
@@ -139,8 +142,10 @@ 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("packed") {
+                } else if meta.path.is_ident("Rust") {
                     va.push(ParsedAttr::Repr(Repr::Packed));
+                } else if meta.path.is_ident("packed") {
+                    va.push(ParsedAttr::Repr(Repr::Rust));
                 } else if meta.path.is_ident("transparent") {
                     va.push(ParsedAttr::Repr(Repr::Transparent));
                 } else if meta.path.is_ident("align") {
@@ -261,7 +266,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))
@@ -410,6 +417,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);
     }
@@ -547,9 +555,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,
                 }
@@ -625,7 +644,7 @@ mod tests {
                     pub f: u32,
                 }
             },
-            ErrorKind::ForbiddenRepr,
+            ErrorKind::MissingRepr,
         );
     }
 }