Linting semicolons

nyurik · nyurik · commit f020669a78f7 · 2024-11-30T12:44:38.000-05:00
```
cargo clippy --workspace --fix --all-targets -- -A clippy::all -W clippy::semicolon_if_nothing_returned
```
diff --git a/bindgen-cli/main.rs b/bindgen-cli/main.rs
@@ -35,7 +35,7 @@ pub fn main() {
 
             std::panic::set_hook(Box::new(move |info| {
                 if verbose {
-                    print_verbose_err()
+                    print_verbose_err();
                 }
                 eprintln!("{info}");
             }));
diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_with_blocklist.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_blocklist.rs
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs
diff --git a/bindgen-tests/tests/quickchecking/src/bin.rs b/bindgen-tests/tests/quickchecking/src/bin.rs
@@ -105,5 +105,5 @@ fn main() {
     let generate_range = *matches.get_one::<usize>("range").unwrap();
     let tests = *matches.get_one::<u64>("count").unwrap();
 
-    quickchecking::test_bindgen(generate_range, tests, output_path)
+    quickchecking::test_bindgen(generate_range, tests, output_path);
 }
diff --git a/bindgen-tests/tests/quickchecking/src/lib.rs b/bindgen-tests/tests/quickchecking/src/lib.rs
@@ -103,5 +103,5 @@ pub fn test_bindgen(
     QuickCheck::new()
         .tests(tests)
         .gen(Gen::new(generate_range))
-        .quickcheck(bindgen_prop as fn(fuzzers::HeaderC) -> TestResult)
+        .quickcheck(bindgen_prop as fn(fuzzers::HeaderC) -> TestResult);
 }
diff --git a/bindgen/clang.rs b/bindgen/clang.rs
@@ -1144,7 +1144,7 @@ impl Eq for Cursor {}
 
 impl Hash for Cursor {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        unsafe { clang_hashCursor(self.x) }.hash(state)
+        unsafe { clang_hashCursor(self.x) }.hash(state);
     }
 }
 
diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs
@@ -852,7 +852,7 @@ impl CodeGenerator for Type {
                 // it to BindgenContext::compute_allowlisted_and_codegen_items.
             }
             TypeKind::TemplateInstantiation(ref inst) => {
-                inst.codegen(ctx, result, item)
+                inst.codegen(ctx, result, item);
             }
             TypeKind::BlockPointer(inner) => {
                 if !ctx.options().generate_block {
@@ -1143,7 +1143,7 @@ impl CodeGenerator for Type {
                 result.saw_objc();
             }
             TypeKind::ObjCInterface(ref interface) => {
-                interface.codegen(ctx, result, item)
+                interface.codegen(ctx, result, item);
             }
             ref u @ TypeKind::UnresolvedTypeRef(..) => {
                 unreachable!("Should have been resolved after parsing {:?}!", u)
@@ -1230,7 +1230,7 @@ impl CodeGenerator for Vtable<'_> {
                 pub struct #name {
                     #( #methods ),*
                 }
-            })
+            });
         } else {
             // For the cases we don't support, simply generate an empty struct.
             let void = helpers::ast_ty::c_void(ctx);
@@ -2323,7 +2323,7 @@ impl CodeGenerator for CompInfo {
                 let ty = helpers::blob(layout);
                 fields.push(quote! {
                     pub bindgen_union_field: #ty ,
-                })
+                });
             }
         }
 
@@ -2472,7 +2472,7 @@ impl CodeGenerator for CompInfo {
         derives.extend(custom_derives.iter().map(|s| s.as_str()));
 
         if !derives.is_empty() {
-            attributes.push(attributes::derives(&derives))
+            attributes.push(attributes::derives(&derives));
         }
 
         attributes.extend(
@@ -3099,7 +3099,7 @@ impl Method {
                 quote! {
                     __bindgen_tmp
                 }
-            })
+            });
         }
 
         let block = ctx.wrap_unsafe_ops(quote! ( #( #stmts );*));
@@ -4764,7 +4764,7 @@ fn unsupported_abi_diagnostic(
             }
         }
 
-        diag.display()
+        diag.display();
     }
 }
 
@@ -4802,7 +4802,7 @@ fn variadic_fn_diagnostic(
             }
         }
 
-        diag.display()
+        diag.display();
     }
 }
 
@@ -5234,10 +5234,10 @@ pub(crate) mod utils {
                     }
                     match ty.kind() {
                         TypeKind::Alias(type_id_alias) => {
-                            type_id = *type_id_alias
+                            type_id = *type_id_alias;
                         }
                         TypeKind::ResolvedTypeRef(type_id_typedef) => {
-                            type_id = *type_id_typedef
+                            type_id = *type_id_typedef;
                         }
                         _ => break,
                     }
@@ -5718,7 +5718,7 @@ pub(crate) mod utils {
             .collect::<Vec<_>>();
 
         if is_variadic {
-            args.push(quote! { ... })
+            args.push(quote! { ... });
         }
 
         args
diff --git a/bindgen/codegen/postprocessing/merge_extern_blocks.rs b/bindgen/codegen/postprocessing/merge_extern_blocks.rs
@@ -4,22 +4,22 @@ use syn::{
 };
 
 pub(super) fn merge_extern_blocks(file: &mut File) {
-    Visitor.visit_file_mut(file)
+    Visitor.visit_file_mut(file);
 }
 
 struct Visitor;
 
 impl VisitMut for Visitor {
     fn visit_file_mut(&mut self, file: &mut File) {
         visit_items(&mut file.items);
-        visit_file_mut(self, file)
+        visit_file_mut(self, file);
     }
 
     fn visit_item_mod_mut(&mut self, item_mod: &mut ItemMod) {
         if let Some((_, ref mut items)) = item_mod.content {
             visit_items(items);
         }
-        visit_item_mod_mut(self, item_mod)
+        visit_item_mod_mut(self, item_mod);
     }
 }
 
diff --git a/bindgen/codegen/postprocessing/sort_semantically.rs b/bindgen/codegen/postprocessing/sort_semantically.rs
@@ -4,22 +4,22 @@ use syn::{
 };
 
 pub(super) fn sort_semantically(file: &mut File) {
-    Visitor.visit_file_mut(file)
+    Visitor.visit_file_mut(file);
 }
 
 struct Visitor;
 
 impl VisitMut for Visitor {
     fn visit_file_mut(&mut self, file: &mut File) {
         visit_items(&mut file.items);
-        visit_file_mut(self, file)
+        visit_file_mut(self, file);
     }
 
     fn visit_item_mod_mut(&mut self, item_mod: &mut ItemMod) {
         if let Some((_, ref mut items)) = item_mod.content {
             visit_items(items);
         }
-        visit_item_mod_mut(self, item_mod)
+        visit_item_mod_mut(self, item_mod);
     }
 }
 
diff --git a/bindgen/codegen/serialize.rs b/bindgen/codegen/serialize.rs
@@ -228,13 +228,13 @@ impl<'a> CSerialize<'a> for Type {
                 if self.is_const() {
                     write!(writer, "const ")?;
                 }
-                write!(writer, "void")?
+                write!(writer, "void")?;
             }
             TypeKind::NullPtr => {
                 if self.is_const() {
                     write!(writer, "const ")?;
                 }
-                write!(writer, "nullptr_t")?
+                write!(writer, "nullptr_t")?;
             }
             TypeKind::Int(int_kind) => {
                 if self.is_const() {
@@ -285,7 +285,7 @@ impl<'a> CSerialize<'a> for Type {
                     FloatKind::Float => write!(writer, "float complex")?,
                     FloatKind::Double => write!(writer, "double complex")?,
                     FloatKind::LongDouble => {
-                        write!(writer, "long double complex")?
+                        write!(writer, "long double complex")?;
                     }
                     FloatKind::Float128 => write!(writer, "__complex128")?,
                 }
@@ -303,7 +303,7 @@ impl<'a> CSerialize<'a> for Type {
             }
             TypeKind::Array(type_id, length) => {
                 type_id.serialize(ctx, (), stack, writer)?;
-                write!(writer, " [{length}]")?
+                write!(writer, " [{length}]")?;
             }
             TypeKind::Function(signature) => {
                 if self.is_const() {
@@ -341,22 +341,22 @@ impl<'a> CSerialize<'a> for Type {
                             type_id.serialize(ctx, (), &mut stack, buf)
                         },
                     )?;
-                    write!(writer, ")")?
+                    write!(writer, ")")?;
                 }
             }
             TypeKind::ResolvedTypeRef(type_id) => {
                 if self.is_const() {
                     write!(writer, "const ")?;
                 }
-                type_id.serialize(ctx, (), stack, writer)?
+                type_id.serialize(ctx, (), stack, writer)?;
             }
             TypeKind::Pointer(type_id) => {
                 if self.is_const() {
                     stack.push("*const ".to_owned());
                 } else {
                     stack.push("*".to_owned());
                 }
-                type_id.serialize(ctx, (), stack, writer)?
+                type_id.serialize(ctx, (), stack, writer)?;
             }
             TypeKind::Comp(comp_info) => {
                 if self.is_const() {
diff --git a/bindgen/ir/analysis/has_vtable.rs b/bindgen/ir/analysis/has_vtable.rs
@@ -40,7 +40,7 @@ impl ops::BitOr for HasVtableResult {
 
 impl ops::BitOrAssign for HasVtableResult {
     fn bitor_assign(&mut self, rhs: HasVtableResult) {
-        *self = self.join(rhs)
+        *self = self.join(rhs);
     }
 }
 
diff --git a/bindgen/ir/analysis/sizedness.rs b/bindgen/ir/analysis/sizedness.rs
@@ -80,7 +80,7 @@ impl ops::BitOr for SizednessResult {
 
 impl ops::BitOrAssign for SizednessResult {
     fn bitor_assign(&mut self, rhs: SizednessResult) {
-        *self = self.join(rhs)
+        *self = self.join(rhs);
     }
 }
 
diff --git a/bindgen/ir/analysis/template_params.rs b/bindgen/ir/analysis/template_params.rs
@@ -480,7 +480,7 @@ impl<'ctx> MonotoneFramework for UsedTemplateParameters<'ctx> {
                         extra_assert!(dependencies.contains_key(&sub_item));
                     },
                     &(),
-                )
+                );
             }
         }
 
diff --git a/bindgen/ir/annotations.rs b/bindgen/ir/annotations.rs
@@ -227,7 +227,7 @@ impl Annotations {
                     "replaces" => {
                         self.use_instead_of = Some(
                             attr.value.split("::").map(Into::into).collect(),
-                        )
+                        );
                     }
                     "derive" => self.derives.push(attr.value),
                     "attribute" => self.attributes.push(attr.value),
@@ -239,7 +239,7 @@ impl Annotations {
                         };
                     }
                     "accessor" => {
-                        self.accessor_kind = Some(parse_accessor(&attr.value))
+                        self.accessor_kind = Some(parse_accessor(&attr.value));
                     }
                     "constant" => self.constify_enum_variant = true,
                     _ => {}
diff --git a/bindgen/ir/comp.rs b/bindgen/ir/comp.rs
@@ -1699,7 +1699,7 @@ impl CompInfo {
         layout: Option<&Layout>,
     ) {
         let packed = self.is_packed(ctx, layout);
-        self.fields.compute_bitfield_units(ctx, packed)
+        self.fields.compute_bitfield_units(ctx, packed);
     }
 
     /// Assign for each anonymous field a generated name.
diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs
@@ -2262,7 +2262,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         let mut module_name = None;
         let spelling = cursor.spelling();
         if !spelling.is_empty() {
-            module_name = Some(spelling)
+            module_name = Some(spelling);
         }
 
         let mut kind = ModuleKind::Normal;
@@ -2647,7 +2647,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
 
     /// Call if a bindgen complex is generated
     pub(crate) fn generated_bindgen_complex(&self) {
-        self.generated_bindgen_complex.set(true)
+        self.generated_bindgen_complex.set(true);
     }
 
     /// Whether we need to generate the bindgen complex type
@@ -2657,7 +2657,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
 
     /// Call if a bindgen float16 is generated
     pub(crate) fn generated_bindgen_float16(&self) {
-        self.generated_bindgen_float16.set(true)
+        self.generated_bindgen_float16.set(true);
     }
 
     /// Whether we need to generate the bindgen float16 type
diff --git a/bindgen/ir/derive.rs b/bindgen/ir/derive.rs
@@ -125,6 +125,6 @@ impl ops::BitOr for CanDerive {
 
 impl ops::BitOrAssign for CanDerive {
     fn bitor_assign(&mut self, rhs: Self) {
-        *self = self.join(rhs)
+        *self = self.join(rhs);
     }
 }
diff --git a/bindgen/ir/module.rs b/bindgen/ir/module.rs
@@ -84,8 +84,8 @@ impl ClangSubItemParser for Module {
                 let module_id = ctx.module(cursor);
                 ctx.with_module(module_id, |ctx| {
                     cursor.visit_sorted(ctx, |ctx, child| {
-                        parse_one(ctx, child, Some(module_id.into()))
-                    })
+                        parse_one(ctx, child, Some(module_id.into()));
+                    });
                 });
 
                 Ok(ParseResult::AlreadyResolved(module_id.into()))
diff --git a/bindgen/ir/objc.rs b/bindgen/ir/objc.rs
@@ -308,7 +308,7 @@ impl ObjCMethod {
             let arg = arg.to_string();
             let name_and_sig: Vec<&str> = arg.split(' ').collect();
             let name = name_and_sig[0];
-            args_without_types.push(Ident::new(name, Span::call_site()))
+            args_without_types.push(Ident::new(name, Span::call_site()));
         }
 
         let args = split_name.into_iter().zip(args_without_types).map(
diff --git a/bindgen/ir/traversal.rs b/bindgen/ir/traversal.rs
diff --git a/bindgen/ir/ty.rs b/bindgen/ir/ty.rs
diff --git a/bindgen/lib.rs b/bindgen/lib.rs
diff --git a/bindgen/options/cli.rs b/bindgen/options/cli.rs
diff --git a/bindgen/regex_set.rs b/bindgen/regex_set.rs

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ pub fn main() {`
`35`	`35`
`36`	`36`	`std::panic::set_hook(Box::new(move \|info\| {`
`37`	`37`	`if verbose {`
`38`		`- print_verbose_err()`
	`38`	`+ print_verbose_err();`
`39`	`39`	`}`
`40`	`40`	`eprintln!("{info}");`
`41`	`41`	`}));`
Original file line number	Diff line number	Diff line change
`@@ -105,5 +105,5 @@ fn main() {`
`105`	`105`	`let generate_range = *matches.get_one::<usize>("range").unwrap();`
`106`	`106`	`let tests = *matches.get_one::<u64>("count").unwrap();`
`107`	`107`
`108`		`- quickchecking::test_bindgen(generate_range, tests, output_path)`
	`108`	`+ quickchecking::test_bindgen(generate_range, tests, output_path);`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,5 +103,5 @@ pub fn test_bindgen(`
`103`	`103`	`QuickCheck::new()`
`104`	`104`	`.tests(tests)`
`105`	`105`	`.gen(Gen::new(generate_range))`
`106`		`- .quickcheck(bindgen_prop as fn(fuzzers::HeaderC) -> TestResult)`
	`106`	`+ .quickcheck(bindgen_prop as fn(fuzzers::HeaderC) -> TestResult);`
`107`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1144,7 +1144,7 @@ impl Eq for Cursor {}`
`1144`	`1144`
`1145`	`1145`	`impl Hash for Cursor {`
`1146`	`1146`	`fn hash<H: Hasher>(&self, state: &mut H) {`
`1147`		`- unsafe { clang_hashCursor(self.x) }.hash(state)`
	`1147`	`+ unsafe { clang_hashCursor(self.x) }.hash(state);`
`1148`	`1148`	`}`
`1149`	`1149`	`}`
`1150`	`1150`
Original file line number	Diff line number	Diff line change
`@@ -852,7 +852,7 @@ impl CodeGenerator for Type {`
`852`	`852`	`// it to BindgenContext::compute_allowlisted_and_codegen_items.`
`853`	`853`	`}`
`854`	`854`	`TypeKind::TemplateInstantiation(ref inst) => {`
`855`		`- inst.codegen(ctx, result, item)`
	`855`	`+ inst.codegen(ctx, result, item);`
`856`	`856`	`}`
`857`	`857`	`TypeKind::BlockPointer(inner) => {`
`858`	`858`	`if !ctx.options().generate_block {`
`@@ -1143,7 +1143,7 @@ impl CodeGenerator for Type {`
`1143`	`1143`	`result.saw_objc();`
`1144`	`1144`	`}`
`1145`	`1145`	`TypeKind::ObjCInterface(ref interface) => {`
`1146`		`- interface.codegen(ctx, result, item)`
	`1146`	`+ interface.codegen(ctx, result, item);`
`1147`	`1147`	`}`
`1148`	`1148`	`ref u @ TypeKind::UnresolvedTypeRef(..) => {`
`1149`	`1149`	`unreachable!("Should have been resolved after parsing {:?}!", u)`
`@@ -1230,7 +1230,7 @@ impl CodeGenerator for Vtable<'_> {`
`1230`	`1230`	`pub struct #name {`
`1231`	`1231`	`#( #methods ),*`
`1232`	`1232`	`}`
`1233`		`- })`
	`1233`	`+ });`
`1234`	`1234`	`} else {`
`1235`	`1235`	`// For the cases we don't support, simply generate an empty struct.`
`1236`	`1236`	`let void = helpers::ast_ty::c_void(ctx);`
`@@ -2323,7 +2323,7 @@ impl CodeGenerator for CompInfo {`
`2323`	`2323`	`let ty = helpers::blob(layout);`
`2324`	`2324`	`fields.push(quote! {`
`2325`	`2325`	`pub bindgen_union_field: #ty ,`
`2326`		`- })`
	`2326`	`+ });`
`2327`	`2327`	`}`
`2328`	`2328`	`}`
`2329`	`2329`
`@@ -2472,7 +2472,7 @@ impl CodeGenerator for CompInfo {`
`2472`	`2472`	`derives.extend(custom_derives.iter().map(\|s\| s.as_str()));`
`2473`	`2473`
`2474`	`2474`	`if !derives.is_empty() {`
`2475`		`- attributes.push(attributes::derives(&derives))`
	`2475`	`+ attributes.push(attributes::derives(&derives));`
`2476`	`2476`	`}`
`2477`	`2477`
`2478`	`2478`	`attributes.extend(`
`@@ -3099,7 +3099,7 @@ impl Method {`
`3099`	`3099`	`quote! {`
`3100`	`3100`	`__bindgen_tmp`
`3101`	`3101`	`}`
`3102`		`- })`
	`3102`	`+ });`
`3103`	`3103`	`}`
`3104`	`3104`
`3105`	`3105`	`let block = ctx.wrap_unsafe_ops(quote! ( #( #stmts );*));`
`@@ -4764,7 +4764,7 @@ fn unsupported_abi_diagnostic(`
`4764`	`4764`	`}`
`4765`	`4765`	`}`
`4766`	`4766`
`4767`		`- diag.display()`
	`4767`	`+ diag.display();`
`4768`	`4768`	`}`
`4769`	`4769`	`}`
`4770`	`4770`
`@@ -4802,7 +4802,7 @@ fn variadic_fn_diagnostic(`
`4802`	`4802`	`}`
`4803`	`4803`	`}`
`4804`	`4804`
`4805`		`- diag.display()`
	`4805`	`+ diag.display();`
`4806`	`4806`	`}`
`4807`	`4807`	`}`
`4808`	`4808`
`@@ -5234,10 +5234,10 @@ pub(crate) mod utils {`
`5234`	`5234`	`}`
`5235`	`5235`	`match ty.kind() {`
`5236`	`5236`	`TypeKind::Alias(type_id_alias) => {`
`5237`		`- type_id = *type_id_alias`
	`5237`	`+ type_id = *type_id_alias;`
`5238`	`5238`	`}`
`5239`	`5239`	`TypeKind::ResolvedTypeRef(type_id_typedef) => {`
`5240`		`- type_id = *type_id_typedef`
	`5240`	`+ type_id = *type_id_typedef;`
`5241`	`5241`	`}`
`5242`	`5242`	`_ => break,`
`5243`	`5243`	`}`
`@@ -5718,7 +5718,7 @@ pub(crate) mod utils {`
`5718`	`5718`	`.collect::<Vec<_>>();`
`5719`	`5719`
`5720`	`5720`	`if is_variadic {`
`5721`		`- args.push(quote! { ... })`
	`5721`	`+ args.push(quote! { ... });`
`5722`	`5722`	`}`
`5723`	`5723`
`5724`	`5724`	`args`
Original file line number	Diff line number	Diff line change
`@@ -4,22 +4,22 @@ use syn::{`
`4`	`4`	`};`
`5`	`5`
`6`	`6`	`pub(super) fn merge_extern_blocks(file: &mut File) {`
`7`		`- Visitor.visit_file_mut(file)`
	`7`	`+ Visitor.visit_file_mut(file);`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`struct Visitor;`
`11`	`11`
`12`	`12`	`impl VisitMut for Visitor {`
`13`	`13`	`fn visit_file_mut(&mut self, file: &mut File) {`
`14`	`14`	`visit_items(&mut file.items);`
`15`		`- visit_file_mut(self, file)`
	`15`	`+ visit_file_mut(self, file);`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`fn visit_item_mod_mut(&mut self, item_mod: &mut ItemMod) {`
`19`	`19`	`if let Some((_, ref mut items)) = item_mod.content {`
`20`	`20`	`visit_items(items);`
`21`	`21`	`}`
`22`		`- visit_item_mod_mut(self, item_mod)`
	`22`	`+ visit_item_mod_mut(self, item_mod);`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
Original file line number	Diff line number	Diff line change
`@@ -4,22 +4,22 @@ use syn::{`
`4`	`4`	`};`
`5`	`5`
`6`	`6`	`pub(super) fn sort_semantically(file: &mut File) {`
`7`		`- Visitor.visit_file_mut(file)`
	`7`	`+ Visitor.visit_file_mut(file);`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`struct Visitor;`
`11`	`11`
`12`	`12`	`impl VisitMut for Visitor {`
`13`	`13`	`fn visit_file_mut(&mut self, file: &mut File) {`
`14`	`14`	`visit_items(&mut file.items);`
`15`		`- visit_file_mut(self, file)`
	`15`	`+ visit_file_mut(self, file);`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`fn visit_item_mod_mut(&mut self, item_mod: &mut ItemMod) {`
`19`	`19`	`if let Some((_, ref mut items)) = item_mod.content {`
`20`	`20`	`visit_items(items);`
`21`	`21`	`}`
`22`		`- visit_item_mod_mut(self, item_mod)`
	`22`	`+ visit_item_mod_mut(self, item_mod);`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
Original file line number	Diff line number	Diff line change
`@@ -228,13 +228,13 @@ impl<'a> CSerialize<'a> for Type {`
`228`	`228`	`if self.is_const() {`
`229`	`229`	`write!(writer, "const ")?;`
`230`	`230`	`}`
`231`		`- write!(writer, "void")?`
	`231`	`+ write!(writer, "void")?;`
`232`	`232`	`}`
`233`	`233`	`TypeKind::NullPtr => {`
`234`	`234`	`if self.is_const() {`
`235`	`235`	`write!(writer, "const ")?;`
`236`	`236`	`}`
`237`		`- write!(writer, "nullptr_t")?`
	`237`	`+ write!(writer, "nullptr_t")?;`
`238`	`238`	`}`
`239`	`239`	`TypeKind::Int(int_kind) => {`
`240`	`240`	`if self.is_const() {`
`@@ -285,7 +285,7 @@ impl<'a> CSerialize<'a> for Type {`
`285`	`285`	`FloatKind::Float => write!(writer, "float complex")?,`
`286`	`286`	`FloatKind::Double => write!(writer, "double complex")?,`
`287`	`287`	`FloatKind::LongDouble => {`
`288`		`- write!(writer, "long double complex")?`
	`288`	`+ write!(writer, "long double complex")?;`
`289`	`289`	`}`
`290`	`290`	`FloatKind::Float128 => write!(writer, "__complex128")?,`
`291`	`291`	`}`
`@@ -303,7 +303,7 @@ impl<'a> CSerialize<'a> for Type {`
`303`	`303`	`}`
`304`	`304`	`TypeKind::Array(type_id, length) => {`
`305`	`305`	`type_id.serialize(ctx, (), stack, writer)?;`
`306`		`- write!(writer, " [{length}]")?`
	`306`	`+ write!(writer, " [{length}]")?;`
`307`	`307`	`}`
`308`	`308`	`TypeKind::Function(signature) => {`
`309`	`309`	`if self.is_const() {`
`@@ -341,22 +341,22 @@ impl<'a> CSerialize<'a> for Type {`
`341`	`341`	`type_id.serialize(ctx, (), &mut stack, buf)`
`342`	`342`	`},`
`343`	`343`	`)?;`
`344`		`- write!(writer, ")")?`
	`344`	`+ write!(writer, ")")?;`
`345`	`345`	`}`
`346`	`346`	`}`
`347`	`347`	`TypeKind::ResolvedTypeRef(type_id) => {`
`348`	`348`	`if self.is_const() {`
`349`	`349`	`write!(writer, "const ")?;`
`350`	`350`	`}`
`351`		`- type_id.serialize(ctx, (), stack, writer)?`
	`351`	`+ type_id.serialize(ctx, (), stack, writer)?;`
`352`	`352`	`}`
`353`	`353`	`TypeKind::Pointer(type_id) => {`
`354`	`354`	`if self.is_const() {`
`355`	`355`	`stack.push("*const ".to_owned());`
`356`	`356`	`} else {`
`357`	`357`	`stack.push("*".to_owned());`
`358`	`358`	`}`
`359`		`- type_id.serialize(ctx, (), stack, writer)?`
	`359`	`+ type_id.serialize(ctx, (), stack, writer)?;`
`360`	`360`	`}`
`361`	`361`	`TypeKind::Comp(comp_info) => {`
`362`	`362`	`if self.is_const() {`