diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 2974ba4254..48e4a4025e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -323,14 +323,14 @@ generated Rust code are implemented using the [`syn`](https://docs.rs/syn) crate ### Implementing new options using `syn` -Here is a list of recommendations to be followed if a new option can be -implemented using the `syn` crate: - -- The `BindgenOptions::require_syn` method must be updated to reflect that this - new option requires parsing the generated Rust code with `syn`. - -- The implementation of the new option should be added at the end of - `Bindings::generate`, inside the `if options.require_syn() { ... }` block. +If a new option can be implemented using the `syn` crate it should be added to +the `codegen::postprocessing` module by following these steps: + +- Introduce a new field to `BindgenOptions` for the option. +- Write a free function inside `codegen::postprocessing` implementing the + option. This function with the same name of the `BindgenOptions` field. +- Add a new value to the `codegen::postprocessing::PASSES` for the option using + the `pass!` macro. ## Pull Requests and Code Reviews diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs index 8eb7b0134c..5660b1262f 100644 --- a/src/codegen/mod.rs +++ b/src/codegen/mod.rs @@ -3,6 +3,7 @@ mod error; mod helpers; mod impl_debug; mod impl_partialeq; +mod postprocessing; pub mod struct_layout; #[cfg(test)] @@ -4439,7 +4440,7 @@ impl CodeGenerator for ObjCInterface { pub(crate) fn codegen( context: BindgenContext, -) -> (Vec, BindgenOptions, Vec) { +) -> (proc_macro2::TokenStream, BindgenOptions, Vec) { context.gen(|context| { let _t = context.timer("codegen"); let counter = Cell::new(0); @@ -4489,7 +4490,7 @@ pub(crate) fn codegen( result.push(dynamic_items_tokens); } - result.items + postprocessing::postprocessing(result.items, context.options()) }) } diff --git a/src/codegen/postprocessing/merge_extern_blocks.rs b/src/codegen/postprocessing/merge_extern_blocks.rs new file mode 100644 index 0000000000..2b7614941e --- /dev/null +++ b/src/codegen/postprocessing/merge_extern_blocks.rs @@ -0,0 +1,46 @@ +use syn::{Item, ItemForeignMod}; + +pub(super) fn merge_extern_blocks(items: &mut Vec) { + // Keep all the extern blocks in a different `Vec` for faster search. + let mut foreign_mods = Vec::::new(); + + for item in std::mem::take(items) { + match item { + Item::ForeignMod(ItemForeignMod { + attrs, + abi, + brace_token, + items: foreign_items, + }) => { + let mut exists = false; + for foreign_mod in &mut foreign_mods { + // Check if there is a extern block with the same ABI and + // attributes. + if foreign_mod.attrs == attrs && foreign_mod.abi == abi { + // Merge the items of the two blocks. + foreign_mod.items.extend_from_slice(&foreign_items); + exists = true; + break; + } + } + // If no existing extern block had the same ABI and attributes, store + // it. + if !exists { + foreign_mods.push(ItemForeignMod { + attrs, + abi, + brace_token, + items: foreign_items, + }); + } + } + // If the item is not an extern block, we don't have to do anything. + _ => items.push(item), + } + } + + // Move all the extern blocks alongside the rest of the items. + for foreign_mod in foreign_mods { + items.push(Item::ForeignMod(foreign_mod)); + } +} diff --git a/src/codegen/postprocessing/mod.rs b/src/codegen/postprocessing/mod.rs new file mode 100644 index 0000000000..c6612f2b91 --- /dev/null +++ b/src/codegen/postprocessing/mod.rs @@ -0,0 +1,66 @@ +use proc_macro2::TokenStream; +use quote::ToTokens; +use syn::Item; + +use crate::BindgenOptions; + +mod merge_extern_blocks; +mod sort_semantically; + +use merge_extern_blocks::merge_extern_blocks; +use sort_semantically::sort_semantically; + +struct PostProcessingPass { + should_run: fn(&BindgenOptions) -> bool, + run: fn(&mut Vec), +} + +// TODO: This can be a const fn when mutable references are allowed in const +// context. +macro_rules! pass { + ($pass:ident) => { + PostProcessingPass { + should_run: |options| options.$pass, + run: |items| $pass(items), + } + }; +} + +const PASSES: &[PostProcessingPass] = + &[pass!(merge_extern_blocks), pass!(sort_semantically)]; + +pub(crate) fn postprocessing( + items: Vec, + options: &BindgenOptions, +) -> TokenStream { + let require_syn = PASSES.iter().any(|pass| (pass.should_run)(options)); + if !require_syn { + return items.into_iter().collect(); + } + let module_wrapped_tokens = + quote!(mod wrapper_for_sorting_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::(module_wrapped_tokens) + .unwrap() + .content + .unwrap(); + + for pass in PASSES { + if (pass.should_run)(options) { + (pass.run)(&mut items); + } + } + + let synful_items = items.into_iter().map(|item| item.into_token_stream()); + + quote! { #( #synful_items )* } +} diff --git a/src/codegen/postprocessing/sort_semantically.rs b/src/codegen/postprocessing/sort_semantically.rs new file mode 100644 index 0000000000..96596cb01e --- /dev/null +++ b/src/codegen/postprocessing/sort_semantically.rs @@ -0,0 +1,24 @@ +use syn::Item; + +pub(super) fn sort_semantically(items: &mut [Item]) { + items.sort_by_key(|item| match item { + Item::Type(_) => 0, + Item::Struct(_) => 1, + Item::Const(_) => 2, + Item::Fn(_) => 3, + Item::Enum(_) => 4, + Item::Union(_) => 5, + Item::Static(_) => 6, + Item::Trait(_) => 7, + Item::TraitAlias(_) => 8, + Item::Impl(_) => 9, + Item::Mod(_) => 10, + Item::Use(_) => 11, + Item::Verbatim(_) => 12, + Item::ExternCrate(_) => 13, + Item::ForeignMod(_) => 14, + Item::Macro(_) => 15, + Item::Macro2(_) => 16, + _ => 18, + }); +} diff --git a/src/lib.rs b/src/lib.rs index 9a5887df8e..3ee46f7540 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -88,7 +88,6 @@ use std::{env, iter}; // Some convenient typedefs for a fast hash map and hash set. type HashMap = ::rustc_hash::FxHashMap; type HashSet = ::rustc_hash::FxHashSet; -use quote::ToTokens; pub(crate) use std::collections::hash_map::Entry; /// Default prefix for the anon fields. @@ -2118,11 +2117,6 @@ struct BindgenOptions { impl ::std::panic::UnwindSafe for BindgenOptions {} impl BindgenOptions { - /// Whether any of the enabled options requires `syn`. - fn require_syn(&self) -> bool { - self.sort_semantically || self.merge_extern_blocks - } - fn build(&mut self) { let mut regex_sets = [ &mut self.allowlisted_vars, @@ -2555,112 +2549,7 @@ impl Bindings { parse(&mut context)?; } - let (items, options, warnings) = codegen::codegen(context); - - let module = if options.require_syn() { - let module_wrapped_tokens = - quote!(mod wrapper_for_sorting_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 syn_parsed_items = - syn::parse2::(module_wrapped_tokens) - .unwrap() - .content - .unwrap() - .1; - - if options.merge_extern_blocks { - // Here we will store all the items after deduplication. - let mut items = Vec::new(); - - // Keep all the extern blocks in a different `Vec` for faster search. - let mut foreign_mods = Vec::::new(); - for item in syn_parsed_items { - match item { - syn::Item::ForeignMod(syn::ItemForeignMod { - attrs, - abi, - brace_token, - items: foreign_items, - }) => { - let mut exists = false; - for foreign_mod in &mut foreign_mods { - // Check if there is a extern block with the same ABI and - // attributes. - if foreign_mod.attrs == attrs && - foreign_mod.abi == abi - { - // Merge the items of the two blocks. - foreign_mod - .items - .extend_from_slice(&foreign_items); - exists = true; - break; - } - } - // If no existing extern block had the same ABI and attributes, store - // it. - if !exists { - foreign_mods.push(syn::ItemForeignMod { - attrs, - abi, - brace_token, - items: foreign_items, - }); - } - } - // If the item is not an extern block, we don't have to do anything. - _ => items.push(item), - } - } - - // Move all the extern blocks alongiside the rest of the items. - for foreign_mod in foreign_mods { - items.push(syn::Item::ForeignMod(foreign_mod)); - } - - syn_parsed_items = items; - } - - if options.sort_semantically { - syn_parsed_items.sort_by_key(|item| match item { - syn::Item::Type(_) => 0, - syn::Item::Struct(_) => 1, - syn::Item::Const(_) => 2, - syn::Item::Fn(_) => 3, - syn::Item::Enum(_) => 4, - syn::Item::Union(_) => 5, - syn::Item::Static(_) => 6, - syn::Item::Trait(_) => 7, - syn::Item::TraitAlias(_) => 8, - syn::Item::Impl(_) => 9, - syn::Item::Mod(_) => 10, - syn::Item::Use(_) => 11, - syn::Item::Verbatim(_) => 12, - syn::Item::ExternCrate(_) => 13, - syn::Item::ForeignMod(_) => 14, - syn::Item::Macro(_) => 15, - syn::Item::Macro2(_) => 16, - _ => 18, - }); - } - - let synful_items = syn_parsed_items - .into_iter() - .map(|item| item.into_token_stream()); - - quote! { #( #synful_items )* } - } else { - quote! { #( #items )* } - }; + let (module, options, warnings) = codegen::codegen(context); Ok(Bindings { options,