Improves Rust code generation

rust/flatbuffers/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://google.github.io/flatbuffers/"
 repository = "https://github.com/google/flatbuffers"
 keywords = ["flatbuffers", "serialization", "zero-copy"]
 categories = ["encoding", "data-structures", "memory-management"]
-rust = "1.51"
+rust-version = "1.51"
 
 [features]
 default = ["std"]

rust/flatbuffers/build.rs

@@ -1,11 +1,12 @@
-use rustc_version::{version_meta, Channel};
+use rustc_version::{Channel, version_meta};
 
 fn main() {
     let version_meta = version_meta().unwrap();
 
     // To use nightly features we declare this and then we can use
     // #[cfg(nightly)]
     // for nightly only features
+    println!("cargo:rustc-check-cfg=cfg(nightly)");
     if version_meta.channel == Channel::Nightly {
         println!("cargo:rustc-cfg=nightly")
     }

rust/flexbuffers/src/builder/ser.rs

@@ -222,7 +222,7 @@ impl<'a> ser::Serializer for &'a mut FlexbufferSerializer {
     type Ok = ();
     type Error = Error;
     fn is_human_readable(&self) -> bool {
-        cfg!(serialize_human_readable)
+        cfg!(feature = "serialize_human_readable")
     }
     fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
         self.builder.push(v);

rust/flexbuffers/src/reader/de.rs

@@ -163,7 +163,7 @@ impl<'de> VariantAccess<'de> for Reader<&'de [u8]> {
 impl<'de> Deserializer<'de> for Reader<&'de [u8]> {
     type Error = DeserializationError;
     fn is_human_readable(&self) -> bool {
-        cfg!(deserialize_human_readable)
+        cfg!(feature = "deserialize_human_readable")
     }
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>

rust/flexbuffers/src/reader/mod.rs

@@ -26,7 +26,7 @@ mod serialize;
 mod vector;
 pub use de::DeserializationError;
 pub use iter::ReaderIterator;
-pub use map::{MapReader, MapReaderIndexer};
+pub use map::MapReader;
 pub use vector::VectorReader;
 
 /// All the possible errors when reading a flexbuffer.

samples/rust_generated/my_game/sample/color_generated.rs

@@ -1,13 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 // @generated
 extern crate alloc;
-extern crate flatbuffers;
-use alloc::boxed::Box;
-use alloc::string::{String, ToString};
-use alloc::vec::Vec;
-use core::mem;
-use core::cmp::Ordering;
-use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MIN_COLOR: i8 = 0;
@@ -47,33 +40,33 @@ impl Color {
     }
   }
 }
-impl core::fmt::Debug for Color {
-  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+impl ::core::fmt::Debug for Color {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
     if let Some(name) = self.variant_name() {
       f.write_str(name)
     } else {
       f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
     }
   }
 }
-impl<'a> flatbuffers::Follow<'a> for Color {
+impl<'a> ::flatbuffers::Follow<'a> for Color {
   type Inner = Self;
   #[inline]
   unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
+    let b = ::flatbuffers::read_scalar_at::<i8>(buf, loc);
     Self(b)
   }
 }
 
-impl flatbuffers::Push for Color {
+impl ::flatbuffers::Push for Color {
     type Output = Color;
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        flatbuffers::emplace_scalar::<i8>(dst, self.0);
+        ::flatbuffers::emplace_scalar::<i8>(dst, self.0);
     }
 }
 
-impl flatbuffers::EndianScalar for Color {
+impl ::flatbuffers::EndianScalar for Color {
   type Scalar = i8;
   #[inline]
   fn to_little_endian(self) -> i8 {
@@ -87,14 +80,13 @@ impl flatbuffers::EndianScalar for Color {
   }
 }
 
-impl<'a> flatbuffers::Verifiable for Color {
+impl<'a> ::flatbuffers::Verifiable for Color {
   #[inline]
   fn run_verifier(
-    v: &mut flatbuffers::Verifier, pos: usize
-  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-    use self::flatbuffers::Verifiable;
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
     i8::run_verifier(v, pos)
   }
 }
 
-impl flatbuffers::SimpleToVerifyInSlice for Color {}
+impl ::flatbuffers::SimpleToVerifyInSlice for Color {}

samples/rust_generated/my_game/sample/equipment_generated.rs

@@ -1,13 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 // @generated
 extern crate alloc;
-extern crate flatbuffers;
-use alloc::boxed::Box;
-use alloc::string::{String, ToString};
-use alloc::vec::Vec;
-use core::mem;
-use core::cmp::Ordering;
-use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MIN_EQUIPMENT: u8 = 0;
@@ -43,33 +36,33 @@ impl Equipment {
     }
   }
 }
-impl core::fmt::Debug for Equipment {
-  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+impl ::core::fmt::Debug for Equipment {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
     if let Some(name) = self.variant_name() {
       f.write_str(name)
     } else {
       f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
     }
   }
 }
-impl<'a> flatbuffers::Follow<'a> for Equipment {
+impl<'a> ::flatbuffers::Follow<'a> for Equipment {
   type Inner = Self;
   #[inline]
   unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+    let b = ::flatbuffers::read_scalar_at::<u8>(buf, loc);
     Self(b)
   }
 }
 
-impl flatbuffers::Push for Equipment {
+impl ::flatbuffers::Push for Equipment {
     type Output = Equipment;
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        flatbuffers::emplace_scalar::<u8>(dst, self.0);
+        ::flatbuffers::emplace_scalar::<u8>(dst, self.0);
     }
 }
 
-impl flatbuffers::EndianScalar for Equipment {
+impl ::flatbuffers::EndianScalar for Equipment {
   type Scalar = u8;
   #[inline]
   fn to_little_endian(self) -> u8 {
@@ -83,25 +76,24 @@ impl flatbuffers::EndianScalar for Equipment {
   }
 }
 
-impl<'a> flatbuffers::Verifiable for Equipment {
+impl<'a> ::flatbuffers::Verifiable for Equipment {
   #[inline]
   fn run_verifier(
-    v: &mut flatbuffers::Verifier, pos: usize
-  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-    use self::flatbuffers::Verifiable;
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
     u8::run_verifier(v, pos)
   }
 }
 
-impl flatbuffers::SimpleToVerifyInSlice for Equipment {}
+impl ::flatbuffers::SimpleToVerifyInSlice for Equipment {}
 pub struct EquipmentUnionTableOffset {}
 
 #[allow(clippy::upper_case_acronyms)]
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub enum EquipmentT {
   NONE,
-  Weapon(Box<WeaponT>),
+  Weapon(alloc::boxed::Box<WeaponT>),
 }
 impl Default for EquipmentT {
   fn default() -> Self {
@@ -115,16 +107,16 @@ impl EquipmentT {
       Self::Weapon(_) => Equipment::Weapon,
     }
   }
-  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(&self, fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
+  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
     match self {
       Self::NONE => None,
       Self::Weapon(v) => Some(v.pack(fbb).as_union_value()),
     }
   }
   /// If the union variant matches, return the owned WeaponT, setting the union to NONE.
-  pub fn take_weapon(&mut self) -> Option<Box<WeaponT>> {
+  pub fn take_weapon(&mut self) -> Option<alloc::boxed::Box<WeaponT>> {
     if let Self::Weapon(_) = self {
-      let v = core::mem::replace(self, Self::NONE);
+      let v = ::core::mem::replace(self, Self::NONE);
       if let Self::Weapon(w) = v {
         Some(w)
       } else {