Rename AnyUniqueAliases.T to AnyUniqueAliases.TS to avoid naming conflict (#5362)

tests/MyGame/Example/AnyUniqueAliases.cs

@@ -9,7 +9,7 @@ public enum AnyUniqueAliases : byte
 {
  NONE = 0,
  M = 1,
- T = 2,
+ TS = 2,
  M2 = 3,
 };
 

tests/MyGame/Example/AnyUniqueAliases.go

@@ -9,21 +9,21 @@ type AnyUniqueAliases byte
 const (
 	AnyUniqueAliasesNONE AnyUniqueAliases = 0
 	AnyUniqueAliasesM    AnyUniqueAliases = 1
-	AnyUniqueAliasesT    AnyUniqueAliases = 2
+	AnyUniqueAliasesTS   AnyUniqueAliases = 2
 	AnyUniqueAliasesM2   AnyUniqueAliases = 3
 )
 
 var EnumNamesAnyUniqueAliases = map[AnyUniqueAliases]string{
 	AnyUniqueAliasesNONE: "NONE",
 	AnyUniqueAliasesM:    "M",
-	AnyUniqueAliasesT:    "T",
+	AnyUniqueAliasesTS:   "TS",
 	AnyUniqueAliasesM2:   "M2",
 }
 
 var EnumValuesAnyUniqueAliases = map[string]AnyUniqueAliases{
 	"NONE": AnyUniqueAliasesNONE,
 	"M":    AnyUniqueAliasesM,
-	"T":    AnyUniqueAliasesT,
+	"TS":   AnyUniqueAliasesTS,
 	"M2":   AnyUniqueAliasesM2,
 }
 

tests/MyGame/Example/AnyUniqueAliases.java

@@ -6,10 +6,10 @@ public final class AnyUniqueAliases {
   private AnyUniqueAliases() { }
   public static final byte NONE = 0;
   public static final byte M = 1;
-  public static final byte T = 2;
+  public static final byte TS = 2;
   public static final byte M2 = 3;
 
-  public static final String[] names = { "NONE", "M", "T", "M2", };
+  public static final String[] names = { "NONE", "M", "TS", "M2", };
 
   public static String name(int e) { return names[e]; }
 }

tests/MyGame/Example/AnyUniqueAliases.lua

@@ -5,7 +5,7 @@
 local AnyUniqueAliases = {
     NONE = 0,
     M = 1,
-    T = 2,
+    TS = 2,
     M2 = 3,
 }
 

tests/MyGame/Example/AnyUniqueAliases.php

@@ -7,13 +7,13 @@ class AnyUniqueAliases
 {
     const NONE = 0;
     const M = 1;
-    const T = 2;
+    const TS = 2;
     const M2 = 3;
 
     private static $names = array(
         AnyUniqueAliases::NONE=>"NONE",
         AnyUniqueAliases::M=>"M",
-        AnyUniqueAliases::T=>"T",
+        AnyUniqueAliases::TS=>"TS",
         AnyUniqueAliases::M2=>"M2",
     );
 

tests/MyGame/Example/AnyUniqueAliases.py

@@ -5,6 +5,6 @@
 class AnyUniqueAliases(object):
     NONE = 0
     M = 1
-    T = 2
+    TS = 2
     M2 = 3
 

tests/monster_test.fbs

@@ -18,7 +18,7 @@ enum Color:ubyte (bit_flags) { Red = 0, Green, Blue = 3, }
 
 union Any { Monster, TestSimpleTableWithEnum, MyGame.Example2.Monster }
 
-union AnyUniqueAliases { M: Monster, T: TestSimpleTableWithEnum, M2: MyGame.Example2.Monster }
+union AnyUniqueAliases { M: Monster, TS: TestSimpleTableWithEnum, M2: MyGame.Example2.Monster }
 union AnyAmbiguousAliases { M1: Monster, M2: Monster, M3: Monster }
 
 struct Test { a:short; b:byte; }

tests/monster_test.schema.json

@@ -15,7 +15,7 @@
     },
     "MyGame_Example_AnyUniqueAliases" : {
       "type" : "string",
-      "enum": ["NONE", "M", "T", "M2"]
+      "enum": ["NONE", "M", "TS", "M2"]
     },
     "MyGame_Example_AnyAmbiguousAliases" : {
       "type" : "string",

tests/monster_test_generated.h

@@ -282,7 +282,7 @@ bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<
 enum AnyUniqueAliases {
   AnyUniqueAliases_NONE = 0,
   AnyUniqueAliases_M = 1,
-  AnyUniqueAliases_T = 2,
+  AnyUniqueAliases_TS = 2,
   AnyUniqueAliases_M2 = 3,
   AnyUniqueAliases_MIN = AnyUniqueAliases_NONE,
   AnyUniqueAliases_MAX = AnyUniqueAliases_M2
@@ -292,7 +292,7 @@ inline const AnyUniqueAliases (&EnumValuesAnyUniqueAliases())[4] {
   static const AnyUniqueAliases values[] = {
     AnyUniqueAliases_NONE,
     AnyUniqueAliases_M,
-    AnyUniqueAliases_T,
+    AnyUniqueAliases_TS,
     AnyUniqueAliases_M2
   };
   return values;
@@ -302,7 +302,7 @@ inline const char * const *EnumNamesAnyUniqueAliases() {
   static const char * const names[5] = {
     "NONE",
     "M",
-    "T",
+    "TS",
     "M2",
     nullptr
   };
@@ -324,7 +324,7 @@ template<> struct AnyUniqueAliasesTraits<Monster> {
 };
 
 template<> struct AnyUniqueAliasesTraits<TestSimpleTableWithEnum> {
-  static const AnyUniqueAliases enum_value = AnyUniqueAliases_T;
+  static const AnyUniqueAliases enum_value = AnyUniqueAliases_TS;
 };
 
 template<> struct AnyUniqueAliasesTraits<MyGame::Example2::Monster> {
@@ -371,12 +371,12 @@ struct AnyUniqueAliasesUnion {
     return type == AnyUniqueAliases_M ?
       reinterpret_cast<const MonsterT *>(value) : nullptr;
   }
-  TestSimpleTableWithEnumT *AsT() {
-    return type == AnyUniqueAliases_T ?
+  TestSimpleTableWithEnumT *AsTS() {
+    return type == AnyUniqueAliases_TS ?
       reinterpret_cast<TestSimpleTableWithEnumT *>(value) : nullptr;
   }
-  const TestSimpleTableWithEnumT *AsT() const {
-    return type == AnyUniqueAliases_T ?
+  const TestSimpleTableWithEnumT *AsTS() const {
+    return type == AnyUniqueAliases_TS ?
       reinterpret_cast<const TestSimpleTableWithEnumT *>(value) : nullptr;
   }
   MyGame::Example2::MonsterT *AsM2() {
@@ -400,7 +400,7 @@ inline bool operator==(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
       return *(reinterpret_cast<const MonsterT *>(lhs.value)) ==
              *(reinterpret_cast<const MonsterT *>(rhs.value));
     }
-    case AnyUniqueAliases_T: {
+    case AnyUniqueAliases_TS: {
       return *(reinterpret_cast<const TestSimpleTableWithEnumT *>(lhs.value)) ==
              *(reinterpret_cast<const TestSimpleTableWithEnumT *>(rhs.value));
     }
@@ -1553,8 +1553,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const Monster *any_unique_as_M() const {
     return any_unique_type() == AnyUniqueAliases_M ? static_cast<const Monster *>(any_unique()) : nullptr;
   }
-  const TestSimpleTableWithEnum *any_unique_as_T() const {
-    return any_unique_type() == AnyUniqueAliases_T ? static_cast<const TestSimpleTableWithEnum *>(any_unique()) : nullptr;
+  const TestSimpleTableWithEnum *any_unique_as_TS() const {
+    return any_unique_type() == AnyUniqueAliases_TS ? static_cast<const TestSimpleTableWithEnum *>(any_unique()) : nullptr;
   }
   const MyGame::Example2::Monster *any_unique_as_M2() const {
     return any_unique_type() == AnyUniqueAliases_M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
@@ -1692,7 +1692,7 @@ template<> inline const Monster *Monster::any_unique_as<Monster>() const {
 }
 
 template<> inline const TestSimpleTableWithEnum *Monster::any_unique_as<TestSimpleTableWithEnum>() const {
-  return any_unique_as_T();
+  return any_unique_as_TS();
 }
 
 template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
@@ -2843,7 +2843,7 @@ inline bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *
       auto ptr = reinterpret_cast<const Monster *>(obj);
       return verifier.VerifyTable(ptr);
     }
-    case AnyUniqueAliases_T: {
+    case AnyUniqueAliases_TS: {
       auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
       return verifier.VerifyTable(ptr);
     }
@@ -2873,7 +2873,7 @@ inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases typ
       auto ptr = reinterpret_cast<const Monster *>(obj);
       return ptr->UnPack(resolver);
     }
-    case AnyUniqueAliases_T: {
+    case AnyUniqueAliases_TS: {
       auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
       return ptr->UnPack(resolver);
     }
@@ -2891,7 +2891,7 @@ inline flatbuffers::Offset<void> AnyUniqueAliasesUnion::Pack(flatbuffers::FlatBu
       auto ptr = reinterpret_cast<const MonsterT *>(value);
       return CreateMonster(_fbb, ptr, _rehasher).Union();
     }
-    case AnyUniqueAliases_T: {
+    case AnyUniqueAliases_TS: {
       auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(value);
       return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
     }
@@ -2909,7 +2909,7 @@ inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion
       FLATBUFFERS_ASSERT(false);  // MonsterT not copyable.
       break;
     }
-    case AnyUniqueAliases_T: {
+    case AnyUniqueAliases_TS: {
       value = new TestSimpleTableWithEnumT(*reinterpret_cast<TestSimpleTableWithEnumT *>(u.value));
       break;
     }
@@ -2929,7 +2929,7 @@ inline void AnyUniqueAliasesUnion::Reset() {
       delete ptr;
       break;
     }
-    case AnyUniqueAliases_T: {
+    case AnyUniqueAliases_TS: {
       auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(value);
       delete ptr;
       break;
@@ -3116,7 +3116,7 @@ inline const flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() {
   static const char * const names[] = {
     "NONE",
     "M",
-    "T",
+    "TS",
     "M2"
   };
   static const flatbuffers::TypeTable tt = {

tests/monster_test_generated.js

@@ -68,7 +68,7 @@ MyGame.Example.AnyName = {
 MyGame.Example.AnyUniqueAliases = {
   NONE: 0,
   M: 1,
-  T: 2,
+  TS: 2,
   M2: 3
 };
 
@@ -78,7 +78,7 @@ MyGame.Example.AnyUniqueAliases = {
 MyGame.Example.AnyUniqueAliasesName = {
   0: 'NONE',
   1: 'M',
-  2: 'T',
+  2: 'TS',
   3: 'M2'
 };
 

tests/monster_test_generated.lobster

@@ -17,7 +17,7 @@ enum Any:
 enum AnyUniqueAliases:
     AnyUniqueAliases_NONE = 0
     AnyUniqueAliases_M = 1
-    AnyUniqueAliases_T = 2
+    AnyUniqueAliases_TS = 2
     AnyUniqueAliases_M2 = 3
 
 enum AnyAmbiguousAliases:
@@ -332,7 +332,7 @@ class Monster : flatbuffers_handle
         return AnyUniqueAliases(buf_.flatbuffers_field_int8(pos_, 90, 0))
     def any_unique_as_M():
         return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) }
-    def any_unique_as_T():
+    def any_unique_as_TS():
         return MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 92) }
     def any_unique_as_M2():
         return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) }

tests/monster_test_generated.rs

@@ -304,7 +304,7 @@ pub struct AnyUnionTableOffset {}
 pub enum AnyUniqueAliases {
   NONE = 0,
   M = 1,
-  T = 2,
+  TS = 2,
   M2 = 3,
 
 }
@@ -347,7 +347,7 @@ impl flatbuffers::Push for AnyUniqueAliases {
 const ENUM_VALUES_ANY_UNIQUE_ALIASES:[AnyUniqueAliases; 4] = [
   AnyUniqueAliases::NONE,
   AnyUniqueAliases::M,
-  AnyUniqueAliases::T,
+  AnyUniqueAliases::TS,
   AnyUniqueAliases::M2
 ];
 
@@ -355,7 +355,7 @@ const ENUM_VALUES_ANY_UNIQUE_ALIASES:[AnyUniqueAliases; 4] = [
 const ENUM_NAMES_ANY_UNIQUE_ALIASES:[&'static str; 4] = [
     "NONE",
     "M",
-    "T",
+    "TS",
     "M2"
 ];
 
@@ -1294,8 +1294,8 @@ impl<'a> Monster<'a> {
 
   #[inline]
   #[allow(non_snake_case)]
-  pub fn any_unique_as_t(&self) -> Option<TestSimpleTableWithEnum<'a>> {
-    if self.any_unique_type() == AnyUniqueAliases::T {
+  pub fn any_unique_as_ts(&self) -> Option<TestSimpleTableWithEnum<'a>> {
+    if self.any_unique_type() == AnyUniqueAliases::TS {
       self.any_unique().map(|u| TestSimpleTableWithEnum::init_from_table(u))
     } else {
       None

tests/monster_test_generated.ts

@@ -28,7 +28,7 @@ export namespace MyGame.Example{
 export enum AnyUniqueAliases{
   NONE= 0,
   M= 1,
-  T= 2,
+  TS= 2,
   M2= 3
 }};
 

tests/monster_test_my_game.example_generated.dart

@@ -106,9 +106,9 @@ class AnyUniqueAliasesTypeId {
 
   static const AnyUniqueAliasesTypeId NONE = const AnyUniqueAliasesTypeId._(0);
   static const AnyUniqueAliasesTypeId M = const AnyUniqueAliasesTypeId._(1);
-  static const AnyUniqueAliasesTypeId T = const AnyUniqueAliasesTypeId._(2);
+  static const AnyUniqueAliasesTypeId TS = const AnyUniqueAliasesTypeId._(2);
   static const AnyUniqueAliasesTypeId M2 = const AnyUniqueAliasesTypeId._(3);
-  static get values => {0: NONE,1: M,2: T,3: M2,};
+  static get values => {0: NONE,1: M,2: TS,3: M2,};
 
   static const fb.Reader<AnyUniqueAliasesTypeId> reader = const _AnyUniqueAliasesTypeIdReader();
 
@@ -738,7 +738,7 @@ class Monster {
   dynamic get anyUnique {
     switch (anyUniqueType?.value) {
       case 1: return M.reader.vTableGet(_bc, _bcOffset, 92, null);
-      case 2: return T.reader.vTableGet(_bc, _bcOffset, 92, null);
+      case 2: return TS.reader.vTableGet(_bc, _bcOffset, 92, null);
       case 3: return M2.reader.vTableGet(_bc, _bcOffset, 92, null);
       default: return null;
     }