Merge pull request #2299 from ferrous-systems/more-robust-postprocessing

Make postprocessing more robust

1 files changed, 14 insertions, 14 deletions

diff --git a/bindgen/codegen/postprocessing/mod.rs b/bindgen/codegen/postprocessing/mod.rs
index c6612f2b..1d5a4983 100644
--- a/bindgen/codegen/postprocessing/mod.rs
+++ b/bindgen/codegen/postprocessing/mod.rs
@@ -1,6 +1,6 @@
 use proc_macro2::TokenStream;
 use quote::ToTokens;
-use syn::Item;
+use syn::{parse2, ItemMod};
 
 use crate::BindgenOptions;
 
@@ -12,7 +12,7 @@ use sort_semantically::sort_semantically;
 
 struct PostProcessingPass {
     should_run: fn(&BindgenOptions) -> bool,
-    run: fn(&mut Vec<Item>),
+    run: fn(&mut ItemMod),
 }
 
 // TODO: This can be a const fn when mutable references are allowed in const
@@ -21,7 +21,7 @@ macro_rules! pass {
     ($pass:ident) => {
         PostProcessingPass {
             should_run: |options| options.$pass,
-            run: |items| $pass(items),
+            run: |item_mod| $pass(item_mod),
         }
     };
 }
@@ -38,29 +38,29 @@ pub(crate) fn postprocessing(
         return items.into_iter().collect();
     }
     let module_wrapped_tokens =
-        quote!(mod wrapper_for_sorting_hack { #( #items )* });
+        quote!(mod wrapper_for_postprocessing_hack { #( #items )* });
 
     // This syn business is a hack, for now. This means that we are re-parsing already
     // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
     // control over the elements.
     // One caveat is that some of the items coming from `quote`d output might have
     // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
-    // The two `unwrap`s here are deliberate because
-    //      The first one won't panic because we build the `mod` and know it is there
-    //      The second one won't panic because we know original output has something in
-    //      it already.
-    let (_, mut items) = syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
-        .unwrap()
-        .content
-        .unwrap();
+    // The `unwrap` here is deliberate because bindgen should generate valid rust items at all
+    // times.
+    let mut item_mod = parse2::<ItemMod>(module_wrapped_tokens).unwrap();
 
     for pass in PASSES {
         if (pass.should_run)(options) {
-            (pass.run)(&mut items);
+            (pass.run)(&mut item_mod);
         }
     }
 
-    let synful_items = items.into_iter().map(|item| item.into_token_stream());
+    let synful_items = item_mod
+        .content
+        .map(|(_, items)| items)
+        .unwrap_or_default()
+        .into_iter()
+        .map(|item| item.into_token_stream());
 
     quote! { #( #synful_items )* }
 }