Clean up some ApiSnippets

PiperOrigin-RevId: 778117503
Change-Id: I5f525ad468f833bef0785983817ca7b32952bf85

Author: Googler

rs_bindings_from_cc/generate_bindings/database/code_snippet.rs

@@ -1220,14 +1220,8 @@ pub struct CppDetails {
 }
 
 impl CppDetails {
-    pub fn new(includes: CppIncludes) -> Self {
-        CppDetails { includes, thunks: vec![] }
-    }
-}
-
-impl Extend<ThunkImpl> for CppDetails {
-    fn extend<T: IntoIterator<Item = ThunkImpl>>(&mut self, iter: T) {
-        self.thunks.extend(iter);
+    pub fn new(includes: CppIncludes, thunks: Vec<ThunkImpl>) -> Self {
+        CppDetails { includes, thunks }
     }
 }
 

rs_bindings_from_cc/generate_bindings/generate_struct_and_union.rs

@@ -23,9 +23,9 @@ use itertools::Itertools;
 use proc_macro2::{Ident, TokenStream};
 use quote::quote;
 use std::collections::HashMap;
-use std::iter;
 use std::num::NonZeroUsize;
 use std::rc::Rc;
+use std::{iter, mem};
 
 /// Returns whether fields of type `ty` need to be wrapped in `ManuallyDrop<T>`
 /// to prevent the fields from being destructed twice (once by the C++
@@ -478,15 +478,14 @@ pub fn generate_record(db: &dyn BindingsGenerator, record: Rc<Record>) -> Result
             })
             .collect(),
     };
-    let mut features = FlagSet::empty();
-
+    let mut api_snippets = ApiSnippets::default();
     let recursively_pinned_attr = if record.is_unpin() {
         None
     } else {
         // negative_impls are necessary for universal initialization due to Rust's
         // coherence rules: PhantomPinned isn't enough to prove to Rust that a
         // blanket impl that requires Unpin doesn't apply. See http://<internal link>=h.f6jp8ifzgt3n
-        features |= Feature::negative_impls;
+        api_snippets.features |= Feature::negative_impls;
         Some(RecursivelyPinnedAttr { pinned_drop: record.should_implement_drop() })
     };
 
@@ -517,21 +516,21 @@ pub fn generate_record(db: &dyn BindingsGenerator, record: Rc<Record>) -> Result
 
     let fully_qualified_cc_name = cpp_tagless_type_name_for_record(&record, ir)?.to_string();
 
-    let mut record_generated_items = vec![];
+    let mut record_generated_snippets = ApiSnippets::default();
     let mut record_child_generated_main_apis = vec![];
     for &child_item_id in &record.child_item_ids {
         let item = ir.find_untyped_decl(child_item_id);
-        let mut api_snippets = db.generate_item(item.clone())?;
+        let mut child_api_snippets = db.generate_item(item.clone())?;
         if item.place_in_nested_module_if_nested_in_record()
             && db.has_bindings(item.clone()).is_ok()
         {
             // If it doesn't have bindings, we don't want to put it in the nested module.
-            record_child_generated_main_apis.append(&mut api_snippets.main_api);
+            record_child_generated_main_apis.append(&mut child_api_snippets.main_api);
         }
-        record_generated_items.push(api_snippets);
+        record_generated_snippets.append(child_api_snippets);
     }
 
-    let generated_inherited_functions: Vec<ApiSnippets> = filter_out_ambiguous_member_functions(
+    filter_out_ambiguous_member_functions(
         db,
         record.clone(),
         collect_unqualified_member_functions_from_all_bases(db, &record),
@@ -544,8 +543,9 @@ pub fn generate_record(db: &dyn BindingsGenerator, record: Rc<Record>) -> Result
             db.generate_function(ir_func.clone(), Some(record.clone())).ok().flatten()?;
         Some((*generated_func.snippets).clone())
     })
-    .collect();
-    record_generated_items.extend(generated_inherited_functions);
+    .for_each(|func_snippets| {
+        record_generated_snippets.append(func_snippets);
+    });
 
     // Both the template definition and its instantiation should enable experimental
     // features.
@@ -554,7 +554,7 @@ pub fn generate_record(db: &dyn BindingsGenerator, record: Rc<Record>) -> Result
         crubit_features |= ir.target_crubit_features(defining_target);
     }
     if crubit_features.contains(crubit_feature::CrubitFeature::Experimental) {
-        record_generated_items.push(cc_struct_upcast_impl(db, &record, ir)?);
+        record_generated_snippets.append(cc_struct_upcast_impl(db, &record, ir)?);
     }
     let no_unique_address_accessors =
         if crubit_features.contains(crubit_feature::CrubitFeature::Experimental) {
@@ -572,18 +572,10 @@ pub fn generate_record(db: &dyn BindingsGenerator, record: Rc<Record>) -> Result
         None
     };
 
-    let mut items = vec![];
-    let mut thunks_from_record_items = vec![];
-    let mut thunk_impls_from_record_items = vec![cc_struct_layout_assertion(db, &record)?];
-    let mut assertions_from_record_items = vec![];
-
-    for generated in record_generated_items {
-        items.extend(generated.main_api);
-        thunks_from_record_items.extend(generated.thunks);
-        assertions_from_record_items.extend(generated.assertions);
-        thunk_impls_from_record_items.extend(generated.cc_details);
-        features |= generated.features;
-    }
+    api_snippets.cc_details.push(cc_struct_layout_assertion(db, &record)?);
+
+    let items = mem::take(&mut record_generated_snippets.main_api);
+    api_snippets.append(record_generated_snippets);
 
     let cxx_impl = if fully_qualified_cc_name.contains('<') {
         // cxx can't parse templated type names.
@@ -638,7 +630,7 @@ pub fn generate_record(db: &dyn BindingsGenerator, record: Rc<Record>) -> Result
         nested_items: record_child_generated_main_apis,
     };
 
-    features |= Feature::negative_impls;
+    api_snippets.features |= Feature::negative_impls;
     let record_trait_assertions = {
         let mut assert_impls = FlagSet::empty();
         let mut assert_not_impls = FlagSet::empty();
@@ -665,27 +657,19 @@ pub fn generate_record(db: &dyn BindingsGenerator, record: Rc<Record>) -> Result
         }
     };
 
-    let mut assertions = vec![];
-    assertions.push(rs_size_align_assertions(qualified_ident, &record.size_align));
-    assertions.push(record_trait_assertions);
-    assertions.push(field_offset_assertions);
-    assertions.extend(fields_that_must_be_copy.into_iter().map(|formatted_field_type| {
-        Assertion::Impls {
+    api_snippets.assertions.push(rs_size_align_assertions(qualified_ident, &record.size_align));
+    api_snippets.assertions.push(record_trait_assertions);
+    api_snippets.assertions.push(field_offset_assertions);
+    api_snippets.assertions.extend(fields_that_must_be_copy.into_iter().map(
+        |formatted_field_type| Assertion::Impls {
             type_name: formatted_field_type,
             all_of: AssertableTrait::Copy.into(),
             none_of: FlagSet::empty(),
-        }
-    }));
-    assertions.extend(assertions_from_record_items);
-
-    Ok(ApiSnippets {
-        main_api: vec![MainApi::Record(record_tokens)],
-        features,
-        assertions,
-        thunks: thunks_from_record_items,
-        cc_details: thunk_impls_from_record_items,
-        ..Default::default()
-    })
+        },
+    ));
+
+    api_snippets.main_api.push(MainApi::Record(record_tokens));
+    Ok(api_snippets)
 }
 
 pub fn rs_size_align_assertions(type_name: TokenStream, size_align: &ir::SizeAlign) -> Assertion {

rs_bindings_from_cc/generate_bindings/lib.rs

@@ -24,6 +24,7 @@ use quote::{quote, ToTokens};
 use rs_type_kind::rs_type_kind_with_lifetime_elision;
 use std::collections::BTreeSet;
 use std::ffi::OsStr;
+use std::mem;
 use std::path::Path;
 use std::rc::Rc;
 use token_stream_printer::{
@@ -128,22 +129,11 @@ fn generate_global_var(db: &dyn BindingsGenerator, var: Rc<GlobalVar>) -> Result
 
 fn generate_namespace(db: &dyn BindingsGenerator, namespace: Rc<Namespace>) -> Result<ApiSnippets> {
     let ir = db.ir();
-    let mut items = vec![];
-    let mut thunks = vec![];
-    let mut cc_details = vec![];
-    let mut assertions = vec![];
-    let mut features = FlagSet::empty();
+    let mut api_snippets = ApiSnippets::default();
 
     for item_id in namespace.child_item_ids.iter() {
-        let item: &Item = ir.find_decl(*item_id).with_context(|| {
-            format!("Failed to look up namespace.child_item_ids for {:?}", namespace)
-        })?;
-        let generated = db.generate_item(item.clone())?;
-        items.extend(generated.main_api);
-        thunks.extend(generated.thunks);
-        cc_details.extend(generated.cc_details);
-        assertions.extend(generated.assertions);
-        features |= generated.features;
+        let item = ir.find_untyped_decl(*item_id);
+        api_snippets.append(db.generate_item(item.clone())?);
     }
 
     let reopened_namespace_idx = ir.get_reopened_namespace_idx(namespace.id)?;
@@ -163,19 +153,14 @@ fn generate_namespace(db: &dyn BindingsGenerator, namespace: Rc<Namespace>) -> R
     });
     let insert_use_stmt_for_inline_namespace = namespace.is_inline && is_canonical_namespace_module;
 
-    Ok(ApiSnippets {
-        main_api: vec![MainApi::Namespace {
-            name,
-            previous_namespace_to_use,
-            items,
-            insert_use_stmt_for_inline_namespace,
-        }],
-        features,
-        thunks,
-        cc_details,
-        assertions,
-        ..Default::default()
-    })
+    let items = mem::take(&mut api_snippets.main_api);
+    api_snippets.main_api.push(MainApi::Namespace {
+        name,
+        previous_namespace_to_use,
+        items,
+        insert_use_stmt_for_inline_namespace,
+    });
+    Ok(api_snippets)
 }
 
 /// Implementation of `BindingsGenerator::generate_item`.
@@ -319,30 +304,24 @@ pub fn generate_bindings_tokens(
     environment: Environment,
 ) -> Result<BindingsTokens> {
     let db = new_database(ir, errors, fatal_errors, environment);
-    let mut items = vec![];
-    let mut thunks = vec![];
-    let mut cc_details =
-        CppDetails::new(generate_rs_api_impl_includes(&db, crubit_support_path_format));
-    let mut assertions = vec![];
-
-    let mut features = FlagSet::empty();
+    let mut snippets = ApiSnippets::default();
 
     // For #![rustfmt::skip].
-    features |= Feature::custom_inner_attributes;
+    snippets.features |= Feature::custom_inner_attributes;
     // For the `vector` in `cc_std`.
-    features |= Feature::allocator_api;
-    features |= Feature::cfg_sanitize;
+    snippets.features |= Feature::allocator_api;
+    snippets.features |= Feature::cfg_sanitize;
 
     for top_level_item_id in ir.top_level_item_ids() {
-        let item: &Item = ir.find_untyped_decl(*top_level_item_id);
-        let generated = db.generate_item(item.clone())?;
-        items.extend(generated.main_api);
-        thunks.extend(generated.thunks);
-        assertions.extend(generated.assertions);
-        cc_details.extend(generated.cc_details);
-        features |= generated.features;
+        let item = ir.find_untyped_decl(*top_level_item_id);
+        snippets.append(db.generate_item(item.clone())?);
     }
 
+    let ApiSnippets { main_api, thunks, assertions, cc_details, features } = snippets;
+
+    let cc_details =
+        CppDetails::new(generate_rs_api_impl_includes(&db, crubit_support_path_format), cc_details);
+
     let mod_detail = if thunks.is_empty() {
         quote! {}
     } else {
@@ -396,7 +375,7 @@ pub fn generate_bindings_tokens(
             #![deny(warnings)] __NEWLINE__ __NEWLINE__
 
 
-            #( #items __NEWLINE__ __NEWLINE__ )*
+            #( #main_api __NEWLINE__ __NEWLINE__ )*
 
             #mod_detail __NEWLINE__ __NEWLINE__
 

rs_bindings_from_cc/test/golden/nested_types_rs_api.rs

@@ -273,19 +273,19 @@ mod detail {
 }
 
 const _: () = {
-    assert!(::core::mem::size_of::<crate::Foo>() == 4);
-    assert!(::core::mem::align_of::<crate::Foo>() == 4);
-    static_assertions::assert_impl_all!(crate::Foo: Copy,Clone);
-    static_assertions::assert_not_impl_any!(crate::Foo: Drop);
-    assert!(::core::mem::offset_of!(crate::Foo, foo) == 0);
-    assert!(::core::mem::size_of::<crate::foo::Bar>() == 4);
-    assert!(::core::mem::align_of::<crate::foo::Bar>() == 4);
-    static_assertions::assert_impl_all!(crate::foo::Bar: Copy,Clone);
-    static_assertions::assert_not_impl_any!(crate::foo::Bar: Drop);
-    assert!(::core::mem::offset_of!(crate::foo::Bar, bar) == 0);
     assert!(::core::mem::size_of::<crate::foo::bar::Baz>() == 4);
     assert!(::core::mem::align_of::<crate::foo::bar::Baz>() == 4);
     static_assertions::assert_impl_all!(crate::foo::bar::Baz: Copy,Clone);
     static_assertions::assert_not_impl_any!(crate::foo::bar::Baz: Drop);
     assert!(::core::mem::offset_of!(crate::foo::bar::Baz, baz) == 0);
+    assert!(::core::mem::size_of::<crate::foo::Bar>() == 4);
+    assert!(::core::mem::align_of::<crate::foo::Bar>() == 4);
+    static_assertions::assert_impl_all!(crate::foo::Bar: Copy,Clone);
+    static_assertions::assert_not_impl_any!(crate::foo::Bar: Drop);
+    assert!(::core::mem::offset_of!(crate::foo::Bar, bar) == 0);
+    assert!(::core::mem::size_of::<crate::Foo>() == 4);
+    assert!(::core::mem::align_of::<crate::Foo>() == 4);
+    static_assertions::assert_impl_all!(crate::Foo: Copy,Clone);
+    static_assertions::assert_not_impl_any!(crate::Foo: Drop);
+    assert!(::core::mem::offset_of!(crate::Foo, foo) == 0);
 };