diff --git a/src/bindgen/bindings.rs b/src/bindgen/bindings.rs
index 289dad8e3..329860ddf 100644
--- a/src/bindgen/bindings.rs
+++ b/src/bindgen/bindings.rs
@@ -202,10 +202,10 @@ impl Bindings {
     pub fn write<F: Write>(&self, file: F) {
         match self.config.language {
             Language::Cxx | Language::C => {
-                self.write_with_backend(file, &CLikeLanguageBackend::new(self.config.clone()))
+                self.write_with_backend(file, &CLikeLanguageBackend::new(&self.config))
             }
             Language::Cython => {
-                self.write_with_backend(file, &CythonLanguageBackend::new(self.config.clone()))
+                self.write_with_backend(file, &CythonLanguageBackend::new(&self.config))
             }
         }
     }
diff --git a/src/bindgen/language_backend/clike.rs b/src/bindgen/language_backend/clike.rs
index 847795121..9be0e102f 100644
--- a/src/bindgen/language_backend/clike.rs
+++ b/src/bindgen/language_backend/clike.rs
@@ -10,17 +10,17 @@ use crate::bindgen::{cdecl, Config, Language, Layout};
 use crate::bindgen::{DocumentationLength, DocumentationStyle};
 use std::io::Write;
 
-pub struct CLikeLanguageBackend {
-    config: Config,
+pub struct CLikeLanguageBackend<'a> {
+    config: &'a Config,
 }
 
-impl CLikeLanguageBackend {
-    pub fn new(config: Config) -> Self {
+impl<'a> CLikeLanguageBackend<'a> {
+    pub fn new(config: &'a Config) -> Self {
         Self { config }
     }
 }
 
-impl LanguageBackend for CLikeLanguageBackend {
+impl LanguageBackend for CLikeLanguageBackend<'_> {
     fn write_headers<W: Write>(&self, out: &mut SourceWriter<W>) {
         if let Some(ref f) = self.config.header {
             out.new_line_if_not_start();
@@ -181,9 +181,9 @@ impl LanguageBackend for CLikeLanguageBackend {
     }
 
     fn write_enum_variant<W: Write>(&self, out: &mut SourceWriter<W>, u: &EnumVariant) {
-        let condition = u.cfg.to_condition(&self.config);
+        let condition = u.cfg.to_condition(self.config);
 
-        condition.write_before(&self.config, out);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &u.documentation);
         write!(out, "{}", u.export_name);
@@ -193,20 +193,17 @@ impl LanguageBackend for CLikeLanguageBackend {
             self.write_literal(out, discriminant);
         }
         out.write(",");
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_enum<W: Write>(&self, out: &mut SourceWriter<W>, e: &Enum) {
-        let size = e
-            .repr
-            .ty
-            .map(|ty| ty.to_primitive().to_repr_c(&self.config));
+        let size = e.repr.ty.map(|ty| ty.to_primitive().to_repr_c(self.config));
         let has_data = e.tag.is_some();
         let inline_tag_field = Enum::inline_tag_field(&e.repr);
         let tag_name = e.tag_name();
 
-        let condition = e.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = e.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &e.documentation);
         self.write_generic_param(out, &e.generic_params);
@@ -215,15 +212,15 @@ impl LanguageBackend for CLikeLanguageBackend {
         // and enum for the tag. C++ supports nested type definitions, so we open
         // the struct or union here and define the tag enum inside it (*).
         if has_data && self.config.language == Language::Cxx {
-            e.open_struct_or_union(&self.config, out, inline_tag_field);
+            e.open_struct_or_union(self.config, out, inline_tag_field);
         }
 
         // Emit the tag enum and everything related to it.
-        e.write_tag_enum(&self.config, self, out, size, has_data, tag_name);
+        e.write_tag_enum(self.config, self, out, size, has_data, tag_name);
 
         // If the enum has data, we need to emit structs for the variants and gather them together.
         if has_data {
-            e.write_variant_defs(&self.config, self, out);
+            e.write_variant_defs(self.config, self, out);
             out.new_line();
             out.new_line();
 
@@ -231,11 +228,11 @@ impl LanguageBackend for CLikeLanguageBackend {
             // together, unless it's C++, then we have already opened that struct/union at (*) and
             // are currently inside it.
             if self.config.language != Language::Cxx {
-                e.open_struct_or_union(&self.config, out, inline_tag_field);
+                e.open_struct_or_union(self.config, out, inline_tag_field);
             }
 
             // Emit tag field that is separate from all variants.
-            e.write_tag_field(&self.config, out, size, inline_tag_field, tag_name);
+            e.write_tag_field(self.config, out, size, inline_tag_field, tag_name);
             out.new_line();
 
             // Open union of all variants with data, only in the non-inline tag scenario.
@@ -245,7 +242,7 @@ impl LanguageBackend for CLikeLanguageBackend {
             }
 
             // Emit fields for all variants with data.
-            e.write_variant_fields(&self.config, self, out, inline_tag_field);
+            e.write_variant_fields(self.config, self, out, inline_tag_field);
 
             // Close union of all variants with data, only in the non-inline tag scenario.
             if !inline_tag_field {
@@ -253,7 +250,7 @@ impl LanguageBackend for CLikeLanguageBackend {
             }
 
             // Emit convenience methods for the struct or enum for the data.
-            e.write_derived_functions_data(&self.config, self, out, tag_name);
+            e.write_derived_functions_data(self.config, self, out, tag_name);
 
             // Emit the post_body section, if relevant.
             if let Some(body) = self.config.export.post_body(&e.path) {
@@ -270,7 +267,7 @@ impl LanguageBackend for CLikeLanguageBackend {
             }
         }
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_struct<W: Write>(&self, out: &mut SourceWriter<W>, s: &Struct) {
@@ -287,13 +284,13 @@ impl LanguageBackend for CLikeLanguageBackend {
             self.write_type_def(out, &typedef);
             for constant in &s.associated_constants {
                 out.new_line();
-                constant.write(&self.config, self, out, Some(s));
+                constant.write(self.config, self, out, Some(s));
             }
             return;
         }
 
-        let condition = s.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = s.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &s.documentation);
 
@@ -331,7 +328,7 @@ impl LanguageBackend for CLikeLanguageBackend {
             }
         }
 
-        if s.annotations.must_use(&self.config) {
+        if s.annotations.must_use(self.config) {
             if let Some(ref anno) = self.config.structure.must_use {
                 write!(out, " {}", anno);
             }
@@ -582,7 +579,7 @@ impl LanguageBackend for CLikeLanguageBackend {
         {
             for constant in &s.associated_constants {
                 out.new_line();
-                constant.write_declaration(&self.config, self, out, s);
+                constant.write_declaration(self.config, self, out, s);
             }
         }
 
@@ -595,15 +592,15 @@ impl LanguageBackend for CLikeLanguageBackend {
 
         for constant in &s.associated_constants {
             out.new_line();
-            constant.write(&self.config, self, out, Some(s));
+            constant.write(self.config, self, out, Some(s));
         }
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_union<W: Write>(&self, out: &mut SourceWriter<W>, u: &Union) {
-        let condition = u.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = u.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &u.documentation);
 
@@ -666,16 +663,16 @@ impl LanguageBackend for CLikeLanguageBackend {
             out.close_brace(true);
         }
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_opaque_item<W: Write>(&self, out: &mut SourceWriter<W>, o: &OpaqueItem) {
-        let condition = o.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = o.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &o.documentation);
 
-        o.generic_params.write_with_default(self, &self.config, out);
+        o.generic_params.write_with_default(self, self.config, out);
 
         match self.config.language {
             Language::C if self.config.style.generate_typedef() => {
@@ -692,21 +689,21 @@ impl LanguageBackend for CLikeLanguageBackend {
             _ => unreachable!(),
         }
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_field<W: Write>(&self, out: &mut SourceWriter<W>, f: &Field) {
-        let condition = f.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = f.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &f.documentation);
-        cdecl::write_field(self, out, &f.ty, &f.name, &self.config);
+        cdecl::write_field(self, out, &f.ty, &f.name, self.config);
 
         if let Some(bitfield) = f.annotations.atom("bitfield") {
             write!(out, ": {}", bitfield.unwrap_or_default());
         }
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
         // FIXME(#634): `write_vertical_source_list` should support
         // configuring list elements natively. For now we print a newline
         // here to avoid printing `#endif;` with semicolon.
@@ -716,12 +713,12 @@ impl LanguageBackend for CLikeLanguageBackend {
     }
 
     fn write_generic_param<W: Write>(&self, out: &mut SourceWriter<W>, g: &GenericParams) {
-        g.write_internal(self, &self.config, out, false);
+        g.write_internal(self, self.config, out, false);
     }
 
     fn write_type_def<W: Write>(&self, out: &mut SourceWriter<W>, t: &Typedef) {
-        let condition = t.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = t.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &t.documentation);
 
@@ -744,7 +741,7 @@ impl LanguageBackend for CLikeLanguageBackend {
 
         out.write(";");
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_static<W: Write>(&self, out: &mut SourceWriter<W>, s: &Static) {
@@ -753,7 +750,7 @@ impl LanguageBackend for CLikeLanguageBackend {
         } else if !s.mutable {
             out.write("const ");
         }
-        cdecl::write_field(self, out, &s.ty, &s.export_name, &self.config);
+        cdecl::write_field(self, out, &s.ty, &s.export_name, self.config);
         out.write(";");
     }
 
@@ -766,8 +763,8 @@ impl LanguageBackend for CLikeLanguageBackend {
             let prefix = language_backend.config.function.prefix(&func.annotations);
             let postfix = language_backend.config.function.postfix(&func.annotations);
 
-            let condition = func.cfg.to_condition(&language_backend.config);
-            condition.write_before(&language_backend.config, out);
+            let condition = func.cfg.to_condition(language_backend.config);
+            condition.write_before(language_backend.config, out);
 
             language_backend.write_documentation(out, &func.documentation);
 
@@ -777,7 +774,7 @@ impl LanguageBackend for CLikeLanguageBackend {
                 if let Some(ref prefix) = prefix {
                     write!(out, "{} ", prefix);
                 }
-                if func.annotations.must_use(&language_backend.config) {
+                if func.annotations.must_use(language_backend.config) {
                     if let Some(ref anno) = language_backend.config.function.must_use {
                         write!(out, "{} ", anno);
                     }
@@ -788,7 +785,7 @@ impl LanguageBackend for CLikeLanguageBackend {
                 out,
                 func,
                 Layout::Horizontal,
-                &language_backend.config,
+                language_backend.config,
             );
 
             if !func.extern_decl {
@@ -798,14 +795,14 @@ impl LanguageBackend for CLikeLanguageBackend {
             }
 
             if let Some(ref swift_name_macro) = language_backend.config.function.swift_name_macro {
-                if let Some(swift_name) = func.swift_name(&language_backend.config) {
+                if let Some(swift_name) = func.swift_name(language_backend.config) {
                     write!(out, " {}({})", swift_name_macro, swift_name);
                 }
             }
 
             out.write(";");
 
-            condition.write_after(&language_backend.config, out);
+            condition.write_after(language_backend.config, out);
         }
 
         fn write_2<W: Write>(
@@ -816,9 +813,9 @@ impl LanguageBackend for CLikeLanguageBackend {
             let prefix = language_backend.config.function.prefix(&func.annotations);
             let postfix = language_backend.config.function.postfix(&func.annotations);
 
-            let condition = func.cfg.to_condition(&language_backend.config);
+            let condition = func.cfg.to_condition(language_backend.config);
 
-            condition.write_before(&language_backend.config, out);
+            condition.write_before(language_backend.config, out);
 
             language_backend.write_documentation(out, &func.documentation);
 
@@ -829,7 +826,7 @@ impl LanguageBackend for CLikeLanguageBackend {
                     write!(out, "{}", prefix);
                     out.new_line();
                 }
-                if func.annotations.must_use(&language_backend.config) {
+                if func.annotations.must_use(language_backend.config) {
                     if let Some(ref anno) = language_backend.config.function.must_use {
                         write!(out, "{}", anno);
                         out.new_line();
@@ -841,7 +838,7 @@ impl LanguageBackend for CLikeLanguageBackend {
                 out,
                 func,
                 Layout::Vertical,
-                &language_backend.config,
+                language_backend.config,
             );
             if !func.extern_decl {
                 if let Some(ref postfix) = postfix {
@@ -851,14 +848,14 @@ impl LanguageBackend for CLikeLanguageBackend {
             }
 
             if let Some(ref swift_name_macro) = language_backend.config.function.swift_name_macro {
-                if let Some(swift_name) = func.swift_name(&language_backend.config) {
+                if let Some(swift_name) = func.swift_name(language_backend.config) {
                     write!(out, " {}({})", swift_name_macro, swift_name);
                 }
             }
 
             out.write(";");
 
-            condition.write_after(&language_backend.config, out);
+            condition.write_after(language_backend.config, out);
         }
 
         match self.config.function.args {
@@ -873,7 +870,7 @@ impl LanguageBackend for CLikeLanguageBackend {
     }
 
     fn write_type<W: Write>(&self, out: &mut SourceWriter<W>, t: &Type) {
-        cdecl::write_type(self, out, t, &self.config);
+        cdecl::write_type(self, out, t, self.config);
     }
 
     fn write_documentation<W: Write>(&self, out: &mut SourceWriter<W>, d: &Documentation) {
diff --git a/src/bindgen/language_backend/cython.rs b/src/bindgen/language_backend/cython.rs
index 6b57cba2e..47a341e5e 100644
--- a/src/bindgen/language_backend/cython.rs
+++ b/src/bindgen/language_backend/cython.rs
@@ -10,17 +10,17 @@ use crate::bindgen::Layout;
 use crate::bindgen::{cdecl, Config};
 use std::io::Write;
 
-pub struct CythonLanguageBackend {
-    config: Config,
+pub struct CythonLanguageBackend<'a> {
+    config: &'a Config,
 }
 
-impl CythonLanguageBackend {
-    pub fn new(config: Config) -> Self {
+impl<'a> CythonLanguageBackend<'a> {
+    pub fn new(config: &'a Config) -> Self {
         Self { config }
     }
 }
 
-impl LanguageBackend for CythonLanguageBackend {
+impl LanguageBackend for CythonLanguageBackend<'_> {
     fn write_headers<W: Write>(&self, out: &mut SourceWriter<W>) {
         if let Some(ref f) = self.config.header {
             out.new_line_if_not_start();
@@ -37,7 +37,7 @@ impl LanguageBackend for CythonLanguageBackend {
             );
             out.new_line();
         }
-        if let Some(ref f) = self.config.autogen_warning {
+        if let Some(ref f) = &self.config.autogen_warning {
             out.new_line_if_not_start();
             write!(out, "{}", f);
             out.new_line();
@@ -54,7 +54,7 @@ impl LanguageBackend for CythonLanguageBackend {
 
         out.new_line_if_not_start();
 
-        if !self.config.no_includes {
+        if !&self.config.no_includes {
             out.write("from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t");
             out.new_line();
             out.write("from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t");
@@ -73,7 +73,7 @@ impl LanguageBackend for CythonLanguageBackend {
             out.new_line();
         }
 
-        if let Some(ref line) = self.config.after_includes {
+        if let Some(ref line) = &self.config.after_includes {
             write!(out, "{}", line);
             out.new_line();
         }
@@ -82,7 +82,7 @@ impl LanguageBackend for CythonLanguageBackend {
     fn open_close_namespaces<W: Write>(&self, op: NamespaceOperation, out: &mut SourceWriter<W>) {
         if op == NamespaceOperation::Open {
             out.new_line();
-            let header = self.config.cython.header.as_deref().unwrap_or("*");
+            let header = &self.config.cython.header.as_deref().unwrap_or("*");
             write!(out, "cdef extern from {}", header);
             out.open_brace();
         } else {
@@ -108,40 +108,37 @@ impl LanguageBackend for CythonLanguageBackend {
     }
 
     fn write_enum<W: Write>(&self, out: &mut SourceWriter<W>, e: &Enum) {
-        let size = e
-            .repr
-            .ty
-            .map(|ty| ty.to_primitive().to_repr_c(&self.config));
+        let size = e.repr.ty.map(|ty| ty.to_primitive().to_repr_c(self.config));
         let has_data = e.tag.is_some();
         let inline_tag_field = Enum::inline_tag_field(&e.repr);
         let tag_name = e.tag_name();
 
-        let condition = e.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = e.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &e.documentation);
         self.write_generic_param(out, &e.generic_params);
 
         // Emit the tag enum and everything related to it.
-        e.write_tag_enum(&self.config, self, out, size, has_data, tag_name);
+        e.write_tag_enum(self.config, self, out, size, has_data, tag_name);
 
         // If the enum has data, we need to emit structs for the variants and gather them together.
         if has_data {
-            e.write_variant_defs(&self.config, self, out);
+            e.write_variant_defs(self.config, self, out);
             out.new_line();
             out.new_line();
 
-            e.open_struct_or_union(&self.config, out, inline_tag_field);
+            e.open_struct_or_union(self.config, out, inline_tag_field);
 
             // Emit tag field that is separate from all variants.
-            e.write_tag_field(&self.config, out, size, inline_tag_field, tag_name);
+            e.write_tag_field(self.config, out, size, inline_tag_field, tag_name);
             out.new_line();
 
             // Emit fields for all variants with data.
-            e.write_variant_fields(&self.config, self, out, inline_tag_field);
+            e.write_variant_fields(self.config, self, out, inline_tag_field);
 
             // Emit the post_body section, if relevant.
-            if let Some(body) = self.config.export.post_body(&e.path) {
+            if let Some(body) = &self.config.export.post_body(&e.path) {
                 out.new_line();
                 out.write_raw_block(body);
             }
@@ -149,7 +146,7 @@ impl LanguageBackend for CythonLanguageBackend {
             out.close_brace(true);
         }
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_struct<W: Write>(&self, out: &mut SourceWriter<W>, s: &Struct) {
@@ -166,13 +163,13 @@ impl LanguageBackend for CythonLanguageBackend {
             self.write_type_def(out, &typedef);
             for constant in &s.associated_constants {
                 out.new_line();
-                constant.write(&self.config, self, out, Some(s));
+                constant.write(self.config, self, out, Some(s));
             }
             return;
         }
 
-        let condition = s.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = s.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &s.documentation);
 
@@ -194,8 +191,8 @@ impl LanguageBackend for CythonLanguageBackend {
 
         out.write("struct");
 
-        if s.annotations.must_use(&self.config) {
-            if let Some(ref anno) = self.config.structure.must_use {
+        if s.annotations.must_use(self.config) {
+            if let Some(ref anno) = &self.config.structure.must_use {
                 write!(out, " {}", anno);
             }
         }
@@ -205,7 +202,7 @@ impl LanguageBackend for CythonLanguageBackend {
         out.open_brace();
 
         // Emit the pre_body section, if relevant
-        if let Some(body) = self.config.export.pre_body(&s.path) {
+        if let Some(body) = &self.config.export.pre_body(&s.path) {
             out.write_raw_block(body);
             out.new_line();
         }
@@ -216,7 +213,7 @@ impl LanguageBackend for CythonLanguageBackend {
         }
 
         // Emit the post_body section, if relevant
-        if let Some(body) = self.config.export.post_body(&s.path) {
+        if let Some(body) = &self.config.export.post_body(&s.path) {
             out.new_line();
             out.write_raw_block(body);
         }
@@ -224,15 +221,15 @@ impl LanguageBackend for CythonLanguageBackend {
 
         for constant in &s.associated_constants {
             out.new_line();
-            constant.write(&self.config, self, out, Some(s));
+            constant.write(self.config, self, out, Some(s));
         }
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_union<W: Write>(&self, out: &mut SourceWriter<W>, u: &Union) {
-        let condition = u.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = u.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &u.documentation);
 
@@ -247,7 +244,7 @@ impl LanguageBackend for CythonLanguageBackend {
         out.open_brace();
 
         // Emit the pre_body section, if relevant
-        if let Some(body) = self.config.export.pre_body(&u.path) {
+        if let Some(body) = &self.config.export.pre_body(&u.path) {
             out.write_raw_block(body);
             out.new_line();
         }
@@ -258,43 +255,43 @@ impl LanguageBackend for CythonLanguageBackend {
         }
 
         // Emit the post_body section, if relevant
-        if let Some(body) = self.config.export.post_body(&u.path) {
+        if let Some(body) = &self.config.export.post_body(&u.path) {
             out.new_line();
             out.write_raw_block(body);
         }
 
         out.close_brace(true);
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_opaque_item<W: Write>(&self, out: &mut SourceWriter<W>, o: &OpaqueItem) {
-        let condition = o.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = o.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &o.documentation);
 
-        o.generic_params.write_with_default(self, &self.config, out);
+        o.generic_params.write_with_default(self, self.config, out);
 
         write!(
             out,
             "{}struct {}",
-            self.config.style.cython_def(),
+            &self.config.style.cython_def(),
             o.export_name()
         );
         out.open_brace();
         out.write("pass");
         out.close_brace(false);
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_field<W: Write>(&self, out: &mut SourceWriter<W>, f: &Field) {
         // Cython doesn't support conditional fields.
-        // let condition = f.cfg.to_condition(&self.config);
+        // let condition = f.cfg.to_condition(self.config);
 
         self.write_documentation(out, &f.documentation);
-        cdecl::write_field(self, out, &f.ty, &f.name, &self.config);
+        cdecl::write_field(self, out, &f.ty, &f.name, self.config);
 
         // Cython extern declarations don't manage layouts, layouts are defined entierly by the
         // corresponding C code. So we can omit bitfield sizes which are not supported by Cython.
@@ -308,14 +305,14 @@ impl LanguageBackend for CythonLanguageBackend {
     }
 
     fn write_type_def<W: Write>(&self, out: &mut SourceWriter<W>, t: &Typedef) {
-        let condition = t.cfg.to_condition(&self.config);
-        condition.write_before(&self.config, out);
+        let condition = t.cfg.to_condition(self.config);
+        condition.write_before(self.config, out);
 
         self.write_documentation(out, &t.documentation);
 
         self.write_generic_param(out, &t.generic_params);
 
-        write!(out, "{} ", self.config.language.typedef());
+        write!(out, "{} ", &self.config.language.typedef());
 
         self.write_field(
             out,
@@ -324,7 +321,7 @@ impl LanguageBackend for CythonLanguageBackend {
 
         out.write(";");
 
-        condition.write_after(&self.config, out);
+        condition.write_after(self.config, out);
     }
 
     fn write_static<W: Write>(&self, out: &mut SourceWriter<W>, s: &Static) {
@@ -333,7 +330,7 @@ impl LanguageBackend for CythonLanguageBackend {
         } else if !s.mutable {
             out.write("const ");
         }
-        cdecl::write_field(self, out, &s.ty, &s.export_name, &self.config);
+        cdecl::write_field(self, out, &s.ty, &s.export_name, self.config);
         out.write(";");
     }
 
@@ -346,8 +343,8 @@ impl LanguageBackend for CythonLanguageBackend {
             let prefix = language_backend.config.function.prefix(&func.annotations);
             let postfix = language_backend.config.function.postfix(&func.annotations);
 
-            let condition = func.cfg.to_condition(&language_backend.config);
-            condition.write_before(&language_backend.config, out);
+            let condition = func.cfg.to_condition(language_backend.config);
+            condition.write_before(language_backend.config, out);
 
             language_backend.write_documentation(out, &func.documentation);
 
@@ -357,7 +354,7 @@ impl LanguageBackend for CythonLanguageBackend {
                 if let Some(ref prefix) = prefix {
                     write!(out, "{} ", prefix);
                 }
-                if func.annotations.must_use(&language_backend.config) {
+                if func.annotations.must_use(language_backend.config) {
                     if let Some(ref anno) = language_backend.config.function.must_use {
                         write!(out, "{} ", anno);
                     }
@@ -368,7 +365,7 @@ impl LanguageBackend for CythonLanguageBackend {
                 out,
                 func,
                 Layout::Horizontal,
-                &language_backend.config,
+                language_backend.config,
             );
 
             if !func.extern_decl {
@@ -378,14 +375,14 @@ impl LanguageBackend for CythonLanguageBackend {
             }
 
             if let Some(ref swift_name_macro) = language_backend.config.function.swift_name_macro {
-                if let Some(swift_name) = func.swift_name(&language_backend.config) {
+                if let Some(swift_name) = func.swift_name(language_backend.config) {
                     write!(out, " {}({})", swift_name_macro, swift_name);
                 }
             }
 
             out.write(";");
 
-            condition.write_after(&language_backend.config, out);
+            condition.write_after(language_backend.config, out);
         }
 
         fn write_2<W: Write>(
@@ -396,9 +393,9 @@ impl LanguageBackend for CythonLanguageBackend {
             let prefix = language_backend.config.function.prefix(&func.annotations);
             let postfix = language_backend.config.function.postfix(&func.annotations);
 
-            let condition = func.cfg.to_condition(&language_backend.config);
+            let condition = func.cfg.to_condition(language_backend.config);
 
-            condition.write_before(&language_backend.config, out);
+            condition.write_before(language_backend.config, out);
 
             language_backend.write_documentation(out, &func.documentation);
 
@@ -409,7 +406,7 @@ impl LanguageBackend for CythonLanguageBackend {
                     write!(out, "{}", prefix);
                     out.new_line();
                 }
-                if func.annotations.must_use(&language_backend.config) {
+                if func.annotations.must_use(language_backend.config) {
                     if let Some(ref anno) = language_backend.config.function.must_use {
                         write!(out, "{}", anno);
                         out.new_line();
@@ -421,7 +418,7 @@ impl LanguageBackend for CythonLanguageBackend {
                 out,
                 func,
                 Layout::Vertical,
-                &language_backend.config,
+                language_backend.config,
             );
             if !func.extern_decl {
                 if let Some(ref postfix) = postfix {
@@ -431,17 +428,17 @@ impl LanguageBackend for CythonLanguageBackend {
             }
 
             if let Some(ref swift_name_macro) = language_backend.config.function.swift_name_macro {
-                if let Some(swift_name) = func.swift_name(&language_backend.config) {
+                if let Some(swift_name) = func.swift_name(language_backend.config) {
                     write!(out, " {}({})", swift_name_macro, swift_name);
                 }
             }
 
             out.write(";");
 
-            condition.write_after(&language_backend.config, out);
+            condition.write_after(language_backend.config, out);
         }
 
-        match self.config.function.args {
+        match &self.config.function.args {
             Layout::Horizontal => write_1(f, self, out),
             Layout::Vertical => write_2(f, self, out),
             Layout::Auto => {
@@ -453,15 +450,15 @@ impl LanguageBackend for CythonLanguageBackend {
     }
 
     fn write_type<W: Write>(&self, out: &mut SourceWriter<W>, t: &Type) {
-        cdecl::write_type(self, out, t, &self.config);
+        cdecl::write_type(self, out, t, self.config);
     }
 
     fn write_documentation<W: Write>(&self, out: &mut SourceWriter<W>, d: &Documentation) {
-        if d.doc_comment.is_empty() || !self.config.documentation {
+        if d.doc_comment.is_empty() || !&self.config.documentation {
             return;
         }
 
-        let end = match self.config.documentation_length {
+        let end = match &self.config.documentation_length {
             DocumentationLength::Short => 1,
             DocumentationLength::Full => d.doc_comment.len(),
         };