From d3c2779a161881453cf73c315429e317a8b88ed4 Mon Sep 17 00:00:00 2001
From: Bilal Elmoussaoui <belmouss@redhat.com>
Date: Thu, 11 Aug 2022 20:57:36 +0200
Subject: [PATCH 1/2] Fix new clippy warnings

---
 src/analysis/functions.rs | 7 +------
 src/codegen/doc/mod.rs    | 2 +-
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/analysis/functions.rs b/src/analysis/functions.rs
index 497edfe3c..6f551978a 100644
--- a/src/analysis/functions.rs
+++ b/src/analysis/functions.rs
@@ -933,12 +933,7 @@ pub fn is_carray_with_direct_elements(env: &Env, typ: library::TypeId) -> bool {
     match *env.library.type_(typ) {
         Type::CArray(inner_tid) => {
             use super::conversion_type::ConversionType;
-            match env.library.type_(inner_tid) {
-                Type::Basic(..) if ConversionType::of(env, inner_tid) == ConversionType::Direct => {
-                    true
-                }
-                _ => false,
-            }
+            matches!(env.library.type_(inner_tid), Type::Basic(..) if ConversionType::of(env, inner_tid) == ConversionType::Direct)
         }
         _ => false,
     }
diff --git a/src/codegen/doc/mod.rs b/src/codegen/doc/mod.rs
index c3fbce253..a3e432eca 100644
--- a/src/codegen/doc/mod.rs
+++ b/src/codegen/doc/mod.rs
@@ -807,7 +807,7 @@ where
             .iter()
             .enumerate()
             .filter_map(|(indice, param)| {
-                (!indices_to_ignore.contains(&(indice as u32))).then(|| param)
+                (!indices_to_ignore.contains(&(indice as u32))).then_some(param)
             })
             .filter(|param| !param.instance_parameter)
             .collect();

From 5f8bc1fd65547eac861c79f195769a15ce8d622f Mon Sep 17 00:00:00 2001
From: Bilal Elmoussaoui <belmouss@redhat.com>
Date: Thu, 11 Aug 2022 21:24:01 +0200
Subject: [PATCH 2/2] codgen: Allow renaming objects/enums/flags

---
 book/src/config_api.md |  2 ++
 src/codegen/enums.rs   | 26 +++++++++-------
 src/codegen/flags.rs   | 25 +++++++++-------
 src/codegen/object.rs  | 68 +++++++++++++++++++++++++-----------------
 src/codegen/record.rs  | 24 +++++++++------
 src/config/gobjects.rs | 23 ++++++++++++++
 6 files changed, 111 insertions(+), 57 deletions(-)

diff --git a/book/src/config_api.md b/book/src/config_api.md
index 3f198ec5a..464795bfa 100644
--- a/book/src/config_api.md
+++ b/book/src/config_api.md
@@ -89,6 +89,8 @@ Sometimes Gir understands the object definition incorrectly or the `.gir` file c
 [[object]]
 # object's fullname
 name = "Gtk.SomeClass"
+# An optional different name of the object
+rename = "Gtk.SomeNewName"
 # can be also "manual" and "ignore" but it's simpler to just put the object in the same array
 status = "generate"
 # replace the parameter name for the child in child properties (instead "child")
diff --git a/src/codegen/enums.rs b/src/codegen/enums.rs
index 4abd59d95..b7b256009 100644
--- a/src/codegen/enums.rs
+++ b/src/codegen/enums.rs
@@ -55,7 +55,7 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
             mod_rs.push(format!(
                 "{} use self::enums::{};",
                 enum_analysis.visibility.export_visibility(),
-                enum_.name
+                config.rename.as_ref().unwrap_or(&enum_.name)
             ));
 
             generate_enum(env, w, enum_, config, enum_analysis)?;
@@ -132,8 +132,12 @@ fn generate_enum(
     writeln!(w, "#[derive(Clone, Copy)]")?;
     writeln!(w, "#[non_exhaustive]")?;
     doc_alias(w, &enum_.c_type, "", 0)?;
+    if config.rename.is_some() {
+        doc_alias(w, &enum_.name, "", 0)?;
+    }
 
-    writeln!(w, "{} enum {} {{", analysis.visibility, enum_.name)?;
+    let enum_name = config.rename.as_ref().unwrap_or(&enum_.name);
+    writeln!(w, "{} enum {} {{", analysis.visibility, enum_name)?;
     for member in &members {
         cfg_deprecated(
             w,
@@ -208,7 +212,7 @@ fn generate_enum(
             "impl fmt::Display for {0} {{\n\
              \tfn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {{\n\
              \t\twrite!(f, \"{0}::{{}}\", match *self {{",
-            enum_.name
+            enum_name
         )?;
         for member in &members {
             version_condition_no_doc(w, env, None, member.version, false, 3)?;
@@ -236,7 +240,7 @@ impl IntoGlib for {name} {{
     fn into_glib(self) -> {sys_crate_name}::{ffi_name} {{
         match self {{",
         sys_crate_name = sys_crate_name,
-        name = enum_.name,
+        name = enum_name,
         ffi_name = enum_.c_type
     )?;
     for member in &members {
@@ -274,7 +278,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
     unsafe fn from_glib(value: {sys_crate_name}::{ffi_name}) -> Self {{
         {assert}match value {{",
         sys_crate_name = sys_crate_name,
-        name = enum_.name,
+        name = enum_name,
         ffi_name = enum_.c_type,
         assert = assert
     )?;
@@ -308,7 +312,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
             "impl ErrorDomain for {name} {{
     fn domain() -> Quark {{
         {assert}",
-            name = enum_.name,
+            name = enum_name,
             assert = assert
         )?;
 
@@ -390,7 +394,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
     }}
 }}",
             sys_crate_name = sys_crate_name,
-            name = enum_.name,
+            name = enum_name,
             get_type = get_type
         )?;
         writeln!(w)?;
@@ -402,7 +406,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
             "impl {valuetype} for {name} {{
     type Type = Self;
 }}",
-            name = enum_.name,
+            name = enum_name,
             valuetype = use_glib_type(env, "value::ValueType"),
         )?;
         writeln!(w)?;
@@ -418,7 +422,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
         {assert}from_glib({glib}(value.to_glib_none().0))
     }}
 }}",
-            name = enum_.name,
+            name = enum_name,
             glib = use_glib_type(env, "gobject_ffi::g_value_get_enum"),
             gvalue = use_glib_type(env, "Value"),
             genericwrongvaluetypechecker = use_glib_type(env, "value::GenericValueTypeChecker"),
@@ -443,7 +447,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
         Self::static_type()
     }}
 }}",
-            name = enum_.name,
+            name = enum_name,
             glib = use_glib_type(env, "gobject_ffi::g_value_set_enum"),
             gvalue = use_glib_type(env, "Value"),
             gtype = use_glib_type(env, "Type"),
@@ -455,7 +459,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
         w,
         env,
         config,
-        &enum_.name,
+        enum_name,
         enum_.version,
         enum_.members.iter(),
         |member| {
diff --git a/src/codegen/flags.rs b/src/codegen/flags.rs
index 6752e04bc..f8287c182 100644
--- a/src/codegen/flags.rs
+++ b/src/codegen/flags.rs
@@ -53,7 +53,7 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
             mod_rs.push(format!(
                 "{} use self::flags::{};",
                 flags_analysis.visibility.export_visibility(),
-                flags.name
+                config.rename.as_ref().unwrap_or(&flags.name),
             ));
             generate_flags(env, w, flags, config, flags_analysis)?;
         }
@@ -92,11 +92,16 @@ fn generate_flags(
         derives(w, d, 1)?;
     }
 
+    let flags_name = config.rename.as_ref().unwrap_or(&flags.name);
+
     doc_alias(w, &flags.c_type, "", 1)?;
+    if config.rename.is_some() {
+        doc_alias(w, &flags.name, "", 0)?;
+    }
     writeln!(
         w,
         "    {} struct {}: u32 {{",
-        analysis.visibility, flags.name
+        analysis.visibility, flags_name
     )?;
     for member in &flags.members {
         let member_config = config.members.matched(&member.name);
@@ -184,14 +189,14 @@ fn generate_flags(
             \t\t<Self as fmt::Debug>::fmt(self, f)\n\
             \t}}\n\
             }}\n",
-            flags.name
+            flags_name
         )?;
     }
     generate_default_impl(
         w,
         env,
         config,
-        &flags.name,
+        flags_name,
         flags.version,
         flags.members.iter(),
         |member| {
@@ -222,7 +227,7 @@ impl IntoGlib for {name} {{
 }}
 ",
         sys_crate_name = sys_crate_name,
-        name = flags.name,
+        name = flags_name,
         ffi_name = flags.c_type
     )?;
 
@@ -244,7 +249,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
 }}
 ",
         sys_crate_name = sys_crate_name,
-        name = flags.name,
+        name = flags_name,
         ffi_name = flags.c_type,
         assert = assert
     )?;
@@ -266,7 +271,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
     }}
 }}",
             sys_crate_name = sys_crate_name,
-            name = flags.name,
+            name = flags_name,
             get_type = get_type
         )?;
         writeln!(w)?;
@@ -278,7 +283,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
             "impl {valuetype} for {name} {{
     type Type = Self;
 }}",
-            name = flags.name,
+            name = flags_name,
             valuetype = use_glib_type(env, "value::ValueType"),
         )?;
         writeln!(w)?;
@@ -294,7 +299,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
         {assert}from_glib({glib}(value.to_glib_none().0))
     }}
 }}",
-            name = flags.name,
+            name = flags_name,
             glib = use_glib_type(env, "gobject_ffi::g_value_get_flags"),
             gvalue = use_glib_type(env, "Value"),
             genericwrongvaluetypechecker = use_glib_type(env, "value::GenericValueTypeChecker"),
@@ -319,7 +324,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
         Self::static_type()
     }}
 }}",
-            name = flags.name,
+            name = flags_name,
             glib = use_glib_type(env, "gobject_ffi::g_value_set_flags"),
             gvalue = use_glib_type(env, "Value"),
             gtype = use_glib_type(env, "Type"),
diff --git a/src/codegen/object.rs b/src/codegen/object.rs
index 4980eadb0..e6493c221 100644
--- a/src/codegen/object.rs
+++ b/src/codegen/object.rs
@@ -29,6 +29,7 @@ pub fn generate(
     general::uses(w, env, &analysis.imports, analysis.version)?;
 
     let config = &env.config.objects[&analysis.full_name];
+    let object_name = config.rename.as_ref().unwrap_or(&analysis.name);
     if config.default_value.is_some() {
         log::error!(
             "`default_value` can only be used on flags and enums. {} is neither. Ignoring \
@@ -78,7 +79,7 @@ pub fn generate(
             general::define_fundamental_type(
                 w,
                 env,
-                &analysis.name,
+                object_name,
                 &analysis.c_type,
                 &analysis.get_type,
                 analysis.ref_fn.as_deref(),
@@ -90,7 +91,7 @@ pub fn generate(
             general::define_object_type(
                 w,
                 env,
-                &analysis.name,
+                object_name,
                 &analysis.c_type,
                 analysis.c_class_type.as_deref(),
                 &analysis.get_type,
@@ -125,7 +126,7 @@ pub fn generate(
                 general::define_object_type(
                     w,
                     env,
-                    &analysis.name,
+                    object_name,
                     &analysis.c_type,
                     analysis.c_class_type.as_deref(),
                     &analysis.get_type,
@@ -155,7 +156,7 @@ pub fn generate(
         general::define_object_type(
             w,
             env,
-            &analysis.name,
+            object_name,
             &analysis.c_type,
             analysis.c_class_type.as_deref(),
             &analysis.get_type,
@@ -169,7 +170,7 @@ pub fn generate(
         || !analysis.final_type
     {
         writeln!(w)?;
-        write!(w, "impl {} {{", analysis.name)?;
+        write!(w, "impl {} {{", object_name)?;
 
         if !analysis.final_type {
             writeln!(
@@ -177,7 +178,7 @@ pub fn generate(
                 "
         pub const NONE: Option<&'static {}> = None;
     ",
-                analysis.name
+                object_name
             )?;
         }
 
@@ -197,7 +198,7 @@ pub fn generate(
 
         if has_builder_properties(&analysis.builder_properties) {
             // generate builder method that returns the corresponding builder
-            let builder_name = format!("{}Builder", analysis.name);
+            let builder_name = format!("{}Builder", object_name);
             writeln!(
                 w,
                 "
@@ -209,7 +210,7 @@ pub fn generate(
                 {builder_name}::default()
             }}
         ",
-                name = analysis.name,
+                name = object_name,
                 builder_name = builder_name
             )?;
         }
@@ -267,7 +268,7 @@ pub fn generate(
         general::declare_default_from_new(
             w,
             env,
-            &analysis.name,
+            object_name,
             &analysis.functions,
             has_builder_properties(&analysis.builder_properties),
         )?;
@@ -276,7 +277,7 @@ pub fn generate(
     trait_impls::generate(
         w,
         env,
-        &analysis.name,
+        object_name,
         &analysis.functions,
         &analysis.specials,
         if analysis.need_generate_trait() {
@@ -290,7 +291,7 @@ pub fn generate(
 
     if has_builder_properties(&analysis.builder_properties) {
         writeln!(w)?;
-        generate_builder(w, env, analysis)?;
+        generate_builder(w, object_name, env, analysis)?;
     }
 
     if analysis.concurrency != library::Concurrency::None {
@@ -299,22 +300,22 @@ pub fn generate(
 
     match analysis.concurrency {
         library::Concurrency::Send | library::Concurrency::SendSync => {
-            writeln!(w, "unsafe impl Send for {} {{}}", analysis.name)?;
+            writeln!(w, "unsafe impl Send for {} {{}}", object_name)?;
         }
         _ => (),
     }
 
     if let library::Concurrency::SendSync = analysis.concurrency {
-        writeln!(w, "unsafe impl Sync for {} {{}}", analysis.name)?;
+        writeln!(w, "unsafe impl Sync for {} {{}}", object_name)?;
     }
 
     if analysis.need_generate_trait() {
         writeln!(w)?;
-        generate_trait(w, env, analysis)?;
+        generate_trait(w, object_name, env, analysis)?;
     }
 
     if generate_display_trait && !analysis.specials.has_trait(Type::Display) {
-        writeln!(w, "\nimpl fmt::Display for {} {{", analysis.name,)?;
+        writeln!(w, "\nimpl fmt::Display for {} {{", object_name,)?;
         // Generate Display trait implementation.
         writeln!(
             w,
@@ -322,7 +323,7 @@ pub fn generate(
              \t\tf.write_str(\"{}\")\n\
              \t}}\n\
              }}",
-            analysis.name
+            object_name
         )?;
     }
 
@@ -330,7 +331,12 @@ pub fn generate(
 }
 
 // TODO: instead create a Vec<> inside the Builder instead of Options.
-fn generate_builder(w: &mut dyn Write, env: &Env, analysis: &analysis::object::Info) -> Result<()> {
+fn generate_builder(
+    w: &mut dyn Write,
+    object_name: &str,
+    env: &Env,
+    analysis: &analysis::object::Info,
+) -> Result<()> {
     let mut methods = vec![];
     let mut properties = vec![];
     writeln!(w, "#[derive(Clone, Default)]")?;
@@ -340,10 +346,10 @@ fn generate_builder(w: &mut dyn Write, env: &Env, analysis: &analysis::object::I
         /// A [builder-pattern] type to construct [`{}`] objects.
         ///
         /// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html",
-        analysis.name,
+        object_name,
     )?;
     writeln!(w, "#[must_use = \"The builder must be built to be used\"]")?;
-    writeln!(w, "pub struct {}Builder {{", analysis.name)?;
+    writeln!(w, "pub struct {}Builder {{", object_name)?;
     for (builder_props, super_tid) in &analysis.builder_properties {
         for property in builder_props {
             match RustType::try_new(env, property.typ) {
@@ -450,7 +456,7 @@ impl {name}Builder {{
         Self::default()
     }}
 ",
-        name = analysis.name
+        name = object_name
     )?;
 
     writeln!(
@@ -461,7 +467,7 @@ impl {name}Builder {{
     #[must_use = \"Building the object from the builder is usually expensive and is not expected to have side effects\"]
     pub fn build(self) -> {name} {{
         let mut properties: Vec<(&str, &dyn ToValue)> = vec![];",
-        name = analysis.name
+        name = object_name
     )?;
     for (property, super_tid) in &properties {
         let name = nameutil::mangle_keywords(nameutil::signal_to_snake(&property.name));
@@ -488,7 +494,7 @@ impl {name}Builder {{
             w,
             r#"        let ret = {}::Object::new::<{}>(&properties)
                 .expect("Failed to create an instance of {}");"#,
-            glib_crate_name, analysis.name, analysis.name,
+            glib_crate_name, object_name, object_name,
         )?;
         writeln!(w, "        {{\n            {}\n        }}", code)?;
         writeln!(w, "    ret\n    }}")?;
@@ -497,7 +503,7 @@ impl {name}Builder {{
             w,
             r#"        {}::Object::new::<{}>(&properties)
                 .expect("Failed to create an instance of {}")"#,
-            glib_crate_name, analysis.name, analysis.name,
+            glib_crate_name, object_name, object_name,
         )?;
         writeln!(w, "\n    }}")?;
     }
@@ -508,7 +514,12 @@ impl {name}Builder {{
     writeln!(w, "}}")
 }
 
-fn generate_trait(w: &mut dyn Write, env: &Env, analysis: &analysis::object::Info) -> Result<()> {
+fn generate_trait(
+    w: &mut dyn Write,
+    object_name: &str,
+    env: &Env,
+    analysis: &analysis::object::Info,
+) -> Result<()> {
     write!(w, "pub trait {}: 'static {{", analysis.trait_name)?;
 
     for func_analysis in &analysis.methods() {
@@ -543,7 +554,7 @@ fn generate_trait(w: &mut dyn Write, env: &Env, analysis: &analysis::object::Inf
     write!(
         w,
         "impl<O: IsA<{}>> {} for O {{",
-        analysis.name, analysis.trait_name,
+        object_name, analysis.trait_name,
     )?;
 
     for func_analysis in &analysis.methods() {
@@ -587,6 +598,9 @@ pub fn generate_reexports(
     traits: &mut Vec<String>,
     builders: &mut Vec<String>,
 ) {
+    let config = &env.config.objects[&analysis.full_name];
+    let object_name = config.rename.as_ref().unwrap_or(&analysis.name);
+
     let mut cfgs: Vec<String> = Vec::new();
     if let Some(cfg) = general::cfg_condition_string(analysis.cfg_condition.as_ref(), false, 0) {
         cfgs.push(cfg);
@@ -613,7 +627,7 @@ pub fn generate_reexports(
         "{} use self::{}::{};",
         analysis.visibility.export_visibility(),
         module_name,
-        analysis.name,
+        object_name,
     ));
 
     if analysis.need_generate_trait() {
@@ -632,7 +646,7 @@ pub fn generate_reexports(
         }
         builders.push(format!(
             "\tpub use super::{}::{}Builder;",
-            module_name, analysis.name
+            module_name, object_name
         ));
     }
 }
diff --git a/src/codegen/record.rs b/src/codegen/record.rs
index 4f99ddc97..fd15fa21b 100644
--- a/src/codegen/record.rs
+++ b/src/codegen/record.rs
@@ -13,12 +13,15 @@ pub fn generate(w: &mut dyn Write, env: &Env, analysis: &analysis::record::Info)
     general::start_comments(w, &env.config)?;
     general::uses(w, env, &analysis.imports, type_.version)?;
 
+    let config = &env.config.objects[&analysis.full_name];
+    let record_name = config.rename.as_ref().unwrap_or(&analysis.name);
+
     if RecordType::of(env.type_(analysis.type_id).maybe_ref().unwrap()) == RecordType::AutoBoxed {
         if let Some((ref glib_get_type, _)) = analysis.glib_get_type {
             general::define_auto_boxed_type(
                 w,
                 env,
-                &analysis.name,
+                record_name,
                 &type_.c_type,
                 analysis.boxed_inline,
                 &analysis.init_function_expression,
@@ -41,7 +44,7 @@ pub fn generate(w: &mut dyn Write, env: &Env, analysis: &analysis::record::Info)
         general::define_shared_type(
             w,
             env,
-            &analysis.name,
+            record_name,
             &type_.c_type,
             &ref_fn.glib_name,
             &unref_fn.glib_name,
@@ -62,7 +65,7 @@ pub fn generate(w: &mut dyn Write, env: &Env, analysis: &analysis::record::Info)
         general::define_boxed_type(
             w,
             env,
-            &analysis.name,
+            record_name,
             &type_.c_type,
             copy_fn,
             &free_fn.glib_name,
@@ -93,7 +96,7 @@ pub fn generate(w: &mut dyn Write, env: &Env, analysis: &analysis::record::Info)
         .any(|f| f.status.need_generate() && !f.hidden)
     {
         writeln!(w)?;
-        write!(w, "impl {} {{", analysis.name)?;
+        write!(w, "impl {} {{", record_name)?;
 
         for func_analysis in &analysis.functions {
             function::generate(
@@ -112,12 +115,12 @@ pub fn generate(w: &mut dyn Write, env: &Env, analysis: &analysis::record::Info)
         writeln!(w, "}}")?;
     }
 
-    general::declare_default_from_new(w, env, &analysis.name, &analysis.functions, false)?;
+    general::declare_default_from_new(w, env, record_name, &analysis.functions, false)?;
 
     trait_impls::generate(
         w,
         env,
-        &analysis.name,
+        record_name,
         &analysis.functions,
         &analysis.specials,
         None,
@@ -131,13 +134,13 @@ pub fn generate(w: &mut dyn Write, env: &Env, analysis: &analysis::record::Info)
 
     match analysis.concurrency {
         library::Concurrency::Send | library::Concurrency::SendSync => {
-            writeln!(w, "unsafe impl Send for {} {{}}", analysis.name)?;
+            writeln!(w, "unsafe impl Send for {} {{}}", record_name)?;
         }
         _ => (),
     }
 
     if analysis.concurrency == library::Concurrency::SendSync {
-        writeln!(w, "unsafe impl Sync for {} {{}}", analysis.name)?;
+        writeln!(w, "unsafe impl Sync for {} {{}}", record_name)?;
     }
 
     Ok(())
@@ -149,6 +152,9 @@ pub fn generate_reexports(
     module_name: &str,
     contents: &mut Vec<String>,
 ) {
+    let config = &env.config.objects[&analysis.full_name];
+    let record_name = config.rename.as_ref().unwrap_or(&analysis.name);
+
     let cfg_condition = general::cfg_condition_string(analysis.cfg_condition.as_ref(), false, 0);
     let version_cfg = general::version_condition_string(
         env,
@@ -173,6 +179,6 @@ pub fn generate_reexports(
         cfg,
         analysis.visibility.export_visibility(),
         module_name,
-        analysis.name
+        record_name
     ));
 }
diff --git a/src/config/gobjects.rs b/src/config/gobjects.rs
index bb3d115d4..03a097903 100644
--- a/src/config/gobjects.rs
+++ b/src/config/gobjects.rs
@@ -67,6 +67,7 @@ impl FromStr for GStatus {
 #[derive(Clone, Debug)]
 pub struct GObject {
     pub name: String,
+    pub rename: Option<String>,
     pub functions: Functions,
     pub constants: Constants,
     pub signals: Signals,
@@ -105,6 +106,7 @@ impl Default for GObject {
     fn default() -> GObject {
         GObject {
             name: "Default".into(),
+            rename: Default::default(),
             functions: Functions::new(),
             constants: Constants::new(),
             signals: Signals::new(),
@@ -257,6 +259,7 @@ fn parse_object(
     toml_object.check_unwanted(
         &[
             "name",
+            "rename",
             "status",
             "function",
             "constant",
@@ -323,6 +326,10 @@ fn parse_object(
 
         v
     };
+    let rename = toml_object
+        .lookup("rename")
+        .and_then(Value::as_str)
+        .map(ToOwned::to_owned);
     let members = Members::parse(toml_object.lookup("member"), &name);
     let properties = Properties::parse(toml_object.lookup("property"), &name);
     let derives = toml_object
@@ -489,6 +496,7 @@ fn parse_object(
 
     GObject {
         name,
+        rename,
         functions,
         constants,
         signals,
@@ -616,6 +624,21 @@ mod tests {
         value.unwrap()
     }
 
+    #[test]
+    fn object_rename() {
+        let toml = &toml(
+            r#"
+name = "Test"
+status = "generate"
+rename = "SomeTest"
+"#,
+        );
+
+        let object = parse_object(toml, Concurrency::default(), false, false, false);
+        assert_eq!(object.name, "Test");
+        assert_eq!(object.rename.as_deref(), Some("SomeTest"));
+    }
+
     #[test]
     fn conversion_type_default() {
         let toml = &toml(