diff --git a/src/idl_gen_rust.cpp b/src/idl_gen_rust.cpp
index 17853a0..a5ce2f7 100644
--- a/src/idl_gen_rust.cpp
+++ b/src/idl_gen_rust.cpp
@@ -20,11 +20,12 @@
 #include "flatbuffers/flatbuffers.h"
 #include "flatbuffers/idl.h"
 #include "flatbuffers/util.h"
-#include "namer.h"
+#include "idl_namer.h"
 
 namespace flatbuffers {
+namespace {
 
-Namer::Config RustDefaultConfig() {
+static Namer::Config RustDefaultConfig() {
   // Historical note: We've been using "keep" casing since the original
   // implementation, presumably because Flatbuffers schema style and Rust style
   // roughly align. We are not going to enforce proper casing since its an
@@ -37,6 +38,7 @@
            /*variables=*/Case::kUnknown,  // Unused.
            /*variants=*/Case::kKeep,
            /*enum_variant_seperator=*/"::",
+           /*escape_keywords=*/Namer::Config::Escape::BeforeConvertingCase,
            /*namespaces=*/Case::kSnake,
            /*namespace_seperator=*/"::",
            /*object_prefix=*/"",
@@ -50,7 +52,7 @@
            /*filename_extension=*/".rs" };
 }
 
-std::set<std::string> RustKeywords() {
+static std::set<std::string> RustKeywords() {
   return {
     // https://doc.rust-lang.org/book/second-edition/appendix-01-keywords.html
     "as",
@@ -172,7 +174,7 @@
 };
 
 // Convert a Type to a FullType (exhaustive).
-FullType GetFullType(const Type &type) {
+static FullType GetFullType(const Type &type) {
   // N.B. The order of these conditionals matters for some types.
 
   if (IsString(type)) {
@@ -262,15 +264,16 @@
   return ftBool;
 }
 
-bool IsBitFlagsEnum(const EnumDef &enum_def) {
+static bool IsBitFlagsEnum(const EnumDef &enum_def) {
   return enum_def.attributes.Lookup("bit_flags") != nullptr;
 }
 
 // TableArgs make required non-scalars "Option<_>".
 // TODO(cneo): Rework how we do defaults and stuff.
-bool IsOptionalToBuilder(const FieldDef &field) {
+static bool IsOptionalToBuilder(const FieldDef &field) {
   return field.IsOptional() || !IsScalar(field.value.type.base_type);
 }
+} // namespace
 
 bool GenerateRustModuleRootFile(const Parser &parser,
                                 const std::string &output_dir) {
@@ -279,7 +282,7 @@
     // so return true.
     return true;
   }
-  Namer namer(RustDefaultConfig().WithFlagOptions(parser.opts, output_dir),
+  Namer namer(WithFlagOptions(RustDefaultConfig(), parser.opts, output_dir),
               RustKeywords());
   // We gather the symbols into a tree of namespaces (which are rust mods) and
   // generate a file that gathers them all.
@@ -329,6 +332,7 @@
   code +=
       "// Automatically generated by the Flatbuffers compiler. "
       "Do not modify.";
+  code += "// @generated";
   root_module.GenerateImports(code);
   const bool success =
       SaveFile((output_dir + "mod.rs").c_str(), code.ToString(), false);
@@ -344,8 +348,8 @@
                 const std::string &file_name)
       : BaseGenerator(parser, path, file_name, "", "::", "rs"),
         cur_name_space_(nullptr),
-        namer_({ RustDefaultConfig().WithFlagOptions(parser.opts, path),
-                 RustKeywords() }) {
+        namer_(WithFlagOptions(RustDefaultConfig(), parser.opts, path),
+               RustKeywords()) {
     // TODO: Namer flag overrides should be in flatc or flatc_main.
     code_.SetPadding("  ");
   }
@@ -366,9 +370,14 @@
       if (symbol.generated) continue;
       code_.Clear();
       code_ += "// " + std::string(FlatBuffersGeneratedWarning());
+      code_ += "// @generated";
+      code_ += "extern crate alloc;";
       code_ += "extern crate flatbuffers;";
-      code_ += "use std::mem;";
-      code_ += "use std::cmp::Ordering;";
+      code_ += "use alloc::boxed::Box;";
+      code_ += "use alloc::string::{String, ToString};";
+      code_ += "use alloc::vec::Vec;";
+      code_ += "use core::mem;";
+      code_ += "use core::cmp::Ordering;";
       if (parser_.opts.rust_serialize) {
         code_ += "extern crate serde;";
         code_ +=
@@ -380,9 +389,9 @@
       gen_symbol(symbol);
 
       const std::string directories =
-          namer_.Directories(symbol.defined_namespace->components);
+          namer_.Directories(*symbol.defined_namespace);
       EnsureDirExists(directories);
-      const std::string file_path = directories + namer_.File(symbol.name);
+      const std::string file_path = directories + namer_.File(symbol);
       const bool save_success =
           SaveFile(file_path.c_str(), code_.ToString(), /*binary=*/false);
       if (!save_success) return false;
@@ -418,6 +427,7 @@
   bool GenerateOneFile() {
     code_.Clear();
     code_ += "// " + std::string(FlatBuffersGeneratedWarning()) + "\n\n";
+    code_ += "// @generated";
 
     assert(!cur_name_space_);
 
@@ -526,8 +536,11 @@
     return false;
   }
 
-  std::string NamespacedNativeName(const Definition &def) {
-    return WrapInNameSpace(def.defined_namespace, namer_.ObjectType(def.name));
+  std::string NamespacedNativeName(const EnumDef &def) {
+    return WrapInNameSpace(def.defined_namespace, namer_.ObjectType(def));
+  }
+  std::string NamespacedNativeName(const StructDef &def) {
+    return WrapInNameSpace(def.defined_namespace, namer_.ObjectType(def));
   }
 
   std::string WrapInNameSpace(const Definition &def) const {
@@ -663,7 +676,7 @@
 
   std::string GetEnumValue(const EnumDef &enum_def,
                            const EnumVal &enum_val) const {
-    return namer_.EnumVariant(enum_def.name, enum_val.name);
+    return namer_.EnumVariant(enum_def, enum_val);
   }
 
   // 1 suffix since old C++ can't figure out the overload.
@@ -671,7 +684,7 @@
                          std::function<void(const EnumVal &)> cb) {
     for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
       const auto &ev = **it;
-      code_.SetValue("VARIANT", namer_.Variant(ev.name));
+      code_.SetValue("VARIANT", namer_.Variant(ev));
       code_.SetValue("VALUE", enum_def.ToString(ev));
       code_.IncrementIdentLevel();
       cb(ev);
@@ -690,7 +703,10 @@
   // an enum match function,
   // and an enum array of values
   void GenEnum(const EnumDef &enum_def) {
-    code_.SetValue("ENUM_TY", namer_.Type(enum_def.name));
+    const bool is_private = parser_.opts.no_leak_private_annotations &&
+        (enum_def.attributes.Lookup("private") != nullptr);
+    code_.SetValue("ACCESS_TYPE", is_private ? "pub(crate)" : "pub");
+    code_.SetValue("ENUM_TY", namer_.Type(enum_def));
     code_.SetValue("BASE_TYPE", GetEnumTypeForDecl(enum_def.underlying_type));
     code_.SetValue("ENUM_NAMESPACE", namer_.Namespace(enum_def.name));
     code_.SetValue("ENUM_CONSTANT", namer_.Constant(enum_def.name));
@@ -710,7 +726,7 @@
       code_ += "  flatbuffers::bitflags::bitflags! {";
       GenComment(enum_def.doc_comment, "    ");
       code_ += "    #[derive(Default)]";
-      code_ += "    pub struct {{ENUM_TY}}: {{BASE_TYPE}} {";
+      code_ += "    {{ACCESS_TYPE}} struct {{ENUM_TY}}: {{BASE_TYPE}} {";
       ForAllEnumValues1(enum_def, [&](const EnumVal &ev) {
         this->GenComment(ev.doc_comment, "    ");
         code_ += "    const {{VARIANT}} = {{VALUE}};";
@@ -743,7 +759,7 @@
       code_ += "pub const ENUM_VALUES_{{ENUM_CONSTANT}}: [{{ENUM_TY}}; " +
                num_fields + "] = [";
       ForAllEnumValues1(enum_def, [&](const EnumVal &ev) {
-        code_ += namer_.EnumVariant(enum_def.name, ev.name) + ",";
+        code_ += namer_.EnumVariant(enum_def, ev) + ",";
       });
       code_ += "];";
       code_ += "";
@@ -756,7 +772,7 @@
           "#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, "
           "Default)]";
       code_ += "#[repr(transparent)]";
-      code_ += "pub struct {{ENUM_TY}}(pub {{BASE_TYPE}});";
+      code_ += "{{ACCESS_TYPE}} struct {{ENUM_TY}}(pub {{BASE_TYPE}});";
       code_ += "#[allow(non_upper_case_globals)]";
       code_ += "impl {{ENUM_TY}} {";
       ForAllEnumValues1(enum_def, [&](const EnumVal &ev) {
@@ -782,10 +798,10 @@
       code_ += "}";
 
       // Generate Debug. Unknown variants are printed like "<UNKNOWN 42>".
-      code_ += "impl std::fmt::Debug for {{ENUM_TY}} {";
+      code_ += "impl core::fmt::Debug for {{ENUM_TY}} {";
       code_ +=
-          "  fn fmt(&self, f: &mut std::fmt::Formatter) ->"
-          " std::fmt::Result {";
+          "  fn fmt(&self, f: &mut core::fmt::Formatter) ->"
+          " core::fmt::Result {";
       code_ += "    if let Some(name) = self.variant_name() {";
       code_ += "      f.write_str(name)";
       code_ += "    } else {";
@@ -872,8 +888,8 @@
 
     if (enum_def.is_union) {
       // Generate typesafe offset(s) for unions
-      code_.SetValue("UNION_TYPE", namer_.Type(enum_def.name));
-      code_ += "pub struct {{UNION_TYPE}}UnionTableOffset {}";
+      code_.SetValue("UNION_TYPE", namer_.Type(enum_def));
+      code_ += "{{ACCESS_TYPE}} struct {{UNION_TYPE}}UnionTableOffset {}";
       code_ += "";
       if (parser_.opts.generate_object_based_api) { GenUnionObject(enum_def); }
     }
@@ -885,13 +901,12 @@
     for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
       auto &enum_val = **it;
       if (enum_val.union_type.base_type == BASE_TYPE_NONE) continue;
-      code_.SetValue("VARIANT_NAME", namer_.Variant(enum_val.name));
+      code_.SetValue("VARIANT_NAME", namer_.Variant(enum_val));
       // For legacy reasons, enum variants are Keep case while enum native
       // variants are UpperCamel case.
-      code_.SetValue(
-          "NATIVE_VARIANT",
-          ConvertCase(namer_.EscapeKeyword(enum_val.name), Case::kUpperCamel));
-      code_.SetValue("U_ELEMENT_NAME", namer_.Method(enum_val.name));
+      code_.SetValue("NATIVE_VARIANT",
+                     namer_.LegacyRustNativeVariant(enum_val));
+      code_.SetValue("U_ELEMENT_NAME", namer_.Method(enum_val));
       code_.SetValue("U_ELEMENT_TABLE_TYPE",
                      NamespacedNativeName(*enum_val.union_type.struct_def));
       code_.IncrementIdentLevel();
@@ -900,16 +915,16 @@
     }
   }
   void GenUnionObject(const EnumDef &enum_def) {
-    code_.SetValue("ENUM_TY", namer_.Type(enum_def.name));
-    code_.SetValue("ENUM_FN", namer_.Function(enum_def.name));
-    code_.SetValue("ENUM_OTY", namer_.ObjectType(enum_def.name));
+    code_.SetValue("ENUM_TY", namer_.Type(enum_def));
+    code_.SetValue("ENUM_FN", namer_.Function(enum_def));
+    code_.SetValue("ENUM_OTY", namer_.ObjectType(enum_def));
 
     // Generate native union.
     code_ += "#[allow(clippy::upper_case_acronyms)]";  // NONE's spelling is
                                                        // intended.
     code_ += "#[non_exhaustive]";
     code_ += "#[derive(Debug, Clone, PartialEq)]";
-    code_ += "pub enum {{ENUM_OTY}} {";
+    code_ += "{{ACCESS_TYPE}} enum {{ENUM_OTY}} {";
     code_ += "  NONE,";
     ForAllUnionObjectVariantsBesidesNone(enum_def, [&] {
       code_ += "{{NATIVE_VARIANT}}(Box<{{U_ELEMENT_TABLE_TYPE}}>),";
@@ -961,7 +976,7 @@
           "pub fn take_{{U_ELEMENT_NAME}}(&mut self) -> "
           "Option<Box<{{U_ELEMENT_TABLE_TYPE}}>> {";
       code_ += "  if let Self::{{NATIVE_VARIANT}}(_) = self {";
-      code_ += "    let v = std::mem::replace(self, Self::NONE);";
+      code_ += "    let v = core::mem::replace(self, Self::NONE);";
       code_ += "    if let Self::{{NATIVE_VARIANT}}(w) = v {";
       code_ += "      Some(w)";
       code_ += "    } else {";
@@ -997,13 +1012,6 @@
     code_ += "}";  // End union methods impl.
   }
 
-  std::string GetFieldOffsetName(const FieldDef &field) {
-    // FIXME: VT_FIELD_NAME is not screaming snake case by legacy mistake.
-    // but changing this is probably a breaking change.
-    return "VT_" +
-           ConvertCase(namer_.EscapeKeyword(field.name), Case::kAllUpper);
-  }
-
   enum DefaultContext { kBuilder, kAccessor, kObject };
   std::string GetDefaultValue(const FieldDef &field,
                               const DefaultContext context) {
@@ -1033,7 +1041,7 @@
         if (!ev) return "Default::default()";  // Bitflags enum.
         return WrapInNameSpace(
             field.value.type.enum_def->defined_namespace,
-            namer_.EnumVariant(field.value.type.enum_def->name, ev->name));
+            namer_.EnumVariant(*field.value.type.enum_def, *ev));
       }
       case ftUnionValue: {
         return ObjectFieldType(field, true) + "::NONE";
@@ -1539,7 +1547,7 @@
 
   std::string GenTableAccessorFuncBody(const FieldDef &field,
                                        const std::string &lifetime) {
-    const std::string vt_offset = GetFieldOffsetName(field);
+    const std::string vt_offset = namer_.LegacyRustFieldOffsetName(field);
     const std::string typname = FollowType(field.value.type, lifetime);
     // Default-y fields (scalars so far) are neither optional nor required.
     const std::string default_value =
@@ -1582,9 +1590,9 @@
       const EnumVal &ev = **it;
       // TODO(cneo): Can variants be deprecated, should we skip them?
       if (ev.union_type.base_type == BASE_TYPE_NONE) { continue; }
-      code_.SetValue("U_ELEMENT_ENUM_TYPE",
-                     WrapInNameSpace(def.defined_namespace,
-                                     namer_.EnumVariant(def.name, ev.name)));
+      code_.SetValue(
+          "U_ELEMENT_ENUM_TYPE",
+          WrapInNameSpace(def.defined_namespace, namer_.EnumVariant(def, ev)));
       code_.SetValue(
           "U_ELEMENT_TABLE_TYPE",
           WrapInNameSpace(ev.union_type.struct_def->defined_namespace,
@@ -1601,11 +1609,11 @@
     // diff when refactoring to the `ForAllX` helper functions.
     auto go = [&](const FieldDef &field) {
       if (field.deprecated) return;
-      code_.SetValue("OFFSET_NAME", GetFieldOffsetName(field));
+      code_.SetValue("OFFSET_NAME", namer_.LegacyRustFieldOffsetName(field));
       code_.SetValue("OFFSET_VALUE", NumToString(field.value.offset));
-      code_.SetValue("FIELD", namer_.Field(field.name));
+      code_.SetValue("FIELD", namer_.Field(field));
       code_.SetValue("BLDR_DEF_VAL", GetDefaultValue(field, kBuilder));
-      code_.SetValue("DISCRIMINANT", namer_.Method(field.name) + "_type");
+      code_.SetValue("DISCRIMINANT", namer_.Field(field) + "_type");
       code_.IncrementIdentLevel();
       cb(field);
       code_.DecrementIdentLevel();
@@ -1620,18 +1628,22 @@
   // Generate an accessor struct, builder struct, and create function for a
   // table.
   void GenTable(const StructDef &struct_def) {
-    code_.SetValue("STRUCT_TY", namer_.Type(struct_def.name));
-    code_.SetValue("STRUCT_FN", namer_.Function(struct_def.name));
+
+    const bool is_private = parser_.opts.no_leak_private_annotations &&
+        (struct_def.attributes.Lookup("private") != nullptr);
+    code_.SetValue("ACCESS_TYPE", is_private ? "pub(crate)" : "pub");
+    code_.SetValue("STRUCT_TY", namer_.Type(struct_def));
+    code_.SetValue("STRUCT_FN", namer_.Function(struct_def));
 
     // Generate an offset type, the base type, the Follow impl, and the
     // init_from_table impl.
-    code_ += "pub enum {{STRUCT_TY}}Offset {}";
+    code_ += "{{ACCESS_TYPE}} enum {{STRUCT_TY}}Offset {}";
     code_ += "#[derive(Copy, Clone, PartialEq)]";
     code_ += "";
 
     GenComment(struct_def.doc_comment);
 
-    code_ += "pub struct {{STRUCT_TY}}<'a> {";
+    code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}<'a> {";
     code_ += "  pub _tab: flatbuffers::Table<'a>,";
     code_ += "}";
     code_ += "";
@@ -1702,7 +1714,7 @@
     if (parser_.opts.generate_object_based_api) {
       // TODO(cneo): Replace more for loops with ForAllX stuff.
       // TODO(cneo): Manage indentation with IncrementIdentLevel?
-      code_.SetValue("STRUCT_OTY", namer_.ObjectType(struct_def.name));
+      code_.SetValue("STRUCT_OTY", namer_.ObjectType(struct_def));
       code_ += "  pub fn unpack(&self) -> {{STRUCT_OTY}} {";
       ForAllObjectTableFields(struct_def, [&](const FieldDef &field) {
         const Type &type = field.value.type;
@@ -1939,7 +1951,7 @@
       const EnumDef &union_def = *field.value.type.enum_def;
       code_.SetValue("UNION_TYPE", WrapInNameSpace(union_def));
       code_.SetValue("UNION_TYPE_OFFSET_NAME",
-                     GetFieldOffsetName(field) + "_TYPE");
+                     namer_.LegacyRustFieldOffsetName(field) + "_TYPE");
       code_ +=
           "\n     .visit_union::<{{UNION_TYPE}}, _>("
           "\"{{FIELD}}_type\", Self::{{UNION_TYPE_OFFSET_NAME}}, "
@@ -1965,7 +1977,7 @@
     // Generate an args struct:
     code_.SetValue("MAYBE_LT",
                    TableBuilderArgsNeedsLifetime(struct_def) ? "<'a>" : "");
-    code_ += "pub struct {{STRUCT_TY}}Args{{MAYBE_LT}} {";
+    code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}Args{{MAYBE_LT}} {";
     ForAllTableFields(struct_def, [&](const FieldDef &field) {
       code_.SetValue("PARAM_TYPE", TableBuilderArgsDefnType(field, "'a"));
       code_ += "  pub {{FIELD}}: {{PARAM_TYPE}},";
@@ -2010,12 +2022,12 @@
           if (type.base_type == BASE_TYPE_UNION) {
             const auto &enum_def = *type.enum_def;
             code_.SetValue("ENUM_TY", WrapInNameSpace(enum_def));
-            code_.SetValue("FIELD", namer_.Field(field.name));
+            code_.SetValue("FIELD", namer_.Field(field));
 
             code_ += "    match self.{{FIELD}}_type() {";
             code_ += "      {{ENUM_TY}}::NONE => (),";
             ForAllUnionObjectVariantsBesidesNone(enum_def, [&] {
-              code_.SetValue("FIELD", namer_.Field(field.name));
+              code_.SetValue("FIELD", namer_.Field(field));
               code_ += "      {{ENUM_TY}}::{{VARIANT_NAME}} => {";
               code_ +=
                   "        let f = "
@@ -2054,7 +2066,7 @@
     }
 
     // Generate a builder struct:
-    code_ += "pub struct {{STRUCT_TY}}Builder<'a: 'b, 'b> {";
+    code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}Builder<'a: 'b, 'b> {";
     code_ += "  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,";
     code_ +=
         "  start_: flatbuffers::WIPOffset<"
@@ -2065,7 +2077,7 @@
     code_ += "impl<'a: 'b, 'b> {{STRUCT_TY}}Builder<'a, 'b> {";
     ForAllTableFields(struct_def, [&](const FieldDef &field) {
       const bool is_scalar = IsScalar(field.value.type.base_type);
-      std::string offset = GetFieldOffsetName(field);
+      std::string offset = namer_.LegacyRustFieldOffsetName(field);
       // Generate functions to add data, which take one of two forms.
       //
       // If a value has a default:
@@ -2077,8 +2089,7 @@
       //   fn add_x(x_: type) {
       //     fbb_.push_slot_always::<type>(offset, x_);
       //   }
-      code_.SetValue("FIELD_OFFSET",
-                     namer_.Type(struct_def.name) + "::" + offset);
+      code_.SetValue("FIELD_OFFSET", namer_.Type(struct_def) + "::" + offset);
       code_.SetValue("FIELD_TYPE", TableBuilderArgsAddFuncType(field, "'b "));
       code_.SetValue("FUNC_BODY", TableBuilderArgsAddFuncBody(field));
       code_ += "#[inline]";
@@ -2126,10 +2137,10 @@
     code_ += "}";
     code_ += "";
 
-    code_ += "impl std::fmt::Debug for {{STRUCT_TY}}<'_> {";
+    code_ += "impl core::fmt::Debug for {{STRUCT_TY}}<'_> {";
     code_ +=
-        "  fn fmt(&self, f: &mut std::fmt::Formatter<'_>"
-        ") -> std::fmt::Result {";
+        "  fn fmt(&self, f: &mut core::fmt::Formatter<'_>"
+        ") -> core::fmt::Result {";
     code_ += "    let mut ds = f.debug_struct(\"{{STRUCT_TY}}\");";
     ForAllTableFields(struct_def, [&](const FieldDef &field) {
       if (GetFullType(field.value.type) == ftUnionValue) {
@@ -2170,13 +2181,13 @@
   }
 
   void GenTableObject(const StructDef &table) {
-    code_.SetValue("STRUCT_OTY", namer_.ObjectType(table.name));
-    code_.SetValue("STRUCT_TY", namer_.Type(table.name));
+    code_.SetValue("STRUCT_OTY", namer_.ObjectType(table));
+    code_.SetValue("STRUCT_TY", namer_.Type(table));
 
     // Generate the native object.
     code_ += "#[non_exhaustive]";
     code_ += "#[derive(Debug, Clone, PartialEq)]";
-    code_ += "pub struct {{STRUCT_OTY}} {";
+    code_ += "{{ACCESS_TYPE}} struct {{STRUCT_OTY}} {";
     ForAllObjectTableFields(table, [&](const FieldDef &field) {
       // Union objects combine both the union discriminant and value, so we
       // skip making a field for the discriminant.
@@ -2221,7 +2232,7 @@
         case ftUnionKey: return;  // Generate union type with union value.
         case ftUnionValue: {
           code_.SetValue("ENUM_METHOD",
-                         namer_.Method(field.value.type.enum_def->name));
+                         namer_.Method(*field.value.type.enum_def));
           code_ +=
               "  let {{FIELD}}_type = "
               "self.{{FIELD}}.{{ENUM_METHOD}}_type();";
@@ -2309,7 +2320,7 @@
     for (auto it = v.begin(); it != v.end(); it++) {
       const FieldDef &field = **it;
       if (field.deprecated) continue;
-      code_.SetValue("FIELD", namer_.Field(field.name));
+      code_.SetValue("FIELD", namer_.Field(field));
       code_.SetValue("FIELD_OTY", ObjectFieldType(field, true));
       code_.IncrementIdentLevel();
       cb(field);
@@ -2349,7 +2360,7 @@
     code_ += "#[inline]";
     code_ +=
         "pub fn key_compare_with_value(&self, val: {{KEY_TYPE}}) -> "
-        "::std::cmp::Ordering {";
+        "::core::cmp::Ordering {";
     code_ += "  let key = self.{{FIELD}}();";
     code_ += "  key.cmp({{REF}}val)";
     code_ += "}";
@@ -2359,8 +2370,8 @@
   // must only be called if the root table is defined.
   void GenRootTableFuncs(const StructDef &struct_def) {
     FLATBUFFERS_ASSERT(parser_.root_struct_def_ && "root table not defined");
-    code_.SetValue("STRUCT_TY", namer_.Type(struct_def.name));
-    code_.SetValue("STRUCT_FN", namer_.Function(struct_def.name));
+    code_.SetValue("STRUCT_TY", namer_.Type(struct_def));
+    code_.SetValue("STRUCT_FN", namer_.Function(struct_def));
     code_.SetValue("STRUCT_CONST", namer_.Constant(struct_def.name));
 
     // The root datatype accessors:
@@ -2570,7 +2581,7 @@
       const auto &field = **it;
       code_.SetValue("FIELD_TYPE", GetTypeGet(field.value.type));
       code_.SetValue("FIELD_OTY", ObjectFieldType(field, false));
-      code_.SetValue("FIELD", namer_.Field(field.name));
+      code_.SetValue("FIELD", namer_.Field(field));
       code_.SetValue("FIELD_OFFSET", NumToString(offset_to_field));
       code_.SetValue(
           "REF",
@@ -2584,12 +2595,15 @@
   }
   // Generate an accessor struct with constructor for a flatbuffers struct.
   void GenStruct(const StructDef &struct_def) {
+    const bool is_private = parser_.opts.no_leak_private_annotations &&
+        (struct_def.attributes.Lookup("private") != nullptr);
+    code_.SetValue("ACCESS_TYPE", is_private ? "pub(crate)" : "pub");
     // Generates manual padding and alignment.
     // Variables are private because they contain little endian data on all
     // platforms.
     GenComment(struct_def.doc_comment);
     code_.SetValue("ALIGN", NumToString(struct_def.minalign));
-    code_.SetValue("STRUCT_TY", namer_.Type(struct_def.name));
+    code_.SetValue("STRUCT_TY", namer_.Type(struct_def));
     code_.SetValue("STRUCT_SIZE", NumToString(struct_def.bytesize));
 
     // We represent Flatbuffers-structs in Rust-u8-arrays since the data may be
@@ -2601,7 +2615,7 @@
     code_ += "// struct {{STRUCT_TY}}, aligned to {{ALIGN}}";
     code_ += "#[repr(transparent)]";
     code_ += "#[derive(Clone, Copy, PartialEq)]";
-    code_ += "pub struct {{STRUCT_TY}}(pub [u8; {{STRUCT_SIZE}}]);";
+    code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}(pub [u8; {{STRUCT_SIZE}}]);";
     code_ += "impl Default for {{STRUCT_TY}} { ";
     code_ += "  fn default() -> Self { ";
     code_ += "    Self([0; {{STRUCT_SIZE}}])";
@@ -2609,10 +2623,10 @@
     code_ += "}";
 
     // Debug for structs.
-    code_ += "impl std::fmt::Debug for {{STRUCT_TY}} {";
+    code_ += "impl core::fmt::Debug for {{STRUCT_TY}} {";
     code_ +=
-        "  fn fmt(&self, f: &mut std::fmt::Formatter"
-        ") -> std::fmt::Result {";
+        "  fn fmt(&self, f: &mut core::fmt::Formatter"
+        ") -> core::fmt::Result {";
     code_ += "    f.debug_struct(\"{{STRUCT_TY}}\")";
     ForAllStructFields(struct_def, [&](const FieldDef &unused) {
       (void)unused;
@@ -2648,7 +2662,7 @@
     code_ += "    fn push(&self, dst: &mut [u8], _rest: &[u8]) {";
     code_ += "        let src = unsafe {";
     code_ +=
-        "            ::std::slice::from_raw_parts("
+        "            ::core::slice::from_raw_parts("
         "self as *const {{STRUCT_TY}} as *const u8, Self::size())";
     code_ += "        };";
     code_ += "        dst.copy_from_slice(src);";
@@ -2661,7 +2675,7 @@
     code_ += "    fn push(&self, dst: &mut [u8], _rest: &[u8]) {";
     code_ += "        let src = unsafe {";
     code_ +=
-        "            ::std::slice::from_raw_parts("
+        "            ::core::slice::from_raw_parts("
         "*self as *const {{STRUCT_TY}} as *const u8, Self::size())";
     code_ += "        };";
     code_ += "        dst.copy_from_slice(src);";
@@ -2793,7 +2807,7 @@
                          NumToString(InlineSize(field.value.type)));
           code_ += "pub fn set_{{FIELD}}(&mut self, x: &{{FIELD_TYPE}}) {";
           code_ += "  unsafe {";
-          code_ += "    std::ptr::copy(";
+          code_ += "    core::ptr::copy(";
           code_ += "      x.as_ptr() as *const u8,";
           code_ += "      self.0.as_mut_ptr().add({{FIELD_OFFSET}}),";
           code_ += "      {{FIELD_SIZE}},";
@@ -2819,7 +2833,7 @@
 
     // Generate Object API unpack method.
     if (parser_.opts.generate_object_based_api) {
-      code_.SetValue("STRUCT_OTY", namer_.ObjectType(struct_def.name));
+      code_.SetValue("STRUCT_OTY", namer_.ObjectType(struct_def));
       code_ += "  pub fn unpack(&self) -> {{STRUCT_OTY}} {";
       code_ += "    {{STRUCT_OTY}} {";
       ForAllStructFields(struct_def, [&](const FieldDef &field) {
@@ -2848,7 +2862,7 @@
     if (parser_.opts.generate_object_based_api) {
       // Struct declaration
       code_ += "#[derive(Debug, Clone, PartialEq, Default)]";
-      code_ += "pub struct {{STRUCT_OTY}} {";
+      code_ += "{{ACCESS_TYPE}} struct {{STRUCT_OTY}} {";
       ForAllStructFields(struct_def, [&](const FieldDef &field) {
         (void)field;  // unused.
         code_ += "pub {{FIELD}}: {{FIELD_OTY}},";
@@ -2906,8 +2920,8 @@
         }
       }
     }
-    code_ += indent + "use std::mem;";
-    code_ += indent + "use std::cmp::Ordering;";
+    code_ += indent + "use core::mem;";
+    code_ += indent + "use core::cmp::Ordering;";
     code_ += "";
     if (parser_.opts.rust_serialize) {
       code_ += indent + "extern crate serde;";
@@ -2964,7 +2978,7 @@
   }
 
  private:
-  Namer namer_;
+  IdlNamer namer_;
 };
 
 }  // namespace rust