Avoid `struct SomeClass` in `..._rs_api_impl.cc`.

After this CL, `..._rs_api_impl.cc` will reflect/preserve whether the
type was a `struct` or a `class`.  This helps avoid `-Wmismatched-tags`
warnings.

PiperOrigin-RevId: 460334053
diff --git a/rs_bindings_from_cc/importers/cxx_record.cc b/rs_bindings_from_cc/importers/cxx_record.cc
index 4ecad22..70e0d00 100644
--- a/rs_bindings_from_cc/importers/cxx_record.cc
+++ b/rs_bindings_from_cc/importers/cxx_record.cc
@@ -42,6 +42,31 @@
   }
 }
 
+absl::StatusOr<RecordType> TranslateRecordType(
+    const clang::RecordDecl& record_decl) {
+  switch (record_decl.getTagKind()) {
+    case clang::TTK_Struct:
+      return RecordType::kStruct;
+    case clang::TTK_Union:
+      return RecordType::kUnion;
+    case clang::TTK_Class:
+      return RecordType::kClass;
+    case clang::TTK_Enum:
+      CRUBIT_CHECK(false &&
+                   "clang::RecordDecl::getTagKind shouldn't return TTK_Enum");
+      return absl::InternalError(
+          "clang::RecordDecl::getTagKind shouldn't return TTK_Enum");
+    case clang::TTK_Interface:
+      // Some docs about `__interface` can be found here:
+      // https://docs.microsoft.com/en-us/cpp/cpp/interface?view=msvc-170
+      return absl::UnimplementedError(
+          "`__interface` / clang::TTK_Interface is not supported");
+  }
+
+  CRUBIT_CHECK(false && "Unrecognized clang::TagKind");
+  return absl::InternalError("Unrecognized clang::TagKind");
+}
+
 }  // namespace
 
 std::optional<IR::Item> CXXRecordDeclImporter::Import(
@@ -78,6 +103,12 @@
     return std::nullopt;
   }
 
+  absl::StatusOr<RecordType> record_type = TranslateRecordType(*record_decl);
+  if (!record_type.ok()) {
+    return ictx_.ImportUnsupportedItem(
+        record_decl, std::string(record_type.status().message()));
+  }
+
   std::string rs_name, cc_name;
   llvm::Optional<std::string> doc_comment;
   bool is_implicit_class_template_specialization_decl = false;
@@ -161,7 +192,7 @@
       .is_trivial_abi = record_decl->canPassInRegisters(),
       .is_inheritable =
           !record_decl->isEffectivelyFinal() && !record_decl->isUnion(),
-      .is_union = record_decl->isUnion(),
+      .record_type = *record_type,
       .is_aggregate = record_decl->isAggregate(),
       .child_item_ids = std::move(item_ids),
       // We generate top level bindings for implicit class template
diff --git a/rs_bindings_from_cc/ir.cc b/rs_bindings_from_cc/ir.cc
index bc8544d..f09ec43 100644
--- a/rs_bindings_from_cc/ir.cc
+++ b/rs_bindings_from_cc/ir.cc
@@ -359,6 +359,21 @@
   };
 }
 
+static std::string RecordTypeToString(RecordType record_type) {
+  switch (record_type) {
+    case kStruct:
+      return "Struct";
+    case kUnion:
+      return "Union";
+    case kClass:
+      return "Class";
+  }
+}
+
+std::ostream& operator<<(std::ostream& o, const RecordType& record_type) {
+  return o << RecordTypeToString(record_type);
+}
+
 llvm::json::Value IncompleteRecord::ToJson() const {
   llvm::json::Object record{
       {"cc_name", cc_name},
@@ -397,7 +412,7 @@
       {"destructor", destructor},
       {"is_trivial_abi", is_trivial_abi},
       {"is_inheritable", is_inheritable},
-      {"is_union", is_union},
+      {"record_type", RecordTypeToString(record_type)},
       {"is_aggregate", is_aggregate},
       {"child_item_ids", std::move(json_item_ids)},
       {"enclosing_namespace_id", enclosing_namespace_id},
diff --git a/rs_bindings_from_cc/ir.h b/rs_bindings_from_cc/ir.h
index 777166a..5876125 100644
--- a/rs_bindings_from_cc/ir.h
+++ b/rs_bindings_from_cc/ir.h
@@ -539,6 +539,21 @@
   llvm::Optional<int64_t> offset;
 };
 
+enum RecordType {
+  // `struct` in Rust and C++
+  kStruct,
+
+  // `union` in Rust and C++
+  kUnion,
+
+  // `class` in C++.  This is distinct from `kStruct` to avoid generating
+  // `struct SomeClass` in `..._rs_api_impl.cc` and getting `-Wmismatched-tags`
+  // warnings (see also b/238212337).
+  kClass,
+};
+
+std::ostream& operator<<(std::ostream& o, const RecordType& record_type);
+
 // A record (struct, class, union).
 struct Record {
   llvm::json::Value ToJson() const;
@@ -595,8 +610,8 @@
   // * The type is a C++ union, which does not support inheritance
   bool is_inheritable = false;
 
-  // Whether this type is a C++ union (rather than a struct)
-  bool is_union = false;
+  // Whether this `Record` corresponds to a C++ `union`, `struct`, or `class`.
+  RecordType record_type;
 
   // Whether this type can be initialized using aggregate initialization syntax.
   //
diff --git a/rs_bindings_from_cc/ir.rs b/rs_bindings_from_cc/ir.rs
index 2e4ddbe..a2e83d5 100644
--- a/rs_bindings_from_cc/ir.rs
+++ b/rs_bindings_from_cc/ir.rs
@@ -382,6 +382,13 @@
     pub enclosing_namespace_id: Option<ItemId>,
 }
 
+#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone, Deserialize)]
+pub enum RecordType {
+    Struct,
+    Union,
+    Class,
+}
+
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Deserialize)]
 pub struct Record {
     pub rs_name: String,
@@ -401,7 +408,7 @@
     pub destructor: SpecialMemberFunc,
     pub is_trivial_abi: bool,
     pub is_inheritable: bool,
-    pub is_union: bool,
+    pub record_type: RecordType,
     pub is_aggregate: bool,
     pub child_item_ids: Vec<ItemId>,
     pub enclosing_namespace_id: Option<ItemId>,
@@ -440,6 +447,13 @@
     pub fn is_unpin(&self) -> bool {
         self.is_trivial_abi && !self.is_inheritable
     }
+
+    pub fn is_union(&self) -> bool {
+        match self.record_type {
+            RecordType::Union => true,
+            RecordType::Struct | RecordType::Class => false,
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Deserialize)]
diff --git a/rs_bindings_from_cc/ir_from_cc_test.rs b/rs_bindings_from_cc/ir_from_cc_test.rs
index 6b1253c..896c3c3 100644
--- a/rs_bindings_from_cc/ir_from_cc_test.rs
+++ b/rs_bindings_from_cc/ir_from_cc_test.rs
@@ -2302,7 +2302,24 @@
                 ], ...
                 size: 8, ...
                 alignment: 4, ...
-                is_union: false, ...
+                record_type: Struct, ...
+            }
+        }
+    );
+}
+
+#[test]
+fn test_class() {
+    // This test verifies that `record_type` correectly captures whether the C++
+    // RecordDecl was for a `struct` VS for a `class`.
+    let ir = ir_from_cc("class SomeClass { int field; };").unwrap();
+    assert_ir_matches!(
+        ir,
+        quote! {
+            Record {
+                rs_name: "SomeClass" ...
+                cc_name: "SomeClass" ...
+                record_type: Class, ...
             }
         }
     );
@@ -2347,7 +2364,7 @@
                 ], ...
                 size: 4, ...
                 alignment: 4, ...
-                is_union: true, ...
+                record_type: Union, ...
             }
         }
     );
diff --git a/rs_bindings_from_cc/src_code_gen.rs b/rs_bindings_from_cc/src_code_gen.rs
index 110a6fe..bc7ce9f 100644
--- a/rs_bindings_from_cc/src_code_gen.rs
+++ b/rs_bindings_from_cc/src_code_gen.rs
@@ -1100,13 +1100,7 @@
                     // Regular field
                     Ok(_rs_type) => Some(field.offset + field.size),
                     // Opaque field
-                    Err(_error) => {
-                        if record.is_union {
-                            Some(field.size)
-                        } else {
-                            None
-                        }
-                    }
+                    Err(_error) => if record.is_union() { Some(field.size) } else { None },
                 },
                 vec![format!(
                     "{} : {} bits",
@@ -1142,7 +1136,7 @@
 
             if let Some((Some(prev_field), _, Some(prev_end), _)) = prev {
                 assert!(
-                    record.is_union || prev_end <= offset,
+                    record.is_union() || prev_end <= offset,
                     "Unexpected offset+size for field {:?} in record {}",
                     prev_field,
                     record.cc_name
@@ -1163,7 +1157,7 @@
             // its original type).
             //
             // We also don't need padding if we're in a union.
-            let padding_size_in_bits = if record.is_union
+            let padding_size_in_bits = if record.is_union()
                 || (field.is_some() && get_field_rs_type_for_layout(field.unwrap()).is_ok())
             {
                 0
@@ -1223,7 +1217,7 @@
                         )
                     })?;
                     let mut formatted = quote! {#type_kind};
-                    if should_implement_drop(record) || record.is_union {
+                    if should_implement_drop(record) || record.is_union() {
                         if needs_manually_drop(db, rs_type.clone())? {
                             // TODO(b/212690698): Avoid (somewhat unergonomic) ManuallyDrop
                             // if we can ask Rust to preserve field destruction order if the
@@ -1248,7 +1242,7 @@
 
     let size = Literal::usize_unsuffixed(record.size);
     let alignment = Literal::usize_unsuffixed(record.alignment);
-    let field_offset_assertions = if record.is_union {
+    let field_offset_assertions = if record.is_union() {
         // TODO(https://github.com/Gilnaa/memoffset/issues/66): generate assertions for unions once
         // offsetof supports them.
         vec![]
@@ -1296,7 +1290,7 @@
     } else {
         quote! {#[derive( #(#derives),* )]}
     };
-    let record_kind = if record.is_union {
+    let record_kind = if record.is_union() {
         quote! { union }
     } else {
         quote! { struct }
@@ -1343,7 +1337,7 @@
     // type must be an *aggregate* type.
     //
     // TODO(b/232969667): Protect unions from direct initialization, too.
-    let allow_direct_init = record.is_aggregate || record.is_union;
+    let allow_direct_init = record.is_aggregate || record.is_union();
     let head_padding = if head_padding > 0 || !allow_direct_init {
         let n = proc_macro2::Literal::usize_unsuffixed(head_padding);
         quote! {
@@ -1459,7 +1453,7 @@
 }
 
 fn should_derive_clone(record: &Record) -> bool {
-    if record.is_union {
+    if record.is_union() {
         // `union`s (unlike `struct`s) should only derive `Clone` if they are `Copy`.
         should_derive_copy(record)
     } else {
@@ -2304,7 +2298,7 @@
         Item::Record(record) => {
             let ident = format_cc_ident(&record.cc_name);
             let namespace_qualifier = generate_namespace_qualifier(record.id, ir)?;
-            let tag_kind = tag_kind(record);
+            let tag_kind = cc_tag_kind(record);
             quote! { #tag_kind #(#namespace_qualifier::)*  #ident }
         }
         Item::TypeAlias(type_alias) => {
@@ -2316,11 +2310,11 @@
     })
 }
 
-fn tag_kind(record: &ir::Record) -> TokenStream {
-    if record.is_union {
-        quote! { union }
-    } else {
-        quote! { class }
+fn cc_tag_kind(record: &ir::Record) -> TokenStream {
+    match record.record_type {
+        RecordType::Struct => quote! { struct },
+        RecordType::Union => quote! { union },
+        RecordType::Class => quote! { class },
     }
 }
 
@@ -2415,7 +2409,7 @@
     let namespace_qualifier = quote! { #(#namespace_qualifier::)* };
     let size = Literal::usize_unsuffixed(record.size);
     let alignment = Literal::usize_unsuffixed(record.alignment);
-    let tag_kind = tag_kind(record);
+    let tag_kind = cc_tag_kind(record);
     let field_assertions = record
         .fields
         .iter()
@@ -2849,7 +2843,7 @@
         assert_cc_matches!(
             rs_api_impl,
             quote! {
-                extern "C" class ReturnStruct __rust_thunk___Z11DoSomething11ParamStruct(class ParamStruct param) {
+                extern "C" struct ReturnStruct __rust_thunk___Z11DoSomething11ParamStruct(struct ParamStruct param) {
                     return DoSomething(std::forward<decltype(param)>(param));
                 }
             }
@@ -2918,7 +2912,7 @@
             quote! {
                 extern "C"
                 int __rust_thunk___ZN10MyTemplateIiE8GetValueEv__2f_2ftest_3atesting_5ftarget(
-                        class MyTemplate<int>* __this) {
+                        struct MyTemplate<int>* __this) {
                     return __this->GetValue();
                 }
             }
@@ -3028,7 +3022,7 @@
         assert_cc_matches!(
             rs_api_impl,
             quote! {
-                extern "C" void __rust_thunk___ZN10SomeStructD1Ev(class SomeStruct * __this) {
+                extern "C" void __rust_thunk___ZN10SomeStructD1Ev(struct SomeStruct * __this) {
                     std :: destroy_at (std::forward<decltype(__this)>(__this)) ;
                 }
             }
@@ -3036,22 +3030,43 @@
         assert_cc_matches!(
             rs_api_impl,
             quote! {
-                static_assert(sizeof(class SomeStruct) == 12);
-                static_assert(alignof(class SomeStruct) == 4);
-                static_assert(CRUBIT_OFFSET_OF(public_int, class SomeStruct) == 0);
+                static_assert(sizeof(struct SomeStruct) == 12);
+                static_assert(alignof(struct SomeStruct) == 4);
+                static_assert(CRUBIT_OFFSET_OF(public_int, struct SomeStruct) == 0);
             }
         );
         Ok(())
     }
 
     #[test]
+    fn test_struct_vs_class() -> Result<()> {
+        let ir = ir_from_cc(&tokens_to_string(quote! {
+            struct SomeStruct final { int field; };
+            class SomeClass final { int field; };
+        })?)?;
+        let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens(ir)?;
+
+        // A Rust `struct` is generated for both `SomeStruct` and `SomeClass`.
+        assert_rs_matches!(rs_api, quote! { pub struct SomeStruct },);
+        assert_rs_matches!(rs_api, quote! { pub struct SomeClass },);
+
+        // But in C++ we still should refer to `struct SomeStruct` and `class
+        // SomeClass`. See also b/238212337.
+        assert_cc_matches!(rs_api_impl, quote! { struct SomeStruct * __this });
+        assert_cc_matches!(rs_api_impl, quote! { class SomeClass * __this });
+        assert_cc_matches!(rs_api_impl, quote! { static_assert(sizeof(struct SomeStruct) == 4); });
+        assert_cc_matches!(rs_api_impl, quote! { static_assert(sizeof(class SomeClass) == 4); });
+        Ok(())
+    }
+
+    #[test]
     fn test_ref_to_struct_in_thunk_impls() -> Result<()> {
-        let ir = ir_from_cc("struct S{}; inline void foo(class S& s) {} ")?;
+        let ir = ir_from_cc("struct S{}; inline void foo(S& s) {} ")?;
         let rs_api_impl = generate_bindings_tokens(ir)?.rs_api_impl;
         assert_cc_matches!(
             rs_api_impl,
             quote! {
-                extern "C" void __rust_thunk___Z3fooR1S(class S& s) {
+                extern "C" void __rust_thunk___Z3fooR1S(struct S& s) {
                     foo(std::forward<decltype(s)>(s));
                 }
             }
@@ -3061,12 +3076,12 @@
 
     #[test]
     fn test_const_ref_to_struct_in_thunk_impls() -> Result<()> {
-        let ir = ir_from_cc("struct S{}; inline void foo(const class S& s) {} ")?;
+        let ir = ir_from_cc("struct S{}; inline void foo(const S& s) {} ")?;
         let rs_api_impl = generate_bindings_tokens(ir)?.rs_api_impl;
         assert_cc_matches!(
             rs_api_impl,
             quote! {
-                extern "C" void __rust_thunk___Z3fooRK1S(const class S& s) {
+                extern "C" void __rust_thunk___Z3fooRK1S(const struct S& s) {
                     foo(std::forward<decltype(s)>(s));
                 }
             }
@@ -3120,7 +3135,7 @@
             generate_bindings_tokens(ir)?.rs_api_impl,
             quote! {
                 extern "C" int __rust_thunk___ZNK10SomeStruct9some_funcEi(
-                        const class SomeStruct* __this, int arg) {
+                        const struct SomeStruct* __this, int arg) {
                     return __this->some_func(std::forward<decltype(arg)>(arg));
                 }
             }
@@ -4638,7 +4653,7 @@
         assert_cc_matches!(
             generate_bindings_tokens(ir)?.rs_api_impl,
             quote! {
-                extern "C" void __rust_thunk___ZN11Polymorphic3FooEv(class Polymorphic * __this)
+                extern "C" void __rust_thunk___ZN11Polymorphic3FooEv(struct Polymorphic * __this)
             }
         );
         Ok(())
@@ -4857,7 +4872,7 @@
             rs_api_impl,
             quote! {
                 extern "C" void __rust_thunk___ZN20DefaultedConstructorC1Ev(
-                        class DefaultedConstructor* __this) {
+                        struct DefaultedConstructor* __this) {
                     crubit::construct_at (std::forward<decltype(__this)>(__this)) ;
                 }
             }
@@ -5048,7 +5063,7 @@
             rs_api_impl,
             quote! {
                 extern "C" bool __rust_thunk___ZNK10SomeStructeqERKS_(
-                        const class SomeStruct* __this, const class SomeStruct& other) {
+                        const struct SomeStruct* __this, const struct SomeStruct& other) {
                     return __this->operator==(std::forward<decltype(other)>(other));
                 }
             }
@@ -5603,7 +5618,7 @@
         let rs_api_impl = generate_bindings_tokens(ir)?.rs_api_impl;
         assert_cc_matches!(
             rs_api_impl,
-            quote! { static_assert(CRUBIT_OFFSET_OF(dyn, class type) ... ) }
+            quote! { static_assert(CRUBIT_OFFSET_OF(dyn, struct type) ... ) }
         );
         Ok(())
     }
@@ -5993,10 +6008,10 @@
                 }
                 ...
                 extern "C" void __rust_thunk___ZN23test_namespace_bindings1SC1Ev(
-                    class test_namespace_bindings::S* __this) {...}
+                    struct test_namespace_bindings::S* __this) {...}
                 ...
                 extern "C" void __rust_thunk___Z4useSN23test_namespace_bindings1SE(
-                    class test_namespace_bindings::S s) { useS(std::forward<decltype(s)>(s)); }
+                    struct test_namespace_bindings::S s) { useS(std::forward<decltype(s)>(s)); }
                 ...
             }
         );
@@ -6105,12 +6120,12 @@
             &bindings.rs_api_impl,
             quote! {
                 ...
-                extern "C" void #my_struct_bool_constructor(class MyStruct<bool>*__this) {...} ...
-                extern "C" void #my_struct_double_constructor(class MyStruct<double>*__this) {...} ...
-                extern "C" void #my_struct_int_constructor(class MyStruct<int>*__this) {...} ...
-                extern "C" bool #my_struct_bool_method(class MyStruct<bool>*__this) {...} ...
-                extern "C" double #my_struct_double_method(class MyStruct<double>*__this) {...} ...
-                extern "C" int #my_struct_int_method(class MyStruct<int>*__this) {...} ...
+                extern "C" void #my_struct_bool_constructor(struct MyStruct<bool>*__this) {...} ...
+                extern "C" void #my_struct_double_constructor(struct MyStruct<double>*__this) {...} ...
+                extern "C" void #my_struct_int_constructor(struct MyStruct<int>*__this) {...} ...
+                extern "C" bool #my_struct_bool_method(struct MyStruct<bool>*__this) {...} ...
+                extern "C" double #my_struct_double_method(struct MyStruct<double>*__this) {...} ...
+                extern "C" int #my_struct_int_method(struct MyStruct<int>*__this) {...} ...
             }
         );
         Ok(())
diff --git a/rs_bindings_from_cc/test/golden/bitfields_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/bitfields_rs_api_impl.cc
index 54cb42a..ffdfdd7 100644
--- a/rs_bindings_from_cc/test/golden/bitfields_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/bitfields_rs_api_impl.cc
@@ -12,36 +12,36 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
 extern "C" void __rust_thunk___ZN13WithBitfieldsC1Ev(
-    class WithBitfields* __this) {
+    struct WithBitfields* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN13WithBitfieldsC1ERKS_(
-    class WithBitfields* __this, const class WithBitfields& __param_0) {
+    struct WithBitfields* __this, const struct WithBitfields& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN13WithBitfieldsC1EOS_(
-    class WithBitfields* __this, class WithBitfields&& __param_0) {
+    struct WithBitfields* __this, struct WithBitfields&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN13WithBitfieldsD1Ev(
-    class WithBitfields* __this) {
+    struct WithBitfields* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class WithBitfields& __rust_thunk___ZN13WithBitfieldsaSERKS_(
-    class WithBitfields* __this, const class WithBitfields& __param_0) {
+extern "C" struct WithBitfields& __rust_thunk___ZN13WithBitfieldsaSERKS_(
+    struct WithBitfields* __this, const struct WithBitfields& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class WithBitfields& __rust_thunk___ZN13WithBitfieldsaSEOS_(
-    class WithBitfields* __this, class WithBitfields&& __param_0) {
+extern "C" struct WithBitfields& __rust_thunk___ZN13WithBitfieldsaSEOS_(
+    struct WithBitfields* __this, struct WithBitfields&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class WithBitfields) == 32);
-static_assert(alignof(class WithBitfields) == 4);
-static_assert(CRUBIT_OFFSET_OF(f2, class WithBitfields) == 4);
-static_assert(CRUBIT_OFFSET_OF(f5, class WithBitfields) == 20);
-static_assert(CRUBIT_OFFSET_OF(f7, class WithBitfields) == 27);
+static_assert(sizeof(struct WithBitfields) == 32);
+static_assert(alignof(struct WithBitfields) == 4);
+static_assert(CRUBIT_OFFSET_OF(f2, struct WithBitfields) == 4);
+static_assert(CRUBIT_OFFSET_OF(f5, struct WithBitfields) == 20);
+static_assert(CRUBIT_OFFSET_OF(f7, struct WithBitfields) == 27);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/clang_attrs_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/clang_attrs_rs_api_impl.cc
index a32fbb8..1af5a08 100644
--- a/rs_bindings_from_cc/test/golden/clang_attrs_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/clang_attrs_rs_api_impl.cc
@@ -12,143 +12,143 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
 extern "C" void __rust_thunk___ZN18HasCustomAlignmentC1Ev(
-    class HasCustomAlignment* __this) {
+    struct HasCustomAlignment* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN18HasCustomAlignmentC1ERKS_(
-    class HasCustomAlignment* __this,
-    const class HasCustomAlignment& __param_0) {
+    struct HasCustomAlignment* __this,
+    const struct HasCustomAlignment& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN18HasCustomAlignmentC1EOS_(
-    class HasCustomAlignment* __this, class HasCustomAlignment&& __param_0) {
+    struct HasCustomAlignment* __this, struct HasCustomAlignment&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN18HasCustomAlignmentD1Ev(
-    class HasCustomAlignment* __this) {
+    struct HasCustomAlignment* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class HasCustomAlignment&
+extern "C" struct HasCustomAlignment&
 __rust_thunk___ZN18HasCustomAlignmentaSERKS_(
-    class HasCustomAlignment* __this,
-    const class HasCustomAlignment& __param_0) {
+    struct HasCustomAlignment* __this,
+    const struct HasCustomAlignment& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class HasCustomAlignment&
+extern "C" struct HasCustomAlignment&
 __rust_thunk___ZN18HasCustomAlignmentaSEOS_(
-    class HasCustomAlignment* __this, class HasCustomAlignment&& __param_0) {
+    struct HasCustomAlignment* __this, struct HasCustomAlignment&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN27HasFieldWithCustomAlignmentC1Ev(
-    class HasFieldWithCustomAlignment* __this) {
+    struct HasFieldWithCustomAlignment* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN27HasFieldWithCustomAlignmentC1ERKS_(
-    class HasFieldWithCustomAlignment* __this,
-    const class HasFieldWithCustomAlignment& __param_0) {
+    struct HasFieldWithCustomAlignment* __this,
+    const struct HasFieldWithCustomAlignment& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN27HasFieldWithCustomAlignmentC1EOS_(
-    class HasFieldWithCustomAlignment* __this,
-    class HasFieldWithCustomAlignment&& __param_0) {
+    struct HasFieldWithCustomAlignment* __this,
+    struct HasFieldWithCustomAlignment&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN27HasFieldWithCustomAlignmentD1Ev(
-    class HasFieldWithCustomAlignment* __this) {
+    struct HasFieldWithCustomAlignment* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class HasFieldWithCustomAlignment&
+extern "C" struct HasFieldWithCustomAlignment&
 __rust_thunk___ZN27HasFieldWithCustomAlignmentaSERKS_(
-    class HasFieldWithCustomAlignment* __this,
-    const class HasFieldWithCustomAlignment& __param_0) {
+    struct HasFieldWithCustomAlignment* __this,
+    const struct HasFieldWithCustomAlignment& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class HasFieldWithCustomAlignment&
+extern "C" struct HasFieldWithCustomAlignment&
 __rust_thunk___ZN27HasFieldWithCustomAlignmentaSEOS_(
-    class HasFieldWithCustomAlignment* __this,
-    class HasFieldWithCustomAlignment&& __param_0) {
+    struct HasFieldWithCustomAlignment* __this,
+    struct HasFieldWithCustomAlignment&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN35InheritsFromBaseWithCustomAlignmentC1Ev(
-    class InheritsFromBaseWithCustomAlignment* __this) {
+    struct InheritsFromBaseWithCustomAlignment* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN35InheritsFromBaseWithCustomAlignmentC1ERKS_(
-    class InheritsFromBaseWithCustomAlignment* __this,
-    const class InheritsFromBaseWithCustomAlignment& __param_0) {
+    struct InheritsFromBaseWithCustomAlignment* __this,
+    const struct InheritsFromBaseWithCustomAlignment& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN35InheritsFromBaseWithCustomAlignmentC1EOS_(
-    class InheritsFromBaseWithCustomAlignment* __this,
-    class InheritsFromBaseWithCustomAlignment&& __param_0) {
+    struct InheritsFromBaseWithCustomAlignment* __this,
+    struct InheritsFromBaseWithCustomAlignment&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN35InheritsFromBaseWithCustomAlignmentD1Ev(
-    class InheritsFromBaseWithCustomAlignment* __this) {
+    struct InheritsFromBaseWithCustomAlignment* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class InheritsFromBaseWithCustomAlignment&
+extern "C" struct InheritsFromBaseWithCustomAlignment&
 __rust_thunk___ZN35InheritsFromBaseWithCustomAlignmentaSERKS_(
-    class InheritsFromBaseWithCustomAlignment* __this,
-    const class InheritsFromBaseWithCustomAlignment& __param_0) {
+    struct InheritsFromBaseWithCustomAlignment* __this,
+    const struct InheritsFromBaseWithCustomAlignment& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class InheritsFromBaseWithCustomAlignment&
+extern "C" struct InheritsFromBaseWithCustomAlignment&
 __rust_thunk___ZN35InheritsFromBaseWithCustomAlignmentaSEOS_(
-    class InheritsFromBaseWithCustomAlignment* __this,
-    class InheritsFromBaseWithCustomAlignment&& __param_0) {
+    struct InheritsFromBaseWithCustomAlignment* __this,
+    struct InheritsFromBaseWithCustomAlignment&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN29HasCustomAlignmentWithGnuAttrC1Ev(
-    class HasCustomAlignmentWithGnuAttr* __this) {
+    struct HasCustomAlignmentWithGnuAttr* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN29HasCustomAlignmentWithGnuAttrC1ERKS_(
-    class HasCustomAlignmentWithGnuAttr* __this,
-    const class HasCustomAlignmentWithGnuAttr& __param_0) {
+    struct HasCustomAlignmentWithGnuAttr* __this,
+    const struct HasCustomAlignmentWithGnuAttr& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN29HasCustomAlignmentWithGnuAttrC1EOS_(
-    class HasCustomAlignmentWithGnuAttr* __this,
-    class HasCustomAlignmentWithGnuAttr&& __param_0) {
+    struct HasCustomAlignmentWithGnuAttr* __this,
+    struct HasCustomAlignmentWithGnuAttr&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN29HasCustomAlignmentWithGnuAttrD1Ev(
-    class HasCustomAlignmentWithGnuAttr* __this) {
+    struct HasCustomAlignmentWithGnuAttr* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class HasCustomAlignmentWithGnuAttr&
+extern "C" struct HasCustomAlignmentWithGnuAttr&
 __rust_thunk___ZN29HasCustomAlignmentWithGnuAttraSERKS_(
-    class HasCustomAlignmentWithGnuAttr* __this,
-    const class HasCustomAlignmentWithGnuAttr& __param_0) {
+    struct HasCustomAlignmentWithGnuAttr* __this,
+    const struct HasCustomAlignmentWithGnuAttr& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class HasCustomAlignmentWithGnuAttr&
+extern "C" struct HasCustomAlignmentWithGnuAttr&
 __rust_thunk___ZN29HasCustomAlignmentWithGnuAttraSEOS_(
-    class HasCustomAlignmentWithGnuAttr* __this,
-    class HasCustomAlignmentWithGnuAttr&& __param_0) {
+    struct HasCustomAlignmentWithGnuAttr* __this,
+    struct HasCustomAlignmentWithGnuAttr&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class HasCustomAlignment) == 64);
-static_assert(alignof(class HasCustomAlignment) == 64);
+static_assert(sizeof(struct HasCustomAlignment) == 64);
+static_assert(alignof(struct HasCustomAlignment) == 64);
 
-static_assert(sizeof(class HasFieldWithCustomAlignment) == 64);
-static_assert(alignof(class HasFieldWithCustomAlignment) == 64);
-static_assert(CRUBIT_OFFSET_OF(field, class HasFieldWithCustomAlignment) == 0);
+static_assert(sizeof(struct HasFieldWithCustomAlignment) == 64);
+static_assert(alignof(struct HasFieldWithCustomAlignment) == 64);
+static_assert(CRUBIT_OFFSET_OF(field, struct HasFieldWithCustomAlignment) == 0);
 
-static_assert(sizeof(class InheritsFromBaseWithCustomAlignment) == 64);
-static_assert(alignof(class InheritsFromBaseWithCustomAlignment) == 64);
+static_assert(sizeof(struct InheritsFromBaseWithCustomAlignment) == 64);
+static_assert(alignof(struct InheritsFromBaseWithCustomAlignment) == 64);
 
-static_assert(sizeof(class HasCustomAlignmentWithGnuAttr) == 64);
-static_assert(alignof(class HasCustomAlignmentWithGnuAttr) == 64);
+static_assert(sizeof(struct HasCustomAlignmentWithGnuAttr) == 64);
+static_assert(alignof(struct HasCustomAlignmentWithGnuAttr) == 64);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/comment_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/comment_rs_api_impl.cc
index 7a00c5c..cba045b 100644
--- a/rs_bindings_from_cc/test/golden/comment_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/comment_rs_api_impl.cc
@@ -11,93 +11,93 @@
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
-extern "C" void __rust_thunk___ZN3FooC1Ev(class Foo* __this) {
+extern "C" void __rust_thunk___ZN3FooC1Ev(struct Foo* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" void __rust_thunk___ZN3FooC1ERKS_(class Foo* __this,
-                                             const class Foo& __param_0) {
+extern "C" void __rust_thunk___ZN3FooC1ERKS_(struct Foo* __this,
+                                             const struct Foo& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN3FooC1EOS_(class Foo* __this,
-                                            class Foo&& __param_0) {
+extern "C" void __rust_thunk___ZN3FooC1EOS_(struct Foo* __this,
+                                            struct Foo&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN3FooD1Ev(class Foo* __this) {
+extern "C" void __rust_thunk___ZN3FooD1Ev(struct Foo* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class Foo& __rust_thunk___ZN3FooaSERKS_(class Foo* __this,
-                                                   const class Foo& __param_0) {
+extern "C" struct Foo& __rust_thunk___ZN3FooaSERKS_(
+    struct Foo* __this, const struct Foo& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class Foo& __rust_thunk___ZN3FooaSEOS_(class Foo* __this,
-                                                  class Foo&& __param_0) {
+extern "C" struct Foo& __rust_thunk___ZN3FooaSEOS_(struct Foo* __this,
+                                                   struct Foo&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___Z3foov() { foo(); }
-extern "C" void __rust_thunk___ZN3BarC1Ev(class Bar* __this) {
+extern "C" void __rust_thunk___ZN3BarC1Ev(struct Bar* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" void __rust_thunk___ZN3BarC1ERKS_(class Bar* __this,
-                                             const class Bar& __param_0) {
+extern "C" void __rust_thunk___ZN3BarC1ERKS_(struct Bar* __this,
+                                             const struct Bar& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN3BarC1EOS_(class Bar* __this,
-                                            class Bar&& __param_0) {
+extern "C" void __rust_thunk___ZN3BarC1EOS_(struct Bar* __this,
+                                            struct Bar&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN3BarD1Ev(class Bar* __this) {
+extern "C" void __rust_thunk___ZN3BarD1Ev(struct Bar* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class Bar& __rust_thunk___ZN3BaraSERKS_(class Bar* __this,
-                                                   const class Bar& __param_0) {
+extern "C" struct Bar& __rust_thunk___ZN3BaraSERKS_(
+    struct Bar* __this, const struct Bar& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class Bar& __rust_thunk___ZN3BaraSEOS_(class Bar* __this,
-                                                  class Bar&& __param_0) {
+extern "C" struct Bar& __rust_thunk___ZN3BaraSEOS_(struct Bar* __this,
+                                                   struct Bar&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN13HasNoCommentsC1Ev(
-    class HasNoComments* __this) {
+    struct HasNoComments* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN13HasNoCommentsC1ERKS_(
-    class HasNoComments* __this, const class HasNoComments& __param_0) {
+    struct HasNoComments* __this, const struct HasNoComments& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN13HasNoCommentsC1EOS_(
-    class HasNoComments* __this, class HasNoComments&& __param_0) {
+    struct HasNoComments* __this, struct HasNoComments&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN13HasNoCommentsD1Ev(
-    class HasNoComments* __this) {
+    struct HasNoComments* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class HasNoComments& __rust_thunk___ZN13HasNoCommentsaSERKS_(
-    class HasNoComments* __this, const class HasNoComments& __param_0) {
+extern "C" struct HasNoComments& __rust_thunk___ZN13HasNoCommentsaSERKS_(
+    struct HasNoComments* __this, const struct HasNoComments& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class HasNoComments& __rust_thunk___ZN13HasNoCommentsaSEOS_(
-    class HasNoComments* __this, class HasNoComments&& __param_0) {
+extern "C" struct HasNoComments& __rust_thunk___ZN13HasNoCommentsaSEOS_(
+    struct HasNoComments* __this, struct HasNoComments&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class Foo) == 8);
-static_assert(alignof(class Foo) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class Foo) == 0);
-static_assert(CRUBIT_OFFSET_OF(j, class Foo) == 4);
+static_assert(sizeof(struct Foo) == 8);
+static_assert(alignof(struct Foo) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct Foo) == 0);
+static_assert(CRUBIT_OFFSET_OF(j, struct Foo) == 4);
 
-static_assert(sizeof(class Bar) == 4);
-static_assert(alignof(class Bar) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class Bar) == 0);
+static_assert(sizeof(struct Bar) == 4);
+static_assert(alignof(struct Bar) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct Bar) == 0);
 
-static_assert(sizeof(class HasNoComments) == 4);
-static_assert(alignof(class HasNoComments) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class HasNoComments) == 0);
+static_assert(sizeof(struct HasNoComments) == 4);
+static_assert(alignof(struct HasNoComments) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct HasNoComments) == 0);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/doc_comment_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/doc_comment_rs_api_impl.cc
index 737378f..d85c430 100644
--- a/rs_bindings_from_cc/test/golden/doc_comment_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/doc_comment_rs_api_impl.cc
@@ -12,233 +12,238 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
 extern "C" void __rust_thunk___ZN17DocCommentSlashesC1ERKS_(
-    class DocCommentSlashes* __this, const class DocCommentSlashes& __param_0) {
+    struct DocCommentSlashes* __this,
+    const struct DocCommentSlashes& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN17DocCommentSlashesC1EOS_(
-    class DocCommentSlashes* __this, class DocCommentSlashes&& __param_0) {
+    struct DocCommentSlashes* __this, struct DocCommentSlashes&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN17DocCommentSlashesD1Ev(
-    class DocCommentSlashes* __this) {
+    struct DocCommentSlashes* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class DocCommentSlashes& __rust_thunk___ZN17DocCommentSlashesaSERKS_(
-    class DocCommentSlashes* __this, const class DocCommentSlashes& __param_0) {
+extern "C" struct DocCommentSlashes&
+__rust_thunk___ZN17DocCommentSlashesaSERKS_(
+    struct DocCommentSlashes* __this,
+    const struct DocCommentSlashes& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class DocCommentSlashes& __rust_thunk___ZN17DocCommentSlashesaSEOS_(
-    class DocCommentSlashes* __this, class DocCommentSlashes&& __param_0) {
+extern "C" struct DocCommentSlashes& __rust_thunk___ZN17DocCommentSlashesaSEOS_(
+    struct DocCommentSlashes* __this, struct DocCommentSlashes&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN14DocCommentBangC1Ev(
-    class DocCommentBang* __this) {
+    struct DocCommentBang* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN14DocCommentBangC1ERKS_(
-    class DocCommentBang* __this, const class DocCommentBang& __param_0) {
+    struct DocCommentBang* __this, const struct DocCommentBang& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN14DocCommentBangC1EOS_(
-    class DocCommentBang* __this, class DocCommentBang&& __param_0) {
+    struct DocCommentBang* __this, struct DocCommentBang&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN14DocCommentBangD1Ev(
-    class DocCommentBang* __this) {
+    struct DocCommentBang* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class DocCommentBang& __rust_thunk___ZN14DocCommentBangaSERKS_(
-    class DocCommentBang* __this, const class DocCommentBang& __param_0) {
+extern "C" struct DocCommentBang& __rust_thunk___ZN14DocCommentBangaSERKS_(
+    struct DocCommentBang* __this, const struct DocCommentBang& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class DocCommentBang& __rust_thunk___ZN14DocCommentBangaSEOS_(
-    class DocCommentBang* __this, class DocCommentBang&& __param_0) {
+extern "C" struct DocCommentBang& __rust_thunk___ZN14DocCommentBangaSEOS_(
+    struct DocCommentBang* __this, struct DocCommentBang&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN24MultilineCommentTwoStarsC1Ev(
-    class MultilineCommentTwoStars* __this) {
+    struct MultilineCommentTwoStars* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN24MultilineCommentTwoStarsC1ERKS_(
-    class MultilineCommentTwoStars* __this,
-    const class MultilineCommentTwoStars& __param_0) {
+    struct MultilineCommentTwoStars* __this,
+    const struct MultilineCommentTwoStars& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN24MultilineCommentTwoStarsC1EOS_(
-    class MultilineCommentTwoStars* __this,
-    class MultilineCommentTwoStars&& __param_0) {
+    struct MultilineCommentTwoStars* __this,
+    struct MultilineCommentTwoStars&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN24MultilineCommentTwoStarsD1Ev(
-    class MultilineCommentTwoStars* __this) {
+    struct MultilineCommentTwoStars* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class MultilineCommentTwoStars&
+extern "C" struct MultilineCommentTwoStars&
 __rust_thunk___ZN24MultilineCommentTwoStarsaSERKS_(
-    class MultilineCommentTwoStars* __this,
-    const class MultilineCommentTwoStars& __param_0) {
+    struct MultilineCommentTwoStars* __this,
+    const struct MultilineCommentTwoStars& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class MultilineCommentTwoStars&
+extern "C" struct MultilineCommentTwoStars&
 __rust_thunk___ZN24MultilineCommentTwoStarsaSEOS_(
-    class MultilineCommentTwoStars* __this,
-    class MultilineCommentTwoStars&& __param_0) {
+    struct MultilineCommentTwoStars* __this,
+    struct MultilineCommentTwoStars&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN11LineCommentC1Ev(class LineComment* __this) {
+extern "C" void __rust_thunk___ZN11LineCommentC1Ev(struct LineComment* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN11LineCommentC1ERKS_(
-    class LineComment* __this, const class LineComment& __param_0) {
+    struct LineComment* __this, const struct LineComment& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN11LineCommentC1EOS_(
-    class LineComment* __this, class LineComment&& __param_0) {
+    struct LineComment* __this, struct LineComment&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN11LineCommentD1Ev(class LineComment* __this) {
+extern "C" void __rust_thunk___ZN11LineCommentD1Ev(struct LineComment* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class LineComment& __rust_thunk___ZN11LineCommentaSERKS_(
-    class LineComment* __this, const class LineComment& __param_0) {
+extern "C" struct LineComment& __rust_thunk___ZN11LineCommentaSERKS_(
+    struct LineComment* __this, const struct LineComment& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class LineComment& __rust_thunk___ZN11LineCommentaSEOS_(
-    class LineComment* __this, class LineComment&& __param_0) {
+extern "C" struct LineComment& __rust_thunk___ZN11LineCommentaSEOS_(
+    struct LineComment* __this, struct LineComment&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN16MultilineOneStarC1Ev(
-    class MultilineOneStar* __this) {
+    struct MultilineOneStar* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN16MultilineOneStarC1ERKS_(
-    class MultilineOneStar* __this, const class MultilineOneStar& __param_0) {
+    struct MultilineOneStar* __this, const struct MultilineOneStar& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN16MultilineOneStarC1EOS_(
-    class MultilineOneStar* __this, class MultilineOneStar&& __param_0) {
+    struct MultilineOneStar* __this, struct MultilineOneStar&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN16MultilineOneStarD1Ev(
-    class MultilineOneStar* __this) {
+    struct MultilineOneStar* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class MultilineOneStar& __rust_thunk___ZN16MultilineOneStaraSERKS_(
-    class MultilineOneStar* __this, const class MultilineOneStar& __param_0) {
+extern "C" struct MultilineOneStar& __rust_thunk___ZN16MultilineOneStaraSERKS_(
+    struct MultilineOneStar* __this, const struct MultilineOneStar& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class MultilineOneStar& __rust_thunk___ZN16MultilineOneStaraSEOS_(
-    class MultilineOneStar* __this, class MultilineOneStar&& __param_0) {
+extern "C" struct MultilineOneStar& __rust_thunk___ZN16MultilineOneStaraSEOS_(
+    struct MultilineOneStar* __this, struct MultilineOneStar&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" int __rust_thunk___Z3foov() { return foo(); }
 extern "C" void
 __rust_thunk___ZN10MyTemplateIiEC1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<int>* __this) {
+    struct MyTemplate<int>* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN10MyTemplateIiEC1ERKS0___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<int>* __this, const class MyTemplate<int>& __param_0) {
+    struct MyTemplate<int>* __this, const struct MyTemplate<int>& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN10MyTemplateIiEC1EOS0___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<int>* __this, class MyTemplate<int>&& __param_0) {
+    struct MyTemplate<int>* __this, struct MyTemplate<int>&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN10MyTemplateIiED1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<int>* __this) {
+    struct MyTemplate<int>* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class MyTemplate<int>&
+extern "C" struct MyTemplate<int>&
 __rust_thunk___ZN10MyTemplateIiEaSERKS0___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<int>* __this, const class MyTemplate<int>& __param_0) {
+    struct MyTemplate<int>* __this, const struct MyTemplate<int>& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
-} extern "C" class MyTemplate<int>&
+} extern "C" struct MyTemplate<int>&
 __rust_thunk___ZN10MyTemplateIiEaSEOS0___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<int>* __this, class MyTemplate<int>&& __param_0) {
+    struct MyTemplate<int>* __this, struct MyTemplate<int>&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 } extern "C" int const&
 __rust_thunk___ZNK10MyTemplateIiE15get_field_valueEv__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    const class MyTemplate<int>* __this) {
+    const struct MyTemplate<int>* __this) {
   return __this->get_field_value();
 }
 extern "C" void
 __rust_thunk___ZN10MyTemplateIfEC1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<float>* __this) {
+    struct MyTemplate<float>* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN10MyTemplateIfEC1ERKS0___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<float>* __this, const class MyTemplate<float>& __param_0) {
+    struct MyTemplate<float>* __this,
+    const struct MyTemplate<float>& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN10MyTemplateIfEC1EOS0___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<float>* __this, class MyTemplate<float>&& __param_0) {
+    struct MyTemplate<float>* __this, struct MyTemplate<float>&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN10MyTemplateIfED1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<float>* __this) {
+    struct MyTemplate<float>* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class MyTemplate<float>&
+extern "C" struct MyTemplate<float>&
 __rust_thunk___ZN10MyTemplateIfEaSERKS0___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<float>* __this, const class MyTemplate<float>& __param_0) {
+    struct MyTemplate<float>* __this,
+    const struct MyTemplate<float>& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
-} extern "C" class MyTemplate<float>&
+} extern "C" struct MyTemplate<float>&
 __rust_thunk___ZN10MyTemplateIfEaSEOS0___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    class MyTemplate<float>* __this, class MyTemplate<float>&& __param_0) {
+    struct MyTemplate<float>* __this, struct MyTemplate<float>&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 } extern "C" float const&
 __rust_thunk___ZNK10MyTemplateIfE15get_field_valueEv__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3adoc_5fcomment_5fcc(
-    const class MyTemplate<float>* __this) {
+    const struct MyTemplate<float>* __this) {
   return __this->get_field_value();
 }
 
-static_assert(sizeof(class DocCommentSlashes) == 4);
-static_assert(alignof(class DocCommentSlashes) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class DocCommentSlashes) == 0);
+static_assert(sizeof(struct DocCommentSlashes) == 4);
+static_assert(alignof(struct DocCommentSlashes) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct DocCommentSlashes) == 0);
 
-static_assert(sizeof(class DocCommentBang) == 4);
-static_assert(alignof(class DocCommentBang) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class DocCommentBang) == 0);
+static_assert(sizeof(struct DocCommentBang) == 4);
+static_assert(alignof(struct DocCommentBang) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct DocCommentBang) == 0);
 
-static_assert(sizeof(class MultilineCommentTwoStars) == 4);
-static_assert(alignof(class MultilineCommentTwoStars) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class MultilineCommentTwoStars) == 0);
+static_assert(sizeof(struct MultilineCommentTwoStars) == 4);
+static_assert(alignof(struct MultilineCommentTwoStars) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct MultilineCommentTwoStars) == 0);
 
-static_assert(sizeof(class LineComment) == 4);
-static_assert(alignof(class LineComment) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class LineComment) == 0);
+static_assert(sizeof(struct LineComment) == 4);
+static_assert(alignof(struct LineComment) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct LineComment) == 0);
 
-static_assert(sizeof(class MultilineOneStar) == 4);
-static_assert(alignof(class MultilineOneStar) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class MultilineOneStar) == 0);
+static_assert(sizeof(struct MultilineOneStar) == 4);
+static_assert(alignof(struct MultilineOneStar) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct MultilineOneStar) == 0);
 
-static_assert(sizeof(class MyTemplate<int>) == 4);
-static_assert(alignof(class MyTemplate<int>) == 4);
-static_assert(CRUBIT_OFFSET_OF(value, class MyTemplate<int>) == 0);
+static_assert(sizeof(struct MyTemplate<int>) == 4);
+static_assert(alignof(struct MyTemplate<int>) == 4);
+static_assert(CRUBIT_OFFSET_OF(value, struct MyTemplate<int>) == 0);
 
-static_assert(sizeof(class MyTemplate<float>) == 4);
-static_assert(alignof(class MyTemplate<float>) == 4);
-static_assert(CRUBIT_OFFSET_OF(value, class MyTemplate<float>) == 0);
+static_assert(sizeof(struct MyTemplate<float>) == 4);
+static_assert(alignof(struct MyTemplate<float>) == 4);
+static_assert(CRUBIT_OFFSET_OF(value, struct MyTemplate<float>) == 0);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/escaping_keywords_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/escaping_keywords_rs_api_impl.cc
index 3fb7c02..ece7671 100644
--- a/rs_bindings_from_cc/test/golden/escaping_keywords_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/escaping_keywords_rs_api_impl.cc
@@ -11,33 +11,33 @@
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
-extern "C" void __rust_thunk___ZN4typeC1Ev(class type* __this) {
+extern "C" void __rust_thunk___ZN4typeC1Ev(struct type* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" void __rust_thunk___ZN4typeC1ERKS_(class type* __this,
-                                              const class type& __param_0) {
+extern "C" void __rust_thunk___ZN4typeC1ERKS_(struct type* __this,
+                                              const struct type& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN4typeC1EOS_(class type* __this,
-                                             class type&& __param_0) {
+extern "C" void __rust_thunk___ZN4typeC1EOS_(struct type* __this,
+                                             struct type&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN4typeD1Ev(class type* __this) {
+extern "C" void __rust_thunk___ZN4typeD1Ev(struct type* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class type& __rust_thunk___ZN4typeaSERKS_(
-    class type* __this, const class type& __param_0) {
+extern "C" struct type& __rust_thunk___ZN4typeaSERKS_(
+    struct type* __this, const struct type& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class type& __rust_thunk___ZN4typeaSEOS_(class type* __this,
-                                                    class type&& __param_0) {
+extern "C" struct type& __rust_thunk___ZN4typeaSEOS_(struct type* __this,
+                                                     struct type&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class type) == 4);
-static_assert(alignof(class type) == 4);
-static_assert(CRUBIT_OFFSET_OF(dyn, class type) == 0);
+static_assert(sizeof(struct type) == 4);
+static_assert(alignof(struct type) == 4);
+static_assert(CRUBIT_OFFSET_OF(dyn, struct type) == 0);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/inheritance_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/inheritance_rs_api_impl.cc
index 4ea50a1..c2d5ac6 100644
--- a/rs_bindings_from_cc/test/golden/inheritance_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/inheritance_rs_api_impl.cc
@@ -83,28 +83,28 @@
                                                       class Base2&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN7DerivedC1Ev(class Derived* __this) {
+extern "C" void __rust_thunk___ZN7DerivedC1Ev(struct Derived* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN7DerivedC1ERKS_(
-    class Derived* __this, const class Derived& __param_0) {
+    struct Derived* __this, const struct Derived& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN7DerivedC1EOS_(class Derived* __this,
-                                                class Derived&& __param_0) {
+extern "C" void __rust_thunk___ZN7DerivedC1EOS_(struct Derived* __this,
+                                                struct Derived&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN7DerivedD1Ev(class Derived* __this) {
+extern "C" void __rust_thunk___ZN7DerivedD1Ev(struct Derived* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class Derived& __rust_thunk___ZN7DerivedaSERKS_(
-    class Derived* __this, const class Derived& __param_0) {
+extern "C" struct Derived& __rust_thunk___ZN7DerivedaSERKS_(
+    struct Derived* __this, const struct Derived& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class Derived& __rust_thunk___ZN7DerivedaSEOS_(
-    class Derived* __this, class Derived&& __param_0) {
+extern "C" struct Derived& __rust_thunk___ZN7DerivedaSEOS_(
+    struct Derived* __this, struct Derived&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN12VirtualBase1C1Ev(
@@ -195,9 +195,9 @@
 static_assert(sizeof(class Base2) == 2);
 static_assert(alignof(class Base2) == 2);
 
-static_assert(sizeof(class Derived) == 16);
-static_assert(alignof(class Derived) == 8);
-static_assert(CRUBIT_OFFSET_OF(derived_1, class Derived) == 12);
+static_assert(sizeof(struct Derived) == 16);
+static_assert(alignof(struct Derived) == 8);
+static_assert(CRUBIT_OFFSET_OF(derived_1, struct Derived) == 12);
 
 static_assert(sizeof(class VirtualBase1) == 24);
 static_assert(alignof(class VirtualBase1) == 8);
diff --git a/rs_bindings_from_cc/test/golden/item_order_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/item_order_rs_api_impl.cc
index 60ca78a..4b74490 100644
--- a/rs_bindings_from_cc/test/golden/item_order_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/item_order_rs_api_impl.cc
@@ -11,65 +11,65 @@
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
-extern "C" void __rust_thunk___ZN11FirstStructC1Ev(class FirstStruct* __this) {
+extern "C" void __rust_thunk___ZN11FirstStructC1Ev(struct FirstStruct* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN11FirstStructC1ERKS_(
-    class FirstStruct* __this, const class FirstStruct& __param_0) {
+    struct FirstStruct* __this, const struct FirstStruct& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN11FirstStructC1EOS_(
-    class FirstStruct* __this, class FirstStruct&& __param_0) {
+    struct FirstStruct* __this, struct FirstStruct&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN11FirstStructD1Ev(class FirstStruct* __this) {
+extern "C" void __rust_thunk___ZN11FirstStructD1Ev(struct FirstStruct* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class FirstStruct& __rust_thunk___ZN11FirstStructaSERKS_(
-    class FirstStruct* __this, const class FirstStruct& __param_0) {
+extern "C" struct FirstStruct& __rust_thunk___ZN11FirstStructaSERKS_(
+    struct FirstStruct* __this, const struct FirstStruct& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class FirstStruct& __rust_thunk___ZN11FirstStructaSEOS_(
-    class FirstStruct* __this, class FirstStruct&& __param_0) {
+extern "C" struct FirstStruct& __rust_thunk___ZN11FirstStructaSEOS_(
+    struct FirstStruct* __this, struct FirstStruct&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" int __rust_thunk___Z10first_funcv() { return first_func(); }
 extern "C" void __rust_thunk___ZN12SecondStructC1Ev(
-    class SecondStruct* __this) {
+    struct SecondStruct* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN12SecondStructC1ERKS_(
-    class SecondStruct* __this, const class SecondStruct& __param_0) {
+    struct SecondStruct* __this, const struct SecondStruct& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN12SecondStructC1EOS_(
-    class SecondStruct* __this, class SecondStruct&& __param_0) {
+    struct SecondStruct* __this, struct SecondStruct&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN12SecondStructD1Ev(
-    class SecondStruct* __this) {
+    struct SecondStruct* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class SecondStruct& __rust_thunk___ZN12SecondStructaSERKS_(
-    class SecondStruct* __this, const class SecondStruct& __param_0) {
+extern "C" struct SecondStruct& __rust_thunk___ZN12SecondStructaSERKS_(
+    struct SecondStruct* __this, const struct SecondStruct& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class SecondStruct& __rust_thunk___ZN12SecondStructaSEOS_(
-    class SecondStruct* __this, class SecondStruct&& __param_0) {
+extern "C" struct SecondStruct& __rust_thunk___ZN12SecondStructaSEOS_(
+    struct SecondStruct* __this, struct SecondStruct&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" int __rust_thunk___Z11second_funcv() { return second_func(); }
 
-static_assert(sizeof(class FirstStruct) == 4);
-static_assert(alignof(class FirstStruct) == 4);
-static_assert(CRUBIT_OFFSET_OF(field, class FirstStruct) == 0);
+static_assert(sizeof(struct FirstStruct) == 4);
+static_assert(alignof(struct FirstStruct) == 4);
+static_assert(CRUBIT_OFFSET_OF(field, struct FirstStruct) == 0);
 
-static_assert(sizeof(class SecondStruct) == 4);
-static_assert(alignof(class SecondStruct) == 4);
-static_assert(CRUBIT_OFFSET_OF(field, class SecondStruct) == 0);
+static_assert(sizeof(struct SecondStruct) == 4);
+static_assert(alignof(struct SecondStruct) == 4);
+static_assert(CRUBIT_OFFSET_OF(field, struct SecondStruct) == 0);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/namespace_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/namespace_rs_api_impl.cc
index 70dabe1..06bbcb9 100644
--- a/rs_bindings_from_cc/test/golden/namespace_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/namespace_rs_api_impl.cc
@@ -12,35 +12,35 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
 extern "C" void __rust_thunk___ZN23test_namespace_bindings1SC1Ev(
-    class test_namespace_bindings::S* __this) {
+    struct test_namespace_bindings::S* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings1SC1ERKS0_(
-    class test_namespace_bindings::S* __this,
-    const class test_namespace_bindings::S& __param_0) {
+    struct test_namespace_bindings::S* __this,
+    const struct test_namespace_bindings::S& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings1SC1EOS0_(
-    class test_namespace_bindings::S* __this,
-    class test_namespace_bindings::S&& __param_0) {
+    struct test_namespace_bindings::S* __this,
+    struct test_namespace_bindings::S&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings1SD1Ev(
-    class test_namespace_bindings::S* __this) {
+    struct test_namespace_bindings::S* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class test_namespace_bindings::S&
+extern "C" struct test_namespace_bindings::S&
 __rust_thunk___ZN23test_namespace_bindings1SaSERKS0_(
-    class test_namespace_bindings::S* __this,
-    const class test_namespace_bindings::S& __param_0) {
+    struct test_namespace_bindings::S* __this,
+    const struct test_namespace_bindings::S& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class test_namespace_bindings::S&
+extern "C" struct test_namespace_bindings::S&
 __rust_thunk___ZN23test_namespace_bindings1SaSEOS0_(
-    class test_namespace_bindings::S* __this,
-    class test_namespace_bindings::S&& __param_0) {
+    struct test_namespace_bindings::S* __this,
+    struct test_namespace_bindings::S&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
@@ -48,100 +48,96 @@
   test_namespace_bindings::inline_function();
 }
 extern "C" void __rust_thunk___ZN32test_namespace_bindings_reopened5inner1SC1Ev(
-    class test_namespace_bindings_reopened::inner::S* __this) {
+    struct test_namespace_bindings_reopened::inner::S* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN32test_namespace_bindings_reopened5inner1SC1ERKS1_(
-    class test_namespace_bindings_reopened::inner::S* __this,
-    const class test_namespace_bindings_reopened::inner::S& __param_0) {
+    struct test_namespace_bindings_reopened::inner::S* __this,
+    const struct test_namespace_bindings_reopened::inner::S& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN32test_namespace_bindings_reopened5inner1SC1EOS1_(
-    class test_namespace_bindings_reopened::inner::S* __this,
-    class test_namespace_bindings_reopened::inner::S&& __param_0) {
+    struct test_namespace_bindings_reopened::inner::S* __this,
+    struct test_namespace_bindings_reopened::inner::S&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN32test_namespace_bindings_reopened5inner1SD1Ev(
-    class test_namespace_bindings_reopened::inner::S* __this) {
+    struct test_namespace_bindings_reopened::inner::S* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class test_namespace_bindings_reopened::inner::S&
+extern "C" struct test_namespace_bindings_reopened::inner::S&
 __rust_thunk___ZN32test_namespace_bindings_reopened5inner1SaSERKS1_(
-    class test_namespace_bindings_reopened::inner::S* __this,
-    const class test_namespace_bindings_reopened::inner::S& __param_0) {
+    struct test_namespace_bindings_reopened::inner::S* __this,
+    const struct test_namespace_bindings_reopened::inner::S& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class test_namespace_bindings_reopened::inner::S&
+extern "C" struct test_namespace_bindings_reopened::inner::S&
 __rust_thunk___ZN32test_namespace_bindings_reopened5inner1SaSEOS1_(
-    class test_namespace_bindings_reopened::inner::S* __this,
-    class test_namespace_bindings_reopened::inner::S&& __param_0) {
+    struct test_namespace_bindings_reopened::inner::S* __this,
+    struct test_namespace_bindings_reopened::inner::S&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN30test_namespace_bindings_inline5inner23StructInInlineNamespaceC1Ev(
-    class test_namespace_bindings_inline::inner::StructInInlineNamespace*
+    struct test_namespace_bindings_inline::inner::StructInInlineNamespace*
         __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN30test_namespace_bindings_inline5inner23StructInInlineNamespaceC1ERKS1_(
-    class test_namespace_bindings_inline::inner::StructInInlineNamespace*
+    struct test_namespace_bindings_inline::inner::StructInInlineNamespace*
         __this,
-    const class test_namespace_bindings_inline::inner::StructInInlineNamespace&
+    const struct test_namespace_bindings_inline::inner::StructInInlineNamespace&
         __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN30test_namespace_bindings_inline5inner23StructInInlineNamespaceC1EOS1_(
-    class test_namespace_bindings_inline::inner::StructInInlineNamespace*
+    struct test_namespace_bindings_inline::inner::StructInInlineNamespace*
         __this,
-    class test_namespace_bindings_inline::inner::StructInInlineNamespace&&
+    struct test_namespace_bindings_inline::inner::StructInInlineNamespace&&
         __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN30test_namespace_bindings_inline5inner23StructInInlineNamespaceD1Ev(
-    class test_namespace_bindings_inline::inner::StructInInlineNamespace*
+    struct test_namespace_bindings_inline::inner::StructInInlineNamespace*
         __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class test_namespace_bindings_inline::inner::StructInInlineNamespace&
+extern "C" struct test_namespace_bindings_inline::inner::StructInInlineNamespace&
 __rust_thunk___ZN30test_namespace_bindings_inline5inner23StructInInlineNamespaceaSERKS1_(
-    class test_namespace_bindings_inline::inner::StructInInlineNamespace*
+    struct test_namespace_bindings_inline::inner::StructInInlineNamespace*
         __this,
-    const class test_namespace_bindings_inline::inner::StructInInlineNamespace&
+    const struct test_namespace_bindings_inline::inner::StructInInlineNamespace&
         __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class test_namespace_bindings_inline::inner::StructInInlineNamespace&
+extern "C" struct test_namespace_bindings_inline::inner::StructInInlineNamespace&
 __rust_thunk___ZN30test_namespace_bindings_inline5inner23StructInInlineNamespaceaSEOS1_(
-    class test_namespace_bindings_inline::inner::StructInInlineNamespace*
+    struct test_namespace_bindings_inline::inner::StructInInlineNamespace*
         __this,
-    class test_namespace_bindings_inline::inner::StructInInlineNamespace&&
+    struct test_namespace_bindings_inline::inner::StructInInlineNamespace&&
         __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class test_namespace_bindings::S) == 4);
-static_assert(alignof(class test_namespace_bindings::S) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class test_namespace_bindings::S) == 0);
+static_assert(sizeof(struct test_namespace_bindings::S) == 4);
+static_assert(alignof(struct test_namespace_bindings::S) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct test_namespace_bindings::S) == 0);
 
-static_assert(sizeof(class test_namespace_bindings_reopened::inner::S) == 1);
-static_assert(alignof(class test_namespace_bindings_reopened::inner::S) == 1);
+static_assert(sizeof(struct test_namespace_bindings_reopened::inner::S) == 1);
+static_assert(alignof(struct test_namespace_bindings_reopened::inner::S) == 1);
 
-static_assert(
-    sizeof(
-        class test_namespace_bindings_inline::inner::StructInInlineNamespace) ==
-    1);
-static_assert(
-    alignof(
-        class test_namespace_bindings_inline::inner::StructInInlineNamespace) ==
-    1);
+static_assert(sizeof(struct test_namespace_bindings_inline::inner::
+                         StructInInlineNamespace) == 1);
+static_assert(alignof(struct test_namespace_bindings_inline::inner::
+                          StructInInlineNamespace) == 1);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/no_elided_lifetimes_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/no_elided_lifetimes_rs_api_impl.cc
index 0242c6c..c4ecc27 100644
--- a/rs_bindings_from_cc/test/golden/no_elided_lifetimes_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/no_elided_lifetimes_rs_api_impl.cc
@@ -11,39 +11,40 @@
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
-extern "C" void __rust_thunk___ZN1SC1Ev(class S* __this) {
+extern "C" void __rust_thunk___ZN1SC1Ev(struct S* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" void __rust_thunk___ZN1SC1ERKS_(class S* __this,
-                                           const class S& __param_0) {
+extern "C" void __rust_thunk___ZN1SC1ERKS_(struct S* __this,
+                                           const struct S& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN1SD1Ev(class S* __this) {
+extern "C" void __rust_thunk___ZN1SD1Ev(struct S* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class S& __rust_thunk___ZN1SaSERKS_(class S* __this,
-                                               const class S& __param_0) {
+extern "C" struct S& __rust_thunk___ZN1SaSERKS_(struct S* __this,
+                                                const struct S& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class TriviallyCopyableButNontriviallyDestructible&
+extern "C" struct TriviallyCopyableButNontriviallyDestructible&
 __rust_thunk___ZN44TriviallyCopyableButNontriviallyDestructibleaSERKS_(
-    class TriviallyCopyableButNontriviallyDestructible* __this,
-    const class TriviallyCopyableButNontriviallyDestructible& __param_0) {
+    struct TriviallyCopyableButNontriviallyDestructible* __this,
+    const struct TriviallyCopyableButNontriviallyDestructible& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN44TriviallyCopyableButNontriviallyDestructibleC1ERKS_(
-    class TriviallyCopyableButNontriviallyDestructible* __this,
-    const class TriviallyCopyableButNontriviallyDestructible& __param_0) {
+    struct TriviallyCopyableButNontriviallyDestructible* __this,
+    const struct TriviallyCopyableButNontriviallyDestructible& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class S) == 1);
-static_assert(alignof(class S) == 1);
+static_assert(sizeof(struct S) == 1);
+static_assert(alignof(struct S) == 1);
 
-static_assert(sizeof(class TriviallyCopyableButNontriviallyDestructible) == 1);
-static_assert(alignof(class TriviallyCopyableButNontriviallyDestructible) == 1);
+static_assert(sizeof(struct TriviallyCopyableButNontriviallyDestructible) == 1);
+static_assert(alignof(struct TriviallyCopyableButNontriviallyDestructible) ==
+              1);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/no_unique_address_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/no_unique_address_rs_api_impl.cc
index 53e9fbe..8d2cb3e 100644
--- a/rs_bindings_from_cc/test/golden/no_unique_address_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/no_unique_address_rs_api_impl.cc
@@ -11,119 +11,119 @@
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
-extern "C" void __rust_thunk___ZN6StructC1Ev(class Struct* __this) {
+extern "C" void __rust_thunk___ZN6StructC1Ev(struct Struct* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" void __rust_thunk___ZN6StructC1ERKS_(class Struct* __this,
-                                                const class Struct& __param_0) {
+extern "C" void __rust_thunk___ZN6StructC1ERKS_(
+    struct Struct* __this, const struct Struct& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN6StructC1EOS_(class Struct* __this,
-                                               class Struct&& __param_0) {
+extern "C" void __rust_thunk___ZN6StructC1EOS_(struct Struct* __this,
+                                               struct Struct&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN6StructD1Ev(class Struct* __this) {
+extern "C" void __rust_thunk___ZN6StructD1Ev(struct Struct* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class Struct& __rust_thunk___ZN6StructaSERKS_(
-    class Struct* __this, const class Struct& __param_0) {
+extern "C" struct Struct& __rust_thunk___ZN6StructaSERKS_(
+    struct Struct* __this, const struct Struct& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class Struct& __rust_thunk___ZN6StructaSEOS_(
-    class Struct* __this, class Struct&& __param_0) {
+extern "C" struct Struct& __rust_thunk___ZN6StructaSEOS_(
+    struct Struct* __this, struct Struct&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class Struct __rust_thunk___ZN6Struct4MakeEic(int f1, char f2) {
+extern "C" struct Struct __rust_thunk___ZN6Struct4MakeEic(int f1, char f2) {
   return Struct::Make(std::forward<decltype(f1)>(f1),
                       std::forward<decltype(f2)>(f2));
 }
 extern "C" void __rust_thunk___ZN20PaddingBetweenFieldsC1Ev(
-    class PaddingBetweenFields* __this) {
+    struct PaddingBetweenFields* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN20PaddingBetweenFieldsC1ERKS_(
-    class PaddingBetweenFields* __this,
-    const class PaddingBetweenFields& __param_0) {
+    struct PaddingBetweenFields* __this,
+    const struct PaddingBetweenFields& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN20PaddingBetweenFieldsC1EOS_(
-    class PaddingBetweenFields* __this,
-    class PaddingBetweenFields&& __param_0) {
+    struct PaddingBetweenFields* __this,
+    struct PaddingBetweenFields&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN20PaddingBetweenFieldsD1Ev(
-    class PaddingBetweenFields* __this) {
+    struct PaddingBetweenFields* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class PaddingBetweenFields&
+extern "C" struct PaddingBetweenFields&
 __rust_thunk___ZN20PaddingBetweenFieldsaSERKS_(
-    class PaddingBetweenFields* __this,
-    const class PaddingBetweenFields& __param_0) {
+    struct PaddingBetweenFields* __this,
+    const struct PaddingBetweenFields& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class PaddingBetweenFields&
+extern "C" struct PaddingBetweenFields&
 __rust_thunk___ZN20PaddingBetweenFieldsaSEOS_(
-    class PaddingBetweenFields* __this,
-    class PaddingBetweenFields&& __param_0) {
+    struct PaddingBetweenFields* __this,
+    struct PaddingBetweenFields&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class PaddingBetweenFields
+extern "C" struct PaddingBetweenFields
 __rust_thunk___ZN20PaddingBetweenFields4MakeEci(char f1, int f2) {
   return PaddingBetweenFields::Make(std::forward<decltype(f1)>(f1),
                                     std::forward<decltype(f2)>(f2));
 }
 extern "C" void __rust_thunk___ZN30FieldInTailPadding_InnerStructC1Ev(
-    class FieldInTailPadding_InnerStruct* __this) {
+    struct FieldInTailPadding_InnerStruct* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN30FieldInTailPadding_InnerStructC1ERKS_(
-    class FieldInTailPadding_InnerStruct* __this,
-    const class FieldInTailPadding_InnerStruct& __param_0) {
+    struct FieldInTailPadding_InnerStruct* __this,
+    const struct FieldInTailPadding_InnerStruct& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class FieldInTailPadding_InnerStruct&
+extern "C" struct FieldInTailPadding_InnerStruct&
 __rust_thunk___ZN30FieldInTailPadding_InnerStructaSERKS_(
-    class FieldInTailPadding_InnerStruct* __this,
-    const class FieldInTailPadding_InnerStruct& __param_0) {
+    struct FieldInTailPadding_InnerStruct* __this,
+    const struct FieldInTailPadding_InnerStruct& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN30FieldInTailPadding_InnerStructD1Ev(
-    class FieldInTailPadding_InnerStruct* __this) {
+    struct FieldInTailPadding_InnerStruct* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN18FieldInTailPaddingC1ERKS_(
-    class FieldInTailPadding* __this,
-    const class FieldInTailPadding& __param_0) {
+    struct FieldInTailPadding* __this,
+    const struct FieldInTailPadding& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN18FieldInTailPaddingC1EOS_(
-    class FieldInTailPadding* __this, class FieldInTailPadding&& __param_0) {
+    struct FieldInTailPadding* __this, struct FieldInTailPadding&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN18FieldInTailPaddingD1Ev(
-    class FieldInTailPadding* __this) {
+    struct FieldInTailPadding* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class FieldInTailPadding&
+extern "C" struct FieldInTailPadding&
 __rust_thunk___ZN18FieldInTailPaddingaSERKS_(
-    class FieldInTailPadding* __this,
-    const class FieldInTailPadding& __param_0) {
+    struct FieldInTailPadding* __this,
+    const struct FieldInTailPadding& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class FieldInTailPadding&
+extern "C" struct FieldInTailPadding&
 __rust_thunk___ZN18FieldInTailPaddingaSEOS_(
-    class FieldInTailPadding* __this, class FieldInTailPadding&& __param_0) {
+    struct FieldInTailPadding* __this, struct FieldInTailPadding&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN18FieldInTailPaddingC1Eicc(
-    class FieldInTailPadding* __this, int inner_int, char inner_char,
+    struct FieldInTailPadding* __this, int inner_int, char inner_char,
     char outer_char) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(inner_int)>(inner_int),
@@ -131,27 +131,27 @@
                        std::forward<decltype(outer_char)>(outer_char));
 }
 
-static_assert(sizeof(class Struct) == 8);
-static_assert(alignof(class Struct) == 4);
-static_assert(CRUBIT_OFFSET_OF(field1, class Struct) == 0);
-static_assert(CRUBIT_OFFSET_OF(field2, class Struct) == 4);
+static_assert(sizeof(struct Struct) == 8);
+static_assert(alignof(struct Struct) == 4);
+static_assert(CRUBIT_OFFSET_OF(field1, struct Struct) == 0);
+static_assert(CRUBIT_OFFSET_OF(field2, struct Struct) == 4);
 
-static_assert(sizeof(class PaddingBetweenFields) == 8);
-static_assert(alignof(class PaddingBetweenFields) == 4);
-static_assert(CRUBIT_OFFSET_OF(field1, class PaddingBetweenFields) == 0);
-static_assert(CRUBIT_OFFSET_OF(field2, class PaddingBetweenFields) == 4);
+static_assert(sizeof(struct PaddingBetweenFields) == 8);
+static_assert(alignof(struct PaddingBetweenFields) == 4);
+static_assert(CRUBIT_OFFSET_OF(field1, struct PaddingBetweenFields) == 0);
+static_assert(CRUBIT_OFFSET_OF(field2, struct PaddingBetweenFields) == 4);
 
-static_assert(sizeof(class FieldInTailPadding_InnerStruct) == 8);
-static_assert(alignof(class FieldInTailPadding_InnerStruct) == 4);
+static_assert(sizeof(struct FieldInTailPadding_InnerStruct) == 8);
+static_assert(alignof(struct FieldInTailPadding_InnerStruct) == 4);
 static_assert(CRUBIT_OFFSET_OF(inner_int_field,
-                               class FieldInTailPadding_InnerStruct) == 0);
+                               struct FieldInTailPadding_InnerStruct) == 0);
 static_assert(CRUBIT_OFFSET_OF(inner_char_field,
-                               class FieldInTailPadding_InnerStruct) == 4);
+                               struct FieldInTailPadding_InnerStruct) == 4);
 
-static_assert(sizeof(class FieldInTailPadding) == 8);
-static_assert(alignof(class FieldInTailPadding) == 4);
-static_assert(CRUBIT_OFFSET_OF(inner_struct, class FieldInTailPadding) == 0);
+static_assert(sizeof(struct FieldInTailPadding) == 8);
+static_assert(alignof(struct FieldInTailPadding) == 4);
+static_assert(CRUBIT_OFFSET_OF(inner_struct, struct FieldInTailPadding) == 0);
 static_assert(CRUBIT_OFFSET_OF(char_in_tail_padding_of_prev_field,
-                               class FieldInTailPadding) == 5);
+                               struct FieldInTailPadding) == 5);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/nontrivial_type_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/nontrivial_type_rs_api_impl.cc
index 681f525..daa1209 100644
--- a/rs_bindings_from_cc/test/golden/nontrivial_type_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/nontrivial_type_rs_api_impl.cc
@@ -12,108 +12,112 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
 extern "C" void __rust_thunk___ZN16NontrivialInlineC1Ev(
-    class NontrivialInline* __this) {
+    struct NontrivialInline* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN16NontrivialInlineC1Ei(
-    class NontrivialInline* __this, int field) {
+    struct NontrivialInline* __this, int field) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(field)>(field));
 }
 extern "C" void __rust_thunk___ZN16NontrivialInlineC1Eii(
-    class NontrivialInline* __this, int field, int unused) {
+    struct NontrivialInline* __this, int field, int unused) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(field)>(field),
                        std::forward<decltype(unused)>(unused));
 }
 extern "C" void __rust_thunk___ZN16NontrivialInlineC1ERKS_(
-    class NontrivialInline* __this, const class NontrivialInline& __param_0) {
+    struct NontrivialInline* __this, const struct NontrivialInline& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN16NontrivialInlineC1EOS_(
-    class NontrivialInline* __this, class NontrivialInline&& __param_0) {
+    struct NontrivialInline* __this, struct NontrivialInline&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class NontrivialInline& __rust_thunk___ZN16NontrivialInlineaSERKS_(
-    class NontrivialInline* __this, const class NontrivialInline& __param_0) {
+extern "C" struct NontrivialInline& __rust_thunk___ZN16NontrivialInlineaSERKS_(
+    struct NontrivialInline* __this, const struct NontrivialInline& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class NontrivialInline& __rust_thunk___ZN16NontrivialInlineaSEOS_(
-    class NontrivialInline* __this, class NontrivialInline&& __param_0) {
+extern "C" struct NontrivialInline& __rust_thunk___ZN16NontrivialInlineaSEOS_(
+    struct NontrivialInline* __this, struct NontrivialInline&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class NontrivialInline& __rust_thunk___ZN16NontrivialInlineaSEi(
-    class NontrivialInline* __this, int __param_0) {
+extern "C" struct NontrivialInline& __rust_thunk___ZN16NontrivialInlineaSEi(
+    struct NontrivialInline* __this, int __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN16NontrivialInlineD1Ev(
-    class NontrivialInline* __this) {
+    struct NontrivialInline* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN16NontrivialInline14MemberFunctionEv(
-    class NontrivialInline* __this) {
+    struct NontrivialInline* __this) {
   __this->MemberFunction();
 }
 extern "C" void __rust_thunk___ZN17NontrivialMembersC1Ev(
-    class NontrivialMembers* __this) {
+    struct NontrivialMembers* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN17NontrivialMembersC1ERKS_(
-    class NontrivialMembers* __this, const class NontrivialMembers& __param_0) {
+    struct NontrivialMembers* __this,
+    const struct NontrivialMembers& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN17NontrivialMembersC1EOS_(
-    class NontrivialMembers* __this, class NontrivialMembers&& __param_0) {
+    struct NontrivialMembers* __this, struct NontrivialMembers&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN17NontrivialMembersD1Ev(
-    class NontrivialMembers* __this) {
+    struct NontrivialMembers* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class NontrivialMembers& __rust_thunk___ZN17NontrivialMembersaSERKS_(
-    class NontrivialMembers* __this, const class NontrivialMembers& __param_0) {
+extern "C" struct NontrivialMembers&
+__rust_thunk___ZN17NontrivialMembersaSERKS_(
+    struct NontrivialMembers* __this,
+    const struct NontrivialMembers& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class NontrivialMembers& __rust_thunk___ZN17NontrivialMembersaSEOS_(
-    class NontrivialMembers* __this, class NontrivialMembers&& __param_0) {
+extern "C" struct NontrivialMembers& __rust_thunk___ZN17NontrivialMembersaSEOS_(
+    struct NontrivialMembers* __this, struct NontrivialMembers&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN17NontrivialByValueC1Ev(
-    class NontrivialByValue* __this) {
+    struct NontrivialByValue* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN17NontrivialByValueC1ERKS_(
-    class NontrivialByValue* __this, const class NontrivialByValue& __param_0) {
+    struct NontrivialByValue* __this,
+    const struct NontrivialByValue& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN17NontrivialByValueD1Ev(
-    class NontrivialByValue* __this) {
+    struct NontrivialByValue* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
 
-static_assert(sizeof(class Nontrivial) == 4);
-static_assert(alignof(class Nontrivial) == 4);
-static_assert(CRUBIT_OFFSET_OF(field, class Nontrivial) == 0);
+static_assert(sizeof(struct Nontrivial) == 4);
+static_assert(alignof(struct Nontrivial) == 4);
+static_assert(CRUBIT_OFFSET_OF(field, struct Nontrivial) == 0);
 
-static_assert(sizeof(class NontrivialInline) == 4);
-static_assert(alignof(class NontrivialInline) == 4);
-static_assert(CRUBIT_OFFSET_OF(field, class NontrivialInline) == 0);
+static_assert(sizeof(struct NontrivialInline) == 4);
+static_assert(alignof(struct NontrivialInline) == 4);
+static_assert(CRUBIT_OFFSET_OF(field, struct NontrivialInline) == 0);
 
-static_assert(sizeof(class NontrivialMembers) == 4);
-static_assert(alignof(class NontrivialMembers) == 4);
-static_assert(CRUBIT_OFFSET_OF(nontrivial_member, class NontrivialMembers) ==
+static_assert(sizeof(struct NontrivialMembers) == 4);
+static_assert(alignof(struct NontrivialMembers) == 4);
+static_assert(CRUBIT_OFFSET_OF(nontrivial_member, struct NontrivialMembers) ==
               0);
 
-static_assert(sizeof(class NontrivialUnpin) == 4);
-static_assert(alignof(class NontrivialUnpin) == 4);
-static_assert(CRUBIT_OFFSET_OF(field, class NontrivialUnpin) == 0);
+static_assert(sizeof(struct NontrivialUnpin) == 4);
+static_assert(alignof(struct NontrivialUnpin) == 4);
+static_assert(CRUBIT_OFFSET_OF(field, struct NontrivialUnpin) == 0);
 
-static_assert(sizeof(class NontrivialByValue) == 1);
-static_assert(alignof(class NontrivialByValue) == 1);
+static_assert(sizeof(struct NontrivialByValue) == 1);
+static_assert(alignof(struct NontrivialByValue) == 1);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/templates_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/templates_rs_api_impl.cc
index d4c3f2a..eecc1c2 100644
--- a/rs_bindings_from_cc/test/golden/templates_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/templates_rs_api_impl.cc
@@ -12,29 +12,29 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
 extern "C" void __rust_thunk___ZN14DifferentScopeC1Ev(
-    class DifferentScope* __this) {
+    struct DifferentScope* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN14DifferentScopeC1ERKS_(
-    class DifferentScope* __this, const class DifferentScope& __param_0) {
+    struct DifferentScope* __this, const struct DifferentScope& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN14DifferentScopeC1EOS_(
-    class DifferentScope* __this, class DifferentScope&& __param_0) {
+    struct DifferentScope* __this, struct DifferentScope&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN14DifferentScopeD1Ev(
-    class DifferentScope* __this) {
+    struct DifferentScope* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class DifferentScope& __rust_thunk___ZN14DifferentScopeaSERKS_(
-    class DifferentScope* __this, const class DifferentScope& __param_0) {
+extern "C" struct DifferentScope& __rust_thunk___ZN14DifferentScopeaSERKS_(
+    struct DifferentScope* __this, const struct DifferentScope& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class DifferentScope& __rust_thunk___ZN14DifferentScopeaSEOS_(
-    class DifferentScope* __this, class DifferentScope&& __param_0) {
+extern "C" struct DifferentScope& __rust_thunk___ZN14DifferentScopeaSEOS_(
+    struct DifferentScope* __this, struct DifferentScope&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
@@ -155,13 +155,13 @@
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 } extern "C" class test_namespace_bindings::MyTemplate<DifferentScope>
 __rust_thunk___ZN23test_namespace_bindings10MyTemplateI14DifferentScopeE6CreateES1___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class DifferentScope value) {
+    struct DifferentScope value) {
   return test_namespace_bindings::MyTemplate<DifferentScope>::Create(
       std::forward<decltype(value)>(value));
 } extern "C" class test_namespace_bindings::MyTemplate<
     test_namespace_bindings::TemplateParam>
 __rust_thunk___ZN23test_namespace_bindings10MyTemplateINS_13TemplateParamEE6CreateES1___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateParam value) {
+    struct test_namespace_bindings::TemplateParam value) {
   return test_namespace_bindings::
       MyTemplate<test_namespace_bindings::TemplateParam>::Create(
           std::forward<decltype(value)>(value));
@@ -170,12 +170,12 @@
     int value) {
   return test_namespace_bindings::MyTemplate<int>::Create(
       std::forward<decltype(value)>(value));
-} extern "C" const class DifferentScope&
+} extern "C" const struct DifferentScope&
 __rust_thunk___ZNK23test_namespace_bindings10MyTemplateI14DifferentScopeE5valueEv__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
     const class test_namespace_bindings::MyTemplate<DifferentScope>* __this) {
   return __this->value();
 }
-extern "C" const class test_namespace_bindings::TemplateParam&
+extern "C" const struct test_namespace_bindings::TemplateParam&
 __rust_thunk___ZNK23test_namespace_bindings10MyTemplateINS_13TemplateParamEE5valueEv__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
     const class test_namespace_bindings::MyTemplate<
         test_namespace_bindings::TemplateParam>* __this) {
@@ -187,56 +187,56 @@
   return __this->value();
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings13TemplateParamC1Ev(
-    class test_namespace_bindings::TemplateParam* __this) {
+    struct test_namespace_bindings::TemplateParam* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings13TemplateParamC1ERKS0_(
-    class test_namespace_bindings::TemplateParam* __this,
-    const class test_namespace_bindings::TemplateParam& __param_0) {
+    struct test_namespace_bindings::TemplateParam* __this,
+    const struct test_namespace_bindings::TemplateParam& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings13TemplateParamC1EOS0_(
-    class test_namespace_bindings::TemplateParam* __this,
-    class test_namespace_bindings::TemplateParam&& __param_0) {
+    struct test_namespace_bindings::TemplateParam* __this,
+    struct test_namespace_bindings::TemplateParam&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings13TemplateParamD1Ev(
-    class test_namespace_bindings::TemplateParam* __this) {
+    struct test_namespace_bindings::TemplateParam* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class test_namespace_bindings::TemplateParam&
+extern "C" struct test_namespace_bindings::TemplateParam&
 __rust_thunk___ZN23test_namespace_bindings13TemplateParamaSERKS0_(
-    class test_namespace_bindings::TemplateParam* __this,
-    const class test_namespace_bindings::TemplateParam& __param_0) {
+    struct test_namespace_bindings::TemplateParam* __this,
+    const struct test_namespace_bindings::TemplateParam& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class test_namespace_bindings::TemplateParam&
+extern "C" struct test_namespace_bindings::TemplateParam&
 __rust_thunk___ZN23test_namespace_bindings13TemplateParamaSEOS0_(
-    class test_namespace_bindings::TemplateParam* __this,
-    class test_namespace_bindings::TemplateParam&& __param_0) {
+    struct test_namespace_bindings::TemplateParam* __this,
+    struct test_namespace_bindings::TemplateParam&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsINS0_IiiEEiEC1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<
+    struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>*
         __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsIifEC1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<int, float>* __this) {
+    struct test_namespace_bindings::TemplateWithTwoParams<int, float>* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsINS0_IiiEEiEC1ERKS2___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<
+    struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>* __this,
-    const class test_namespace_bindings::TemplateWithTwoParams<
+    const struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>&
         __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
@@ -244,17 +244,17 @@
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsIifEC1ERKS1___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<int, float>* __this,
-    const class test_namespace_bindings::TemplateWithTwoParams<int, float>&
+    struct test_namespace_bindings::TemplateWithTwoParams<int, float>* __this,
+    const struct test_namespace_bindings::TemplateWithTwoParams<int, float>&
         __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsINS0_IiiEEiEC1EOS2___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<
+    struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>* __this,
-    class test_namespace_bindings::TemplateWithTwoParams<
+    struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>&&
         __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
@@ -262,96 +262,96 @@
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsIifEC1EOS1___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<int, float>* __this,
-    class test_namespace_bindings::TemplateWithTwoParams<int, float>&&
+    struct test_namespace_bindings::TemplateWithTwoParams<int, float>* __this,
+    struct test_namespace_bindings::TemplateWithTwoParams<int, float>&&
         __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsINS0_IiiEEiED1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<
+    struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>*
         __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsIifED1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<int, float>* __this) {
+    struct test_namespace_bindings::TemplateWithTwoParams<int, float>* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class test_namespace_bindings::TemplateWithTwoParams<
+extern "C" struct test_namespace_bindings::TemplateWithTwoParams<
     test_namespace_bindings::TemplateWithTwoParams<int, int>, int>&
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsINS0_IiiEEiEaSERKS2___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<
+    struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>* __this,
-    const class test_namespace_bindings::TemplateWithTwoParams<
+    const struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>&
         __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
-} extern "C" class test_namespace_bindings::TemplateWithTwoParams<int, float>&
+} extern "C" struct test_namespace_bindings::TemplateWithTwoParams<int, float>&
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsIifEaSERKS1___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<int, float>* __this,
-    const class test_namespace_bindings::TemplateWithTwoParams<int, float>&
+    struct test_namespace_bindings::TemplateWithTwoParams<int, float>* __this,
+    const struct test_namespace_bindings::TemplateWithTwoParams<int, float>&
         __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
-} extern "C" class test_namespace_bindings::TemplateWithTwoParams<
+} extern "C" struct test_namespace_bindings::TemplateWithTwoParams<
     test_namespace_bindings::TemplateWithTwoParams<int, int>, int>&
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsINS0_IiiEEiEaSEOS2___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<
+    struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>* __this,
-    class test_namespace_bindings::TemplateWithTwoParams<
+    struct test_namespace_bindings::TemplateWithTwoParams<
         test_namespace_bindings::TemplateWithTwoParams<int, int>, int>&&
         __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
-} extern "C" class test_namespace_bindings::TemplateWithTwoParams<int, float>&
+} extern "C" struct test_namespace_bindings::TemplateWithTwoParams<int, float>&
 __rust_thunk___ZN23test_namespace_bindings21TemplateWithTwoParamsIifEaSEOS1___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class test_namespace_bindings::TemplateWithTwoParams<int, float>* __this,
-    class test_namespace_bindings::TemplateWithTwoParams<int, float>&&
+    struct test_namespace_bindings::TemplateWithTwoParams<int, float>* __this,
+    struct test_namespace_bindings::TemplateWithTwoParams<int, float>&&
         __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 } extern "C" void
 __rust_thunk___ZN18MyTopLevelTemplateIN23test_namespace_bindings13TemplateParamEEC1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this) {
+    struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN18MyTopLevelTemplateIN23test_namespace_bindings13TemplateParamEEC1ERKS2___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this,
-    const class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&
+    struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this,
+    const struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&
         __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN18MyTopLevelTemplateIN23test_namespace_bindings13TemplateParamEEC1EOS2___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this,
-    class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&&
+    struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this,
+    struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&&
         __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN18MyTopLevelTemplateIN23test_namespace_bindings13TemplateParamEED1Ev__2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this) {
+    struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&
+extern "C" struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&
 __rust_thunk___ZN18MyTopLevelTemplateIN23test_namespace_bindings13TemplateParamEEaSERKS2___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this,
-    const class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&
+    struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this,
+    const struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&
         __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
-} extern "C" class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&
+} extern "C" struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&
 __rust_thunk___ZN18MyTopLevelTemplateIN23test_namespace_bindings13TemplateParamEEaSEOS2___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fcc(
-    class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this,
-    class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&&
+    struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>* __this,
+    struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>&&
         __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class DifferentScope) == 1);
-static_assert(alignof(class DifferentScope) == 1);
+static_assert(sizeof(struct DifferentScope) == 1);
+static_assert(alignof(struct DifferentScope) == 1);
 
 static_assert(
     sizeof(class test_namespace_bindings::MyTemplate<DifferentScope>) == 1);
@@ -366,54 +366,59 @@
 static_assert(sizeof(class test_namespace_bindings::MyTemplate<int>) == 4);
 static_assert(alignof(class test_namespace_bindings::MyTemplate<int>) == 4);
 
-static_assert(sizeof(class test_namespace_bindings::TemplateParam) == 1);
-static_assert(alignof(class test_namespace_bindings::TemplateParam) == 1);
+static_assert(sizeof(struct test_namespace_bindings::TemplateParam) == 1);
+static_assert(alignof(struct test_namespace_bindings::TemplateParam) == 1);
 
 static_assert(
-    sizeof(class test_namespace_bindings::TemplateWithTwoParams<
+    sizeof(struct test_namespace_bindings::TemplateWithTwoParams<
            test_namespace_bindings::TemplateWithTwoParams<int, int>, int>) ==
     12);
 static_assert(
-    alignof(class test_namespace_bindings::TemplateWithTwoParams<
+    alignof(struct test_namespace_bindings::TemplateWithTwoParams<
             test_namespace_bindings::TemplateWithTwoParams<int, int>, int>) ==
     4);
 static_assert(
     CRUBIT_OFFSET_OF(
         value1,
-        class test_namespace_bindings::TemplateWithTwoParams<
+        struct test_namespace_bindings::TemplateWithTwoParams<
             test_namespace_bindings::TemplateWithTwoParams<int, int>, int>) ==
     0);
 static_assert(
     CRUBIT_OFFSET_OF(
         value2,
-        class test_namespace_bindings::TemplateWithTwoParams<
+        struct test_namespace_bindings::TemplateWithTwoParams<
             test_namespace_bindings::TemplateWithTwoParams<int, int>, int>) ==
     8);
 
 static_assert(
-    sizeof(class test_namespace_bindings::TemplateWithTwoParams<int, float>) ==
+    sizeof(struct test_namespace_bindings::TemplateWithTwoParams<int, float>) ==
     8);
 static_assert(
-    alignof(class test_namespace_bindings::TemplateWithTwoParams<int, float>) ==
+    alignof(
+        struct test_namespace_bindings::TemplateWithTwoParams<int, float>) ==
     4);
 static_assert(
     CRUBIT_OFFSET_OF(
         value1,
-        class test_namespace_bindings::TemplateWithTwoParams<int, float>) == 0);
+        struct test_namespace_bindings::TemplateWithTwoParams<int, float>) ==
+    0);
 static_assert(
     CRUBIT_OFFSET_OF(
         value2,
-        class test_namespace_bindings::TemplateWithTwoParams<int, float>) == 4);
+        struct test_namespace_bindings::TemplateWithTwoParams<int, float>) ==
+    4);
 
 static_assert(
-    sizeof(class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>) ==
+    sizeof(struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>) ==
     1);
 static_assert(
-    alignof(class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>) ==
+    alignof(
+        struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>) ==
     1);
 static_assert(
     CRUBIT_OFFSET_OF(
         value,
-        class MyTopLevelTemplate<test_namespace_bindings::TemplateParam>) == 0);
+        struct MyTopLevelTemplate<test_namespace_bindings::TemplateParam>) ==
+    0);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/templates_source_order_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/templates_source_order_rs_api_impl.cc
index eda9690..2a1ce5a 100644
--- a/rs_bindings_from_cc/test/golden/templates_source_order_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/templates_source_order_rs_api_impl.cc
@@ -205,13 +205,13 @@
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 } extern "C" void
 __rust_thunk___ZN10MyTemplateI8TopLevelE8processTES0___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fsource_5forder_5fcc(
-    class MyTemplate<TopLevel>* __this, class TopLevel t) {
+    class MyTemplate<TopLevel>* __this, struct TopLevel t) {
   __this->processT(std::forward<decltype(t)>(t));
 }
 extern "C" void
 __rust_thunk___ZN10MyTemplateIN23test_namespace_bindings5InnerEE8processTES1___2f_2fthird_5fparty_2fcrubit_2frs_5fbindings_5ffrom_5fcc_2ftest_2fgolden_3atemplates_5fsource_5forder_5fcc(
     class MyTemplate<test_namespace_bindings::Inner>* __this,
-    class test_namespace_bindings::Inner t) {
+    struct test_namespace_bindings::Inner t) {
   __this->processT(std::forward<decltype(t)>(t));
 }
 extern "C" void
@@ -251,39 +251,39 @@
     class MyTemplate<int>* __this, int t) {
   __this->processT(std::forward<decltype(t)>(t));
 }
-extern "C" void __rust_thunk___ZN8TopLevelC1Ev(class TopLevel* __this) {
+extern "C" void __rust_thunk___ZN8TopLevelC1Ev(struct TopLevel* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN8TopLevelC1ERKS_(
-    class TopLevel* __this, const class TopLevel& __param_0) {
+    struct TopLevel* __this, const struct TopLevel& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN8TopLevelD1Ev(class TopLevel* __this) {
+extern "C" void __rust_thunk___ZN8TopLevelD1Ev(struct TopLevel* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class TopLevel& __rust_thunk___ZN8TopLevelaSERKS_(
-    class TopLevel* __this, const class TopLevel& __param_0) {
+extern "C" struct TopLevel& __rust_thunk___ZN8TopLevelaSERKS_(
+    struct TopLevel* __this, const struct TopLevel& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings5InnerC1Ev(
-    class test_namespace_bindings::Inner* __this) {
+    struct test_namespace_bindings::Inner* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings5InnerC1ERKS0_(
-    class test_namespace_bindings::Inner* __this,
-    const class test_namespace_bindings::Inner& __param_0) {
+    struct test_namespace_bindings::Inner* __this,
+    const struct test_namespace_bindings::Inner& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings5InnerD1Ev(
-    class test_namespace_bindings::Inner* __this) {
+    struct test_namespace_bindings::Inner* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class test_namespace_bindings::Inner&
+extern "C" struct test_namespace_bindings::Inner&
 __rust_thunk___ZN23test_namespace_bindings5InneraSERKS0_(
-    class test_namespace_bindings::Inner* __this,
-    const class test_namespace_bindings::Inner& __param_0) {
+    struct test_namespace_bindings::Inner* __this,
+    const struct test_namespace_bindings::Inner& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
@@ -316,10 +316,10 @@
 static_assert(sizeof(class MyTemplate<int>) == 4);
 static_assert(alignof(class MyTemplate<int>) == 4);
 
-static_assert(sizeof(class TopLevel) == 1);
-static_assert(alignof(class TopLevel) == 1);
+static_assert(sizeof(struct TopLevel) == 1);
+static_assert(alignof(struct TopLevel) == 1);
 
-static_assert(sizeof(class test_namespace_bindings::Inner) == 1);
-static_assert(alignof(class test_namespace_bindings::Inner) == 1);
+static_assert(sizeof(struct test_namespace_bindings::Inner) == 1);
+static_assert(alignof(struct test_namespace_bindings::Inner) == 1);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/trivial_type_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/trivial_type_rs_api_impl.cc
index 209f25a..b0ba21b 100644
--- a/rs_bindings_from_cc/test/golden/trivial_type_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/trivial_type_rs_api_impl.cc
@@ -12,124 +12,125 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
 extern "C" void __rust_thunk___ZN23test_namespace_bindings7TrivialC1Ev(
-    class test_namespace_bindings::Trivial* __this) {
+    struct test_namespace_bindings::Trivial* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings7TrivialC1ERKS0_(
-    class test_namespace_bindings::Trivial* __this,
-    const class test_namespace_bindings::Trivial& __param_0) {
+    struct test_namespace_bindings::Trivial* __this,
+    const struct test_namespace_bindings::Trivial& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings7TrivialC1EOS0_(
-    class test_namespace_bindings::Trivial* __this,
-    class test_namespace_bindings::Trivial&& __param_0) {
+    struct test_namespace_bindings::Trivial* __this,
+    struct test_namespace_bindings::Trivial&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings7TrivialD1Ev(
-    class test_namespace_bindings::Trivial* __this) {
+    struct test_namespace_bindings::Trivial* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class test_namespace_bindings::Trivial&
+extern "C" struct test_namespace_bindings::Trivial&
 __rust_thunk___ZN23test_namespace_bindings7TrivialaSERKS0_(
-    class test_namespace_bindings::Trivial* __this,
-    const class test_namespace_bindings::Trivial& __param_0) {
+    struct test_namespace_bindings::Trivial* __this,
+    const struct test_namespace_bindings::Trivial& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class test_namespace_bindings::Trivial&
+extern "C" struct test_namespace_bindings::Trivial&
 __rust_thunk___ZN23test_namespace_bindings7TrivialaSEOS0_(
-    class test_namespace_bindings::Trivial* __this,
-    class test_namespace_bindings::Trivial&& __param_0) {
+    struct test_namespace_bindings::Trivial* __this,
+    struct test_namespace_bindings::Trivial&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings20TrivialWithDefaultedC1Ev(
-    class test_namespace_bindings::TrivialWithDefaulted* __this) {
+    struct test_namespace_bindings::TrivialWithDefaulted* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings20TrivialWithDefaultedC1ERKS0_(
-    class test_namespace_bindings::TrivialWithDefaulted* __this,
-    const class test_namespace_bindings::TrivialWithDefaulted& __param_0) {
+    struct test_namespace_bindings::TrivialWithDefaulted* __this,
+    const struct test_namespace_bindings::TrivialWithDefaulted& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class test_namespace_bindings::TrivialWithDefaulted&
+extern "C" struct test_namespace_bindings::TrivialWithDefaulted&
 __rust_thunk___ZN23test_namespace_bindings20TrivialWithDefaultedaSERKS0_(
-    class test_namespace_bindings::TrivialWithDefaulted* __this,
-    const class test_namespace_bindings::TrivialWithDefaulted& __param_0) {
+    struct test_namespace_bindings::TrivialWithDefaulted* __this,
+    const struct test_namespace_bindings::TrivialWithDefaulted& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings20TrivialWithDefaultedC1EOS0_(
-    class test_namespace_bindings::TrivialWithDefaulted* __this,
-    class test_namespace_bindings::TrivialWithDefaulted&& __param_0) {
+    struct test_namespace_bindings::TrivialWithDefaulted* __this,
+    struct test_namespace_bindings::TrivialWithDefaulted&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class test_namespace_bindings::TrivialWithDefaulted&
+extern "C" struct test_namespace_bindings::TrivialWithDefaulted&
 __rust_thunk___ZN23test_namespace_bindings20TrivialWithDefaultedaSEOS0_(
-    class test_namespace_bindings::TrivialWithDefaulted* __this,
-    class test_namespace_bindings::TrivialWithDefaulted&& __param_0) {
+    struct test_namespace_bindings::TrivialWithDefaulted* __this,
+    struct test_namespace_bindings::TrivialWithDefaulted&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings20TrivialWithDefaultedD1Ev(
-    class test_namespace_bindings::TrivialWithDefaulted* __this) {
+    struct test_namespace_bindings::TrivialWithDefaulted* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings15TrivialNonfinalC1Ev(
-    class test_namespace_bindings::TrivialNonfinal* __this) {
+    struct test_namespace_bindings::TrivialNonfinal* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings15TrivialNonfinalC1ERKS0_(
-    class test_namespace_bindings::TrivialNonfinal* __this,
-    const class test_namespace_bindings::TrivialNonfinal& __param_0) {
+    struct test_namespace_bindings::TrivialNonfinal* __this,
+    const struct test_namespace_bindings::TrivialNonfinal& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN23test_namespace_bindings15TrivialNonfinalC1EOS0_(
-    class test_namespace_bindings::TrivialNonfinal* __this,
-    class test_namespace_bindings::TrivialNonfinal&& __param_0) {
+    struct test_namespace_bindings::TrivialNonfinal* __this,
+    struct test_namespace_bindings::TrivialNonfinal&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN23test_namespace_bindings15TrivialNonfinalD1Ev(
-    class test_namespace_bindings::TrivialNonfinal* __this) {
+    struct test_namespace_bindings::TrivialNonfinal* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class test_namespace_bindings::TrivialNonfinal&
+extern "C" struct test_namespace_bindings::TrivialNonfinal&
 __rust_thunk___ZN23test_namespace_bindings15TrivialNonfinalaSERKS0_(
-    class test_namespace_bindings::TrivialNonfinal* __this,
-    const class test_namespace_bindings::TrivialNonfinal& __param_0) {
+    struct test_namespace_bindings::TrivialNonfinal* __this,
+    const struct test_namespace_bindings::TrivialNonfinal& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class test_namespace_bindings::TrivialNonfinal&
+extern "C" struct test_namespace_bindings::TrivialNonfinal&
 __rust_thunk___ZN23test_namespace_bindings15TrivialNonfinalaSEOS0_(
-    class test_namespace_bindings::TrivialNonfinal* __this,
-    class test_namespace_bindings::TrivialNonfinal&& __param_0) {
+    struct test_namespace_bindings::TrivialNonfinal* __this,
+    struct test_namespace_bindings::TrivialNonfinal&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class test_namespace_bindings::Trivial) == 4);
-static_assert(alignof(class test_namespace_bindings::Trivial) == 4);
+static_assert(sizeof(struct test_namespace_bindings::Trivial) == 4);
+static_assert(alignof(struct test_namespace_bindings::Trivial) == 4);
 static_assert(CRUBIT_OFFSET_OF(trivial_field,
-                               class test_namespace_bindings::Trivial) == 0);
+                               struct test_namespace_bindings::Trivial) == 0);
 
-static_assert(sizeof(class test_namespace_bindings::TrivialWithDefaulted) == 4);
-static_assert(alignof(class test_namespace_bindings::TrivialWithDefaulted) ==
+static_assert(sizeof(struct test_namespace_bindings::TrivialWithDefaulted) ==
               4);
-static_assert(
-    CRUBIT_OFFSET_OF(trivial_field,
-                     class test_namespace_bindings::TrivialWithDefaulted) == 0);
+static_assert(alignof(struct test_namespace_bindings::TrivialWithDefaulted) ==
+              4);
+static_assert(CRUBIT_OFFSET_OF(
+                  trivial_field,
+                  struct test_namespace_bindings::TrivialWithDefaulted) == 0);
 
-static_assert(sizeof(class test_namespace_bindings::TrivialNonfinal) == 4);
-static_assert(alignof(class test_namespace_bindings::TrivialNonfinal) == 4);
+static_assert(sizeof(struct test_namespace_bindings::TrivialNonfinal) == 4);
+static_assert(alignof(struct test_namespace_bindings::TrivialNonfinal) == 4);
 static_assert(
     CRUBIT_OFFSET_OF(trivial_field,
-                     class test_namespace_bindings::TrivialNonfinal) == 0);
+                     struct test_namespace_bindings::TrivialNonfinal) == 0);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/typedefs_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/typedefs_rs_api_impl.cc
index 3d0ecef..d6da225 100644
--- a/rs_bindings_from_cc/test/golden/typedefs_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/typedefs_rs_api_impl.cc
@@ -11,28 +11,28 @@
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
-extern "C" void __rust_thunk___ZN10SomeStructC1Ev(class SomeStruct* __this) {
+extern "C" void __rust_thunk___ZN10SomeStructC1Ev(struct SomeStruct* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN10SomeStructC1ERKS_(
-    class SomeStruct* __this, const class SomeStruct& __param_0) {
+    struct SomeStruct* __this, const struct SomeStruct& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN10SomeStructC1EOS_(
-    class SomeStruct* __this, class SomeStruct&& __param_0) {
+    struct SomeStruct* __this, struct SomeStruct&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN10SomeStructD1Ev(class SomeStruct* __this) {
+extern "C" void __rust_thunk___ZN10SomeStructD1Ev(struct SomeStruct* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class SomeStruct& __rust_thunk___ZN10SomeStructaSERKS_(
-    class SomeStruct* __this, const class SomeStruct& __param_0) {
+extern "C" struct SomeStruct& __rust_thunk___ZN10SomeStructaSERKS_(
+    struct SomeStruct* __this, const struct SomeStruct& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class SomeStruct& __rust_thunk___ZN10SomeStructaSEOS_(
-    class SomeStruct* __this, class SomeStruct&& __param_0) {
+extern "C" struct SomeStruct& __rust_thunk___ZN10SomeStructaSEOS_(
+    struct SomeStruct* __this, struct SomeStruct&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN9SomeUnionC1Ev(union SomeUnion* __this) {
@@ -60,8 +60,8 @@
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class SomeStruct) == 1);
-static_assert(alignof(class SomeStruct) == 1);
+static_assert(sizeof(struct SomeStruct) == 1);
+static_assert(alignof(struct SomeStruct) == 1);
 
 static_assert(sizeof(union SomeUnion) == 1);
 static_assert(alignof(union SomeUnion) == 1);
diff --git a/rs_bindings_from_cc/test/golden/types_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/types_rs_api_impl.cc
index 1c02729..1f436bb 100644
--- a/rs_bindings_from_cc/test/golden/types_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/types_rs_api_impl.cc
@@ -11,140 +11,150 @@
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
-extern "C" void __rust_thunk___ZN10SomeStructC1Ev(class SomeStruct* __this) {
+extern "C" void __rust_thunk___ZN10SomeStructC1Ev(struct SomeStruct* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN10SomeStructC1ERKS_(
-    class SomeStruct* __this, const class SomeStruct& __param_0) {
+    struct SomeStruct* __this, const struct SomeStruct& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN10SomeStructC1EOS_(
-    class SomeStruct* __this, class SomeStruct&& __param_0) {
+    struct SomeStruct* __this, struct SomeStruct&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN10SomeStructD1Ev(class SomeStruct* __this) {
+extern "C" void __rust_thunk___ZN10SomeStructD1Ev(struct SomeStruct* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class SomeStruct& __rust_thunk___ZN10SomeStructaSERKS_(
-    class SomeStruct* __this, const class SomeStruct& __param_0) {
+extern "C" struct SomeStruct& __rust_thunk___ZN10SomeStructaSERKS_(
+    struct SomeStruct* __this, const struct SomeStruct& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class SomeStruct& __rust_thunk___ZN10SomeStructaSEOS_(
-    class SomeStruct* __this, class SomeStruct&& __param_0) {
+extern "C" struct SomeStruct& __rust_thunk___ZN10SomeStructaSEOS_(
+    struct SomeStruct* __this, struct SomeStruct&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN19FieldTypeTestStructC1ERKS_(
-    class FieldTypeTestStruct* __this,
-    const class FieldTypeTestStruct& __param_0) {
+    struct FieldTypeTestStruct* __this,
+    const struct FieldTypeTestStruct& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN19FieldTypeTestStructC1EOS_(
-    class FieldTypeTestStruct* __this, class FieldTypeTestStruct&& __param_0) {
+    struct FieldTypeTestStruct* __this,
+    struct FieldTypeTestStruct&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN19FieldTypeTestStructD1Ev(
-    class FieldTypeTestStruct* __this) {
+    struct FieldTypeTestStruct* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___Z21VoidReturningFunctionv() {
   VoidReturningFunction();
 }
 
-static_assert(sizeof(class SomeStruct) == 1);
-static_assert(alignof(class SomeStruct) == 1);
+static_assert(sizeof(struct SomeStruct) == 1);
+static_assert(alignof(struct SomeStruct) == 1);
 
-static_assert(sizeof(class FieldTypeTestStruct) == 288);
-static_assert(alignof(class FieldTypeTestStruct) == 8);
-static_assert(CRUBIT_OFFSET_OF(bool_field, class FieldTypeTestStruct) == 0);
-static_assert(CRUBIT_OFFSET_OF(char_field, class FieldTypeTestStruct) == 1);
+static_assert(sizeof(struct FieldTypeTestStruct) == 288);
+static_assert(alignof(struct FieldTypeTestStruct) == 8);
+static_assert(CRUBIT_OFFSET_OF(bool_field, struct FieldTypeTestStruct) == 0);
+static_assert(CRUBIT_OFFSET_OF(char_field, struct FieldTypeTestStruct) == 1);
 static_assert(CRUBIT_OFFSET_OF(unsigned_char_field,
-                               class FieldTypeTestStruct) == 2);
-static_assert(CRUBIT_OFFSET_OF(signed_char_field, class FieldTypeTestStruct) ==
+                               struct FieldTypeTestStruct) == 2);
+static_assert(CRUBIT_OFFSET_OF(signed_char_field, struct FieldTypeTestStruct) ==
               3);
-static_assert(CRUBIT_OFFSET_OF(char16_t_field, class FieldTypeTestStruct) == 4);
-static_assert(CRUBIT_OFFSET_OF(char32_t_field, class FieldTypeTestStruct) == 8);
-static_assert(CRUBIT_OFFSET_OF(wchar_t_field, class FieldTypeTestStruct) == 12);
-static_assert(CRUBIT_OFFSET_OF(short_field, class FieldTypeTestStruct) == 16);
-static_assert(CRUBIT_OFFSET_OF(int_field, class FieldTypeTestStruct) == 20);
-static_assert(CRUBIT_OFFSET_OF(long_field, class FieldTypeTestStruct) == 24);
-static_assert(CRUBIT_OFFSET_OF(long_long_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(char16_t_field, struct FieldTypeTestStruct) ==
+              4);
+static_assert(CRUBIT_OFFSET_OF(char32_t_field, struct FieldTypeTestStruct) ==
+              8);
+static_assert(CRUBIT_OFFSET_OF(wchar_t_field, struct FieldTypeTestStruct) ==
+              12);
+static_assert(CRUBIT_OFFSET_OF(short_field, struct FieldTypeTestStruct) == 16);
+static_assert(CRUBIT_OFFSET_OF(int_field, struct FieldTypeTestStruct) == 20);
+static_assert(CRUBIT_OFFSET_OF(long_field, struct FieldTypeTestStruct) == 24);
+static_assert(CRUBIT_OFFSET_OF(long_long_field, struct FieldTypeTestStruct) ==
               32);
 static_assert(CRUBIT_OFFSET_OF(unsigned_short_field,
-                               class FieldTypeTestStruct) == 40);
-static_assert(CRUBIT_OFFSET_OF(unsigned_int_field, class FieldTypeTestStruct) ==
-              44);
+                               struct FieldTypeTestStruct) == 40);
+static_assert(CRUBIT_OFFSET_OF(unsigned_int_field,
+                               struct FieldTypeTestStruct) == 44);
 static_assert(CRUBIT_OFFSET_OF(unsigned_long_field,
-                               class FieldTypeTestStruct) == 48);
+                               struct FieldTypeTestStruct) == 48);
 static_assert(CRUBIT_OFFSET_OF(unsigned_long_long_field,
-                               class FieldTypeTestStruct) == 56);
-static_assert(CRUBIT_OFFSET_OF(signed_short_field, class FieldTypeTestStruct) ==
-              64);
-static_assert(CRUBIT_OFFSET_OF(signed_int_field, class FieldTypeTestStruct) ==
+                               struct FieldTypeTestStruct) == 56);
+static_assert(CRUBIT_OFFSET_OF(signed_short_field,
+                               struct FieldTypeTestStruct) == 64);
+static_assert(CRUBIT_OFFSET_OF(signed_int_field, struct FieldTypeTestStruct) ==
               68);
-static_assert(CRUBIT_OFFSET_OF(signed_long_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(signed_long_field, struct FieldTypeTestStruct) ==
               72);
 static_assert(CRUBIT_OFFSET_OF(signed_long_long_field,
-                               class FieldTypeTestStruct) == 80);
-static_assert(CRUBIT_OFFSET_OF(int8_t_field, class FieldTypeTestStruct) == 88);
-static_assert(CRUBIT_OFFSET_OF(int16_t_field, class FieldTypeTestStruct) == 90);
-static_assert(CRUBIT_OFFSET_OF(int32_t_field, class FieldTypeTestStruct) == 92);
-static_assert(CRUBIT_OFFSET_OF(int64_t_field, class FieldTypeTestStruct) == 96);
-static_assert(CRUBIT_OFFSET_OF(std_int8_t_field, class FieldTypeTestStruct) ==
+                               struct FieldTypeTestStruct) == 80);
+static_assert(CRUBIT_OFFSET_OF(int8_t_field, struct FieldTypeTestStruct) == 88);
+static_assert(CRUBIT_OFFSET_OF(int16_t_field, struct FieldTypeTestStruct) ==
+              90);
+static_assert(CRUBIT_OFFSET_OF(int32_t_field, struct FieldTypeTestStruct) ==
+              92);
+static_assert(CRUBIT_OFFSET_OF(int64_t_field, struct FieldTypeTestStruct) ==
+              96);
+static_assert(CRUBIT_OFFSET_OF(std_int8_t_field, struct FieldTypeTestStruct) ==
               104);
-static_assert(CRUBIT_OFFSET_OF(std_int16_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(std_int16_t_field, struct FieldTypeTestStruct) ==
               106);
-static_assert(CRUBIT_OFFSET_OF(std_int32_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(std_int32_t_field, struct FieldTypeTestStruct) ==
               108);
-static_assert(CRUBIT_OFFSET_OF(std_int64_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(std_int64_t_field, struct FieldTypeTestStruct) ==
               112);
-static_assert(CRUBIT_OFFSET_OF(uint8_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(uint8_t_field, struct FieldTypeTestStruct) ==
               120);
-static_assert(CRUBIT_OFFSET_OF(uint16_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(uint16_t_field, struct FieldTypeTestStruct) ==
               122);
-static_assert(CRUBIT_OFFSET_OF(uint32_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(uint32_t_field, struct FieldTypeTestStruct) ==
               124);
-static_assert(CRUBIT_OFFSET_OF(uint64_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(uint64_t_field, struct FieldTypeTestStruct) ==
               128);
-static_assert(CRUBIT_OFFSET_OF(std_uint8_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(std_uint8_t_field, struct FieldTypeTestStruct) ==
               136);
-static_assert(CRUBIT_OFFSET_OF(std_uint16_t_field, class FieldTypeTestStruct) ==
-              138);
-static_assert(CRUBIT_OFFSET_OF(std_uint32_t_field, class FieldTypeTestStruct) ==
-              140);
-static_assert(CRUBIT_OFFSET_OF(std_uint64_t_field, class FieldTypeTestStruct) ==
-              144);
-static_assert(CRUBIT_OFFSET_OF(ptrdiff_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(std_uint16_t_field,
+                               struct FieldTypeTestStruct) == 138);
+static_assert(CRUBIT_OFFSET_OF(std_uint32_t_field,
+                               struct FieldTypeTestStruct) == 140);
+static_assert(CRUBIT_OFFSET_OF(std_uint64_t_field,
+                               struct FieldTypeTestStruct) == 144);
+static_assert(CRUBIT_OFFSET_OF(ptrdiff_t_field, struct FieldTypeTestStruct) ==
               152);
-static_assert(CRUBIT_OFFSET_OF(size_t_field, class FieldTypeTestStruct) == 160);
-static_assert(CRUBIT_OFFSET_OF(intptr_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(size_t_field, struct FieldTypeTestStruct) ==
+              160);
+static_assert(CRUBIT_OFFSET_OF(intptr_t_field, struct FieldTypeTestStruct) ==
               168);
-static_assert(CRUBIT_OFFSET_OF(uintptr_t_field, class FieldTypeTestStruct) ==
+static_assert(CRUBIT_OFFSET_OF(uintptr_t_field, struct FieldTypeTestStruct) ==
               176);
 static_assert(CRUBIT_OFFSET_OF(std_ptrdiff_t_field,
-                               class FieldTypeTestStruct) == 184);
-static_assert(CRUBIT_OFFSET_OF(std_size_t_field, class FieldTypeTestStruct) ==
+                               struct FieldTypeTestStruct) == 184);
+static_assert(CRUBIT_OFFSET_OF(std_size_t_field, struct FieldTypeTestStruct) ==
               192);
-static_assert(CRUBIT_OFFSET_OF(std_intptr_t_field, class FieldTypeTestStruct) ==
-              200);
+static_assert(CRUBIT_OFFSET_OF(std_intptr_t_field,
+                               struct FieldTypeTestStruct) == 200);
 static_assert(CRUBIT_OFFSET_OF(std_uintptr_t_field,
-                               class FieldTypeTestStruct) == 208);
-static_assert(CRUBIT_OFFSET_OF(float_field, class FieldTypeTestStruct) == 216);
-static_assert(CRUBIT_OFFSET_OF(double_field, class FieldTypeTestStruct) == 224);
-static_assert(CRUBIT_OFFSET_OF(ptr_field, class FieldTypeTestStruct) == 232);
-static_assert(CRUBIT_OFFSET_OF(struct_field, class FieldTypeTestStruct) == 240);
-static_assert(CRUBIT_OFFSET_OF(struct_ptr_field, class FieldTypeTestStruct) ==
+                               struct FieldTypeTestStruct) == 208);
+static_assert(CRUBIT_OFFSET_OF(float_field, struct FieldTypeTestStruct) == 216);
+static_assert(CRUBIT_OFFSET_OF(double_field, struct FieldTypeTestStruct) ==
+              224);
+static_assert(CRUBIT_OFFSET_OF(ptr_field, struct FieldTypeTestStruct) == 232);
+static_assert(CRUBIT_OFFSET_OF(struct_field, struct FieldTypeTestStruct) ==
+              240);
+static_assert(CRUBIT_OFFSET_OF(struct_ptr_field, struct FieldTypeTestStruct) ==
               248);
 static_assert(CRUBIT_OFFSET_OF(const_struct_ptr_field,
-                               class FieldTypeTestStruct) == 256);
-static_assert(CRUBIT_OFFSET_OF(struct_ref_field, class FieldTypeTestStruct) ==
+                               struct FieldTypeTestStruct) == 256);
+static_assert(CRUBIT_OFFSET_OF(struct_ref_field, struct FieldTypeTestStruct) ==
               264);
 static_assert(CRUBIT_OFFSET_OF(const_struct_ref_field,
-                               class FieldTypeTestStruct) == 272);
+                               struct FieldTypeTestStruct) == 272);
 static_assert(CRUBIT_OFFSET_OF(forward_declared_ptr_field,
-                               class FieldTypeTestStruct) == 280);
+                               struct FieldTypeTestStruct) == 280);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/unions_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/unions_rs_api_impl.cc
index b49a806..68fda12 100644
--- a/rs_bindings_from_cc/test/golden/unions_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/unions_rs_api_impl.cc
@@ -35,25 +35,25 @@
     union EmptyUnion* __this, union EmptyUnion&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN10NontrivialD1Ev(class Nontrivial* __this) {
+extern "C" void __rust_thunk___ZN10NontrivialD1Ev(struct Nontrivial* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class TriviallyCopyableButNontriviallyDestructible&
+extern "C" struct TriviallyCopyableButNontriviallyDestructible&
 __rust_thunk___ZN44TriviallyCopyableButNontriviallyDestructibleaSERKS_(
-    class TriviallyCopyableButNontriviallyDestructible* __this,
-    const class TriviallyCopyableButNontriviallyDestructible& __param_0) {
+    struct TriviallyCopyableButNontriviallyDestructible* __this,
+    const struct TriviallyCopyableButNontriviallyDestructible& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN44TriviallyCopyableButNontriviallyDestructibleC1ERKS_(
-    class TriviallyCopyableButNontriviallyDestructible* __this,
-    const class TriviallyCopyableButNontriviallyDestructible& __param_0) {
+    struct TriviallyCopyableButNontriviallyDestructible* __this,
+    const struct TriviallyCopyableButNontriviallyDestructible& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void
 __rust_thunk___ZN44TriviallyCopyableButNontriviallyDestructibleD1Ev(
-    class TriviallyCopyableButNontriviallyDestructible* __this) {
+    struct TriviallyCopyableButNontriviallyDestructible* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN13NonEmptyUnionC1Ev(
@@ -140,12 +140,13 @@
 static_assert(sizeof(union EmptyUnion) == 1);
 static_assert(alignof(union EmptyUnion) == 1);
 
-static_assert(sizeof(class Nontrivial) == 4);
-static_assert(alignof(class Nontrivial) == 4);
-static_assert(CRUBIT_OFFSET_OF(field, class Nontrivial) == 0);
+static_assert(sizeof(struct Nontrivial) == 4);
+static_assert(alignof(struct Nontrivial) == 4);
+static_assert(CRUBIT_OFFSET_OF(field, struct Nontrivial) == 0);
 
-static_assert(sizeof(class TriviallyCopyableButNontriviallyDestructible) == 1);
-static_assert(alignof(class TriviallyCopyableButNontriviallyDestructible) == 1);
+static_assert(sizeof(struct TriviallyCopyableButNontriviallyDestructible) == 1);
+static_assert(alignof(struct TriviallyCopyableButNontriviallyDestructible) ==
+              1);
 
 static_assert(sizeof(union NonEmptyUnion) == 8);
 static_assert(alignof(union NonEmptyUnion) == 8);
diff --git a/rs_bindings_from_cc/test/golden/unsupported_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/unsupported_rs_api_impl.cc
index c6772fe..bb34dca 100644
--- a/rs_bindings_from_cc/test/golden/unsupported_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/unsupported_rs_api_impl.cc
@@ -12,72 +12,75 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
 extern "C" void __rust_thunk___ZN17TrivialCustomTypeC1Ev(
-    class TrivialCustomType* __this) {
+    struct TrivialCustomType* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN17TrivialCustomTypeC1ERKS_(
-    class TrivialCustomType* __this, const class TrivialCustomType& __param_0) {
+    struct TrivialCustomType* __this,
+    const struct TrivialCustomType& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN17TrivialCustomTypeC1EOS_(
-    class TrivialCustomType* __this, class TrivialCustomType&& __param_0) {
+    struct TrivialCustomType* __this, struct TrivialCustomType&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN17TrivialCustomTypeD1Ev(
-    class TrivialCustomType* __this) {
+    struct TrivialCustomType* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class TrivialCustomType& __rust_thunk___ZN17TrivialCustomTypeaSERKS_(
-    class TrivialCustomType* __this, const class TrivialCustomType& __param_0) {
+extern "C" struct TrivialCustomType&
+__rust_thunk___ZN17TrivialCustomTypeaSERKS_(
+    struct TrivialCustomType* __this,
+    const struct TrivialCustomType& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class TrivialCustomType& __rust_thunk___ZN17TrivialCustomTypeaSEOS_(
-    class TrivialCustomType* __this, class TrivialCustomType&& __param_0) {
+extern "C" struct TrivialCustomType& __rust_thunk___ZN17TrivialCustomTypeaSEOS_(
+    struct TrivialCustomType* __this, struct TrivialCustomType&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN20NontrivialCustomTypeD1Ev(
-    class NontrivialCustomType* __this) {
+    struct NontrivialCustomType* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN16ContainingStructC1Ev(
-    class ContainingStruct* __this) {
+    struct ContainingStruct* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN16ContainingStructC1ERKS_(
-    class ContainingStruct* __this, const class ContainingStruct& __param_0) {
+    struct ContainingStruct* __this, const struct ContainingStruct& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN16ContainingStructC1EOS_(
-    class ContainingStruct* __this, class ContainingStruct&& __param_0) {
+    struct ContainingStruct* __this, struct ContainingStruct&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN16ContainingStructD1Ev(
-    class ContainingStruct* __this) {
+    struct ContainingStruct* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class ContainingStruct& __rust_thunk___ZN16ContainingStructaSERKS_(
-    class ContainingStruct* __this, const class ContainingStruct& __param_0) {
+extern "C" struct ContainingStruct& __rust_thunk___ZN16ContainingStructaSERKS_(
+    struct ContainingStruct* __this, const struct ContainingStruct& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class ContainingStruct& __rust_thunk___ZN16ContainingStructaSEOS_(
-    class ContainingStruct* __this, class ContainingStruct&& __param_0) {
+extern "C" struct ContainingStruct& __rust_thunk___ZN16ContainingStructaSEOS_(
+    struct ContainingStruct* __this, struct ContainingStruct&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class TrivialCustomType) == 4);
-static_assert(alignof(class TrivialCustomType) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class TrivialCustomType) == 0);
+static_assert(sizeof(struct TrivialCustomType) == 4);
+static_assert(alignof(struct TrivialCustomType) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct TrivialCustomType) == 0);
 
-static_assert(sizeof(class NontrivialCustomType) == 4);
-static_assert(alignof(class NontrivialCustomType) == 4);
-static_assert(CRUBIT_OFFSET_OF(i, class NontrivialCustomType) == 0);
+static_assert(sizeof(struct NontrivialCustomType) == 4);
+static_assert(alignof(struct NontrivialCustomType) == 4);
+static_assert(CRUBIT_OFFSET_OF(i, struct NontrivialCustomType) == 0);
 
-static_assert(sizeof(class ContainingStruct) == 1);
-static_assert(alignof(class ContainingStruct) == 1);
-static_assert(CRUBIT_OFFSET_OF(nested_struct, class ContainingStruct) == 0);
+static_assert(sizeof(struct ContainingStruct) == 1);
+static_assert(alignof(struct ContainingStruct) == 1);
+static_assert(CRUBIT_OFFSET_OF(nested_struct, struct ContainingStruct) == 0);
 
 #pragma clang diagnostic pop
diff --git a/rs_bindings_from_cc/test/golden/user_of_base_class_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/user_of_base_class_rs_api_impl.cc
index bc15511..e585112 100644
--- a/rs_bindings_from_cc/test/golden/user_of_base_class_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/user_of_base_class_rs_api_impl.cc
@@ -11,28 +11,28 @@
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
-extern "C" void __rust_thunk___ZN8Derived2C1Ev(class Derived2* __this) {
+extern "C" void __rust_thunk___ZN8Derived2C1Ev(struct Derived2* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN8Derived2C1ERKS_(
-    class Derived2* __this, const class Derived2& __param_0) {
+    struct Derived2* __this, const struct Derived2& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN8Derived2C1EOS_(class Derived2* __this,
-                                                 class Derived2&& __param_0) {
+extern "C" void __rust_thunk___ZN8Derived2C1EOS_(struct Derived2* __this,
+                                                 struct Derived2&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" void __rust_thunk___ZN8Derived2D1Ev(class Derived2* __this) {
+extern "C" void __rust_thunk___ZN8Derived2D1Ev(struct Derived2* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class Derived2& __rust_thunk___ZN8Derived2aSERKS_(
-    class Derived2* __this, const class Derived2& __param_0) {
+extern "C" struct Derived2& __rust_thunk___ZN8Derived2aSERKS_(
+    struct Derived2* __this, const struct Derived2& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class Derived2& __rust_thunk___ZN8Derived2aSEOS_(
-    class Derived2* __this, class Derived2&& __param_0) {
+extern "C" struct Derived2& __rust_thunk___ZN8Derived2aSEOS_(
+    struct Derived2* __this, struct Derived2&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN15VirtualDerived2C1Ev(
@@ -62,9 +62,9 @@
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class Derived2) == 24);
-static_assert(alignof(class Derived2) == 8);
-static_assert(CRUBIT_OFFSET_OF(derived_1, class Derived2) == 20);
+static_assert(sizeof(struct Derived2) == 24);
+static_assert(alignof(struct Derived2) == 8);
+static_assert(CRUBIT_OFFSET_OF(derived_1, struct Derived2) == 20);
 
 static_assert(sizeof(class VirtualDerived2) == 32);
 static_assert(alignof(class VirtualDerived2) == 8);
diff --git a/rs_bindings_from_cc/test/golden/user_of_imported_type_rs_api_impl.cc b/rs_bindings_from_cc/test/golden/user_of_imported_type_rs_api_impl.cc
index 4f495bb..27f566e 100644
--- a/rs_bindings_from_cc/test/golden/user_of_imported_type_rs_api_impl.cc
+++ b/rs_bindings_from_cc/test/golden/user_of_imported_type_rs_api_impl.cc
@@ -12,38 +12,38 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wthread-safety-analysis"
 extern "C" void __rust_thunk___ZN18UserOfImportedTypeC1Ev(
-    class UserOfImportedType* __this) {
+    struct UserOfImportedType* __this) {
   crubit::construct_at(std::forward<decltype(__this)>(__this));
 }
 extern "C" void __rust_thunk___ZN18UserOfImportedTypeC1ERKS_(
-    class UserOfImportedType* __this,
-    const class UserOfImportedType& __param_0) {
+    struct UserOfImportedType* __this,
+    const struct UserOfImportedType& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN18UserOfImportedTypeC1EOS_(
-    class UserOfImportedType* __this, class UserOfImportedType&& __param_0) {
+    struct UserOfImportedType* __this, struct UserOfImportedType&& __param_0) {
   crubit::construct_at(std::forward<decltype(__this)>(__this),
                        std::forward<decltype(__param_0)>(__param_0));
 }
 extern "C" void __rust_thunk___ZN18UserOfImportedTypeD1Ev(
-    class UserOfImportedType* __this) {
+    struct UserOfImportedType* __this) {
   std::destroy_at(std::forward<decltype(__this)>(__this));
 }
-extern "C" class UserOfImportedType&
+extern "C" struct UserOfImportedType&
 __rust_thunk___ZN18UserOfImportedTypeaSERKS_(
-    class UserOfImportedType* __this,
-    const class UserOfImportedType& __param_0) {
+    struct UserOfImportedType* __this,
+    const struct UserOfImportedType& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
-extern "C" class UserOfImportedType&
+extern "C" struct UserOfImportedType&
 __rust_thunk___ZN18UserOfImportedTypeaSEOS_(
-    class UserOfImportedType* __this, class UserOfImportedType&& __param_0) {
+    struct UserOfImportedType* __this, struct UserOfImportedType&& __param_0) {
   return __this->operator=(std::forward<decltype(__param_0)>(__param_0));
 }
 
-static_assert(sizeof(class UserOfImportedType) == 8);
-static_assert(alignof(class UserOfImportedType) == 8);
-static_assert(CRUBIT_OFFSET_OF(trivial, class UserOfImportedType) == 0);
+static_assert(sizeof(struct UserOfImportedType) == 8);
+static_assert(alignof(struct UserOfImportedType) == 8);
+static_assert(CRUBIT_OFFSET_OF(trivial, struct UserOfImportedType) == 0);
 
 #pragma clang diagnostic pop