Refactor idl_gen_rust and Rust generated code to use consistent whitespace (#6809)

* Remove dead code in idl_gen_rust

* Use 2space indentation in mod.rs

* use In/DecrementIdentValue in idl_gen_rust

Fix some whitespace too in generated code.

* make default fn 2space ident

* More 2space formatting

* git clang format

* make vs2015 happy

Co-authored-by: Casper Neo <cneo@google.com>

samples/rust_generated/mod.rs

@@ -1,17 +1,17 @@
 // Automatically generated by the Flatbuffers compiler. Do not modify.
 pub mod my_game {
+  use super::*;
+  pub mod sample {
     use super::*;
-    pub mod sample {
-        use super::*;
-        mod color_generated;
-        pub use self::color_generated::*;
-        mod equipment_generated;
-        pub use self::equipment_generated::*;
-        mod vec_3_generated;
-        pub use self::vec_3_generated::*;
-        mod monster_generated;
-        pub use self::monster_generated::*;
-        mod weapon_generated;
-        pub use self::weapon_generated::*;
-    } // sample
+    mod color_generated;
+    pub use self::color_generated::*;
+    mod equipment_generated;
+    pub use self::equipment_generated::*;
+    mod vec_3_generated;
+    pub use self::vec_3_generated::*;
+    mod monster_generated;
+    pub use self::monster_generated::*;
+    mod weapon_generated;
+    pub use self::weapon_generated::*;
+  } // sample
 } // my_game

samples/rust_generated/my_game/sample/monster_generated.rs

@@ -12,90 +12,92 @@ pub struct Monster<'a> {
 }
 
 impl<'a> flatbuffers::Follow<'a> for Monster<'a> {
-    type Inner = Monster<'a>;
-    #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self { _tab: flatbuffers::Table { buf, loc } }
-    }
+  type Inner = Monster<'a>;
+  #[inline]
+  fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: flatbuffers::Table { buf, loc } }
+  }
 }
 
 impl<'a> Monster<'a> {
-    pub const fn get_fully_qualified_name() -> &'static str {
-        "MyGame.Sample.Monster"
-    }
+  pub const VT_POS: flatbuffers::VOffsetT = 4;
+  pub const VT_MANA: flatbuffers::VOffsetT = 6;
+  pub const VT_HP: flatbuffers::VOffsetT = 8;
+  pub const VT_NAME: flatbuffers::VOffsetT = 10;
+  pub const VT_INVENTORY: flatbuffers::VOffsetT = 14;
+  pub const VT_COLOR: flatbuffers::VOffsetT = 16;
+  pub const VT_WEAPONS: flatbuffers::VOffsetT = 18;
+  pub const VT_EQUIPPED_TYPE: flatbuffers::VOffsetT = 20;
+  pub const VT_EQUIPPED: flatbuffers::VOffsetT = 22;
+  pub const VT_PATH: flatbuffers::VOffsetT = 24;
 
-    #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
-        Monster { _tab: table }
-    }
-    #[allow(unused_mut)]
-    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
-        _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
-        args: &'args MonsterArgs<'args>) -> flatbuffers::WIPOffset<Monster<'bldr>> {
-      let mut builder = MonsterBuilder::new(_fbb);
-      if let Some(x) = args.path { builder.add_path(x); }
-      if let Some(x) = args.equipped { builder.add_equipped(x); }
-      if let Some(x) = args.weapons { builder.add_weapons(x); }
-      if let Some(x) = args.inventory { builder.add_inventory(x); }
-      if let Some(x) = args.name { builder.add_name(x); }
-      if let Some(x) = args.pos { builder.add_pos(x); }
-      builder.add_hp(args.hp);
-      builder.add_mana(args.mana);
-      builder.add_equipped_type(args.equipped_type);
-      builder.add_color(args.color);
-      builder.finish()
-    }
+  pub const fn get_fully_qualified_name() -> &'static str {
+    "MyGame.Sample.Monster"
+  }
 
-    pub fn unpack(&self) -> MonsterT {
-      let pos = self.pos().map(|x| {
-        x.unpack()
-      });
-      let mana = self.mana();
-      let hp = self.hp();
-      let name = self.name().map(|x| {
-        x.to_string()
-      });
-      let inventory = self.inventory().map(|x| {
-        x.to_vec()
-      });
-      let color = self.color();
-      let weapons = self.weapons().map(|x| {
-        x.iter().map(|t| t.unpack()).collect()
-      });
-      let equipped = match self.equipped_type() {
-        Equipment::NONE => EquipmentT::NONE,
-        Equipment::Weapon => EquipmentT::Weapon(Box::new(
-          self.equipped_as_weapon()
-              .expect("Invalid union table, expected `Equipment::Weapon`.")
-              .unpack()
-        )),
-        _ => EquipmentT::NONE,
-      };
-      let path = self.path().map(|x| {
-        x.iter().map(|t| t.unpack()).collect()
-      });
-      MonsterT {
-        pos,
-        mana,
-        hp,
-        name,
-        inventory,
-        color,
-        weapons,
-        equipped,
-        path,
-      }
+  #[inline]
+  pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    Monster { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
+    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
+    args: &'args MonsterArgs<'args>
+  ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
+    let mut builder = MonsterBuilder::new(_fbb);
+    if let Some(x) = args.path { builder.add_path(x); }
+    if let Some(x) = args.equipped { builder.add_equipped(x); }
+    if let Some(x) = args.weapons { builder.add_weapons(x); }
+    if let Some(x) = args.inventory { builder.add_inventory(x); }
+    if let Some(x) = args.name { builder.add_name(x); }
+    if let Some(x) = args.pos { builder.add_pos(x); }
+    builder.add_hp(args.hp);
+    builder.add_mana(args.mana);
+    builder.add_equipped_type(args.equipped_type);
+    builder.add_color(args.color);
+    builder.finish()
+  }
+
+  pub fn unpack(&self) -> MonsterT {
+    let pos = self.pos().map(|x| {
+      x.unpack()
+    });
+    let mana = self.mana();
+    let hp = self.hp();
+    let name = self.name().map(|x| {
+      x.to_string()
+    });
+    let inventory = self.inventory().map(|x| {
+      x.to_vec()
+    });
+    let color = self.color();
+    let weapons = self.weapons().map(|x| {
+      x.iter().map(|t| t.unpack()).collect()
+    });
+    let equipped = match self.equipped_type() {
+      Equipment::NONE => EquipmentT::NONE,
+      Equipment::Weapon => EquipmentT::Weapon(Box::new(
+        self.equipped_as_weapon()
+            .expect("Invalid union table, expected `Equipment::Weapon`.")
+            .unpack()
+      )),
+      _ => EquipmentT::NONE,
+    };
+    let path = self.path().map(|x| {
+      x.iter().map(|t| t.unpack()).collect()
+    });
+    MonsterT {
+      pos,
+      mana,
+      hp,
+      name,
+      inventory,
+      color,
+      weapons,
+      equipped,
+      path,
     }
-    pub const VT_POS: flatbuffers::VOffsetT = 4;
-    pub const VT_MANA: flatbuffers::VOffsetT = 6;
-    pub const VT_HP: flatbuffers::VOffsetT = 8;
-    pub const VT_NAME: flatbuffers::VOffsetT = 10;
-    pub const VT_INVENTORY: flatbuffers::VOffsetT = 14;
-    pub const VT_COLOR: flatbuffers::VOffsetT = 16;
-    pub const VT_WEAPONS: flatbuffers::VOffsetT = 18;
-    pub const VT_EQUIPPED_TYPE: flatbuffers::VOffsetT = 20;
-    pub const VT_EQUIPPED: flatbuffers::VOffsetT = 22;
-    pub const VT_PATH: flatbuffers::VOffsetT = 24;
+  }
 
   #[inline]
   pub fn pos(&self) -> Option<&'a Vec3> {
@@ -187,21 +189,21 @@ pub struct MonsterArgs<'a> {
     pub path: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Vec3>>>,
 }
 impl<'a> Default for MonsterArgs<'a> {
-    #[inline]
-    fn default() -> Self {
-        MonsterArgs {
-            pos: None,
-            mana: 150,
-            hp: 100,
-            name: None,
-            inventory: None,
-            color: Color::Blue,
-            weapons: None,
-            equipped_type: Equipment::NONE,
-            equipped: None,
-            path: None,
-        }
+  #[inline]
+  fn default() -> Self {
+    MonsterArgs {
+      pos: None,
+      mana: 150,
+      hp: 100,
+      name: None,
+      inventory: None,
+      color: Color::Blue,
+      weapons: None,
+      equipped_type: Equipment::NONE,
+      equipped: None,
+      path: None,
     }
+  }
 }
 pub struct MonsterBuilder<'a: 'b, 'b> {
   fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,

samples/rust_generated/my_game/sample/vec_3_generated.rs

@@ -84,9 +84,9 @@ impl<'a> Vec3 {
     s
   }
 
-    pub const fn get_fully_qualified_name() -> &'static str {
-        "MyGame.Sample.Vec3"
-    }
+  pub const fn get_fully_qualified_name() -> &'static str {
+    "MyGame.Sample.Vec3"
+  }
 
   pub fn x(&self) -> f32 {
     let mut mem = core::mem::MaybeUninit::<f32>::uninit();

samples/rust_generated/my_game/sample/weapon_generated.rs

@@ -12,44 +12,46 @@ pub struct Weapon<'a> {
 }
 
 impl<'a> flatbuffers::Follow<'a> for Weapon<'a> {
-    type Inner = Weapon<'a>;
-    #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self { _tab: flatbuffers::Table { buf, loc } }
-    }
+  type Inner = Weapon<'a>;
+  #[inline]
+  fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: flatbuffers::Table { buf, loc } }
+  }
 }
 
 impl<'a> Weapon<'a> {
-    pub const fn get_fully_qualified_name() -> &'static str {
-        "MyGame.Sample.Weapon"
-    }
+  pub const VT_NAME: flatbuffers::VOffsetT = 4;
+  pub const VT_DAMAGE: flatbuffers::VOffsetT = 6;
 
-    #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
-        Weapon { _tab: table }
-    }
-    #[allow(unused_mut)]
-    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
-        _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
-        args: &'args WeaponArgs<'args>) -> flatbuffers::WIPOffset<Weapon<'bldr>> {
-      let mut builder = WeaponBuilder::new(_fbb);
-      if let Some(x) = args.name { builder.add_name(x); }
-      builder.add_damage(args.damage);
-      builder.finish()
-    }
+  pub const fn get_fully_qualified_name() -> &'static str {
+    "MyGame.Sample.Weapon"
+  }
 
-    pub fn unpack(&self) -> WeaponT {
-      let name = self.name().map(|x| {
-        x.to_string()
-      });
-      let damage = self.damage();
-      WeaponT {
-        name,
-        damage,
-      }
+  #[inline]
+  pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    Weapon { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
+    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
+    args: &'args WeaponArgs<'args>
+  ) -> flatbuffers::WIPOffset<Weapon<'bldr>> {
+    let mut builder = WeaponBuilder::new(_fbb);
+    if let Some(x) = args.name { builder.add_name(x); }
+    builder.add_damage(args.damage);
+    builder.finish()
+  }
+
+  pub fn unpack(&self) -> WeaponT {
+    let name = self.name().map(|x| {
+      x.to_string()
+    });
+    let damage = self.damage();
+    WeaponT {
+      name,
+      damage,
     }
-    pub const VT_NAME: flatbuffers::VOffsetT = 4;
-    pub const VT_DAMAGE: flatbuffers::VOffsetT = 6;
+  }
 
   #[inline]
   pub fn name(&self) -> Option<&'a str> {
@@ -79,13 +81,13 @@ pub struct WeaponArgs<'a> {
     pub damage: i16,
 }
 impl<'a> Default for WeaponArgs<'a> {
-    #[inline]
-    fn default() -> Self {
-        WeaponArgs {
-            name: None,
-            damage: 0,
-        }
+  #[inline]
+  fn default() -> Self {
+    WeaponArgs {
+      name: None,
+      damage: 0,
     }
+  }
 }
 pub struct WeaponBuilder<'a: 'b, 'b> {
   fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,