Support parsing 'unsafe extern "C++"'

This was added in Rust 1.48 by
rust-lang/rust#75857

src/gen/clone.rs

@@ -1121,6 +1121,7 @@ impl Clone for ItemForeignMod {
     fn clone(&self) -> Self {
         ItemForeignMod {
             attrs: self.attrs.clone(),
+            unsafety: self.unsafety.clone(),
             abi: self.abi.clone(),
             brace_token: self.brace_token.clone(),
             items: self.items.clone(),

src/gen/debug.rs

@@ -1599,6 +1599,7 @@ impl Debug for ItemForeignMod {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         let mut formatter = formatter.debug_struct("ItemForeignMod");
         formatter.field("attrs", &self.attrs);
+        formatter.field("unsafety", &self.unsafety);
         formatter.field("abi", &self.abi);
         formatter.field("brace_token", &self.brace_token);
         formatter.field("items", &self.items);

src/gen/eq.rs

@@ -1128,7 +1128,7 @@ impl Eq for ItemForeignMod {}
 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
 impl PartialEq for ItemForeignMod {
     fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.abi == other.abi && self.items == other.items
+        self.attrs == other.attrs && self.unsafety == other.unsafety && self.abi == other.abi && self.items == other.items
     }
 }
 #[cfg(feature = "full")]

src/gen/fold.rs

@@ -1955,6 +1955,7 @@ where
 {
     ItemForeignMod {
         attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
+        unsafety: (node.unsafety).map(|it| Token![unsafe](tokens_helper(f, &it.span))),
         abi: f.fold_abi(node.abi),
         brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
         items: FoldHelper::lift(node.items, |it| f.fold_foreign_item(it)),

src/gen/hash.rs

@@ -1482,6 +1482,7 @@ impl Hash for ItemForeignMod {
         H: Hasher,
     {
         self.attrs.hash(state);
+        self.unsafety.hash(state);
         self.abi.hash(state);
         self.items.hash(state);
     }

src/item.rs

@@ -150,6 +150,7 @@ ast_struct! {
     #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     pub struct ItemForeignMod {
         pub attrs: Vec<Attribute>,
+        pub unsafety: Option<Token![unsafe]>,
         pub abi: Abi,
         pub brace_token: token::Brace,
         pub items: Vec<ForeignItem>,
@@ -1620,6 +1621,7 @@ pub mod parsing {
     impl Parse for ItemForeignMod {
         fn parse(input: ParseStream) -> Result<Self> {
             let outer_attrs = input.call(Attribute::parse_outer)?;
+            let unsafety = input.parse()?;
             let abi: Abi = input.parse()?;
 
             let content;
@@ -1632,6 +1634,7 @@ pub mod parsing {
 
             Ok(ItemForeignMod {
                 attrs: private::attrs(outer_attrs, inner_attrs),
+                unsafety,
                 abi,
                 brace_token,
                 items,
@@ -2775,6 +2778,7 @@ mod printing {
     impl ToTokens for ItemForeignMod {
         fn to_tokens(&self, tokens: &mut TokenStream) {
             tokens.append_all(self.attrs.outer());
+            self.unsafety.to_tokens(tokens);
             self.abi.to_tokens(tokens);
             self.brace_token.surround(tokens, |tokens| {
                 tokens.append_all(self.attrs.inner());

tests/debug/gen.rs

@@ -3027,6 +3027,18 @@ impl Debug for Lite<syn::ItemForeignMod> {
         if !_val.attrs.is_empty() {
             formatter.field("attrs", Lite(&_val.attrs));
         }
+        if let Some(val) = &_val.unsafety {
+            #[derive(RefCast)]
+            #[repr(transparent)]
+            struct Print(syn::token::Unsafe);
+            impl Debug for Print {
+                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("Some")?;
+                    Ok(())
+                }
+            }
+            formatter.field("unsafety", Print::ref_cast(val));
+        }
         formatter.field("abi", Lite(&_val.abi));
         if !_val.items.is_empty() {
             formatter.field("items", Lite(&_val.items));