diff --git a/source/blender/blenloader/intern/writefile.cc b/source/blender/blenloader/intern/writefile.cc
index 6ea74411ed7..0829d34c596 100644
--- a/source/blender/blenloader/intern/writefile.cc
+++ b/source/blender/blenloader/intern/writefile.cc
@@ -1492,7 +1492,7 @@ static bool write_file_handle(Main *mainvar,
    *
    * Note that we *borrow* the pointer to 'DNAstr',
    * so writing each time uses the same address and doesn't cause unnecessary undo overhead. */
-  writedata(wd, BLO_CODE_DNA1, size_t(wd->sdna->data_len), wd->sdna->data);
+  writedata(wd, BLO_CODE_DNA1, size_t(wd->sdna->data_size), wd->sdna->data);
 
   /* End of file. */
   memset(&bhead, 0, sizeof(BHead));
diff --git a/source/blender/makesdna/DNA_genfile.h b/source/blender/makesdna/DNA_genfile.h
index 7e9e23c77d7..0b834c84f07 100644
--- a/source/blender/makesdna/DNA_genfile.h
+++ b/source/blender/makesdna/DNA_genfile.h
@@ -96,24 +96,24 @@ struct DNA_ReconstructInfo *DNA_reconstruct_info_create(const struct SDNA *oldsd
 void DNA_reconstruct_info_free(struct DNA_ReconstructInfo *reconstruct_info);
 
 /**
- * \param index_last: Support faster lookups when there is the possibility
+ * \param struct_index_last: Support faster lookups when there is the possibility
  * of the same name being looked up multiple times. Initialize to `UINT_MAX`.
  *
  * \return the index of the struct or -1 on failure.
  */
-int DNA_struct_find_with_alias_ex(const struct SDNA *sdna,
-                                  const char *str,
-                                  unsigned int *index_last);
+int DNA_struct_find_index_with_alias_ex(const struct SDNA *sdna,
+                                        const char *str,
+                                        unsigned int *struct_index_last);
 /** \note prefer #DNA_struct_find_with_alias_ex unless there is a good reason not to. */
-int DNA_struct_find_without_alias_ex(const struct SDNA *sdna,
-                                     const char *str,
-                                     unsigned int *index_last);
+int DNA_struct_find_index_without_alias_ex(const struct SDNA *sdna,
+                                           const char *str,
+                                           unsigned int *struct_index_last);
 /**
  * \return the index of the struct or -1 on failure.
  */
 int DNA_struct_find_with_alias(const struct SDNA *sdna, const char *str);
 /** \note prefer #DNA_struct_find_with_alias unless there is a good reason not to. */
-int DNA_struct_find_without_alias(const struct SDNA *sdna, const char *str);
+int DNA_struct_find_index_without_alias(const struct SDNA *sdna, const char *str);
 
 /**
  * A convenience function, the equivalent of: `DNA_struct_find_with_alias(..) != -1`
@@ -141,7 +141,7 @@ bool DNA_struct_member_exists_without_alias(const struct SDNA *sdna,
  * \param struct_nr: Index of struct info within sdna
  * \param data: Struct data that is to be converted
  */
-void DNA_struct_switch_endian(const struct SDNA *sdna, int struct_nr, char *data);
+void DNA_struct_switch_endian(const struct SDNA *sdna, int struct_index, char *data);
 /**
  * Constructs and returns an array of byte flags with one element for each struct in oldsdna,
  * indicating how it compares to newsdna.
@@ -149,14 +149,14 @@ void DNA_struct_switch_endian(const struct SDNA *sdna, int struct_nr, char *data
 const char *DNA_struct_get_compareflags(const struct SDNA *sdna, const struct SDNA *newsdna);
 /**
  * \param reconstruct_info: Information preprocessed by #DNA_reconstruct_info_create.
- * \param old_struct_nr: Index of struct info within oldsdna.
+ * \param old_struct_index: Index of struct info within oldsdna.
  * \param blocks: The number of array elements.
  * \param old_blocks: Array of struct data.
  * \param alloc_name: String to pass to the allocation calls for reconstructed data.
  * \return An allocated reconstructed struct.
  */
 void *DNA_struct_reconstruct(const struct DNA_ReconstructInfo *reconstruct_info,
-                             int old_struct_nr,
+                             int old_struct_index,
                              int blocks,
                              const void *old_blocks,
                              const char *alloc_name);
@@ -179,13 +179,13 @@ int DNA_struct_member_offset_by_name_with_alias(const struct SDNA *sdna,
                                                 const char *name);
 
 /**
- * Returns the size of struct fields of the specified type and name.
+ * Returns the size of struct fields of the specified type and member_index.
  *
  * \param type: Index into sdna->types/types_size
- * \param name: Index into sdna->names,
- * needed to extract possible pointer/array information.
+ * \param member_index: Index into sdna->names, needed to extract possible pointer/array
+ * information.
  */
-int DNA_struct_member_size(const struct SDNA *sdna, short type, short name);
+int DNA_struct_member_size(const struct SDNA *sdna, short type, short member_index);
 
 /**
  * Returns the size in bytes of a primitive type.
@@ -202,7 +202,7 @@ int DNA_struct_size(const struct SDNA *sdna, int struct_index);
 /**
  * Get the alignment that should be used when allocating memory for this type.
  */
-int DNA_struct_alignment(const struct SDNA *sdna, int struct_nr);
+int DNA_struct_alignment(const struct SDNA *sdna, int struct_index);
 
 /**
  * Return the current (alias) type name of the given struct index.
@@ -210,20 +210,28 @@ int DNA_struct_alignment(const struct SDNA *sdna, int struct_nr);
 const char *DNA_struct_identifier(struct SDNA *sdna, int struct_index);
 
 /**
- * Rename a struct
+ * Find the struct matching the given `old_type_name`, and rename its type (referenced by its
+ * #SDNA_Struct.type_index) to the given `new_type_name`.
+ *
+ * WARNING: Deprecated, do not use in new code. Only used to version some renaming done during
+ * early 2.80 development.
  */
 bool DNA_sdna_patch_struct_by_name(struct SDNA *sdna,
-                                   const char *struct_name_old,
-                                   const char *struct_name_new);
+                                   const char *old_type_name,
+                                   const char *new_type_name);
 /**
- * Replace \a elem_old with \a elem_new for struct \a struct_name
- * handles search & replace, maintaining surrounding non-identifier characters
- * such as pointer & array size.
+ * Rename \a old_member_name with \a new_member_name for struct matching \a type_name.
+ *
+ * Handles search & replace, maintaining surrounding non-identifier characters such as pointer &
+ * array size.
+ *
+ * WARNING: Deprecated, do not use in new code. Only used to version some renaming done during
+ * early 2.80 development.
  */
 bool DNA_sdna_patch_struct_member_by_name(struct SDNA *sdna,
-                                          const char *struct_name,
-                                          const char *elem_old,
-                                          const char *elem_new);
+                                          const char *type_name,
+                                          const char *old_member_name,
+                                          const char *new_member_name);
 
 void DNA_sdna_alias_data_ensure(struct SDNA *sdna);
 
diff --git a/source/blender/makesdna/DNA_listBase.h b/source/blender/makesdna/DNA_listBase.h
index c316a37553c..eee99757d38 100644
--- a/source/blender/makesdna/DNA_listBase.h
+++ b/source/blender/makesdna/DNA_listBase.h
@@ -23,7 +23,12 @@ typedef struct LinkData {
   void *data;
 } LinkData;
 
-/** Never change the size of this! dna_genfile.cc detects pointer_size with it. */
+/**
+ * The basic double linked-list structure.
+ *
+ * \warning Never change the size/definition of this struct! The #init_structDNA
+ * function (from dna_genfile.cc) uses it to compute the #pointer_size.
+ */
 typedef struct ListBase {
   void *first, *last;
 } ListBase;
diff --git a/source/blender/makesdna/DNA_sdna_types.h b/source/blender/makesdna/DNA_sdna_types.h
index ad2ff9e5049..441040273e1 100644
--- a/source/blender/makesdna/DNA_sdna_types.h
+++ b/source/blender/makesdna/DNA_sdna_types.h
@@ -15,9 +15,9 @@ typedef struct SDNA_StructMember {
   /** This struct must not change, it's only a convenience view for raw data stored in SDNA. */
 
   /** An index into SDNA->types. */
-  short type;
-  /** An index into SDNA->names. */
-  short name;
+  short type_index;
+  /** An index into SDNA->members. */
+  short member_index;
 } SDNA_StructMember;
 
 #
@@ -26,9 +26,9 @@ typedef struct SDNA_Struct {
   /** This struct must not change, it's only a convenience view for raw data stored in SDNA. */
 
   /** An index into SDNA->types. */
-  short type;
+  short type_index;
   /** The amount of members in this struct. */
-  short members_len;
+  short members_num;
   /** "Flexible array member" that contains information about all members of this struct. */
   SDNA_StructMember members[];
 } SDNA_Struct;
@@ -36,57 +36,99 @@ typedef struct SDNA_Struct {
 #
 #
 typedef struct SDNA {
-  /** Full copy of 'encoded' data (when data_alloc is set, otherwise borrowed). */
+  /** The 'encoded' data (full copy when #data_alloc is set, otherwise borrowed memory). */
   const char *data;
-  /** Length of data. */
-  int data_len;
+  /** Length of #data, in bytes. */
+  int data_size;
   bool data_alloc;
 
-  /** Total number of struct members. */
-  int names_len, names_len_alloc;
-  /** Struct member names. */
-  const char **names;
-  /** Result of #DNA_elem_array_size (aligned with #names). */
-  short *names_array_len;
-
   /** Size of a pointer in bytes. */
   int pointer_size;
 
+  /* ***** Start of SDNA types. ***** */
+  /**
+   * This covers all known types (basic and structs ones) from SDNA.
+   *
+   * NOTE: This data is not in sync with the SDNA #structs info below. Among other things:
+   *   - Basic types (int, float, etc.) have _no_ matching struct definitions currently.
+   *   - Types can be discovered and added before their struct definition, when they are used for
+   *     members of another struct which gets parsed first.
+   */
+  /** Number of types. */
+  int types_num;
   /** Type names. */
   const char **types;
-  /** Number of basic types + struct types. */
-  int types_len;
-
   /** Type lengths. */
   short *types_size;
-
-  /** Information about structs and their members. */
-  SDNA_Struct **structs;
-  /** Number of struct types. */
-  int structs_len;
-
-  /** #GHash for faster lookups, requires WITH_DNA_GHASH to be used for now. */
-  struct GHash *structs_map;
-
-  /** Temporary memory currently only used for version patching DNA. */
-  struct MemArena *mem_arena;
-  /** Runtime versions of data stored in DNA, lazy initialized,
-   * only different when renaming is done. */
-  struct {
-    /** Aligned with #SDNA.names, same pointers when unchanged. */
-    const char **names;
-    /** Aligned with #SDNA.types, same pointers when unchanged. */
-    const char **types;
-    /** A version of #SDNA.structs_map that uses #SDNA.alias.types for its keys. */
-    struct GHash *structs_map;
-  } alias;
-
   /**
    * Alignment used when allocating pointers to this type. The actual minimum alignment of the
    * type may be lower in some cases. For example, the pointer alignment of a single char is at
    * least 8 bytes, but the alignment of the type itself is 1.
    */
   int *types_alignment;
+  /* ***** End of SDNA types. ***** */
+
+  /* ***** Start of SDNA structs. ***** */
+  /**
+   * This covers all known structs from SDNA (pointers to #SDNA_Struct data).
+   *
+   * NOTE: See comment above about SDNA types above for differences between structs and types
+   * definitions.
+   */
+  /** Number of struct definitions. */
+  int structs_num;
+  /** Information about structs and their members. */
+  SDNA_Struct **structs;
+  /* ***** End of SDNA structs. ***** */
+
+  /* ***** Start of SDNA struct members. ***** */
+  /** Total number of struct members. */
+  int members_num;
+  /**
+   * Contains the number of allocated items in both #members and #members_array_num arrays below.
+   *
+   * Typically same as #members_len, unless after versionning DNA info (these arrays are
+   * reallocated by chunks, see #DNA_sdna_patch_struct_member).
+   */
+  int members_num_alloc;
+  /** Struct member names. */
+  const char **members;
+  /**
+   * Aligned with #members. The total number of items in the array defined by the matching member,
+   * if any, otherwise 1.
+   *
+   * Result of #DNA_member_array_num.
+   */
+  short *members_array_num;
+  /* ***** End of SDNA struct members. ***** */
+
+  /**
+   * Mapping between type names (from #types array above) and struct indices (into #structs array
+   * above).
+   *
+   * Requires WITH_DNA_GHASH to be used for now.
+   */
+  struct GHash *types_to_structs_map;
+
+  /**
+   * Runtime versions of data stored in DNA, lazy initialized, only different when renaming is
+   * done.
+   *
+   * Contains mapping from original (static) types/members names to their current (alias)
+   * DNA-defined versions (i.e. results from calling #DNA_alias_maps with
+   * #DNA_RENAME_ALIAS_FROM_STATIC).
+   */
+  struct {
+    /** Aligned with #SDNA.types, same pointers when unchanged. */
+    const char **types;
+    /** Aligned with #SDNA.members, same pointers when unchanged. */
+    const char **members;
+    /** A version of #SDNA.types_to_structs_map that uses #SDNA.alias.types for its keys. */
+    struct GHash *types_to_structs_map;
+  } alias;
+
+  /** Temporary memory currently only used for version patching DNA. */
+  struct MemArena *mem_arena;
 } SDNA;
 
 #
diff --git a/source/blender/makesdna/intern/dna_genfile.cc b/source/blender/makesdna/intern/dna_genfile.cc
index 625b00d78ab..a37e5c76a0a 100644
--- a/source/blender/makesdna/intern/dna_genfile.cc
+++ b/source/blender/makesdna/intern/dna_genfile.cc
@@ -129,15 +129,15 @@ void DNA_sdna_free(SDNA *sdna)
     MEM_freeN((void *)sdna->data);
   }
 
-  MEM_freeN((void *)sdna->names);
-  MEM_freeN((void *)sdna->names_array_len);
+  MEM_freeN((void *)sdna->members);
+  MEM_freeN((void *)sdna->members_array_num);
   MEM_freeN((void *)sdna->types);
   MEM_freeN(sdna->structs);
   MEM_freeN(sdna->types_alignment);
 
 #ifdef WITH_DNA_GHASH
-  if (sdna->structs_map) {
-    BLI_ghash_free(sdna->structs_map, nullptr, nullptr);
+  if (sdna->types_to_structs_map) {
+    BLI_ghash_free(sdna->types_to_structs_map, nullptr, nullptr);
   }
 #endif
 
@@ -145,11 +145,11 @@ void DNA_sdna_free(SDNA *sdna)
     BLI_memarena_free(sdna->mem_arena);
   }
 
-  MEM_SAFE_FREE(sdna->alias.names);
+  MEM_SAFE_FREE(sdna->alias.members);
   MEM_SAFE_FREE(sdna->alias.types);
 #ifdef WITH_DNA_GHASH
-  if (sdna->alias.structs_map) {
-    BLI_ghash_free(sdna->alias.structs_map, nullptr, nullptr);
+  if (sdna->alias.types_to_structs_map) {
+    BLI_ghash_free(sdna->alias.types_to_structs_map, nullptr, nullptr);
   }
 #endif
 
@@ -158,7 +158,7 @@ void DNA_sdna_free(SDNA *sdna)
 
 int DNA_struct_size(const SDNA *sdna, int struct_index)
 {
-  return sdna->types_size[sdna->structs[struct_index]->type];
+  return sdna->types_size[sdna->structs[struct_index]->type_index];
 }
 
 /**
@@ -170,30 +170,30 @@ static bool ispointer(const char *name)
   return (name[0] == '*' || (name[0] == '(' && name[1] == '*'));
 }
 
-int DNA_struct_member_size(const SDNA *sdna, short type, short name)
+int DNA_struct_member_size(const SDNA *sdna, short type, short member_index)
 {
-  const char *cp = sdna->names[name];
+  const char *cp = sdna->members[member_index];
   int len = 0;
 
   /* is it a pointer or function pointer? */
   if (ispointer(cp)) {
     /* has the name an extra length? (array) */
-    len = sdna->pointer_size * sdna->names_array_len[name];
+    len = sdna->pointer_size * sdna->members_array_num[member_index];
   }
   else if (sdna->types_size[type]) {
     /* has the name an extra length? (array) */
-    len = int(sdna->types_size[type]) * sdna->names_array_len[name];
+    len = int(sdna->types_size[type]) * sdna->members_array_num[member_index];
   }
 
   return len;
 }
 
 #if 0
-static void printstruct(SDNA *sdna, short strnr)
+static void printstruct(SDNA *sdna, short struct_index)
 {
   /* is for debug */
 
-  SDNA_Struct *struct_info = sdna->structs[strnr];
+  SDNA_Struct *struct_info = sdna->structs[struct_index];
   printf("struct %s\n", sdna->types[struct_info->type]);
 
   for (int b = 0; b < struct_info->members_len; b++) {
@@ -206,42 +206,42 @@ static void printstruct(SDNA *sdna, short strnr)
 /**
  * Returns the index of the struct info for the struct with the specified name.
  */
-static int dna_struct_find_nr_ex_impl(
+static int dna_struct_find_index_ex_impl(
     /* From SDNA struct. */
     const char **types,
-    const int /*types_len*/,
+    const int /*types_num*/,
     SDNA_Struct **const structs,
-    const int structs_len,
+    const int structs_num,
 #ifdef WITH_DNA_GHASH
     GHash *structs_map,
 #endif
     /* Regular args. */
     const char *str,
-    uint *index_last)
+    uint *struct_index_last)
 {
-  if (*index_last < structs_len) {
-    const SDNA_Struct *struct_info = structs[*index_last];
-    if (STREQ(types[struct_info->type], str)) {
-      return *index_last;
+  if (*struct_index_last < structs_num) {
+    const SDNA_Struct *struct_info = structs[*struct_index_last];
+    if (STREQ(types[struct_info->type_index], str)) {
+      return *struct_index_last;
     }
   }
 
 #ifdef WITH_DNA_GHASH
   {
-    void **index_p = BLI_ghash_lookup_p(structs_map, str);
-    if (index_p) {
-      const int index = POINTER_AS_INT(*index_p);
-      *index_last = index;
-      return index;
+    void **struct_index_p = BLI_ghash_lookup_p(structs_map, str);
+    if (struct_index_p) {
+      const int struct_index = POINTER_AS_INT(*struct_index_p);
+      *struct_index_last = struct_index;
+      return struct_index;
     }
   }
 #else
   {
-    for (int index = 0; index < structs_len; index++) {
-      const SDNA_Struct *struct_info = structs[index];
+    for (int struct_index = 0; struct_index < types_num; struct_index++) {
+      const SDNA_Struct *struct_info = structs[struct_index];
       if (STREQ(types[struct_info->type], str)) {
-        *index_last = index;
-        return index;
+        *struct_index_last = struct_index;
+        return struct_index;
       }
     }
   }
@@ -249,51 +249,56 @@ static int dna_struct_find_nr_ex_impl(
   return -1;
 }
 
-int DNA_struct_find_without_alias_ex(const SDNA *sdna, const char *str, uint *index_last)
+int DNA_struct_find_index_without_alias_ex(const SDNA *sdna,
+                                           const char *str,
+                                           uint *struct_index_last)
 {
-  return dna_struct_find_nr_ex_impl(
+#ifdef WITH_DNA_GHASH
+  BLI_assert(sdna->types_to_structs_map != nullptr);
+#endif
+  return dna_struct_find_index_ex_impl(
       /* Expand SDNA. */
       sdna->types,
-      sdna->types_len,
+      sdna->types_num,
       sdna->structs,
-      sdna->structs_len,
+      sdna->structs_num,
 #ifdef WITH_DNA_GHASH
-      sdna->structs_map,
+      sdna->types_to_structs_map,
 #endif
       /* Regular args. */
       str,
-      index_last);
+      struct_index_last);
 }
 
-int DNA_struct_find_with_alias_ex(const SDNA *sdna, const char *str, uint *index_last)
+int DNA_struct_find_index_with_alias_ex(const SDNA *sdna, const char *str, uint *struct_index_last)
 {
 #ifdef WITH_DNA_GHASH
-  BLI_assert(sdna->alias.structs_map != nullptr);
+  BLI_assert(sdna->alias.types_to_structs_map != nullptr);
 #endif
-  return dna_struct_find_nr_ex_impl(
+  return dna_struct_find_index_ex_impl(
       /* Expand SDNA. */
       sdna->alias.types,
-      sdna->types_len,
+      sdna->types_num,
       sdna->structs,
-      sdna->structs_len,
+      sdna->structs_num,
 #ifdef WITH_DNA_GHASH
-      sdna->alias.structs_map,
+      sdna->alias.types_to_structs_map,
 #endif
       /* Regular args. */
       str,
-      index_last);
+      struct_index_last);
 }
 
-int DNA_struct_find_without_alias(const SDNA *sdna, const char *str)
+int DNA_struct_find_index_without_alias(const SDNA *sdna, const char *str)
 {
   uint index_last_dummy = UINT_MAX;
-  return DNA_struct_find_without_alias_ex(sdna, str, &index_last_dummy);
+  return DNA_struct_find_index_without_alias_ex(sdna, str, &index_last_dummy);
 }
 
 int DNA_struct_find_with_alias(const SDNA *sdna, const char *str)
 {
   uint index_last_dummy = UINT_MAX;
-  return DNA_struct_find_with_alias_ex(sdna, str, &index_last_dummy);
+  return DNA_struct_find_index_with_alias_ex(sdna, str, &index_last_dummy);
 }
 
 bool DNA_struct_exists_with_alias(const SDNA *sdna, const char *str)
@@ -315,16 +320,16 @@ BLI_INLINE const char *pad_up_4(const char *ptr)
  */
 static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error_message)
 {
-  int gravity_fix = -1;
+  int member_index_gravity_fix = -1;
 
   int *data = (int *)sdna->data;
 
   /* Clear pointers in case of error. */
-  sdna->names = nullptr;
+  sdna->members = nullptr;
   sdna->types = nullptr;
   sdna->structs = nullptr;
 #ifdef WITH_DNA_GHASH
-  sdna->structs_map = nullptr;
+  sdna->types_to_structs_map = nullptr;
 #endif
   sdna->mem_arena = nullptr;
 
@@ -344,15 +349,15 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
   if (*data == MAKE_ID('N', 'A', 'M', 'E')) {
     data++;
 
-    sdna->names_len = *data;
+    sdna->members_num = *data;
     if (do_endian_swap) {
-      BLI_endian_switch_int32(&sdna->names_len);
+      BLI_endian_switch_int32(&sdna->members_num);
     }
-    sdna->names_len_alloc = sdna->names_len;
+    sdna->members_num_alloc = sdna->members_num;
 
     data++;
-    sdna->names = static_cast<const char **>(
-        MEM_callocN(sizeof(void *) * sdna->names_len, "sdnanames"));
+    sdna->members = static_cast<const char **>(
+        MEM_callocN(sizeof(void *) * sdna->members_num, "sdnanames"));
   }
   else {
     *r_error_message = "NAME error in SDNA file";
@@ -360,16 +365,16 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
   }
 
   cp = (char *)data;
-  for (int nr = 0; nr < sdna->names_len; nr++) {
-    sdna->names[nr] = cp;
+  for (int member_index = 0; member_index < sdna->members_num; member_index++) {
+    sdna->members[member_index] = cp;
 
     /* "float gravity [3]" was parsed wrong giving both "gravity" and
      * "[3]"  members. we rename "[3]", and later set the type of
      * "gravity" to "void" so the offsets work out correct */
     if (*cp == '[' && STREQ(cp, "[3]")) {
-      if (nr && STREQ(sdna->names[nr - 1], "Cvi")) {
-        sdna->names[nr] = "gravity[3]";
-        gravity_fix = nr;
+      if (member_index && STREQ(sdna->members[member_index - 1], "Cvi")) {
+        sdna->members[member_index] = "gravity[3]";
+        member_index_gravity_fix = member_index;
       }
     }
     while (*cp) {
@@ -385,14 +390,14 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
   if (*data == MAKE_ID('T', 'Y', 'P', 'E')) {
     data++;
 
-    sdna->types_len = *data;
+    sdna->types_num = *data;
     if (do_endian_swap) {
-      BLI_endian_switch_int32(&sdna->types_len);
+      BLI_endian_switch_int32(&sdna->types_num);
     }
 
     data++;
     sdna->types = static_cast<const char **>(
-        MEM_callocN(sizeof(void *) * sdna->types_len, "sdnatypes"));
+        MEM_callocN(sizeof(void *) * sdna->types_num, "sdnatypes"));
   }
   else {
     *r_error_message = "TYPE error in SDNA file";
@@ -400,9 +405,9 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
   }
 
   cp = (char *)data;
-  for (int nr = 0; nr < sdna->types_len; nr++) {
+  for (int type_index = 0; type_index < sdna->types_num; type_index++) {
     /* WARNING! See: DNA_struct_rename_legacy_hack_static_from_alias docs. */
-    sdna->types[nr] = DNA_struct_rename_legacy_hack_static_from_alias(cp);
+    sdna->types[type_index] = DNA_struct_rename_legacy_hack_static_from_alias(cp);
     while (*cp) {
       cp++;
     }
@@ -420,17 +425,17 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
     sdna->types_size = sp;
 
     if (do_endian_swap) {
-      BLI_endian_switch_int16_array(sp, sdna->types_len);
+      BLI_endian_switch_int16_array(sp, sdna->types_num);
     }
 
-    sp += sdna->types_len;
+    sp += sdna->types_num;
   }
   else {
     *r_error_message = "TLEN error in SDNA file";
     return false;
   }
   /* prevent BUS error */
-  if (sdna->types_len & 1) {
+  if (sdna->types_num & 1) {
     sp++;
   }
 
@@ -439,14 +444,14 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
   if (*data == MAKE_ID('S', 'T', 'R', 'C')) {
     data++;
 
-    sdna->structs_len = *data;
+    sdna->structs_num = *data;
     if (do_endian_swap) {
-      BLI_endian_switch_int32(&sdna->structs_len);
+      BLI_endian_switch_int32(&sdna->structs_num);
     }
 
     data++;
     sdna->structs = static_cast<SDNA_Struct **>(
-        MEM_callocN(sizeof(SDNA_Struct *) * sdna->structs_len, "sdnastrcs"));
+        MEM_callocN(sizeof(SDNA_Struct *) * sdna->structs_num, "sdnastrcs"));
   }
   else {
     *r_error_message = "STRC error in SDNA file";
@@ -454,28 +459,28 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
   }
 
   sp = (short *)data;
-  for (int nr = 0; nr < sdna->structs_len; nr++) {
+  for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
     SDNA_Struct *struct_info = (SDNA_Struct *)sp;
-    sdna->structs[nr] = struct_info;
+    sdna->structs[struct_index] = struct_info;
 
     if (do_endian_swap) {
-      BLI_endian_switch_int16(&struct_info->type);
-      BLI_endian_switch_int16(&struct_info->members_len);
+      BLI_endian_switch_int16(&struct_info->type_index);
+      BLI_endian_switch_int16(&struct_info->members_num);
 
-      for (short a = 0; a < struct_info->members_len; a++) {
+      for (short a = 0; a < struct_info->members_num; a++) {
         SDNA_StructMember *member = &struct_info->members[a];
-        BLI_endian_switch_int16(&member->type);
-        BLI_endian_switch_int16(&member->name);
+        BLI_endian_switch_int16(&member->type_index);
+        BLI_endian_switch_int16(&member->member_index);
       }
     }
-    sp += 2 + (sizeof(SDNA_StructMember) / sizeof(short)) * struct_info->members_len;
+    sp += 2 + (sizeof(SDNA_StructMember) / sizeof(short)) * struct_info->members_num;
   }
 
   {
     /* second part of gravity problem, setting "gravity" type to void */
-    if (gravity_fix > -1) {
-      for (int nr = 0; nr < sdna->structs_len; nr++) {
-        sp = (short *)sdna->structs[nr];
+    if (member_index_gravity_fix > -1) {
+      for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
+        sp = (short *)sdna->structs[struct_index];
         if (STREQ(sdna->types[sp[0]], "ClothSimSettings")) {
           sp[10] = SDNA_TYPE_VOID;
         }
@@ -486,61 +491,72 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
 #ifdef WITH_DNA_GHASH
   {
     /* create a ghash lookup to speed up */
-    sdna->structs_map = BLI_ghash_str_new_ex("init_structDNA gh", sdna->structs_len);
+    sdna->types_to_structs_map = BLI_ghash_str_new_ex("init_structDNA gh", sdna->structs_num);
 
-    for (intptr_t nr = 0; nr < sdna->structs_len; nr++) {
-      SDNA_Struct *struct_info = sdna->structs[nr];
-      BLI_ghash_insert(
-          sdna->structs_map, (void *)sdna->types[struct_info->type], POINTER_FROM_INT(nr));
+    for (intptr_t struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
+      SDNA_Struct *struct_info = sdna->structs[struct_index];
+      BLI_ghash_insert(sdna->types_to_structs_map,
+                       (void *)sdna->types[struct_info->type_index],
+                       POINTER_FROM_INT(struct_index));
     }
   }
 #endif
 
-  /* Calculate 'sdna->pointer_size' */
+  /* Calculate 'sdna->pointer_size'.
+   *
+   * NOTE: Cannot just do `sizeof(void *)` here, since the current DNA may come from a blendfile
+   * saved on a different system, using a different pointer size. So instead, use half the size of
+   * the #ListBase struct (only made of two pointers).
+   */
   {
-    const int nr = DNA_struct_find_without_alias(sdna, "ListBase");
+    const int struct_index = DNA_struct_find_index_without_alias(sdna, "ListBase");
 
-    /* should never happen, only with corrupt file for example */
-    if (UNLIKELY(nr == -1)) {
+    /* Should never happen, only with corrupt file for example. */
+    if (UNLIKELY(struct_index == -1)) {
       *r_error_message = "ListBase struct error! Not found.";
       return false;
     }
 
-    /* finally pointer_size: use struct #ListBase to test it, never change the size of it! */
-    const SDNA_Struct *struct_info = sdna->structs[nr];
-    /* Weird; I have no memory of that... I think I used `sizeof(void *)` before... (ton). */
+    const SDNA_Struct *struct_info = sdna->structs[struct_index];
+    sdna->pointer_size = sdna->types_size[struct_info->type_index] / 2;
 
-    sdna->pointer_size = sdna->types_size[struct_info->type] / 2;
-
-    if (struct_info->members_len != 2 || !ELEM(sdna->pointer_size, 4, 8)) {
-      *r_error_message = "ListBase struct error! Needs it to calculate pointer-size.";
-      /* Well, at least `sizeof(ListBase)` is error proof! (ton). */
+    /* Should never fail, double-check that #ListBase struct is still what is should be (akak a
+     * couple of pointers and nothing else). */
+    if (UNLIKELY(struct_info->members_num != 2 || !ELEM(sdna->pointer_size, 4, 8))) {
+      *r_error_message = "ListBase struct error: invalid computed pointer-size.";
       return false;
     }
   }
 
   /* Cache name size. */
   {
-    short *names_array_len = static_cast<short int *>(
-        MEM_mallocN(sizeof(*names_array_len) * sdna->names_len, __func__));
-    for (int i = 0; i < sdna->names_len; i++) {
-      names_array_len[i] = DNA_elem_array_size(sdna->names[i]);
+    short *members_array_num = static_cast<short int *>(
+        MEM_mallocN(sizeof(*members_array_num) * sdna->members_num, __func__));
+    for (int member_index = 0; member_index < sdna->members_num; member_index++) {
+      members_array_num[member_index] = DNA_member_array_num(sdna->members[member_index]);
     }
-    sdna->names_array_len = names_array_len;
+    sdna->members_array_num = members_array_num;
   }
 
   sdna->types_alignment = static_cast<int *>(
-      MEM_malloc_arrayN(sdna->types_len, sizeof(int), __func__));
-  for (int i = 0; i < sdna->types_len; i++) {
-    sdna->types_alignment[i] = int(__STDCPP_DEFAULT_NEW_ALIGNMENT__);
+      MEM_malloc_arrayN(sdna->types_num, sizeof(int), __func__));
+  for (int type_index = 0; type_index < sdna->types_num; type_index++) {
+    sdna->types_alignment[type_index] = int(__STDCPP_DEFAULT_NEW_ALIGNMENT__);
   }
   {
     /* TODO: This should be generalized at some point. We should be able to specify `overaligned`
      * types directly in the DNA struct definitions. */
     uint dummy_index = 0;
-    const int mat4x4f_nr = DNA_struct_find_without_alias_ex(sdna, "mat4x4f", &dummy_index);
-    if (mat4x4f_nr >= 0) {
-      sdna->types_alignment[mat4x4f_nr] = alignof(blender::float4x4);
+    const int mat4x4f_struct_index = DNA_struct_find_index_without_alias_ex(
+        sdna, "mat4x4f", &dummy_index);
+    if (mat4x4f_struct_index >= 0) {
+#if 0 /* FIXME: This is using the wrong index. Code should be: */
+      SDNA_Struct *struct_info = sdna->structs[mat4x4f_struct_index];
+      const int mat4x4f_type_index = struct_info->type_index;
+      sdna->types_alignment[mat4x4f_type_index] = alignof(blender::float4x4);
+#else
+      sdna->types_alignment[mat4x4f_struct_index] = alignof(blender::float4x4);
+#endif
     }
   }
 
@@ -557,7 +573,7 @@ SDNA *DNA_sdna_from_data(const void *data,
   SDNA *sdna = static_cast<SDNA *>(MEM_mallocN(sizeof(*sdna), "sdna"));
   const char *error_message = nullptr;
 
-  sdna->data_len = data_len;
+  sdna->data_size = data_len;
   if (data_alloc) {
     char *data_copy = static_cast<char *>(MEM_mallocN(data_len, "sdna_data"));
     memcpy(data_copy, data, data_len);
@@ -629,9 +645,9 @@ static void set_compare_flags_for_struct(const SDNA *oldsdna,
   }
 
   SDNA_Struct *old_struct = oldsdna->structs[old_struct_index];
-  const char *struct_name = oldsdna->types[old_struct->type];
+  const char *struct_name = oldsdna->types[old_struct->type_index];
 
-  const int new_struct_index = DNA_struct_find_without_alias(newsdna, struct_name);
+  const int new_struct_index = DNA_struct_find_index_without_alias(newsdna, struct_name);
   if (new_struct_index == -1) {
     /* Didn't find a matching new struct, so it has been removed. */
     compare_flags[old_struct_index] = SDNA_CMP_REMOVED;
@@ -639,32 +655,32 @@ static void set_compare_flags_for_struct(const SDNA *oldsdna,
   }
 
   SDNA_Struct *new_struct = newsdna->structs[new_struct_index];
-  if (old_struct->members_len != new_struct->members_len) {
+  if (old_struct->members_num != new_struct->members_num) {
     /* Structs with a different amount of members are not equal. */
     compare_flags[old_struct_index] = SDNA_CMP_NOT_EQUAL;
     return;
   }
-  if (oldsdna->types_size[old_struct->type] != newsdna->types_size[new_struct->type]) {
+  if (oldsdna->types_size[old_struct->type_index] != newsdna->types_size[new_struct->type_index]) {
     /* Structs that don't have the same size are not equal. */
     compare_flags[old_struct_index] = SDNA_CMP_NOT_EQUAL;
     return;
   }
 
   /* Compare each member individually. */
-  for (int member_index = 0; member_index < old_struct->members_len; member_index++) {
+  for (int member_index = 0; member_index < old_struct->members_num; member_index++) {
     const SDNA_StructMember *old_member = &old_struct->members[member_index];
     const SDNA_StructMember *new_member = &new_struct->members[member_index];
 
-    const char *old_type_name = oldsdna->types[old_member->type];
-    const char *new_type_name = newsdna->types[new_member->type];
+    const char *old_type_name = oldsdna->types[old_member->type_index];
+    const char *new_type_name = newsdna->types[new_member->type_index];
     if (!STREQ(old_type_name, new_type_name)) {
       /* If two members have a different type in the same place, the structs are not equal. */
       compare_flags[old_struct_index] = SDNA_CMP_NOT_EQUAL;
       return;
     }
 
-    const char *old_member_name = oldsdna->names[old_member->name];
-    const char *new_member_name = newsdna->names[new_member->name];
+    const char *old_member_name = oldsdna->members[old_member->member_index];
+    const char *new_member_name = newsdna->members[new_member->member_index];
     if (!STREQ(old_member_name, new_member_name)) {
       /* If two members have a different name in the same place, the structs are not equal. */
       compare_flags[old_struct_index] = SDNA_CMP_NOT_EQUAL;
@@ -680,7 +696,8 @@ static void set_compare_flags_for_struct(const SDNA *oldsdna,
       }
     }
     else {
-      const int old_member_struct_index = DNA_struct_find_without_alias(oldsdna, old_type_name);
+      const int old_member_struct_index = DNA_struct_find_index_without_alias(oldsdna,
+                                                                              old_type_name);
       if (old_member_struct_index >= 0) {
         set_compare_flags_for_struct(oldsdna, newsdna, compare_flags, old_member_struct_index);
         if (compare_flags[old_member_struct_index] != SDNA_CMP_EQUAL) {
@@ -697,18 +714,18 @@ static void set_compare_flags_for_struct(const SDNA *oldsdna,
 
 const char *DNA_struct_get_compareflags(const SDNA *oldsdna, const SDNA *newsdna)
 {
-  if (oldsdna->structs_len == 0) {
+  if (oldsdna->structs_num == 0) {
     printf("error: file without SDNA\n");
     return nullptr;
   }
 
-  char *compare_flags = static_cast<char *>(MEM_mallocN(oldsdna->structs_len, "compare flags"));
-  memset(compare_flags, SDNA_CMP_UNKNOWN, oldsdna->structs_len);
+  char *compare_flags = static_cast<char *>(MEM_mallocN(oldsdna->structs_num, "compare flags"));
+  memset(compare_flags, SDNA_CMP_UNKNOWN, oldsdna->structs_num);
 
   /* Set correct flag for every struct. */
-  for (int a = 0; a < oldsdna->structs_len; a++) {
-    set_compare_flags_for_struct(oldsdna, newsdna, compare_flags, a);
-    BLI_assert(compare_flags[a] != SDNA_CMP_UNKNOWN);
+  for (int old_struct_index = 0; old_struct_index < oldsdna->structs_num; old_struct_index++) {
+    set_compare_flags_for_struct(oldsdna, newsdna, compare_flags, old_struct_index);
+    BLI_assert(compare_flags[old_struct_index] != SDNA_CMP_UNKNOWN);
   }
 
   /* First struct is `struct Link`, this is skipped in compare_flags (at index `0`).
@@ -926,10 +943,10 @@ static bool elem_exists_impl(
     const SDNA_Struct *old)
 {
   /* in old is the old struct */
-  for (int a = 0; a < old->members_len; a++) {
+  for (int a = 0; a < old->members_num; a++) {
     const SDNA_StructMember *member = &old->members[a];
-    const char *otype = types[member->type];
-    const char *oname = names[member->name];
+    const char *otype = types[member->type_index];
+    const char *oname = names[member->member_index];
 
     if (elem_streq(name, oname)) { /* name equal */
       return STREQ(type, otype);   /* type equal */
@@ -949,7 +966,7 @@ static bool elem_exists_without_alias(const SDNA *sdna,
   return elem_exists_impl(
       /* Expand SDNA. */
       sdna->types,
-      sdna->names,
+      sdna->members,
       /* Regular args. */
       type,
       name,
@@ -964,7 +981,7 @@ static bool elem_exists_with_alias(const SDNA *sdna,
   return elem_exists_impl(
       /* Expand SDNA. */
       sdna->alias.types,
-      sdna->alias.names,
+      sdna->alias.members,
       /* Regular args. */
       type,
       name,
@@ -982,17 +999,17 @@ static int elem_offset_impl(const SDNA *sdna,
 
   /* in old is the old struct */
   int offset = 0;
-  for (int a = 0; a < old->members_len; a++) {
+  for (int a = 0; a < old->members_num; a++) {
     const SDNA_StructMember *member = &old->members[a];
-    const char *otype = types[member->type];
-    const char *oname = names[member->name];
+    const char *otype = types[member->type_index];
+    const char *oname = names[member->member_index];
     if (elem_streq(name, oname)) { /* name equal */
       if (STREQ(type, otype)) {    /* type equal */
         return offset;
       }
       break; /* Fail below. */
     }
-    offset += DNA_struct_member_size(sdna, member->type, member->name);
+    offset += DNA_struct_member_size(sdna, member->type_index, member->member_index);
   }
   return -1;
 }
@@ -1017,7 +1034,7 @@ static int elem_offset_without_alias(const SDNA *sdna,
                                      const char *name,
                                      const SDNA_Struct *old)
 {
-  return elem_offset_impl(sdna, sdna->types, sdna->names, type, name, old);
+  return elem_offset_impl(sdna, sdna->types, sdna->members, type, name, old);
 }
 
 /**
@@ -1028,7 +1045,7 @@ static int elem_offset_with_alias(const SDNA *sdna,
                                   const char *name,
                                   const SDNA_Struct *old)
 {
-  return elem_offset_impl(sdna, sdna->alias.types, sdna->alias.names, type, name, old);
+  return elem_offset_impl(sdna, sdna->alias.types, sdna->alias.members, type, name, old);
 }
 
 /* Each struct member belongs to one of the categories below. */
@@ -1041,11 +1058,11 @@ enum eStructMemberCategory {
 static eStructMemberCategory get_struct_member_category(const SDNA *sdna,
                                                         const SDNA_StructMember *member)
 {
-  const char *member_name = sdna->names[member->name];
+  const char *member_name = sdna->members[member->member_index];
   if (ispointer(member_name)) {
     return STRUCT_MEMBER_CATEGORY_POINTER;
   }
-  const char *member_type_name = sdna->types[member->type];
+  const char *member_type_name = sdna->types[member->type_index];
   if (DNA_struct_exists_without_alias(sdna, member_type_name)) {
     return STRUCT_MEMBER_CATEGORY_STRUCT;
   }
@@ -1054,43 +1071,43 @@ static eStructMemberCategory get_struct_member_category(const SDNA *sdna,
 
 static int get_member_size_in_bytes(const SDNA *sdna, const SDNA_StructMember *member)
 {
-  const char *name = sdna->names[member->name];
-  const int array_length = sdna->names_array_len[member->name];
+  const char *name = sdna->members[member->member_index];
+  const int array_length = sdna->members_array_num[member->member_index];
   if (ispointer(name)) {
     return sdna->pointer_size * array_length;
   }
-  const int type_size = sdna->types_size[member->type];
+  const int type_size = sdna->types_size[member->type_index];
   return type_size * array_length;
 }
 
-void DNA_struct_switch_endian(const SDNA *sdna, int struct_nr, char *data)
+void DNA_struct_switch_endian(const SDNA *sdna, int struct_index, char *data)
 {
-  if (struct_nr == -1) {
+  if (struct_index == -1) {
     return;
   }
 
-  const SDNA_Struct *struct_info = sdna->structs[struct_nr];
+  const SDNA_Struct *struct_info = sdna->structs[struct_index];
 
   int offset_in_bytes = 0;
-  for (int member_index = 0; member_index < struct_info->members_len; member_index++) {
+  for (int member_index = 0; member_index < struct_info->members_num; member_index++) {
     const SDNA_StructMember *member = &struct_info->members[member_index];
     const eStructMemberCategory member_category = get_struct_member_category(sdna, member);
     char *member_data = data + offset_in_bytes;
-    const char *member_type_name = sdna->types[member->type];
-    const int member_array_length = sdna->names_array_len[member->name];
+    const char *member_type_name = sdna->types[member->type_index];
+    const int member_array_length = sdna->members_array_num[member->member_index];
 
     switch (member_category) {
       case STRUCT_MEMBER_CATEGORY_STRUCT: {
-        const int substruct_size = sdna->types_size[member->type];
-        const int substruct_nr = DNA_struct_find_without_alias(sdna, member_type_name);
-        BLI_assert(substruct_nr != -1);
+        const int substruct_size = sdna->types_size[member->type_index];
+        const int substruct_index = DNA_struct_find_index_without_alias(sdna, member_type_name);
+        BLI_assert(substruct_index != -1);
         for (int a = 0; a < member_array_length; a++) {
-          DNA_struct_switch_endian(sdna, substruct_nr, member_data + a * substruct_size);
+          DNA_struct_switch_endian(sdna, substruct_index, member_data + a * substruct_size);
         }
         break;
       }
       case STRUCT_MEMBER_CATEGORY_PRIMITIVE: {
-        switch (member->type) {
+        switch (member->type_index) {
           case SDNA_TYPE_SHORT:
           case SDNA_TYPE_USHORT: {
             BLI_endian_switch_int16_array((int16_t *)member_data, member_array_length);
@@ -1164,8 +1181,8 @@ struct ReconstructStep {
       int old_offset;
       int new_offset;
       int array_len;
-      short old_struct_nr;
-      short new_struct_nr;
+      short old_struct_index;
+      short new_struct_index;
     } substruct;
   } data;
 };
@@ -1196,12 +1213,12 @@ static void reconstruct_structs(const DNA_ReconstructInfo *reconstruct_info,
  * \param new_block: Where to put converted struct contents.
  */
 static void reconstruct_struct(const DNA_ReconstructInfo *reconstruct_info,
-                               const int new_struct_nr,
+                               const int new_struct_index,
                                const char *old_block,
                                char *new_block)
 {
-  const ReconstructStep *steps = reconstruct_info->steps[new_struct_nr];
-  const int step_count = reconstruct_info->step_counts[new_struct_nr];
+  const ReconstructStep *steps = reconstruct_info->steps[new_struct_index];
+  const int step_count = reconstruct_info->step_counts[new_struct_index];
 
   /* Execute all preprocessed steps. */
   for (int a = 0; a < step_count; a++) {
@@ -1232,8 +1249,8 @@ static void reconstruct_struct(const DNA_ReconstructInfo *reconstruct_info,
       case RECONSTRUCT_STEP_SUBSTRUCT:
         reconstruct_structs(reconstruct_info,
                             step->data.substruct.array_len,
-                            step->data.substruct.old_struct_nr,
-                            step->data.substruct.new_struct_nr,
+                            step->data.substruct.old_struct_index,
+                            step->data.substruct.new_struct_index,
                             old_block + step->data.substruct.old_offset,
                             new_block + step->data.substruct.new_offset);
         break;
@@ -1250,26 +1267,26 @@ static void reconstruct_struct(const DNA_ReconstructInfo *reconstruct_info,
 /** Reconstructs an array of structs. */
 static void reconstruct_structs(const DNA_ReconstructInfo *reconstruct_info,
                                 const int blocks,
-                                const int old_struct_nr,
-                                const int new_struct_nr,
+                                const int old_struct_index,
+                                const int new_struct_index,
                                 const char *old_blocks,
                                 char *new_blocks)
 {
-  const SDNA_Struct *old_struct = reconstruct_info->oldsdna->structs[old_struct_nr];
-  const SDNA_Struct *new_struct = reconstruct_info->newsdna->structs[new_struct_nr];
+  const SDNA_Struct *old_struct = reconstruct_info->oldsdna->structs[old_struct_index];
+  const SDNA_Struct *new_struct = reconstruct_info->newsdna->structs[new_struct_index];
 
-  const int old_block_size = reconstruct_info->oldsdna->types_size[old_struct->type];
-  const int new_block_size = reconstruct_info->newsdna->types_size[new_struct->type];
+  const int old_block_size = reconstruct_info->oldsdna->types_size[old_struct->type_index];
+  const int new_block_size = reconstruct_info->newsdna->types_size[new_struct->type_index];
 
   for (int a = 0; a < blocks; a++) {
     const char *old_block = old_blocks + a * old_block_size;
     char *new_block = new_blocks + a * new_block_size;
-    reconstruct_struct(reconstruct_info, new_struct_nr, old_block, new_block);
+    reconstruct_struct(reconstruct_info, new_struct_index, old_block, new_block);
   }
 }
 
 void *DNA_struct_reconstruct(const DNA_ReconstructInfo *reconstruct_info,
-                             int old_struct_nr,
+                             int old_struct_index,
                              int blocks,
                              const void *old_blocks,
                              const char *alloc_name)
@@ -1277,24 +1294,24 @@ void *DNA_struct_reconstruct(const DNA_ReconstructInfo *reconstruct_info,
   const SDNA *oldsdna = reconstruct_info->oldsdna;
   const SDNA *newsdna = reconstruct_info->newsdna;
 
-  const SDNA_Struct *old_struct = oldsdna->structs[old_struct_nr];
-  const char *type_name = oldsdna->types[old_struct->type];
-  const int new_struct_nr = DNA_struct_find_without_alias(newsdna, type_name);
+  const SDNA_Struct *old_struct = oldsdna->structs[old_struct_index];
+  const char *type_name = oldsdna->types[old_struct->type_index];
+  const int new_struct_index = DNA_struct_find_index_without_alias(newsdna, type_name);
 
-  if (new_struct_nr == -1) {
+  if (new_struct_index == -1) {
     return nullptr;
   }
 
-  const SDNA_Struct *new_struct = newsdna->structs[new_struct_nr];
-  const int new_block_size = newsdna->types_size[new_struct->type];
+  const SDNA_Struct *new_struct = newsdna->structs[new_struct_index];
+  const int new_block_size = newsdna->types_size[new_struct->type_index];
 
-  const int alignment = DNA_struct_alignment(newsdna, new_struct_nr);
+  const int alignment = DNA_struct_alignment(newsdna, new_struct_index);
   char *new_blocks = static_cast<char *>(
       MEM_calloc_arrayN_aligned(new_block_size, blocks, alignment, alloc_name));
   reconstruct_structs(reconstruct_info,
                       blocks,
-                      old_struct_nr,
-                      new_struct_nr,
+                      old_struct_index,
+                      new_struct_index,
                       static_cast<const char *>(old_blocks),
                       new_blocks);
   return new_blocks;
@@ -1307,9 +1324,9 @@ static const SDNA_StructMember *find_member_with_matching_name(const SDNA *sdna,
                                                                int *r_offset)
 {
   int offset = 0;
-  for (int a = 0; a < struct_info->members_len; a++) {
+  for (int a = 0; a < struct_info->members_num; a++) {
     const SDNA_StructMember *member = &struct_info->members[a];
-    const char *member_name = sdna->names[member->name];
+    const char *member_name = sdna->members[member->member_index];
     if (elem_streq(name, member_name)) {
       *r_offset = offset;
       return member;
@@ -1331,7 +1348,7 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
 
   /* Find the matching old member. */
   int old_member_offset;
-  const char *new_name = newsdna->names[new_member->name];
+  const char *new_name = newsdna->members[new_member->member_index];
   const SDNA_StructMember *old_member = find_member_with_matching_name(
       oldsdna, old_struct, new_name, &old_member_offset);
 
@@ -1352,30 +1369,32 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
     return;
   }
 
-  const int new_array_length = newsdna->names_array_len[new_member->name];
-  const int old_array_length = oldsdna->names_array_len[old_member->name];
+  const int new_array_length = newsdna->members_array_num[new_member->member_index];
+  const int old_array_length = oldsdna->members_array_num[old_member->member_index];
   const int shared_array_length = std::min(new_array_length, old_array_length);
 
-  const char *new_type_name = newsdna->types[new_member->type];
-  const char *old_type_name = oldsdna->types[old_member->type];
+  const char *new_type_name = newsdna->types[new_member->type_index];
+  const char *old_type_name = oldsdna->types[old_member->type_index];
 
   switch (new_category) {
     case STRUCT_MEMBER_CATEGORY_STRUCT: {
       if (STREQ(new_type_name, old_type_name)) {
-        const int old_struct_nr = DNA_struct_find_without_alias(oldsdna, old_type_name);
-        BLI_assert(old_struct_nr != -1);
-        enum eSDNA_StructCompare compare_flag = eSDNA_StructCompare(compare_flags[old_struct_nr]);
+        const int old_struct_index = DNA_struct_find_index_without_alias(oldsdna, old_type_name);
+        BLI_assert(old_struct_index != -1);
+        enum eSDNA_StructCompare compare_flag = eSDNA_StructCompare(
+            compare_flags[old_struct_index]);
         BLI_assert(compare_flag != SDNA_CMP_REMOVED);
         if (compare_flag == SDNA_CMP_EQUAL) {
           /* The old and new members are identical, just do a #memcpy. */
           r_step->type = RECONSTRUCT_STEP_MEMCPY;
           r_step->data.memcpy.new_offset = new_member_offset;
           r_step->data.memcpy.old_offset = old_member_offset;
-          r_step->data.memcpy.size = newsdna->types_size[new_member->type] * shared_array_length;
+          r_step->data.memcpy.size = newsdna->types_size[new_member->type_index] *
+                                     shared_array_length;
         }
         else {
-          const int new_struct_nr = DNA_struct_find_without_alias(newsdna, new_type_name);
-          BLI_assert(new_struct_nr != -1);
+          const int new_struct_index = DNA_struct_find_index_without_alias(newsdna, new_type_name);
+          BLI_assert(new_struct_index != -1);
 
           /* The old and new members are different, use recursion to reconstruct the
            * nested struct. */
@@ -1384,8 +1403,8 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
           r_step->data.substruct.new_offset = new_member_offset;
           r_step->data.substruct.old_offset = old_member_offset;
           r_step->data.substruct.array_len = shared_array_length;
-          r_step->data.substruct.new_struct_nr = new_struct_nr;
-          r_step->data.substruct.old_struct_nr = old_struct_nr;
+          r_step->data.substruct.new_struct_index = new_struct_index;
+          r_step->data.substruct.old_struct_index = old_struct_index;
         }
       }
       else {
@@ -1400,7 +1419,8 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
         r_step->type = RECONSTRUCT_STEP_MEMCPY;
         r_step->data.memcpy.new_offset = new_member_offset;
         r_step->data.memcpy.old_offset = old_member_offset;
-        r_step->data.memcpy.size = newsdna->types_size[new_member->type] * shared_array_length;
+        r_step->data.memcpy.size = newsdna->types_size[new_member->type_index] *
+                                   shared_array_length;
       }
       else {
         /* The old and new primitive types are different, cast from the old to new type. */
@@ -1408,8 +1428,8 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
         r_step->data.cast_primitive.array_len = shared_array_length;
         r_step->data.cast_primitive.new_offset = new_member_offset;
         r_step->data.cast_primitive.old_offset = old_member_offset;
-        r_step->data.cast_primitive.new_type = eSDNA_Type(new_member->type);
-        r_step->data.cast_primitive.old_type = eSDNA_Type(old_member->type);
+        r_step->data.cast_primitive.new_type = eSDNA_Type(new_member->type_index);
+        r_step->data.cast_primitive.old_type = eSDNA_Type(old_member->type_index);
       }
       break;
     }
@@ -1494,9 +1514,9 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
           "length: %d",
           step->data.substruct.old_offset,
           step->data.substruct.new_offset,
-          step->data.substruct.new_struct_nr,
-          newsdna->types[newsdna->structs[step->data.substruct.new_struct_nr]->type],
-          newsdna->types_size[newsdna->structs[step->data.substruct.new_struct_nr]->type],
+          step->data.substruct.new_struct_index,
+          newsdna->types[newsdna->structs[step->data.substruct.new_struct_index]->type_index],
+          newsdna->types_size[newsdna->structs[step->data.substruct.new_struct_index]->type_index],
           step->data.substruct.array_len);
       break;
     }
@@ -1514,10 +1534,10 @@ static ReconstructStep *create_reconstruct_steps_for_struct(const SDNA *oldsdna,
                                                             const SDNA_Struct *new_struct)
 {
   ReconstructStep *steps = static_cast<ReconstructStep *>(
-      MEM_calloc_arrayN(new_struct->members_len, sizeof(ReconstructStep), __func__));
+      MEM_calloc_arrayN(new_struct->members_num, sizeof(ReconstructStep), __func__));
 
   int new_member_offset = 0;
-  for (int new_member_index = 0; new_member_index < new_struct->members_len; new_member_index++) {
+  for (int new_member_index = 0; new_member_index < new_struct->members_num; new_member_index++) {
     const SDNA_StructMember *new_member = &new_struct->members[new_member_index];
     init_reconstruct_step_for_member(oldsdna,
                                      newsdna,
@@ -1585,29 +1605,29 @@ DNA_ReconstructInfo *DNA_reconstruct_info_create(const SDNA *oldsdna,
   reconstruct_info->newsdna = newsdna;
   reconstruct_info->compare_flags = compare_flags;
   reconstruct_info->step_counts = static_cast<int *>(
-      MEM_malloc_arrayN(newsdna->structs_len, sizeof(int), __func__));
+      MEM_malloc_arrayN(newsdna->structs_num, sizeof(int), __func__));
   reconstruct_info->steps = static_cast<ReconstructStep **>(
-      MEM_malloc_arrayN(newsdna->structs_len, sizeof(ReconstructStep *), __func__));
+      MEM_malloc_arrayN(newsdna->structs_num, sizeof(ReconstructStep *), __func__));
 
   /* Generate reconstruct steps for all structs. */
-  for (int new_struct_nr = 0; new_struct_nr < newsdna->structs_len; new_struct_nr++) {
-    const SDNA_Struct *new_struct = newsdna->structs[new_struct_nr];
-    const char *new_struct_name = newsdna->types[new_struct->type];
-    const int old_struct_nr = DNA_struct_find_without_alias(oldsdna, new_struct_name);
-    if (old_struct_nr < 0) {
-      reconstruct_info->steps[new_struct_nr] = nullptr;
-      reconstruct_info->step_counts[new_struct_nr] = 0;
+  for (int new_struct_index = 0; new_struct_index < newsdna->structs_num; new_struct_index++) {
+    const SDNA_Struct *new_struct = newsdna->structs[new_struct_index];
+    const char *new_struct_name = newsdna->types[new_struct->type_index];
+    const int old_struct_index = DNA_struct_find_index_without_alias(oldsdna, new_struct_name);
+    if (old_struct_index < 0) {
+      reconstruct_info->steps[new_struct_index] = nullptr;
+      reconstruct_info->step_counts[new_struct_index] = 0;
       continue;
     }
-    const SDNA_Struct *old_struct = oldsdna->structs[old_struct_nr];
+    const SDNA_Struct *old_struct = oldsdna->structs[old_struct_index];
     ReconstructStep *steps = create_reconstruct_steps_for_struct(
         oldsdna, newsdna, compare_flags, old_struct, new_struct);
 
     /* Comment the line below to skip the compression for debugging purposes. */
-    const int steps_len = compress_reconstruct_steps(steps, new_struct->members_len);
+    const int steps_len = compress_reconstruct_steps(steps, new_struct->members_num);
 
-    reconstruct_info->steps[new_struct_nr] = steps;
-    reconstruct_info->step_counts[new_struct_nr] = steps_len;
+    reconstruct_info->steps[new_struct_index] = steps;
+    reconstruct_info->step_counts[new_struct_index] = steps_len;
 
 /* This is useful when debugging the reconstruct steps. */
 #if 0
@@ -1625,9 +1645,11 @@ DNA_ReconstructInfo *DNA_reconstruct_info_create(const SDNA *oldsdna,
 
 void DNA_reconstruct_info_free(DNA_ReconstructInfo *reconstruct_info)
 {
-  for (int a = 0; a < reconstruct_info->newsdna->structs_len; a++) {
-    if (reconstruct_info->steps[a] != nullptr) {
-      MEM_freeN(reconstruct_info->steps[a]);
+  for (int new_struct_index = 0; new_struct_index < reconstruct_info->newsdna->structs_num;
+       new_struct_index++)
+  {
+    if (reconstruct_info->steps[new_struct_index] != nullptr) {
+      MEM_freeN(reconstruct_info->steps[new_struct_index]);
     }
   }
   MEM_freeN(reconstruct_info->steps);
@@ -1640,10 +1662,10 @@ int DNA_struct_member_offset_by_name_without_alias(const SDNA *sdna,
                                                    const char *vartype,
                                                    const char *name)
 {
-  const int SDNAnr = DNA_struct_find_without_alias(sdna, stype);
-  BLI_assert(SDNAnr != -1);
-  const SDNA_Struct *const spo = sdna->structs[SDNAnr];
-  return elem_offset_without_alias(sdna, vartype, name, spo);
+  const int struct_index = DNA_struct_find_index_without_alias(sdna, stype);
+  BLI_assert(struct_index != -1);
+  const SDNA_Struct *const struct_info = sdna->structs[struct_index];
+  return elem_offset_without_alias(sdna, vartype, name, struct_info);
 }
 
 int DNA_struct_member_offset_by_name_with_alias(const SDNA *sdna,
@@ -1651,15 +1673,15 @@ int DNA_struct_member_offset_by_name_with_alias(const SDNA *sdna,
                                                 const char *vartype,
                                                 const char *name)
 {
-  const int SDNAnr = DNA_struct_find_with_alias(sdna, stype);
-  BLI_assert(SDNAnr != -1);
-  const SDNA_Struct *const spo = sdna->structs[SDNAnr];
-  return elem_offset_with_alias(sdna, vartype, name, spo);
+  const int struct_index = DNA_struct_find_with_alias(sdna, stype);
+  BLI_assert(struct_index != -1);
+  const SDNA_Struct *const struct_info = sdna->structs[struct_index];
+  return elem_offset_with_alias(sdna, vartype, name, struct_info);
 }
 
 bool DNA_struct_exists_without_alias(const SDNA *sdna, const char *stype)
 {
-  return DNA_struct_find_without_alias(sdna, stype) != -1;
+  return DNA_struct_find_index_without_alias(sdna, stype) != -1;
 }
 
 bool DNA_struct_member_exists_without_alias(const SDNA *sdna,
@@ -1667,11 +1689,11 @@ bool DNA_struct_member_exists_without_alias(const SDNA *sdna,
                                             const char *vartype,
                                             const char *name)
 {
-  const int SDNAnr = DNA_struct_find_without_alias(sdna, stype);
+  const int struct_index = DNA_struct_find_index_without_alias(sdna, stype);
 
-  if (SDNAnr != -1) {
-    const SDNA_Struct *const spo = sdna->structs[SDNAnr];
-    const bool found = elem_exists_without_alias(sdna, vartype, name, spo);
+  if (struct_index != -1) {
+    const SDNA_Struct *const struct_info = sdna->structs[struct_index];
+    const bool found = elem_exists_without_alias(sdna, vartype, name, struct_info);
 
     if (found) {
       return true;
@@ -1722,90 +1744,96 @@ int DNA_elem_type_size(const eSDNA_Type elem_nr)
   return 8;
 }
 
-int DNA_struct_alignment(const SDNA *sdna, const int struct_nr)
+int DNA_struct_alignment(const SDNA *sdna, const int struct_index)
 {
-  return sdna->types_alignment[struct_nr];
+  return sdna->types_alignment[struct_index];
 }
 
 const char *DNA_struct_identifier(struct SDNA *sdna, const int struct_index)
 {
   DNA_sdna_alias_data_ensure(sdna);
   const SDNA_Struct *struct_info = sdna->structs[struct_index];
-  return sdna->alias.types[struct_info->type];
+  return sdna->alias.types[struct_info->type_index];
 }
 
 /* -------------------------------------------------------------------- */
 /** \name Version Patch DNA
  * \{ */
 
-static bool DNA_sdna_patch_struct(SDNA *sdna,
-                                  const int struct_name_old_nr,
-                                  const char *struct_name_new)
+static bool DNA_sdna_patch_struct(SDNA *sdna, const int struct_index, const char *new_type_name)
 {
-  BLI_assert(DNA_struct_find_without_alias(DNA_sdna_current_get(), struct_name_new) != -1);
-  const SDNA_Struct *struct_info = sdna->structs[struct_name_old_nr];
+  BLI_assert(DNA_struct_find_index_without_alias(DNA_sdna_current_get(), new_type_name) != -1);
+  const SDNA_Struct *struct_info = sdna->structs[struct_index];
 #ifdef WITH_DNA_GHASH
-  BLI_ghash_remove(sdna->structs_map, (void *)sdna->types[struct_info->type], nullptr, nullptr);
+  BLI_ghash_remove(
+      sdna->types_to_structs_map, (void *)sdna->types[struct_info->type_index], nullptr, nullptr);
   BLI_ghash_insert(
-      sdna->structs_map, (void *)struct_name_new, POINTER_FROM_INT(struct_name_old_nr));
+      sdna->types_to_structs_map, (void *)new_type_name, POINTER_FROM_INT(struct_index));
 #endif
-  sdna->types[struct_info->type] = struct_name_new;
+  sdna->types[struct_info->type_index] = new_type_name;
   return true;
 }
 bool DNA_sdna_patch_struct_by_name(SDNA *sdna,
-                                   const char *struct_name_old,
-                                   const char *struct_name_new)
+                                   const char *old_type_name,
+                                   const char *new_type_name)
 {
-  const int struct_name_old_nr = DNA_struct_find_without_alias(sdna, struct_name_old);
-  if (struct_name_old_nr != -1) {
-    return DNA_sdna_patch_struct(sdna, struct_name_old_nr, struct_name_new);
+  const int struct_index = DNA_struct_find_index_without_alias(sdna, old_type_name);
+  if (struct_index != -1) {
+    return DNA_sdna_patch_struct(sdna, struct_index, new_type_name);
   }
   return false;
 }
 
 /* Make public if called often with same struct (avoid duplicate lookups). */
 static bool DNA_sdna_patch_struct_member(SDNA *sdna,
-                                         const int struct_name_nr,
-                                         const char *elem_old,
-                                         const char *elem_new)
+                                         const int struct_index,
+                                         const char *old_member_name,
+                                         const char *new_member_name)
 {
   /* These names aren't handled here (it's not used).
    * Ensure they are never used or we get out of sync arrays. */
-  BLI_assert(sdna->alias.names == nullptr);
-  const int elem_old_len = strlen(elem_old);
-  const int elem_new_len = strlen(elem_new);
-  BLI_assert(elem_new != nullptr);
-  SDNA_Struct *sp = sdna->structs[struct_name_nr];
-  for (int elem_index = sp->members_len; elem_index > 0; elem_index--) {
-    SDNA_StructMember *member = &sp->members[elem_index];
-    const char *elem_old_full = sdna->names[member->name];
-    /* Start & end offsets in 'elem_old_full'. */
-    uint elem_old_full_offset_start;
-    if (DNA_elem_id_match(elem_old, elem_old_len, elem_old_full, &elem_old_full_offset_start)) {
+  BLI_assert(sdna->alias.members == nullptr);
+  const int old_member_name_len = strlen(old_member_name);
+  const int new_member_name_len = strlen(new_member_name);
+  BLI_assert(new_member_name != nullptr);
+  SDNA_Struct *struct_info = sdna->structs[struct_index];
+  for (int struct_member_index = struct_info->members_num; struct_member_index > 0;
+       struct_member_index--)
+  {
+    SDNA_StructMember *member_info = &struct_info->members[struct_member_index];
+    const char *old_member_name_full = sdna->members[member_info->member_index];
+    /* Start & end offsets in #old_member_full. */
+    uint old_member_name_full_offset_start;
+    if (DNA_member_id_match(old_member_name,
+                            old_member_name_len,
+                            old_member_name_full,
+                            &old_member_name_full_offset_start))
+    {
       if (sdna->mem_arena == nullptr) {
         sdna->mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
       }
-      const char *elem_new_full = DNA_elem_id_rename(sdna->mem_arena,
-                                                     elem_old,
-                                                     elem_old_len,
-                                                     elem_new,
-                                                     elem_new_len,
-                                                     elem_old_full,
-                                                     strlen(elem_old_full),
-                                                     elem_old_full_offset_start);
+      const char *new_member_name_full = DNA_member_id_rename(sdna->mem_arena,
+                                                              old_member_name,
+                                                              old_member_name_len,
+                                                              new_member_name,
+                                                              new_member_name_len,
+                                                              old_member_name_full,
+                                                              strlen(old_member_name_full),
+                                                              old_member_name_full_offset_start);
 
-      if (sdna->names_len == sdna->names_len_alloc) {
-        sdna->names_len_alloc += 64;
-        sdna->names = static_cast<const char **>(
-            MEM_recallocN((void *)sdna->names, sizeof(*sdna->names) * sdna->names_len_alloc));
-        sdna->names_array_len = static_cast<short int *>(
-            MEM_recallocN((void *)sdna->names_array_len,
-                          sizeof(*sdna->names_array_len) * sdna->names_len_alloc));
+      if (sdna->members_num == sdna->members_num_alloc) {
+        sdna->members_num_alloc += 64;
+        sdna->members = static_cast<const char **>(MEM_recallocN(
+            (void *)sdna->members, sizeof(*sdna->members) * sdna->members_num_alloc));
+        sdna->members_array_num = static_cast<short int *>(
+            MEM_recallocN((void *)sdna->members_array_num,
+                          sizeof(*sdna->members_array_num) * sdna->members_num_alloc));
       }
-      const short name_nr_prev = member->name;
-      member->name = sdna->names_len++;
-      sdna->names[member->name] = elem_new_full;
-      sdna->names_array_len[member->name] = sdna->names_array_len[name_nr_prev];
+      const short old_member_index = member_info->member_index;
+      member_info->member_index = sdna->members_num++;
+      sdna->members[member_info->member_index] = new_member_name_full;
+      sdna->members_array_num[member_info->member_index] =
+          sdna->members_array_num[old_member_index];
 
       return true;
     }
@@ -1813,13 +1841,13 @@ static bool DNA_sdna_patch_struct_member(SDNA *sdna,
   return false;
 }
 bool DNA_sdna_patch_struct_member_by_name(SDNA *sdna,
-                                          const char *struct_name,
-                                          const char *elem_old,
-                                          const char *elem_new)
+                                          const char *type_name,
+                                          const char *old_member_name,
+                                          const char *new_member_name)
 {
-  const int struct_name_nr = DNA_struct_find_without_alias(sdna, struct_name);
-  if (struct_name_nr != -1) {
-    return DNA_sdna_patch_struct_member(sdna, struct_name_nr, elem_old, elem_new);
+  const int struct_index = DNA_struct_find_index_without_alias(sdna, type_name);
+  if (struct_index != -1) {
+    return DNA_sdna_patch_struct_member(sdna, struct_index, old_member_name, new_member_name);
   }
   return false;
 }
@@ -1841,9 +1869,9 @@ bool DNA_sdna_patch_struct_member_by_name(SDNA *sdna,
 static void sdna_expand_names(SDNA *sdna)
 {
   int names_expand_len = 0;
-  for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
-    const SDNA_Struct *struct_old = sdna->structs[struct_nr];
-    names_expand_len += struct_old->members_len;
+  for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
+    const SDNA_Struct *struct_old = sdna->structs[struct_index];
+    names_expand_len += struct_old->members_num;
   }
   const char **names_expand = static_cast<const char **>(
       MEM_mallocN(sizeof(*names_expand) * names_expand_len, __func__));
@@ -1851,35 +1879,36 @@ static void sdna_expand_names(SDNA *sdna)
       MEM_mallocN(sizeof(*names_array_len_expand) * names_expand_len, __func__));
 
   int names_expand_index = 0;
-  for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
+  for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
     /* We can't edit this memory 'sdna->structs' points to (read-only `datatoc` file). */
-    const SDNA_Struct *struct_old = sdna->structs[struct_nr];
+    const SDNA_Struct *struct_old = sdna->structs[struct_index];
 
-    const int array_size = sizeof(short) * 2 + sizeof(SDNA_StructMember) * struct_old->members_len;
+    const int array_size = sizeof(short) * 2 + sizeof(SDNA_StructMember) * struct_old->members_num;
     SDNA_Struct *struct_new = static_cast<SDNA_Struct *>(
         BLI_memarena_alloc(sdna->mem_arena, array_size));
     memcpy(struct_new, struct_old, array_size);
-    sdna->structs[struct_nr] = struct_new;
+    sdna->structs[struct_index] = struct_new;
 
-    for (int i = 0; i < struct_old->members_len; i++) {
+    for (int i = 0; i < struct_old->members_num; i++) {
       const SDNA_StructMember *member_old = &struct_old->members[i];
       SDNA_StructMember *member_new = &struct_new->members[i];
 
-      names_expand[names_expand_index] = sdna->names[member_old->name];
-      names_array_len_expand[names_expand_index] = sdna->names_array_len[member_old->name];
+      names_expand[names_expand_index] = sdna->members[member_old->member_index];
+      names_array_len_expand[names_expand_index] =
+          sdna->members_array_num[member_old->member_index];
 
       BLI_assert(names_expand_index < SHRT_MAX);
-      member_new->name = names_expand_index;
+      member_new->member_index = names_expand_index;
       names_expand_index++;
     }
   }
-  MEM_freeN((void *)sdna->names);
-  sdna->names = names_expand;
+  MEM_freeN((void *)sdna->members);
+  sdna->members = names_expand;
 
-  MEM_freeN((void *)sdna->names_array_len);
-  sdna->names_array_len = names_array_len_expand;
+  MEM_freeN((void *)sdna->members_array_num);
+  sdna->members_array_num = names_array_len_expand;
 
-  sdna->names_len = names_expand_len;
+  sdna->members_num = names_expand_len;
 }
 
 static const char *dna_sdna_alias_from_static_elem_full(SDNA *sdna,
@@ -1889,26 +1918,26 @@ static const char *dna_sdna_alias_from_static_elem_full(SDNA *sdna,
 {
   const int elem_static_full_len = strlen(elem_static_full);
   char *elem_static = static_cast<char *>(alloca(elem_static_full_len + 1));
-  const int elem_static_len = DNA_elem_id_strip_copy(elem_static, elem_static_full);
+  const int elem_static_len = DNA_member_id_strip_copy(elem_static, elem_static_full);
   const char *str_pair[2] = {struct_name_static, elem_static};
   const char *elem_alias = static_cast<const char *>(
       BLI_ghash_lookup(elem_map_alias_from_static, str_pair));
   if (elem_alias) {
-    return DNA_elem_id_rename(sdna->mem_arena,
-                              elem_static,
-                              elem_static_len,
-                              elem_alias,
-                              strlen(elem_alias),
-                              elem_static_full,
-                              elem_static_full_len,
-                              DNA_elem_id_offset_start(elem_static_full));
+    return DNA_member_id_rename(sdna->mem_arena,
+                                elem_static,
+                                elem_static_len,
+                                elem_alias,
+                                strlen(elem_alias),
+                                elem_static_full,
+                                elem_static_full_len,
+                                DNA_member_id_offset_start(elem_static_full));
   }
   return nullptr;
 }
 
 void DNA_sdna_alias_data_ensure(SDNA *sdna)
 {
-  if (sdna->alias.names && sdna->alias.types) {
+  if (sdna->alias.members && sdna->alias.types) {
     return;
   }
 
@@ -1919,72 +1948,76 @@ void DNA_sdna_alias_data_ensure(SDNA *sdna)
     sdna->mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
   }
 
-  GHash *struct_map_alias_from_static;
-  GHash *elem_map_alias_from_static;
+  GHash *type_map_alias_from_static;
+  GHash *member_map_alias_from_static;
 
   DNA_alias_maps(
-      DNA_RENAME_ALIAS_FROM_STATIC, &struct_map_alias_from_static, &elem_map_alias_from_static);
+      DNA_RENAME_ALIAS_FROM_STATIC, &type_map_alias_from_static, &member_map_alias_from_static);
 
   if (sdna->alias.types == nullptr) {
     sdna->alias.types = static_cast<const char **>(
-        MEM_mallocN(sizeof(*sdna->alias.types) * sdna->types_len, __func__));
-    for (int type_nr = 0; type_nr < sdna->types_len; type_nr++) {
-      const char *struct_name_static = sdna->types[type_nr];
+        MEM_mallocN(sizeof(*sdna->alias.types) * sdna->types_num, __func__));
+    for (int type_index = 0; type_index < sdna->types_num; type_index++) {
+      const char *type_name_static = sdna->types[type_index];
 
       if (use_legacy_hack) {
-        struct_name_static = DNA_struct_rename_legacy_hack_alias_from_static(struct_name_static);
+        type_name_static = DNA_struct_rename_legacy_hack_alias_from_static(type_name_static);
       }
 
-      sdna->alias.types[type_nr] = static_cast<const char *>(BLI_ghash_lookup_default(
-          struct_map_alias_from_static, struct_name_static, (void *)struct_name_static));
+      sdna->alias.types[type_index] = static_cast<const char *>(BLI_ghash_lookup_default(
+          type_map_alias_from_static, type_name_static, (void *)type_name_static));
     }
   }
 
-  if (sdna->alias.names == nullptr) {
+  if (sdna->alias.members == nullptr) {
     sdna_expand_names(sdna);
-    sdna->alias.names = static_cast<const char **>(
-        MEM_mallocN(sizeof(*sdna->alias.names) * sdna->names_len, __func__));
-    for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
-      const SDNA_Struct *struct_info = sdna->structs[struct_nr];
-      const char *struct_name_static = sdna->types[struct_info->type];
+    sdna->alias.members = static_cast<const char **>(
+        MEM_mallocN(sizeof(*sdna->alias.members) * sdna->members_num, __func__));
+    for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
+      const SDNA_Struct *struct_info = sdna->structs[struct_index];
+      const char *struct_name_static = sdna->types[struct_info->type_index];
 
       if (use_legacy_hack) {
         struct_name_static = DNA_struct_rename_legacy_hack_alias_from_static(struct_name_static);
       }
 
-      for (int a = 0; a < struct_info->members_len; a++) {
+      for (int a = 0; a < struct_info->members_num; a++) {
         const SDNA_StructMember *member = &struct_info->members[a];
-        const char *elem_alias_full = dna_sdna_alias_from_static_elem_full(
-            sdna, elem_map_alias_from_static, struct_name_static, sdna->names[member->name]);
-        if (elem_alias_full != nullptr) {
-          sdna->alias.names[member->name] = elem_alias_full;
+        const char *member_alias_full = dna_sdna_alias_from_static_elem_full(
+            sdna,
+            member_map_alias_from_static,
+            struct_name_static,
+            sdna->members[member->member_index]);
+        if (member_alias_full != nullptr) {
+          sdna->alias.members[member->member_index] = member_alias_full;
         }
         else {
-          sdna->alias.names[member->name] = sdna->names[member->name];
+          sdna->alias.members[member->member_index] = sdna->members[member->member_index];
         }
       }
     }
   }
-  BLI_ghash_free(struct_map_alias_from_static, nullptr, nullptr);
-  BLI_ghash_free(elem_map_alias_from_static, MEM_freeN, nullptr);
+  BLI_ghash_free(type_map_alias_from_static, nullptr, nullptr);
+  BLI_ghash_free(member_map_alias_from_static, MEM_freeN, nullptr);
 }
 
 void DNA_sdna_alias_data_ensure_structs_map(SDNA *sdna)
 {
-  if (sdna->alias.structs_map) {
+  if (sdna->alias.types_to_structs_map) {
     return;
   }
 
   DNA_sdna_alias_data_ensure(sdna);
 #ifdef WITH_DNA_GHASH
   /* create a ghash lookup to speed up */
-  GHash *structs_map = BLI_ghash_str_new_ex(__func__, sdna->structs_len);
-  for (intptr_t nr = 0; nr < sdna->structs_len; nr++) {
-    const SDNA_Struct *struct_info = sdna->structs[nr];
-    BLI_ghash_insert(
-        structs_map, (void *)sdna->alias.types[struct_info->type], POINTER_FROM_INT(nr));
+  GHash *type_to_struct_index_map = BLI_ghash_str_new_ex(__func__, sdna->structs_num);
+  for (intptr_t struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
+    const SDNA_Struct *struct_info = sdna->structs[struct_index];
+    BLI_ghash_insert(type_to_struct_index_map,
+                     (void *)sdna->alias.types[struct_info->type_index],
+                     POINTER_FROM_INT(struct_index));
   }
-  sdna->alias.structs_map = structs_map;
+  sdna->alias.types_to_structs_map = type_to_struct_index_map;
 #else
   UNUSED_VARS(sdna);
 #endif
diff --git a/source/blender/makesdna/intern/dna_rename_defs.h b/source/blender/makesdna/intern/dna_rename_defs.h
index 95fb426daf1..5e4320c1afd 100644
--- a/source/blender/makesdna/intern/dna_rename_defs.h
+++ b/source/blender/makesdna/intern/dna_rename_defs.h
@@ -47,190 +47,190 @@ DNA_STRUCT_RENAME(SeqRetimingHandle, SeqRetimingKey)
 DNA_STRUCT_RENAME(SpaceButs, SpaceProperties)
 DNA_STRUCT_RENAME(SpaceIpo, SpaceGraph)
 DNA_STRUCT_RENAME(SpaceOops, SpaceOutliner)
-DNA_STRUCT_RENAME_ELEM(BPoint, alfa, tilt)
-DNA_STRUCT_RENAME_ELEM(BezTriple, alfa, tilt)
-DNA_STRUCT_RENAME_ELEM(Bone, curveInX, curve_in_x)
-DNA_STRUCT_RENAME_ELEM(Bone, curveInY, curve_in_z)
-DNA_STRUCT_RENAME_ELEM(Bone, curveOutX, curve_out_x)
-DNA_STRUCT_RENAME_ELEM(Bone, curveOutY, curve_out_z)
-DNA_STRUCT_RENAME_ELEM(Bone, scaleIn, scale_in_x)
-DNA_STRUCT_RENAME_ELEM(Bone, scaleOut, scale_out_x)
-DNA_STRUCT_RENAME_ELEM(Bone, scale_in_y, scale_in_z)
-DNA_STRUCT_RENAME_ELEM(Bone, scale_out_y, scale_out_z)
-DNA_STRUCT_RENAME_ELEM(BrushGpencilSettings, gradient_f, hardness)
-DNA_STRUCT_RENAME_ELEM(BrushGpencilSettings, gradient_s, aspect_ratio)
-DNA_STRUCT_RENAME_ELEM(Camera, YF_dofdist, dof_distance)
-DNA_STRUCT_RENAME_ELEM(Camera, clipend, clip_end)
-DNA_STRUCT_RENAME_ELEM(Camera, clipsta, clip_start)
-DNA_STRUCT_RENAME_ELEM(Collection, dupli_ofs, instance_offset)
-DNA_STRUCT_RENAME_ELEM(Curve, ext1, extrude)
-DNA_STRUCT_RENAME_ELEM(Curve, ext2, bevel_radius)
-DNA_STRUCT_RENAME_ELEM(Curve, len_wchar, len_char32)
-DNA_STRUCT_RENAME_ELEM(Curve, loc, texspace_location)
-DNA_STRUCT_RENAME_ELEM(Curve, size, texspace_size)
-DNA_STRUCT_RENAME_ELEM(Curve, texflag, texspace_flag)
-DNA_STRUCT_RENAME_ELEM(Curve, width, offset)
-DNA_STRUCT_RENAME_ELEM(Curves, attributes_active_index, attributes_active_index_legacy)
-DNA_STRUCT_RENAME_ELEM(CurvesGeometry, curve_size, curve_num)
-DNA_STRUCT_RENAME_ELEM(CurvesGeometry, point_size, point_num)
-DNA_STRUCT_RENAME_ELEM(CustomDataExternal, filename, filepath)
-DNA_STRUCT_RENAME_ELEM(Editing, over_border, overlay_frame_rect)
-DNA_STRUCT_RENAME_ELEM(Editing, over_cfra, overlay_frame_abs)
-DNA_STRUCT_RENAME_ELEM(Editing, over_flag, overlay_frame_flag)
-DNA_STRUCT_RENAME_ELEM(Editing, over_ofs, overlay_frame_ofs)
-DNA_STRUCT_RENAME_ELEM(FileAssetSelectParams, import_type, import_method)
-DNA_STRUCT_RENAME_ELEM(FileGlobal, filename, filepath)
-DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, cache_frame_pause_guiding, cache_frame_pause_guide)
-DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_alpha, guide_alpha)
-DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_beta, guide_beta)
-DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_parent, guide_parent)
-DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_source, guide_source)
-DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_vel_factor, guide_vel_factor)
-DNA_STRUCT_RENAME_ELEM(FluidEffectorSettings, guiding_mode, guide_mode)
-DNA_STRUCT_RENAME_ELEM(GreasePencil, drawing_array_size, drawing_array_num)
-DNA_STRUCT_RENAME_ELEM(GreasePencil, material_array_size, material_array_num)
-DNA_STRUCT_RENAME_ELEM(GreasePencilLayerFramesMapStorage, size, num)
-DNA_STRUCT_RENAME_ELEM(HookModifierData, totindex, indexar_num)
-DNA_STRUCT_RENAME_ELEM(Image, name, filepath)
-DNA_STRUCT_RENAME_ELEM(LaplacianDeformModifierData, total_verts, verts_num)
-DNA_STRUCT_RENAME_ELEM(Library, name, filepath)
-DNA_STRUCT_RENAME_ELEM(Light, energy, energy_deprecated)
-DNA_STRUCT_RENAME_ELEM(Light, energy_new, energy)
-DNA_STRUCT_RENAME_ELEM(LineartGpencilModifierData, line_types, edge_types)
-DNA_STRUCT_RENAME_ELEM(LineartGpencilModifierData, transparency_flags, mask_switches)
-DNA_STRUCT_RENAME_ELEM(LineartGpencilModifierData, transparency_mask, material_mask_bits)
-DNA_STRUCT_RENAME_ELEM(MDefCell, totinfluence, influences_num)
-DNA_STRUCT_RENAME_ELEM(MEdge, bweight, bweight_legacy)
-DNA_STRUCT_RENAME_ELEM(MEdge, crease, crease_legacy)
-DNA_STRUCT_RENAME_ELEM(MEdge, flag, flag_legacy)
-DNA_STRUCT_RENAME_ELEM(MPoly, flag, flag_legacy)
-DNA_STRUCT_RENAME_ELEM(MPoly, mat_nr, mat_nr_legacy)
-DNA_STRUCT_RENAME_ELEM(MVert, bweight, bweight_legacy)
-DNA_STRUCT_RENAME_ELEM(MVert, co, co_legacy)
-DNA_STRUCT_RENAME_ELEM(MVert, flag, flag_legacy)
-DNA_STRUCT_RENAME_ELEM(MaskLayer, restrictflag, visibility_flag)
-DNA_STRUCT_RENAME_ELEM(MaterialLineArt, transparency_mask, material_mask_bits)
-DNA_STRUCT_RENAME_ELEM(Mesh, edata, edge_data)
-DNA_STRUCT_RENAME_ELEM(Mesh, fdata, fdata_legacy)
-DNA_STRUCT_RENAME_ELEM(Mesh, ldata, corner_data)
-DNA_STRUCT_RENAME_ELEM(Mesh, loc, texspace_location)
-DNA_STRUCT_RENAME_ELEM(Mesh, pdata, face_data)
-DNA_STRUCT_RENAME_ELEM(Mesh, poly_offset_indices, face_offset_indices)
-DNA_STRUCT_RENAME_ELEM(Mesh, size, texspace_size)
-DNA_STRUCT_RENAME_ELEM(Mesh, smoothresh, smoothresh_legacy)
-DNA_STRUCT_RENAME_ELEM(Mesh, texflag, texspace_flag)
-DNA_STRUCT_RENAME_ELEM(Mesh, totedge, edges_num)
-DNA_STRUCT_RENAME_ELEM(Mesh, totface, totface_legacy)
-DNA_STRUCT_RENAME_ELEM(Mesh, totloop, corners_num)
-DNA_STRUCT_RENAME_ELEM(Mesh, totpoly, faces_num)
-DNA_STRUCT_RENAME_ELEM(Mesh, totvert, verts_num)
-DNA_STRUCT_RENAME_ELEM(Mesh, vdata, vert_data)
-DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totcagevert, cage_verts_num)
-DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totinfluence, influences_num)
-DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totvert, verts_num)
-DNA_STRUCT_RENAME_ELEM(MetaBall, loc, texspace_location)
-DNA_STRUCT_RENAME_ELEM(MetaBall, size, texspace_size)
-DNA_STRUCT_RENAME_ELEM(MetaBall, texflag, texspace_flag)
-DNA_STRUCT_RENAME_ELEM(MovieClip, name, filepath)
-DNA_STRUCT_RENAME_ELEM(MovieTracking, act_plane_track, act_plane_track_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTracking, act_track, act_track_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTracking, plane_tracks, plane_tracks_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTracking, reconstruction, reconstruction_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTracking, tracks, tracks_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTrackingCamera, principal, principal_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTrackingSettings, keyframe1, keyframe1_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTrackingSettings, keyframe2, keyframe2_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTrackingStabilization, rot_track, rot_track_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTrackingTrack, pat_max, pat_max_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTrackingTrack, pat_min, pat_min_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTrackingTrack, search_max, search_max_legacy)
-DNA_STRUCT_RENAME_ELEM(MovieTrackingTrack, search_min, search_min_legacy)
-DNA_STRUCT_RENAME_ELEM(NodeCryptomatte, num_inputs, inputs_num)
-DNA_STRUCT_RENAME_ELEM(NodeGeometryAttributeCapture, data_type, data_type_legacy)
-DNA_STRUCT_RENAME_ELEM(NodesModifierData, simulation_bake_directory, bake_directory)
-DNA_STRUCT_RENAME_ELEM(Object, col, color)
-DNA_STRUCT_RENAME_ELEM(Object, dup_group, instance_collection)
-DNA_STRUCT_RENAME_ELEM(Object, dupfacesca, instance_faces_scale)
-DNA_STRUCT_RENAME_ELEM(Object, restrictflag, visibility_flag)
-DNA_STRUCT_RENAME_ELEM(Object, size, scale)
-DNA_STRUCT_RENAME_ELEM(OpacityGpencilModifierData, hardeness, hardness)
-DNA_STRUCT_RENAME_ELEM(Paint, num_input_samples, num_input_samples_deprecated)
-DNA_STRUCT_RENAME_ELEM(ParticleSettings, child_nbr, child_percent)
-DNA_STRUCT_RENAME_ELEM(ParticleSettings, dup_group, instance_collection)
-DNA_STRUCT_RENAME_ELEM(ParticleSettings, dup_ob, instance_object)
-DNA_STRUCT_RENAME_ELEM(ParticleSettings, dupliweights, instance_weights)
-DNA_STRUCT_RENAME_ELEM(ParticleSettings, ren_child_nbr, child_render_percent)
-DNA_STRUCT_RENAME_ELEM(RenderData, bake_filter, bake_margin)
-DNA_STRUCT_RENAME_ELEM(RenderData, blurfac, motion_blur_shutter)
-DNA_STRUCT_RENAME_ELEM(RigidBodyWorld, steps_per_second, substeps_per_frame)
-DNA_STRUCT_RENAME_ELEM(SceneEEVEE, motion_blur_position, motion_blur_position_deprecated)
-DNA_STRUCT_RENAME_ELEM(SceneEEVEE, motion_blur_shutter, motion_blur_shutter_deprecated)
-DNA_STRUCT_RENAME_ELEM(SDefBind, numverts, verts_num)
-DNA_STRUCT_RENAME_ELEM(SDefVert, numbinds, binds_num)
-DNA_STRUCT_RENAME_ELEM(Sequence, retiming_handle_num, retiming_keys_num)
-DNA_STRUCT_RENAME_ELEM(Sequence, retiming_handles, retiming_keys)
-DNA_STRUCT_RENAME_ELEM(SpaceImage, pixel_snap_mode, pixel_round_mode)
-DNA_STRUCT_RENAME_ELEM(SpaceSeq, overlay_type, overlay_frame_type)
-DNA_STRUCT_RENAME_ELEM(Strip, dir, dirpath)
-DNA_STRUCT_RENAME_ELEM(StripElem, name, filename)
-DNA_STRUCT_RENAME_ELEM(StripProxy, dir, dirpath)
-DNA_STRUCT_RENAME_ELEM(StripProxy, file, filename)
-DNA_STRUCT_RENAME_ELEM(SurfaceDeformModifierData, num_mesh_verts, mesh_verts_num)
-DNA_STRUCT_RENAME_ELEM(SurfaceDeformModifierData, numpoly, target_polys_num)
-DNA_STRUCT_RENAME_ELEM(SurfaceDeformModifierData, numverts, bind_verts_num)
-DNA_STRUCT_RENAME_ELEM(Text, name, filepath)
-DNA_STRUCT_RENAME_ELEM(ThemeSpace, scrubbing_background, time_scrub_background)
-DNA_STRUCT_RENAME_ELEM(ThemeSpace, show_back_grad, background_type)
-DNA_STRUCT_RENAME_ELEM(UVProjectModifierData, num_projectors, projectors_num)
-DNA_STRUCT_RENAME_ELEM(UserDef, autokey_flag, keying_flag)
-DNA_STRUCT_RENAME_ELEM(UserDef, gp_manhattendist, gp_manhattandist)
-DNA_STRUCT_RENAME_ELEM(UserDef, pythondir, pythondir_legacy)
-DNA_STRUCT_RENAME_ELEM(VFont, name, filepath)
-DNA_STRUCT_RENAME_ELEM(View3D, far, clip_end)
-DNA_STRUCT_RENAME_ELEM(View3D, local_collections_uuid, local_collections_uid)
-DNA_STRUCT_RENAME_ELEM(View3D, local_view_uuid, local_view_uid)
-DNA_STRUCT_RENAME_ELEM(View3D, near, clip_start)
-DNA_STRUCT_RENAME_ELEM(View3D, ob_centre, ob_center)
-DNA_STRUCT_RENAME_ELEM(View3D, ob_centre_bone, ob_center_bone)
-DNA_STRUCT_RENAME_ELEM(View3D, ob_centre_cursor, ob_center_cursor)
-DNA_STRUCT_RENAME_ELEM(bArmature, collections, collections_legacy)
-DNA_STRUCT_RENAME_ELEM(bGPDstroke, gradient_f, hardness)
-DNA_STRUCT_RENAME_ELEM(bGPDstroke, gradient_s, aspect_ratio)
-DNA_STRUCT_RENAME_ELEM(bNodeLink, multi_input_socket_index, multi_input_sort_id)
-DNA_STRUCT_RENAME_ELEM(bNodeTree, inputs, inputs_legacy)
-DNA_STRUCT_RENAME_ELEM(bNodeTree, outputs, outputs_legacy)
-DNA_STRUCT_RENAME_ELEM(bPoseChannel, curveInX, curve_in_x)
-DNA_STRUCT_RENAME_ELEM(bPoseChannel, curveInY, curve_in_z)
-DNA_STRUCT_RENAME_ELEM(bPoseChannel, curveOutX, curve_out_x)
-DNA_STRUCT_RENAME_ELEM(bPoseChannel, curveOutY, curve_out_z)
-DNA_STRUCT_RENAME_ELEM(bPoseChannel, scaleIn, scale_in_x)
-DNA_STRUCT_RENAME_ELEM(bPoseChannel, scaleOut, scale_out_x)
-DNA_STRUCT_RENAME_ELEM(bPoseChannel, scale_in_y, scale_in_z)
-DNA_STRUCT_RENAME_ELEM(bPoseChannel, scale_out_y, scale_out_z)
-DNA_STRUCT_RENAME_ELEM(bSameVolumeConstraint, flag, free_axis)
-DNA_STRUCT_RENAME_ELEM(bSound, name, filepath)
-DNA_STRUCT_RENAME_ELEM(bTheme, tact, space_action)
-DNA_STRUCT_RENAME_ELEM(bTheme, tbuts, space_properties)
-DNA_STRUCT_RENAME_ELEM(bTheme, tclip, space_clip)
-DNA_STRUCT_RENAME_ELEM(bTheme, tconsole, space_console)
-DNA_STRUCT_RENAME_ELEM(bTheme, text, space_text)
-DNA_STRUCT_RENAME_ELEM(bTheme, tfile, space_file)
-DNA_STRUCT_RENAME_ELEM(bTheme, tima, space_image)
-DNA_STRUCT_RENAME_ELEM(bTheme, tinfo, space_info)
-DNA_STRUCT_RENAME_ELEM(bTheme, tipo, space_graph)
-DNA_STRUCT_RENAME_ELEM(bTheme, tnla, space_nla)
-DNA_STRUCT_RENAME_ELEM(bTheme, tnode, space_node)
-DNA_STRUCT_RENAME_ELEM(bTheme, toops, space_outliner)
-DNA_STRUCT_RENAME_ELEM(bTheme, tseq, space_sequencer)
-DNA_STRUCT_RENAME_ELEM(bTheme, tstatusbar, space_statusbar)
-DNA_STRUCT_RENAME_ELEM(bTheme, ttopbar, space_topbar)
-DNA_STRUCT_RENAME_ELEM(bTheme, tuserpref, space_preferences)
-DNA_STRUCT_RENAME_ELEM(bTheme, tv3d, space_view3d)
-DNA_STRUCT_RENAME_ELEM(bUserAssetLibrary, path, dirpath)
+DNA_STRUCT_RENAME_MEMBER(BPoint, alfa, tilt)
+DNA_STRUCT_RENAME_MEMBER(BezTriple, alfa, tilt)
+DNA_STRUCT_RENAME_MEMBER(Bone, curveInX, curve_in_x)
+DNA_STRUCT_RENAME_MEMBER(Bone, curveInY, curve_in_z)
+DNA_STRUCT_RENAME_MEMBER(Bone, curveOutX, curve_out_x)
+DNA_STRUCT_RENAME_MEMBER(Bone, curveOutY, curve_out_z)
+DNA_STRUCT_RENAME_MEMBER(Bone, scaleIn, scale_in_x)
+DNA_STRUCT_RENAME_MEMBER(Bone, scaleOut, scale_out_x)
+DNA_STRUCT_RENAME_MEMBER(Bone, scale_in_y, scale_in_z)
+DNA_STRUCT_RENAME_MEMBER(Bone, scale_out_y, scale_out_z)
+DNA_STRUCT_RENAME_MEMBER(BrushGpencilSettings, gradient_f, hardness)
+DNA_STRUCT_RENAME_MEMBER(BrushGpencilSettings, gradient_s, aspect_ratio)
+DNA_STRUCT_RENAME_MEMBER(Camera, YF_dofdist, dof_distance)
+DNA_STRUCT_RENAME_MEMBER(Camera, clipend, clip_end)
+DNA_STRUCT_RENAME_MEMBER(Camera, clipsta, clip_start)
+DNA_STRUCT_RENAME_MEMBER(Collection, dupli_ofs, instance_offset)
+DNA_STRUCT_RENAME_MEMBER(Curve, ext1, extrude)
+DNA_STRUCT_RENAME_MEMBER(Curve, ext2, bevel_radius)
+DNA_STRUCT_RENAME_MEMBER(Curve, len_wchar, len_char32)
+DNA_STRUCT_RENAME_MEMBER(Curve, loc, texspace_location)
+DNA_STRUCT_RENAME_MEMBER(Curve, size, texspace_size)
+DNA_STRUCT_RENAME_MEMBER(Curve, texflag, texspace_flag)
+DNA_STRUCT_RENAME_MEMBER(Curve, width, offset)
+DNA_STRUCT_RENAME_MEMBER(Curves, attributes_active_index, attributes_active_index_legacy)
+DNA_STRUCT_RENAME_MEMBER(CurvesGeometry, curve_size, curve_num)
+DNA_STRUCT_RENAME_MEMBER(CurvesGeometry, point_size, point_num)
+DNA_STRUCT_RENAME_MEMBER(CustomDataExternal, filename, filepath)
+DNA_STRUCT_RENAME_MEMBER(Editing, over_border, overlay_frame_rect)
+DNA_STRUCT_RENAME_MEMBER(Editing, over_cfra, overlay_frame_abs)
+DNA_STRUCT_RENAME_MEMBER(Editing, over_flag, overlay_frame_flag)
+DNA_STRUCT_RENAME_MEMBER(Editing, over_ofs, overlay_frame_ofs)
+DNA_STRUCT_RENAME_MEMBER(FileAssetSelectParams, import_type, import_method)
+DNA_STRUCT_RENAME_MEMBER(FileGlobal, filename, filepath)
+DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, cache_frame_pause_guiding, cache_frame_pause_guide)
+DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_alpha, guide_alpha)
+DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_beta, guide_beta)
+DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_parent, guide_parent)
+DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_source, guide_source)
+DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_vel_factor, guide_vel_factor)
+DNA_STRUCT_RENAME_MEMBER(FluidEffectorSettings, guiding_mode, guide_mode)
+DNA_STRUCT_RENAME_MEMBER(GreasePencil, drawing_array_size, drawing_array_num)
+DNA_STRUCT_RENAME_MEMBER(GreasePencil, material_array_size, material_array_num)
+DNA_STRUCT_RENAME_MEMBER(GreasePencilLayerFramesMapStorage, size, num)
+DNA_STRUCT_RENAME_MEMBER(HookModifierData, totindex, indexar_num)
+DNA_STRUCT_RENAME_MEMBER(Image, name, filepath)
+DNA_STRUCT_RENAME_MEMBER(LaplacianDeformModifierData, total_verts, verts_num)
+DNA_STRUCT_RENAME_MEMBER(Library, name, filepath)
+DNA_STRUCT_RENAME_MEMBER(Light, energy, energy_deprecated)
+DNA_STRUCT_RENAME_MEMBER(Light, energy_new, energy)
+DNA_STRUCT_RENAME_MEMBER(LineartGpencilModifierData, line_types, edge_types)
+DNA_STRUCT_RENAME_MEMBER(LineartGpencilModifierData, transparency_flags, mask_switches)
+DNA_STRUCT_RENAME_MEMBER(LineartGpencilModifierData, transparency_mask, material_mask_bits)
+DNA_STRUCT_RENAME_MEMBER(MDefCell, totinfluence, influences_num)
+DNA_STRUCT_RENAME_MEMBER(MEdge, bweight, bweight_legacy)
+DNA_STRUCT_RENAME_MEMBER(MEdge, crease, crease_legacy)
+DNA_STRUCT_RENAME_MEMBER(MEdge, flag, flag_legacy)
+DNA_STRUCT_RENAME_MEMBER(MPoly, flag, flag_legacy)
+DNA_STRUCT_RENAME_MEMBER(MPoly, mat_nr, mat_nr_legacy)
+DNA_STRUCT_RENAME_MEMBER(MVert, bweight, bweight_legacy)
+DNA_STRUCT_RENAME_MEMBER(MVert, co, co_legacy)
+DNA_STRUCT_RENAME_MEMBER(MVert, flag, flag_legacy)
+DNA_STRUCT_RENAME_MEMBER(MaskLayer, restrictflag, visibility_flag)
+DNA_STRUCT_RENAME_MEMBER(MaterialLineArt, transparency_mask, material_mask_bits)
+DNA_STRUCT_RENAME_MEMBER(Mesh, edata, edge_data)
+DNA_STRUCT_RENAME_MEMBER(Mesh, fdata, fdata_legacy)
+DNA_STRUCT_RENAME_MEMBER(Mesh, ldata, corner_data)
+DNA_STRUCT_RENAME_MEMBER(Mesh, loc, texspace_location)
+DNA_STRUCT_RENAME_MEMBER(Mesh, pdata, face_data)
+DNA_STRUCT_RENAME_MEMBER(Mesh, poly_offset_indices, face_offset_indices)
+DNA_STRUCT_RENAME_MEMBER(Mesh, size, texspace_size)
+DNA_STRUCT_RENAME_MEMBER(Mesh, smoothresh, smoothresh_legacy)
+DNA_STRUCT_RENAME_MEMBER(Mesh, texflag, texspace_flag)
+DNA_STRUCT_RENAME_MEMBER(Mesh, totedge, edges_num)
+DNA_STRUCT_RENAME_MEMBER(Mesh, totface, totface_legacy)
+DNA_STRUCT_RENAME_MEMBER(Mesh, totloop, corners_num)
+DNA_STRUCT_RENAME_MEMBER(Mesh, totpoly, faces_num)
+DNA_STRUCT_RENAME_MEMBER(Mesh, totvert, verts_num)
+DNA_STRUCT_RENAME_MEMBER(Mesh, vdata, vert_data)
+DNA_STRUCT_RENAME_MEMBER(MeshDeformModifierData, totcagevert, cage_verts_num)
+DNA_STRUCT_RENAME_MEMBER(MeshDeformModifierData, totinfluence, influences_num)
+DNA_STRUCT_RENAME_MEMBER(MeshDeformModifierData, totvert, verts_num)
+DNA_STRUCT_RENAME_MEMBER(MetaBall, loc, texspace_location)
+DNA_STRUCT_RENAME_MEMBER(MetaBall, size, texspace_size)
+DNA_STRUCT_RENAME_MEMBER(MetaBall, texflag, texspace_flag)
+DNA_STRUCT_RENAME_MEMBER(MovieClip, name, filepath)
+DNA_STRUCT_RENAME_MEMBER(MovieTracking, act_plane_track, act_plane_track_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTracking, act_track, act_track_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTracking, plane_tracks, plane_tracks_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTracking, reconstruction, reconstruction_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTracking, tracks, tracks_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTrackingCamera, principal, principal_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTrackingSettings, keyframe1, keyframe1_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTrackingSettings, keyframe2, keyframe2_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTrackingStabilization, rot_track, rot_track_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTrackingTrack, pat_max, pat_max_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTrackingTrack, pat_min, pat_min_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTrackingTrack, search_max, search_max_legacy)
+DNA_STRUCT_RENAME_MEMBER(MovieTrackingTrack, search_min, search_min_legacy)
+DNA_STRUCT_RENAME_MEMBER(NodeCryptomatte, num_inputs, inputs_num)
+DNA_STRUCT_RENAME_MEMBER(NodeGeometryAttributeCapture, data_type, data_type_legacy)
+DNA_STRUCT_RENAME_MEMBER(NodesModifierData, simulation_bake_directory, bake_directory)
+DNA_STRUCT_RENAME_MEMBER(Object, col, color)
+DNA_STRUCT_RENAME_MEMBER(Object, dup_group, instance_collection)
+DNA_STRUCT_RENAME_MEMBER(Object, dupfacesca, instance_faces_scale)
+DNA_STRUCT_RENAME_MEMBER(Object, restrictflag, visibility_flag)
+DNA_STRUCT_RENAME_MEMBER(Object, size, scale)
+DNA_STRUCT_RENAME_MEMBER(OpacityGpencilModifierData, hardeness, hardness)
+DNA_STRUCT_RENAME_MEMBER(Paint, num_input_samples, num_input_samples_deprecated)
+DNA_STRUCT_RENAME_MEMBER(ParticleSettings, child_nbr, child_percent)
+DNA_STRUCT_RENAME_MEMBER(ParticleSettings, dup_group, instance_collection)
+DNA_STRUCT_RENAME_MEMBER(ParticleSettings, dup_ob, instance_object)
+DNA_STRUCT_RENAME_MEMBER(ParticleSettings, dupliweights, instance_weights)
+DNA_STRUCT_RENAME_MEMBER(ParticleSettings, ren_child_nbr, child_render_percent)
+DNA_STRUCT_RENAME_MEMBER(RenderData, bake_filter, bake_margin)
+DNA_STRUCT_RENAME_MEMBER(RenderData, blurfac, motion_blur_shutter)
+DNA_STRUCT_RENAME_MEMBER(RigidBodyWorld, steps_per_second, substeps_per_frame)
+DNA_STRUCT_RENAME_MEMBER(SceneEEVEE, motion_blur_position, motion_blur_position_deprecated)
+DNA_STRUCT_RENAME_MEMBER(SceneEEVEE, motion_blur_shutter, motion_blur_shutter_deprecated)
+DNA_STRUCT_RENAME_MEMBER(SDefBind, numverts, verts_num)
+DNA_STRUCT_RENAME_MEMBER(SDefVert, numbinds, binds_num)
+DNA_STRUCT_RENAME_MEMBER(Sequence, retiming_handle_num, retiming_keys_num)
+DNA_STRUCT_RENAME_MEMBER(Sequence, retiming_handles, retiming_keys)
+DNA_STRUCT_RENAME_MEMBER(SpaceImage, pixel_snap_mode, pixel_round_mode)
+DNA_STRUCT_RENAME_MEMBER(SpaceSeq, overlay_type, overlay_frame_type)
+DNA_STRUCT_RENAME_MEMBER(Strip, dir, dirpath)
+DNA_STRUCT_RENAME_MEMBER(StripElem, name, filename)
+DNA_STRUCT_RENAME_MEMBER(StripProxy, dir, dirpath)
+DNA_STRUCT_RENAME_MEMBER(StripProxy, file, filename)
+DNA_STRUCT_RENAME_MEMBER(SurfaceDeformModifierData, num_mesh_verts, mesh_verts_num)
+DNA_STRUCT_RENAME_MEMBER(SurfaceDeformModifierData, numpoly, target_polys_num)
+DNA_STRUCT_RENAME_MEMBER(SurfaceDeformModifierData, numverts, bind_verts_num)
+DNA_STRUCT_RENAME_MEMBER(Text, name, filepath)
+DNA_STRUCT_RENAME_MEMBER(ThemeSpace, scrubbing_background, time_scrub_background)
+DNA_STRUCT_RENAME_MEMBER(ThemeSpace, show_back_grad, background_type)
+DNA_STRUCT_RENAME_MEMBER(UVProjectModifierData, num_projectors, projectors_num)
+DNA_STRUCT_RENAME_MEMBER(UserDef, autokey_flag, keying_flag)
+DNA_STRUCT_RENAME_MEMBER(UserDef, gp_manhattendist, gp_manhattandist)
+DNA_STRUCT_RENAME_MEMBER(UserDef, pythondir, pythondir_legacy)
+DNA_STRUCT_RENAME_MEMBER(VFont, name, filepath)
+DNA_STRUCT_RENAME_MEMBER(View3D, far, clip_end)
+DNA_STRUCT_RENAME_MEMBER(View3D, local_collections_uuid, local_collections_uid)
+DNA_STRUCT_RENAME_MEMBER(View3D, local_view_uuid, local_view_uid)
+DNA_STRUCT_RENAME_MEMBER(View3D, near, clip_start)
+DNA_STRUCT_RENAME_MEMBER(View3D, ob_centre, ob_center)
+DNA_STRUCT_RENAME_MEMBER(View3D, ob_centre_bone, ob_center_bone)
+DNA_STRUCT_RENAME_MEMBER(View3D, ob_centre_cursor, ob_center_cursor)
+DNA_STRUCT_RENAME_MEMBER(bArmature, collections, collections_legacy)
+DNA_STRUCT_RENAME_MEMBER(bGPDstroke, gradient_f, hardness)
+DNA_STRUCT_RENAME_MEMBER(bGPDstroke, gradient_s, aspect_ratio)
+DNA_STRUCT_RENAME_MEMBER(bNodeLink, multi_input_socket_index, multi_input_sort_id)
+DNA_STRUCT_RENAME_MEMBER(bNodeTree, inputs, inputs_legacy)
+DNA_STRUCT_RENAME_MEMBER(bNodeTree, outputs, outputs_legacy)
+DNA_STRUCT_RENAME_MEMBER(bPoseChannel, curveInX, curve_in_x)
+DNA_STRUCT_RENAME_MEMBER(bPoseChannel, curveInY, curve_in_z)
+DNA_STRUCT_RENAME_MEMBER(bPoseChannel, curveOutX, curve_out_x)
+DNA_STRUCT_RENAME_MEMBER(bPoseChannel, curveOutY, curve_out_z)
+DNA_STRUCT_RENAME_MEMBER(bPoseChannel, scaleIn, scale_in_x)
+DNA_STRUCT_RENAME_MEMBER(bPoseChannel, scaleOut, scale_out_x)
+DNA_STRUCT_RENAME_MEMBER(bPoseChannel, scale_in_y, scale_in_z)
+DNA_STRUCT_RENAME_MEMBER(bPoseChannel, scale_out_y, scale_out_z)
+DNA_STRUCT_RENAME_MEMBER(bSameVolumeConstraint, flag, free_axis)
+DNA_STRUCT_RENAME_MEMBER(bSound, name, filepath)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tact, space_action)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tbuts, space_properties)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tclip, space_clip)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tconsole, space_console)
+DNA_STRUCT_RENAME_MEMBER(bTheme, text, space_text)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tfile, space_file)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tima, space_image)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tinfo, space_info)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tipo, space_graph)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tnla, space_nla)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tnode, space_node)
+DNA_STRUCT_RENAME_MEMBER(bTheme, toops, space_outliner)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tseq, space_sequencer)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tstatusbar, space_statusbar)
+DNA_STRUCT_RENAME_MEMBER(bTheme, ttopbar, space_topbar)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tuserpref, space_preferences)
+DNA_STRUCT_RENAME_MEMBER(bTheme, tv3d, space_view3d)
+DNA_STRUCT_RENAME_MEMBER(bUserAssetLibrary, path, dirpath)
 /* NOTE: Keep sorted! */
 
 /* Write with a different name, old Blender versions crash loading files with non-NULL
  * global_areas. See D9442. */
-DNA_STRUCT_RENAME_ELEM(wmWindow, global_area_map, global_areas)
+DNA_STRUCT_RENAME_MEMBER(wmWindow, global_area_map, global_areas)
 
 /* NOTE: Keep sorted! */
diff --git a/source/blender/makesdna/intern/dna_utils.cc b/source/blender/makesdna/intern/dna_utils.cc
index 50e97770334..6b199096fde 100644
--- a/source/blender/makesdna/intern/dna_utils.cc
+++ b/source/blender/makesdna/intern/dna_utils.cc
@@ -26,7 +26,7 @@
 /** \name Struct Member Evaluation
  * \{ */
 
-int DNA_elem_array_size(const char *str)
+int DNA_member_array_num(const char *str)
 {
   int result = 1;
   int current = 0;
@@ -71,95 +71,100 @@ static bool is_identifier(const char c)
           (c == '_'));
 }
 
-uint DNA_elem_id_offset_start(const char *elem_full)
+uint DNA_member_id_offset_start(const char *member_full)
 {
   uint elem_full_offset = 0;
-  while (!is_identifier(elem_full[elem_full_offset])) {
+  while (!is_identifier(member_full[elem_full_offset])) {
     elem_full_offset++;
   }
   return elem_full_offset;
 }
 
-uint DNA_elem_id_offset_end(const char *elem_full)
+uint DNA_member_id_offset_end(const char *member_full)
 {
   uint elem_full_offset = 0;
-  while (is_identifier(elem_full[elem_full_offset])) {
+  while (is_identifier(member_full[elem_full_offset])) {
     elem_full_offset++;
   }
   return elem_full_offset;
 }
 
-uint DNA_elem_id_strip_copy(char *elem_dst, const char *elem_src)
+uint DNA_member_id_strip_copy(char *member_id_dst, const char *member_full_src)
 {
-  const uint elem_src_offset = DNA_elem_id_offset_start(elem_src);
-  const char *elem_src_trim = elem_src + elem_src_offset;
-  const uint elem_src_trim_len = DNA_elem_id_offset_end(elem_src_trim);
-  memcpy(elem_dst, elem_src_trim, elem_src_trim_len);
-  elem_dst[elem_src_trim_len] = '\0';
-  return elem_src_trim_len;
+  const uint member_src_offset = DNA_member_id_offset_start(member_full_src);
+  const char *member_src_trimmed = member_full_src + member_src_offset;
+  const uint member_src_trimmed_len = DNA_member_id_offset_end(member_src_trimmed);
+  memcpy(member_id_dst, member_src_trimmed, member_src_trimmed_len);
+  member_id_dst[member_src_trimmed_len] = '\0';
+  return member_src_trimmed_len;
 }
 
-uint DNA_elem_id_strip(char *elem)
+uint DNA_member_id_strip(char *member)
 {
-  const uint elem_offset = DNA_elem_id_offset_start(elem);
-  const char *elem_trim = elem + elem_offset;
-  const uint elem_trim_len = DNA_elem_id_offset_end(elem_trim);
-  memmove(elem, elem_trim, elem_trim_len);
-  elem[elem_trim_len] = '\0';
-  return elem_trim_len;
+  const uint member_offset = DNA_member_id_offset_start(member);
+  const char *member_trimmed = member + member_offset;
+  const uint member_trimmed_len = DNA_member_id_offset_end(member_trimmed);
+  memmove(member, member_trimmed, member_trimmed_len);
+  member[member_trimmed_len] = '\0';
+  return member_trimmed_len;
 }
 
-bool DNA_elem_id_match(const char *elem_search,
-                       const int elem_search_len,
-                       const char *elem_full,
-                       uint *r_elem_full_offset)
+bool DNA_member_id_match(const char *member_id,
+                         const int member_id_len,
+                         const char *member_full,
+                         uint *r_member_full_offset)
 {
-  BLI_assert(strlen(elem_search) == elem_search_len);
-  const uint elem_full_offset = DNA_elem_id_offset_start(elem_full);
-  const char *elem_full_trim = elem_full + elem_full_offset;
-  if (strncmp(elem_search, elem_full_trim, elem_search_len) == 0) {
-    const char c = elem_full_trim[elem_search_len];
+  BLI_assert(strlen(member_id) == member_id_len);
+  const uint elem_full_offset = DNA_member_id_offset_start(member_full);
+  const char *elem_full_trim = member_full + elem_full_offset;
+  if (strncmp(member_id, elem_full_trim, member_id_len) == 0) {
+    const char c = elem_full_trim[member_id_len];
     if (c == '\0' || !is_identifier(c)) {
-      *r_elem_full_offset = elem_full_offset;
+      *r_member_full_offset = elem_full_offset;
       return true;
     }
   }
   return false;
 }
 
-char *DNA_elem_id_rename(MemArena *mem_arena,
-                         const char *elem_src,
-                         const int elem_src_len,
-                         const char *elem_dst,
-                         const int elem_dst_len,
-                         const char *elem_src_full,
-                         const int elem_src_full_len,
-                         const uint elem_src_full_offset_len)
+char *DNA_member_id_rename(MemArena *mem_arena,
+                           const char *member_id_src,
+                           const int member_id_src_len,
+                           const char *member_id_dst,
+                           const int member_id_dst_len,
+                           const char *member_full_src,
+                           const int member_full_src_len,
+                           const uint member_full_src_offset_len)
 {
-  BLI_assert(strlen(elem_src) == elem_src_len);
-  BLI_assert(strlen(elem_dst) == elem_dst_len);
-  BLI_assert(strlen(elem_src_full) == elem_src_full_len);
-  BLI_assert(DNA_elem_id_offset_start(elem_src_full) == elem_src_full_offset_len);
-  UNUSED_VARS_NDEBUG(elem_src);
+  BLI_assert(strlen(member_id_src) == member_id_src_len);
+  BLI_assert(strlen(member_id_dst) == member_id_dst_len);
+  BLI_assert(strlen(member_full_src) == member_full_src_len);
+  BLI_assert(DNA_member_id_offset_start(member_full_src) == member_full_src_offset_len);
+  UNUSED_VARS_NDEBUG(member_src);
 
-  const int elem_final_len = (elem_src_full_len - elem_src_len) + elem_dst_len;
-  char *elem_dst_full = static_cast<char *>(BLI_memarena_alloc(mem_arena, elem_final_len + 1));
+  const int member_full_dst_len = (member_full_src_len - member_id_src_len) + member_id_dst_len;
+  char *member_full_dst = static_cast<char *>(
+      BLI_memarena_alloc(mem_arena, member_full_dst_len + 1));
   uint i = 0;
-  if (elem_src_full_offset_len != 0) {
-    memcpy(elem_dst_full, elem_src_full, elem_src_full_offset_len);
-    i = elem_src_full_offset_len;
+  if (member_full_src_offset_len != 0) {
+    memcpy(member_full_dst, member_full_src, member_full_src_offset_len);
+    i = member_full_src_offset_len;
   }
-  memcpy(&elem_dst_full[i], elem_dst, elem_dst_len + 1);
-  i += elem_dst_len;
-  uint elem_src_full_offset_end = elem_src_full_offset_len + elem_src_len;
-  if (elem_src_full[elem_src_full_offset_end] != '\0') {
-    const int elem_full_tail_len = (elem_src_full_len - elem_src_full_offset_end);
-    memcpy(&elem_dst_full[i], &elem_src_full[elem_src_full_offset_end], elem_full_tail_len + 1);
-    i += elem_full_tail_len;
+  memcpy(&member_full_dst[i], member_id_dst, member_id_dst_len + 1);
+  i += member_id_dst_len;
+  const uint member_full_src_offset_end = member_full_src_offset_len + member_id_src_len;
+  BLI_assert(DNA_member_id_offset_end(member_full_src + member_full_src_offset_len) ==
+             (member_full_src_offset_end - member_full_src_offset_len));
+  if (member_full_src[member_full_src_offset_end] != '\0') {
+    const int member_full_tail_len = (member_full_src_len - member_full_src_offset_end);
+    memcpy(&member_full_dst[i],
+           &member_full_src[member_full_src_offset_end],
+           member_full_tail_len + 1);
+    i += member_full_tail_len;
   }
-  BLI_assert((strlen(elem_dst_full) == elem_final_len) && (i == elem_final_len));
+  BLI_assert((strlen(member_full_dst) == member_full_dst_len) && (i == member_full_dst_len));
   UNUSED_VARS_NDEBUG(i);
-  return elem_dst_full;
+  return member_full_dst;
 }
 
 /** \} */
@@ -181,16 +186,16 @@ static bool strhash_pair_cmp(const void *a, const void *b)
   return (STREQ(pair_a[0], pair_b[0]) && STREQ(pair_a[1], pair_b[1])) ? false : true;
 }
 
-void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_struct_map, GHash **r_elem_map)
+void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_type_map, GHash **r_member_map)
 {
-  GHash *struct_map_local = nullptr;
-  if (r_struct_map) {
-    const char *data[][2] = {
+  GHash *type_map_local = nullptr;
+  if (r_type_map) {
+    const char *type_data[][2] = {
 #define DNA_STRUCT_RENAME(old, new) {#old, #new},
-#define DNA_STRUCT_RENAME_ELEM(struct_name, old, new)
+#define DNA_STRUCT_RENAME_MEMBER(struct_name, old, new)
 #include "dna_rename_defs.h"
 #undef DNA_STRUCT_RENAME
-#undef DNA_STRUCT_RENAME_ELEM
+#undef DNA_STRUCT_RENAME_MEMBER
     };
 
     int elem_key, elem_val;
@@ -202,40 +207,41 @@ void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_struct_map, GHash
       elem_key = 1;
       elem_val = 0;
     }
-    GHash *struct_map = BLI_ghash_str_new_ex(__func__, ARRAY_SIZE(data));
-    for (int i = 0; i < ARRAY_SIZE(data); i++) {
-      BLI_ghash_insert(struct_map, (void *)data[i][elem_key], (void *)data[i][elem_val]);
+    GHash *type_map = BLI_ghash_str_new_ex(__func__, ARRAY_SIZE(type_data));
+    for (int i = 0; i < ARRAY_SIZE(type_data); i++) {
+      BLI_ghash_insert(type_map, (void *)type_data[i][elem_key], (void *)type_data[i][elem_val]);
     }
 
     if (version_dir == DNA_RENAME_STATIC_FROM_ALIAS) {
       const char *renames[][2] = {
-          {"uint8_t", "uchar"},
-          {"int16_t", "short"},
-          {"uint16_t", "ushort"},
-          {"int32_t", "int"},
-          {"uint32_t", "int"},
+          /* {old, new}, like in #DNA_STRUCT_RENAME */
+          {"uchar", "uint8_t"},
+          {"short", "int16_t"},
+          {"ushort", "uint16_t"},
+          {"int", "int32_t"},
+          {"int", "uint32_t"},
       };
       for (int i = 0; i < ARRAY_SIZE(renames); i++) {
-        BLI_ghash_insert(struct_map, (void *)renames[i][0], (void *)renames[i][1]);
+        BLI_ghash_insert(type_map, (void *)renames[i][elem_key], (void *)renames[i][elem_val]);
       }
     }
 
-    *r_struct_map = struct_map;
+    *r_type_map = type_map;
 
     /* We know the direction of this, for local use. */
-    struct_map_local = BLI_ghash_str_new_ex(__func__, ARRAY_SIZE(data));
-    for (int i = 0; i < ARRAY_SIZE(data); i++) {
-      BLI_ghash_insert(struct_map_local, (void *)data[i][1], (void *)data[i][0]);
+    type_map_local = BLI_ghash_str_new_ex(__func__, ARRAY_SIZE(type_data));
+    for (int i = 0; i < ARRAY_SIZE(type_data); i++) {
+      BLI_ghash_insert(type_map_local, (void *)type_data[i][1], (void *)type_data[i][0]);
     }
   }
 
-  if (r_elem_map != nullptr) {
-    const char *data[][3] = {
+  if (r_member_map != nullptr) {
+    const char *member_data[][3] = {
 #define DNA_STRUCT_RENAME(old, new)
-#define DNA_STRUCT_RENAME_ELEM(struct_name, old, new) {#struct_name, #old, #new},
+#define DNA_STRUCT_RENAME_MEMBER(struct_name, old, new) {#struct_name, #old, #new},
 #include "dna_rename_defs.h"
 #undef DNA_STRUCT_RENAME
-#undef DNA_STRUCT_RENAME_ELEM
+#undef DNA_STRUCT_RENAME_MEMBER
     };
 
     int elem_key, elem_val;
@@ -247,21 +253,21 @@ void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_struct_map, GHash
       elem_key = 2;
       elem_val = 1;
     }
-    GHash *elem_map = BLI_ghash_new_ex(
-        strhash_pair_p, strhash_pair_cmp, __func__, ARRAY_SIZE(data));
-    for (int i = 0; i < ARRAY_SIZE(data); i++) {
+    GHash *member_map = BLI_ghash_new_ex(
+        strhash_pair_p, strhash_pair_cmp, __func__, ARRAY_SIZE(member_data));
+    for (int i = 0; i < ARRAY_SIZE(member_data); i++) {
       const char **str_pair = static_cast<const char **>(
           MEM_mallocN(sizeof(char *) * 2, __func__));
       str_pair[0] = static_cast<const char *>(
-          BLI_ghash_lookup_default(struct_map_local, data[i][0], (void *)data[i][0]));
-      str_pair[1] = data[i][elem_key];
-      BLI_ghash_insert(elem_map, (void *)str_pair, (void *)data[i][elem_val]);
+          BLI_ghash_lookup_default(type_map_local, member_data[i][0], (void *)member_data[i][0]));
+      str_pair[1] = member_data[i][elem_key];
+      BLI_ghash_insert(member_map, (void *)str_pair, (void *)member_data[i][elem_val]);
     }
-    *r_elem_map = elem_map;
+    *r_member_map = member_map;
   }
 
-  if (struct_map_local) {
-    BLI_ghash_free(struct_map_local, nullptr, nullptr);
+  if (type_map_local) {
+    BLI_ghash_free(type_map_local, nullptr, nullptr);
   }
 }
 
@@ -273,15 +279,15 @@ void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_struct_map, GHash
 /** \name Struct Name Legacy Hack
  * \{ */
 
+/* WARNING: Only keep this for compatibility: *NEVER ADD NEW STRINGS HERE*.
+ *
+ * The renaming here isn't complete, references to the old struct names
+ * are still included in DNA, now fixing these struct names properly
+ * breaks forward compatibility. Leave these as-is, but don't add to them!
+ * See D4342#98780. */
+
 const char *DNA_struct_rename_legacy_hack_static_from_alias(const char *name)
 {
-  /* Only keep this for compatibility: *NEVER ADD NEW STRINGS HERE*.
-   *
-   * The renaming here isn't complete, references to the old struct names
-   * are still included in DNA, now fixing these struct names properly
-   * breaks forward compatibility. Leave these as-is, but don't add to them!
-   * See D4342#98780. */
-
   /* 'bScreen' replaces the old IrisGL 'Screen' struct */
   if (STREQ("bScreen", name)) {
     return "Screen";
diff --git a/source/blender/makesdna/intern/dna_utils.h b/source/blender/makesdna/intern/dna_utils.h
index 752ce2e17ef..c5a287aff6b 100644
--- a/source/blender/makesdna/intern/dna_utils.h
+++ b/source/blender/makesdna/intern/dna_utils.h
@@ -16,53 +16,86 @@ struct GHash;
 struct MemArena;
 
 /**
- * Parses the `[n1][n2]...` on the end of an array name
- * and returns the number of array elements `n1 * n2 ...`.
+ * Naming convention in this header:
+ *  - `member_full` refers to the full definition of a struct member, including its prefixes (like
+ *    the pointer `*` ones) and suffixes (like the `[]` array ones).
+ *  - `member_id` (for member identifier) refers to the bare name of the struct member (e.g. `var`
+ *    is the member identifier of the `*var[n1][n2]` full member).
  */
-int DNA_elem_array_size(const char *str);
 
-uint DNA_elem_id_offset_start(const char *elem_full);
-uint DNA_elem_id_offset_end(const char *elem_full);
 /**
- * \a elem_dst must be at least the size of \a elem_src.
+ * Parse the `[n1][n2]...` at the end of an array struct member.
+ *
+ * \return the total number of array elements `n1 * n2 ...`, or `1` if the member is not an array.
  */
-uint DNA_elem_id_strip_copy(char *elem_dst, const char *elem_src);
-uint DNA_elem_id_strip(char *elem);
+int DNA_member_array_num(const char *str);
+
+/** Find the start offset of the member id (the name) within the full member definition. */
+uint DNA_member_id_offset_start(const char *member_full);
 /**
- * Check if 'var' matches '*var[3]' for eg,
- * return true if it does, with start/end offsets.
+ * Find the end offset of the member id (the name) within the trimmed full member definition.
+ *
+ * WARNING: Expects an input string which has already been trimmed from its non-identifier
+ * prefixes. E.g. passing `*var[n1]` to this function will return `0`, while passing `var[n1]` will
+ * return the expected `3` value.
  */
-bool DNA_elem_id_match(const char *elem_search,
-                       int elem_search_len,
-                       const char *elem_full,
-                       uint *r_elem_full_offset);
+uint DNA_member_id_offset_end(const char *member_full_trimmed);
 /**
- * \return a renamed DNA name, allocated from \a mem_arena.
+ * Copy the member id part (the bare name) of the full source member into \a member_id_dst.
+ *
+ * \param member_id_dst destination char buffer, must be at least the size of \a member_src_full.
  */
-char *DNA_elem_id_rename(struct MemArena *mem_arena,
-                         const char *elem_src,
-                         int elem_src_len,
-                         const char *elem_dst,
-                         int elem_dst_len,
-                         const char *elem_src_full,
-                         int elem_src_full_len,
-                         uint elem_src_full_offset_len);
+uint DNA_member_id_strip_copy(char *member_id_dst, const char *member_full_src);
+/**
+ * Same as #DNA_member_id_strip_copy, but modifies the given \a member string in place.
+ */
+uint DNA_member_id_strip(char *member);
+/**
+ * Check if the member identifier given in \a member_id matches the full name given in \a
+ * member_full. E.g. `var` matches full names like `var` or `*var[3]`, but not `variable`.
+ *
+ * \return true if it does, with the start offset of the match in \a r_member_full_offset.
+ */
+bool DNA_member_id_match(const char *member_id,
+                         int member_id_len,
+                         const char *member_full,
+                         uint *r_member_full_offset);
+/**
+ * Rename a struct member to a different name.
+ *
+ * Replace the source member identifier (\a member_id_src) by the destination one
+ * (\a member_id_dst), while preserving the potential prefixes and suffixes.
+ *
+ * \return a renamed DNA full member, allocated from \a mem_arena.
+ */
+char *DNA_member_id_rename(struct MemArena *mem_arena,
+                           const char *member_id_src,
+                           int member_id_src_len,
+                           const char *member_id_dst,
+                           int member_id_dst_len,
+                           const char *member_full_src,
+                           int member_full_src_len,
+                           uint member_full_src_offset_len);
 
 /**
  * When requesting version info, support both directions.
+ *
+ *  - 'Static' is the original name of the data, the one that is still stored in blendfiles DNA
+ *    info (to avoid breaking forward compatibility).
+ *  - 'Alias' is the current name of the data, the one used in current DNA definition code.
  */
 enum eDNA_RenameDir {
   DNA_RENAME_STATIC_FROM_ALIAS = -1,
   DNA_RENAME_ALIAS_FROM_STATIC = 1,
 };
 void DNA_alias_maps(enum eDNA_RenameDir version_dir,
-                    struct GHash **r_struct_map,
-                    struct GHash **r_elem_map);
+                    struct GHash **r_type_map,
+                    struct GHash **r_member_map);
 
-const char *DNA_struct_rename_legacy_hack_alias_from_static(const char *name);
 /**
  * DNA Compatibility Hack.
  */
+const char *DNA_struct_rename_legacy_hack_alias_from_static(const char *name);
 const char *DNA_struct_rename_legacy_hack_static_from_alias(const char *name);
 
 #ifdef __cplusplus
diff --git a/source/blender/makesdna/intern/makesdna.cc b/source/blender/makesdna/intern/makesdna.cc
index 077d03062a6..4c819dbd2e8 100644
--- a/source/blender/makesdna/intern/makesdna.cc
+++ b/source/blender/makesdna/intern/makesdna.cc
@@ -61,11 +61,11 @@ static const char *includefiles[] = {
 static MemArena *mem_arena = nullptr;
 
 static int max_data_size = 500000, max_array_len = 50000;
-static int names_len = 0;
-static int types_len = 0;
-static int structs_len = 0;
-/** At address `names[a]` is string `a`. */
-static char **names;
+static int members_num = 0;
+static int types_num = 0;
+static int structs_num = 0;
+/** At address `members[a]` is string `a`. */
+static char **members;
 /** At address `types[a]` is string `a`. */
 static char **types;
 /** At `types_size[a]` is the size of type `a` on this systems bitness (32 or 64). */
@@ -80,18 +80,18 @@ static short *types_size_32;
 static short *types_size_64;
 /**
  * At `sp = structs[a]` is the first address of a struct definition:
- * - `sp[0]` is type number.
- * - `sp[1]` is the length of the element array (next).
- * - `sp[2]` sp[3] is [(type_index, name_index), ..] (number of pairs is defined by `sp[1]`),
+ * - `sp[0]` is type index.
+ * - `sp[1]` is the length of the member array (next).
+ * - `sp[2]` sp[3] is [(type_index, member_index), ..] (number of pairs is defined by `sp[1]`),
  */
 static short **structs, *structdata;
 
 /** Versioning data */
 static struct {
-  GHash *struct_map_alias_from_static;
-  GHash *struct_map_static_from_alias;
-  GHash *elem_map_alias_from_static;
-  GHash *elem_map_static_from_alias;
+  GHash *type_map_alias_from_static;
+  GHash *type_map_static_from_alias;
+  GHash *member_map_alias_from_static;
+  GHash *member_map_static_from_alias;
 } g_version_data = {nullptr};
 
 /**
@@ -128,25 +128,26 @@ void BLI_system_backtrace(FILE *fp)
  * \{ */
 
 /**
- * Ensure type \c str to is in the #types array.
- * \param str: Struct name without any qualifiers.
+ * Ensure that type \a type_name is in the #types array.
+ * \param type_name: Struct name without any qualifiers.
  * \param size: The struct size in bytes.
  * \return Index in the #types array.
  */
-static int add_type(const char *str, int size);
+static int add_type(const char *type_name, int size);
 
 /**
- * Ensure \c str is int the #names array.
- * \param str: Struct member name which may include pointer prefix & array size.
- * \return Index in the #names array.
+ * Ensure that \a member_name is in the #members array.
+ * \param member_name: Full struct member name (may include pointer prefix & array size).
+ * \return Index in the #members array.
  */
-static int add_name(const char *str);
+static int add_member(const char *member_name);
 
 /**
- * Search whether this structure type was already found, and if not,
- * add it.
+ * Add a new structure definition, of type matching the given \a type_index.
+ *
+ * NOTE: there is no lookup performed here, a new struct definition is always added.
  */
-static short *add_struct(int namecode);
+static short *add_struct(int type_index);
 
 /**
  * Remove comments from this buffer. Assumes that the buffer refers to
@@ -214,45 +215,46 @@ static bool match_identifier_and_advance(char **str_ptr, const char *identifier)
   return false;
 }
 
-static const char *version_struct_static_from_alias(const char *str)
+static const char *version_struct_static_from_alias(const char *type_alias)
 {
-  const char *str_test = static_cast<const char *>(
-      BLI_ghash_lookup(g_version_data.struct_map_static_from_alias, str));
-  if (str_test != nullptr) {
-    return str_test;
+  const char *type_static = static_cast<const char *>(
+      BLI_ghash_lookup(g_version_data.type_map_static_from_alias, type_alias));
+  if (type_static != nullptr) {
+    return type_static;
   }
-  return str;
+  return type_alias;
 }
 
-static const char *version_struct_alias_from_static(const char *str)
+static const char *version_struct_alias_from_static(const char *type_static)
 {
-  const char *str_test = static_cast<const char *>(
-      BLI_ghash_lookup(g_version_data.struct_map_alias_from_static, str));
-  if (str_test != nullptr) {
-    return str_test;
+  const char *type_alias = static_cast<const char *>(
+      BLI_ghash_lookup(g_version_data.type_map_alias_from_static, type_static));
+  if (type_alias != nullptr) {
+    return type_alias;
   }
-  return str;
+  return type_static;
 }
 
-static const char *version_elem_static_from_alias(const int strct, const char *elem_alias_full)
+static const char *version_member_static_from_alias(const int type_index,
+                                                    const char *member_alias_full)
 {
-  const uint elem_alias_full_len = strlen(elem_alias_full);
-  char *elem_alias = static_cast<char *>(alloca(elem_alias_full_len + 1));
-  const int elem_alias_len = DNA_elem_id_strip_copy(elem_alias, elem_alias_full);
-  const char *str_pair[2] = {types[strct], elem_alias};
-  const char *elem_static = static_cast<const char *>(
-      BLI_ghash_lookup(g_version_data.elem_map_static_from_alias, str_pair));
-  if (elem_static != nullptr) {
-    return DNA_elem_id_rename(mem_arena,
-                              elem_alias,
-                              elem_alias_len,
-                              elem_static,
-                              strlen(elem_static),
-                              elem_alias_full,
-                              elem_alias_full_len,
-                              DNA_elem_id_offset_start(elem_alias_full));
+  const uint member_alias_full_len = strlen(member_alias_full);
+  char *member_alias = static_cast<char *>(alloca(member_alias_full_len + 1));
+  const int member_alias_len = DNA_member_id_strip_copy(member_alias, member_alias_full);
+  const char *str_pair[2] = {types[type_index], member_alias};
+  const char *member_static = static_cast<const char *>(
+      BLI_ghash_lookup(g_version_data.member_map_static_from_alias, str_pair));
+  if (member_static != nullptr) {
+    return DNA_member_id_rename(mem_arena,
+                                member_alias,
+                                member_alias_len,
+                                member_static,
+                                strlen(member_static),
+                                member_alias_full,
+                                member_alias_full_len,
+                                DNA_member_id_offset_start(member_alias_full));
   }
-  return elem_alias_full;
+  return member_alias_full;
 }
 
 /**
@@ -263,7 +265,7 @@ static bool is_name_legal(const char *name)
 {
   const int name_size = strlen(name) + 1;
   char *name_strip = static_cast<char *>(alloca(name_size));
-  DNA_elem_id_strip_copy(name_strip, name);
+  DNA_member_id_strip_copy(name_strip, name);
 
   const char prefix[] = {'p', 'a', 'd'};
 
@@ -298,51 +300,51 @@ static bool is_name_legal(const char *name)
   return true;
 }
 
-static int add_type(const char *str, int size)
+static int add_type(const char *type_name, int size)
 {
   /* first do validity check */
-  if (str[0] == 0) {
+  if (type_name[0] == 0) {
     return -1;
   }
-  if (strchr(str, '*')) {
+  if (strchr(type_name, '*')) {
     /* NOTE: this is valid C syntax but we can't parse, complain!
      * `struct SomeStruct* some_var;` <-- correct but we can't handle right now. */
     return -1;
   }
 
-  str = version_struct_static_from_alias(str);
+  type_name = version_struct_static_from_alias(type_name);
 
   /* search through type array */
-  for (int index = 0; index < types_len; index++) {
-    if (STREQ(str, types[index])) {
+  for (int type_index = 0; type_index < types_num; type_index++) {
+    if (STREQ(type_name, types[type_index])) {
       if (size) {
-        types_size_native[index] = size;
-        types_size_32[index] = size;
-        types_size_64[index] = size;
-        types_align_32[index] = size;
-        types_align_64[index] = size;
+        types_size_native[type_index] = size;
+        types_size_32[type_index] = size;
+        types_size_64[type_index] = size;
+        types_align_32[type_index] = size;
+        types_align_64[type_index] = size;
       }
-      return index;
+      return type_index;
     }
   }
 
   /* append new type */
-  const int str_size = strlen(str) + 1;
-  char *cp = static_cast<char *>(BLI_memarena_alloc(mem_arena, str_size));
-  memcpy(cp, str, str_size);
-  types[types_len] = cp;
-  types_size_native[types_len] = size;
-  types_size_32[types_len] = size;
-  types_size_64[types_len] = size;
-  types_align_32[types_len] = size;
-  types_align_64[types_len] = size;
-  if (types_len >= max_array_len) {
+  const int type_name_len = strlen(type_name) + 1;
+  char *cp = static_cast<char *>(BLI_memarena_alloc(mem_arena, type_name_len));
+  memcpy(cp, type_name, type_name_len);
+  types[types_num] = cp;
+  types_size_native[types_num] = size;
+  types_size_32[types_num] = size;
+  types_size_64[types_num] = size;
+  types_align_32[types_num] = size;
+  types_align_64[types_num] = size;
+  if (types_num >= max_array_len) {
     printf("too many types\n");
-    return types_len - 1;
+    return types_num - 1;
   }
-  types_len++;
+  types_num++;
 
-  return types_len - 1;
+  return types_num - 1;
 }
 
 /**
@@ -351,30 +353,30 @@ static int add_type(const char *str, int size)
  * we add name and type at the same time... There are two special
  * cases, unfortunately. These are explicitly checked.
  */
-static int add_name(const char *str)
+static int add_member(const char *member_name)
 {
   char buf[255]; /* stupid limit, change it :) */
   const char *name;
 
   additional_slen_offset = 0;
 
-  if (str[0] == 0 /*  || (str[1] == 0) */) {
+  if (member_name[0] == 0 /*  || (member_name[1] == 0) */) {
     return -1;
   }
 
-  if (str[0] == '(' && str[1] == '*') {
+  if (member_name[0] == '(' && member_name[1] == '*') {
     /* We handle function pointer and special array cases here, e.g.
      * `void (*function)(...)` and `float (*array)[..]`. the array case
      * name is still converted to (array *)() though because it is that
      * way in old DNA too, and works correct with #DNA_struct_member_size. */
-    int isfuncptr = (strchr(str + 1, '(')) != nullptr;
+    int isfuncptr = (strchr(member_name + 1, '(')) != nullptr;
 
     DEBUG_PRINTF(3, "\t\t\t\t*** Function pointer or multidim array pointer found\n");
     /* function-pointer: transform the type (sometimes). */
     int i = 0;
 
-    while (str[i] != ')') {
-      buf[i] = str[i];
+    while (member_name[i] != ')') {
+      buf[i] = member_name[i];
       i++;
     }
 
@@ -386,38 +388,38 @@ static int add_name(const char *str)
     DEBUG_PRINTF(3, "first brace after offset %d\n", i);
 
     j++; /* j beyond closing brace ? */
-    while ((str[j] != 0) && (str[j] != ')')) {
-      DEBUG_PRINTF(3, "seen %c (%d)\n", str[j], str[j]);
+    while ((member_name[j] != 0) && (member_name[j] != ')')) {
+      DEBUG_PRINTF(3, "seen %c (%d)\n", member_name[j], member_name[j]);
       j++;
     }
     DEBUG_PRINTF(3,
                  "seen %c (%d)\n"
                  "special after offset%d\n",
-                 str[j],
-                 str[j],
+                 member_name[j],
+                 member_name[j],
                  j);
 
     if (!isfuncptr) {
       /* multidimensional array pointer case */
-      if (str[j] == 0) {
+      if (member_name[j] == 0) {
         DEBUG_PRINTF(3, "offsetting for multi-dimensional array pointer\n");
       }
       else {
         printf("Error during tokenizing multi-dimensional array pointer\n");
       }
     }
-    else if (str[j] == 0) {
+    else if (member_name[j] == 0) {
       DEBUG_PRINTF(3, "offsetting for space\n");
       /* get additional offset */
       int k = 0;
-      while (str[j] != ')') {
+      while (member_name[j] != ')') {
         j++;
         k++;
       }
       DEBUG_PRINTF(3, "extra offset %d\n", k);
       additional_slen_offset = k;
     }
-    else if (str[j] == ')') {
+    else if (member_name[j] == ')') {
       DEBUG_PRINTF(3, "offsetting for brace\n");
       /* don't get extra offset */
     }
@@ -460,13 +462,13 @@ static int add_name(const char *str)
   }
   else {
     /* normal field: old code */
-    name = str;
+    name = member_name;
   }
 
   /* search name array */
-  for (int nr = 0; nr < names_len; nr++) {
-    if (STREQ(name, names[nr])) {
-      return nr;
+  for (int member_index = 0; member_index < members_num; member_index++) {
+    if (STREQ(name, members[member_index])) {
+      return member_index;
     }
   }
 
@@ -476,39 +478,39 @@ static int add_name(const char *str)
   }
 
   /* Append new name. */
-  const int name_size = strlen(name) + 1;
-  char *cp = static_cast<char *>(BLI_memarena_alloc(mem_arena, name_size));
-  memcpy(cp, name, name_size);
-  names[names_len] = cp;
+  const int name_len = strlen(name) + 1;
+  char *cp = static_cast<char *>(BLI_memarena_alloc(mem_arena, name_len));
+  memcpy(cp, name, name_len);
+  members[members_num] = cp;
 
-  if (names_len >= max_array_len) {
+  if (members_num >= max_array_len) {
     printf("too many names\n");
-    return names_len - 1;
+    return members_num - 1;
   }
-  names_len++;
+  members_num++;
 
-  return names_len - 1;
+  return members_num - 1;
 }
 
-static short *add_struct(int namecode)
+static short *add_struct(int type_index)
 {
-  if (structs_len == 0) {
+  if (structs_num == 0) {
     structs[0] = structdata;
   }
   else {
-    short *sp = structs[structs_len - 1];
+    short *sp = structs[structs_num - 1];
     const int len = sp[1];
-    structs[structs_len] = sp + 2 * len + 2;
+    structs[structs_num] = sp + 2 * len + 2;
   }
 
-  short *sp = structs[structs_len];
-  sp[0] = namecode;
+  short *sp = structs[structs_num];
+  sp[0] = type_index;
 
-  if (structs_len >= max_array_len) {
+  if (structs_num >= max_array_len) {
     printf("too many structs\n");
     return sp;
   }
-  structs_len++;
+  structs_num++;
 
   return sp;
 }
@@ -746,16 +748,16 @@ static int convert_include(const char *filepath)
         /* we've got a struct name when... */
         if (match_identifier(md1 - 7, "struct")) {
 
-          const int strct = add_type(md1, 0);
-          if (strct == -1) {
+          const int struct_type_index = add_type(md1, 0);
+          if (struct_type_index == -1) {
             fprintf(stderr, "File '%s' contains struct we can't parse \"%s\"\n", filepath, md1);
             return 1;
           }
 
-          short *structpoin = add_struct(strct);
+          short *structpoin = add_struct(struct_type_index);
           short *sp = structpoin + 2;
 
-          DEBUG_PRINTF(1, "\t|\t|-- detected struct %s\n", types[strct]);
+          DEBUG_PRINTF(1, "\t|\t|-- detected struct %s\n", types[struct_type_index]);
 
           /* first lets make it all nice strings */
           md1 = md + 1;
@@ -807,8 +809,8 @@ static int convert_include(const char *filepath)
                         md1);
                 return -1;
               }
-              const int type = add_type(md1, 0);
-              if (type == -1) {
+              const int member_type_index = add_type(md1, 0);
+              if (member_type_index == -1) {
                 fprintf(
                     stderr, "File '%s' contains struct we can't parse \"%s\"\n", filepath, md1);
                 return 1;
@@ -832,7 +834,8 @@ static int convert_include(const char *filepath)
                   if (md1[slen - 1] == ';') {
                     md1[slen - 1] = 0;
 
-                    const int name = add_name(version_elem_static_from_alias(strct, md1));
+                    const int name = add_member(
+                        version_member_static_from_alias(struct_type_index, md1));
                     if (name == -1) {
                       fprintf(stderr,
                               "File '%s' contains struct with name that can't be added \"%s\"\n",
@@ -841,11 +844,11 @@ static int convert_include(const char *filepath)
                       return 1;
                     }
                     slen += additional_slen_offset;
-                    sp[0] = type;
+                    sp[0] = member_type_index;
                     sp[1] = name;
 
-                    if (names[name] != nullptr) {
-                      DEBUG_PRINTF(1, "%s |", names[name]);
+                    if (members[name] != nullptr) {
+                      DEBUG_PRINTF(1, "%s |", members[name]);
                     }
 
                     structpoin[1]++;
@@ -855,7 +858,8 @@ static int convert_include(const char *filepath)
                     break;
                   }
 
-                  const int name = add_name(version_elem_static_from_alias(strct, md1));
+                  const int name = add_member(
+                      version_member_static_from_alias(struct_type_index, md1));
                   if (name == -1) {
                     fprintf(stderr,
                             "File '%s' contains struct with name that can't be added \"%s\"\n",
@@ -865,10 +869,10 @@ static int convert_include(const char *filepath)
                   }
                   slen += additional_slen_offset;
 
-                  sp[0] = type;
+                  sp[0] = member_type_index;
                   sp[1] = name;
-                  if (names[name] != nullptr) {
-                    DEBUG_PRINTF(1, "%s ||", names[name]);
+                  if (members[name] != nullptr) {
+                    DEBUG_PRINTF(1, "%s ||", members[name]);
                   }
 
                   structpoin[1]++;
@@ -895,15 +899,19 @@ static int convert_include(const char *filepath)
   return 0;
 }
 
-static bool check_field_alignment(
-    int firststruct, int structtype, int type, int len, const char *name, const char *detail)
+static bool check_field_alignment(int firststruct,
+                                  int struct_type_index,
+                                  int type,
+                                  int len,
+                                  const char *name,
+                                  const char *detail)
 {
   bool result = true;
   if (type < firststruct && types_size_native[type] > 4 && (len % 8)) {
     fprintf(stderr,
             "Align 8 error (%s) in struct: %s %s (add %d padding bytes)\n",
             detail,
-            types[structtype],
+            types[struct_type_index],
             name,
             len % 8);
     result = false;
@@ -912,7 +920,7 @@ static bool check_field_alignment(
     fprintf(stderr,
             "Align 4 error (%s) in struct: %s %s (add %d padding bytes)\n",
             detail,
-            types[structtype],
+            types[struct_type_index],
             name,
             len % 4);
     result = false;
@@ -921,7 +929,7 @@ static bool check_field_alignment(
     fprintf(stderr,
             "Align 2 error (%s) in struct: %s %s (add %d padding bytes)\n",
             detail,
-            types[structtype],
+            types[struct_type_index],
             name,
             len % 2);
     result = false;
@@ -948,19 +956,19 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
   fprintf(file_verify, "\n");
 
   /* Multiple iterations to handle nested structs. */
-  int unknown = structs_len;
+  int unknown = structs_num;
   while (unknown) {
     const int lastunknown = unknown;
     unknown = 0;
 
     /* check all structs... */
-    for (int a = 0; a < structs_len; a++) {
+    for (int a = 0; a < structs_num; a++) {
       const short *structpoin = structs[a];
-      const int structtype = structpoin[0];
-      const char *structname = version_struct_alias_from_static(types[structtype]);
+      const int struct_type_index = structpoin[0];
+      const char *struct_type_name = version_struct_alias_from_static(types[struct_type_index]);
 
       /* when length is not known... */
-      if (types_size_native[structtype] == 0) {
+      if (types_size_native[struct_type_index] == 0) {
 
         const short *sp = structpoin + 2;
         int size_native = 0;
@@ -970,10 +978,10 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
         int max_align_32 = 0;
         int max_align_64 = 0;
 
-        /* check all elements in struct */
+        /* check all members in struct */
         for (int b = 0; b < structpoin[1]; b++, sp += 2) {
           int type = sp[0];
-          const char *cp = names[sp[1]];
+          const char *cp = members[sp[1]];
           int namelen = int(strlen(cp));
 
           /* Write size verification to file. */
@@ -983,14 +991,14 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
             char name_static[1024];
             BLI_assert(sizeof(name_static) > namelen);
 
-            DNA_elem_id_strip_copy(name_static, cp);
-            const char *str_pair[2] = {types[structtype], name_static};
+            DNA_member_id_strip_copy(name_static, cp);
+            const char *str_pair[2] = {types[struct_type_index], name_static};
             const char *name_alias = static_cast<const char *>(
-                BLI_ghash_lookup(g_version_data.elem_map_alias_from_static, str_pair));
+                BLI_ghash_lookup(g_version_data.member_map_alias_from_static, str_pair));
             fprintf(file_verify,
                     "BLI_STATIC_ASSERT(offsetof(struct %s, %s) == %d, \"DNA member offset "
                     "verify\");\n",
-                    structname,
+                    struct_type_name,
                     name_alias ? name_alias : name_static,
                     size_native);
           }
@@ -1000,13 +1008,13 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
             /* has the name an extra length? (array) */
             int mul = 1;
             if (cp[namelen - 1] == ']') {
-              mul = DNA_elem_array_size(cp);
+              mul = DNA_member_array_num(cp);
             }
 
             if (mul == 0) {
               fprintf(stderr,
                       "Zero array size found or could not parse %s: '%.*s'\n",
-                      types[structtype],
+                      types[struct_type_index],
                       namelen + 1,
                       cp);
               dna_error = true;
@@ -1017,7 +1025,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
               if (size_native % 4) {
                 fprintf(stderr,
                         "Align pointer error in struct (size_native 4): %s %s\n",
-                        types[structtype],
+                        types[struct_type_index],
                         cp);
                 dna_error = true;
               }
@@ -1026,7 +1034,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
               if (size_native % 8) {
                 fprintf(stderr,
                         "Align pointer error in struct (size_native 8): %s %s\n",
-                        types[structtype],
+                        types[struct_type_index],
                         cp);
                 dna_error = true;
               }
@@ -1035,7 +1043,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
             if (size_64 % 8) {
               fprintf(stderr,
                       "Align pointer error in struct (size_64 8): %s %s\n",
-                      types[structtype],
+                      types[struct_type_index],
                       cp);
               dna_error = true;
             }
@@ -1051,7 +1059,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
              * to be found for "float var [3]" */
             fprintf(stderr,
                     "Parse error in struct, invalid member name: %s %s\n",
-                    types[structtype],
+                    types[struct_type_index],
                     cp);
             dna_error = true;
           }
@@ -1059,13 +1067,13 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
             /* has the name an extra length? (array) */
             int mul = 1;
             if (cp[namelen - 1] == ']') {
-              mul = DNA_elem_array_size(cp);
+              mul = DNA_member_array_num(cp);
             }
 
             if (mul == 0) {
               fprintf(stderr,
                       "Zero array size found or could not parse %s: '%.*s'\n",
-                      types[structtype],
+                      types[struct_type_index],
                       namelen + 1,
                       cp);
               dna_error = true;
@@ -1077,7 +1085,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
                 fprintf(stderr,
                         "Align struct error: %s::%s (starts at %d on the native platform; "
                         "%d %% %zu = %d bytes)\n",
-                        types[structtype],
+                        types[struct_type_index],
                         cp,
                         size_native,
                         size_native,
@@ -1088,10 +1096,14 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
             }
 
             /* Check 2-4-8 aligned. */
-            if (!check_field_alignment(firststruct, structtype, type, size_32, cp, "32 bit")) {
+            if (!check_field_alignment(
+                    firststruct, struct_type_index, type, size_32, cp, "32 bit"))
+            {
               dna_error = true;
             }
-            if (!check_field_alignment(firststruct, structtype, type, size_64, cp, "64 bit")) {
+            if (!check_field_alignment(
+                    firststruct, struct_type_index, type, size_64, cp, "64 bit"))
+            {
               dna_error = true;
             }
 
@@ -1113,11 +1125,11 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
           unknown++;
         }
         else {
-          types_size_native[structtype] = size_native;
-          types_size_32[structtype] = size_32;
-          types_size_64[structtype] = size_64;
-          types_align_32[structtype] = max_align_32;
-          types_align_64[structtype] = max_align_64;
+          types_size_native[struct_type_index] = size_native;
+          types_size_32[struct_type_index] = size_32;
+          types_size_64[struct_type_index] = size_64;
+          types_align_32[struct_type_index] = max_align_32;
+          types_align_64[struct_type_index] = max_align_64;
 
           /* Sanity check 1: alignment should never be 0. */
           BLI_assert(max_align_32);
@@ -1135,12 +1147,12 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
             if ((size_64 % max_align_64 == 0) && (size_32 % max_align_32 == 4)) {
               fprintf(stderr,
                       "Sizeerror in 32 bit struct: %s (add padding pointer)\n",
-                      types[structtype]);
+                      types[struct_type_index]);
             }
             else {
               fprintf(stderr,
                       "Sizeerror in 32 bit struct: %s (add %d bytes)\n",
-                      types[structtype],
+                      types[struct_type_index],
                       max_align_32 - (size_32 % max_align_32));
             }
             dna_error = true;
@@ -1149,7 +1161,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
           if (size_64 % max_align_64) {
             fprintf(stderr,
                     "Sizeerror in 64 bit struct: %s (add %d bytes)\n",
-                    types[structtype],
+                    types[struct_type_index],
                     max_align_64 - (size_64 % max_align_64));
             dna_error = true;
           }
@@ -1157,7 +1169,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
           if (size_native % 4 && !ELEM(size_native, 1, 2)) {
             fprintf(stderr,
                     "Sizeerror 4 in struct: %s (add %d bytes)\n",
-                    types[structtype],
+                    types[struct_type_index],
                     size_native % 4);
             dna_error = true;
           }
@@ -1165,7 +1177,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
           /* Write size verification to file. */
           fprintf(file_verify,
                   "BLI_STATIC_ASSERT(sizeof(struct %s) == %d, \"DNA struct size verify\");\n\n",
-                  structname,
+                  struct_type_name,
                   size_native);
         }
       }
@@ -1182,7 +1194,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
     if (debugSDNA) {
       fprintf(stderr, "*** Known structs :\n");
 
-      for (int a = 0; a < structs_len; a++) {
+      for (int a = 0; a < structs_num; a++) {
         const short *structpoin = structs[a];
         const int structtype = structpoin[0];
 
@@ -1195,7 +1207,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
 
     fprintf(stderr, "*** Unknown structs :\n");
 
-    for (int a = 0; a < structs_len; a++) {
+    for (int a = 0; a < structs_num; a++) {
       const short *structpoin = structs[a];
       const int structtype = structpoin[0];
 
@@ -1230,14 +1242,14 @@ static void dna_write(FILE *file, const void *pntr, const int size)
 
 void print_struct_sizes()
 {
-  int unknown = structs_len;
+  int unknown = structs_num;
   printf("\n\n*** All detected structs:\n");
 
   while (unknown) {
     unknown = 0;
 
     /* check all structs... */
-    for (int a = 0; a < structs_len; a++) {
+    for (int a = 0; a < structs_num; a++) {
       const short *structpoin = structs[a];
       const int structtype = structpoin[0];
       printf("\t%s\t:%d\n", types[structtype], types_size_native[structtype]);
@@ -1263,7 +1275,7 @@ static int make_structDNA(const char *base_directory,
   structdata = static_cast<short *>(MEM_callocN(max_data_size, "structdata"));
 
   /* a maximum of 5000 variables, must be sufficient? */
-  names = static_cast<char **>(MEM_callocN(sizeof(char *) * max_array_len, "names"));
+  members = static_cast<char **>(MEM_callocN(sizeof(char *) * max_array_len, "names"));
   types = static_cast<char **>(MEM_callocN(sizeof(char *) * max_array_len, "types"));
   types_size_native = static_cast<short *>(
       MEM_callocN(sizeof(short) * max_array_len, "types_size_native"));
@@ -1280,11 +1292,11 @@ static int make_structDNA(const char *base_directory,
 
   /* Build versioning data */
   DNA_alias_maps(DNA_RENAME_ALIAS_FROM_STATIC,
-                 &g_version_data.struct_map_alias_from_static,
-                 &g_version_data.elem_map_alias_from_static);
+                 &g_version_data.type_map_alias_from_static,
+                 &g_version_data.member_map_alias_from_static);
   DNA_alias_maps(DNA_RENAME_STATIC_FROM_ALIAS,
-                 &g_version_data.struct_map_static_from_alias,
-                 &g_version_data.elem_map_static_from_alias);
+                 &g_version_data.type_map_static_from_alias,
+                 &g_version_data.member_map_static_from_alias);
 
   /**
    * Insertion of all known types.
@@ -1312,7 +1324,7 @@ static int make_structDNA(const char *base_directory,
   add_type("int8_t", 1);   /* SDNA_TYPE_INT8 */
 
   /* the defines above shouldn't be output in the padding file... */
-  const int firststruct = types_len;
+  const int firststruct = types_num;
 
   /* Add all include files defined in the global array.
    * Since the internal file+path name buffer has limited length,
@@ -1343,30 +1355,29 @@ static int make_structDNA(const char *base_directory,
   if (debugSDNA > 1) {
     int a, b;
     // short *elem;
-    short num_types;
+    short struct_members_num;
 
-    printf("names_len %d types_len %d structs_len %d\n", names_len, types_len, structs_len);
-    for (a = 0; a < names_len; a++) {
-      printf(" %s\n", names[a]);
+    printf("names_len %d types_len %d structs_len %d\n", members_num, types_num, structs_num);
+    for (a = 0; a < members_num; a++) {
+      printf(" %s\n", members[a]);
     }
     printf("\n");
 
     const short *sp = types_size_native;
-    for (a = 0; a < types_len; a++, sp++) {
+    for (a = 0; a < types_num; a++, sp++) {
       printf(" %s %d\n", types[a], *sp);
     }
     printf("\n");
 
-    for (a = 0; a < structs_len; a++) {
+    for (a = 0; a < structs_num; a++) {
       sp = structs[a];
       printf(" struct %s elems: %d size: %d\n", types[sp[0]], sp[1], types_size_native[sp[0]]);
-      num_types = sp[1];
+      struct_members_num = sp[1];
       sp += 2;
-      /* ? num_types was elem? */
-      for (b = 0; b < num_types; b++, sp += 2) {
+      for (b = 0; b < struct_members_num; b++, sp += 2) {
         printf("   %s %s allign32:%d, allign64:%d\n",
                types[sp[0]],
-               names[sp[1]],
+               members[sp[1]],
                types_align_32[sp[0]],
                types_align_64[sp[0]]);
       }
@@ -1377,7 +1388,7 @@ static int make_structDNA(const char *base_directory,
 
   DEBUG_PRINTF(0, "Writing file ... ");
 
-  if (names_len == 0 || structs_len == 0) {
+  if (members_num == 0 || structs_num == 0) {
     /* pass */
   }
   else {
@@ -1387,14 +1398,14 @@ static int make_structDNA(const char *base_directory,
 
     /* write names */
     dna_write(file, "NAME", 4);
-    int len = names_len;
+    int len = members_num;
     dna_write(file, &len, 4);
     /* write array */
     len = 0;
-    for (int nr = 0; nr < names_len; nr++) {
-      int name_size = strlen(names[nr]) + 1;
-      dna_write(file, names[nr], name_size);
-      len += name_size;
+    for (int member_index = 0; member_index < members_num; member_index++) {
+      int member_len = strlen(members[member_index]) + 1;
+      dna_write(file, members[member_index], member_len);
+      len += member_len;
     }
     int len_align = (len + 3) & ~3;
     if (len != len_align) {
@@ -1403,14 +1414,14 @@ static int make_structDNA(const char *base_directory,
 
     /* write TYPES */
     dna_write(file, "TYPE", 4);
-    len = types_len;
+    len = types_num;
     dna_write(file, &len, 4);
     /* write array */
     len = 0;
-    for (int nr = 0; nr < types_len; nr++) {
-      int type_size = strlen(types[nr]) + 1;
-      dna_write(file, types[nr], type_size);
-      len += type_size;
+    for (int type_index = 0; type_index < types_num; type_index++) {
+      int type_len = strlen(types[type_index]) + 1;
+      dna_write(file, types[type_index], type_len);
+      len += type_len;
     }
     len_align = (len + 3) & ~3;
     if (len != len_align) {
@@ -1420,19 +1431,19 @@ static int make_structDNA(const char *base_directory,
     /* WRITE TYPELENGTHS */
     dna_write(file, "TLEN", 4);
 
-    len = 2 * types_len;
-    if (types_len & 1) {
+    len = 2 * types_num;
+    if (types_num & 1) {
       len += 2;
     }
     dna_write(file, types_size_native, len);
 
     /* WRITE STRUCTS */
     dna_write(file, "STRC", 4);
-    len = structs_len;
+    len = structs_num;
     dna_write(file, &len, 4);
 
     /* calc datablock size */
-    const short *sp = structs[structs_len - 1];
+    const short *sp = structs[structs_num - 1];
     sp += 2 + 2 * (sp[1]);
     len = intptr_t((char *)sp - (char *)structs[0]);
     len = (len + 3) & ~3;
@@ -1446,46 +1457,46 @@ static int make_structDNA(const char *base_directory,
     fprintf(file_offsets, "#pragma once\n");
     fprintf(file_offsets, "#define SDNA_TYPE_FROM_STRUCT(id) _SDNA_TYPE_##id\n");
     fprintf(file_offsets, "enum {\n");
-    for (int i = 0; i < structs_len; i++) {
+    for (int i = 0; i < structs_num; i++) {
       const short *structpoin = structs[i];
-      const int structtype = structpoin[0];
+      const int struct_type_index = structpoin[0];
       fprintf(file_offsets,
               "\t_SDNA_TYPE_%s = %d,\n",
-              version_struct_alias_from_static(types[structtype]),
+              version_struct_alias_from_static(types[struct_type_index]),
               i);
     }
-    fprintf(file_offsets, "\tSDNA_TYPE_MAX = %d,\n", structs_len);
+    fprintf(file_offsets, "\tSDNA_TYPE_MAX = %d,\n", structs_num);
     fprintf(file_offsets, "};\n\n");
   }
 
   /* Check versioning errors which could cause duplicate names,
    * do last because names are stripped. */
   {
-    GSet *names_unique = BLI_gset_str_new_ex(__func__, 512);
-    for (int struct_nr = 0; struct_nr < structs_len; struct_nr++) {
-      const short *sp = structs[struct_nr];
-      const char *struct_name = types[sp[0]];
+    GSet *members_unique = BLI_gset_str_new_ex(__func__, 512);
+    for (int struct_index = 0; struct_index < structs_num; struct_index++) {
+      const short *sp = structs[struct_index];
+      const char *type = types[sp[0]];
       const int len = sp[1];
       sp += 2;
       for (int a = 0; a < len; a++, sp += 2) {
-        char *name = names[sp[1]];
-        DNA_elem_id_strip(name);
-        if (!BLI_gset_add(names_unique, name)) {
+        char *member = members[sp[1]];
+        DNA_member_id_strip(member);
+        if (!BLI_gset_add(members_unique, member)) {
           fprintf(stderr,
                   "Error: duplicate name found '%s.%s', "
                   "likely cause is 'dna_rename_defs.h'\n",
-                  struct_name,
-                  name);
+                  type,
+                  member);
           return 1;
         }
       }
-      BLI_gset_clear(names_unique, nullptr);
+      BLI_gset_clear(members_unique, nullptr);
     }
-    BLI_gset_free(names_unique, nullptr);
+    BLI_gset_free(members_unique, nullptr);
   }
 
   MEM_freeN(structdata);
-  MEM_freeN(names);
+  MEM_freeN(members);
   MEM_freeN(types);
   MEM_freeN(types_size_native);
   MEM_freeN(types_size_32);
@@ -1496,10 +1507,10 @@ static int make_structDNA(const char *base_directory,
 
   BLI_memarena_free(mem_arena);
 
-  BLI_ghash_free(g_version_data.struct_map_alias_from_static, nullptr, nullptr);
-  BLI_ghash_free(g_version_data.struct_map_static_from_alias, nullptr, nullptr);
-  BLI_ghash_free(g_version_data.elem_map_static_from_alias, MEM_freeN, nullptr);
-  BLI_ghash_free(g_version_data.elem_map_alias_from_static, MEM_freeN, nullptr);
+  BLI_ghash_free(g_version_data.type_map_alias_from_static, nullptr, nullptr);
+  BLI_ghash_free(g_version_data.type_map_static_from_alias, nullptr, nullptr);
+  BLI_ghash_free(g_version_data.member_map_static_from_alias, MEM_freeN, nullptr);
+  BLI_ghash_free(g_version_data.member_map_alias_from_static, MEM_freeN, nullptr);
 
   DEBUG_PRINTF(0, "done.\n");
 
@@ -1634,10 +1645,10 @@ int main(int argc, char **argv)
 static void UNUSED_FUNCTION(dna_rename_defs_ensure)()
 {
 #define DNA_STRUCT_RENAME(old, new) (void)sizeof(new);
-#define DNA_STRUCT_RENAME_ELEM(struct_name, old, new) (void)offsetof(struct_name, new);
+#define DNA_STRUCT_RENAME_MEMBER(struct_name, old, new) (void)offsetof(struct_name, new);
 #include "dna_rename_defs.h"
 #undef DNA_STRUCT_RENAME
-#undef DNA_STRUCT_RENAME_ELEM
+#undef DNA_STRUCT_RENAME_MEMBER
 }
 
 /** \} */
diff --git a/source/blender/makesrna/intern/rna_define.cc b/source/blender/makesrna/intern/rna_define.cc
index d7366a3ac34..a3ced0fc879 100644
--- a/source/blender/makesrna/intern/rna_define.cc
+++ b/source/blender/makesrna/intern/rna_define.cc
@@ -64,7 +64,7 @@ BlenderDefRNA DefRNA = {
 
 #ifndef RNA_RUNTIME
 static struct {
-  GHash *struct_map_static_from_alias;
+  GHash *type_map_static_from_alias;
 } g_version_data;
 #endif
 
@@ -202,17 +202,17 @@ static void rna_brna_structs_remove_and_free(BlenderRNA *brna, StructRNA *srna)
 }
 #endif
 
-static int DNA_struct_find_nr_wrapper(const SDNA *sdna, const char *struct_name)
+static int DNA_struct_find_index_wrapper(const SDNA *sdna, const char *type_name)
 {
-  struct_name = DNA_struct_rename_legacy_hack_static_from_alias(struct_name);
+  type_name = DNA_struct_rename_legacy_hack_static_from_alias(type_name);
 #ifdef RNA_RUNTIME
   /* We may support this at some point but for now we don't. */
   BLI_assert_unreachable();
 #else
-  struct_name = static_cast<const char *>(BLI_ghash_lookup_default(
-      g_version_data.struct_map_static_from_alias, struct_name, (void *)struct_name));
+  type_name = static_cast<const char *>(BLI_ghash_lookup_default(
+      g_version_data.type_map_static_from_alias, type_name, (void *)type_name));
 #endif
-  return DNA_struct_find_without_alias(sdna, struct_name);
+  return DNA_struct_find_index_without_alias(sdna, type_name);
 }
 
 StructDefRNA *rna_find_struct_def(StructRNA *srna)
@@ -448,7 +448,7 @@ static int rna_find_sdna_member(SDNA *sdna,
     CLOG_ERROR(&LOG, "only during preprocessing.");
     return 0;
   }
-  structnr = DNA_struct_find_nr_wrapper(sdna, structname);
+  structnr = DNA_struct_find_index_wrapper(sdna, structname);
 
   smember->offset = -1;
   if (structnr == -1) {
@@ -457,14 +457,14 @@ static int rna_find_sdna_member(SDNA *sdna,
   }
 
   const SDNA_Struct *struct_info = sdna->structs[structnr];
-  for (int a = 0; a < struct_info->members_len; a++) {
+  for (int a = 0; a < struct_info->members_num; a++) {
     const SDNA_StructMember *member = &struct_info->members[a];
-    const int size = DNA_struct_member_size(sdna, member->type, member->name);
-    dnaname = sdna->alias.names[member->name];
+    const int size = DNA_struct_member_size(sdna, member->type_index, member->member_index);
+    dnaname = sdna->alias.members[member->member_index];
     cmp = rna_member_cmp(dnaname, membername);
 
     if (cmp == 1) {
-      smember->type = sdna->alias.types[member->type];
+      smember->type = sdna->alias.types[member->type_index];
       smember->name = dnaname;
       smember->offset = *offset;
       smember->size = size;
@@ -473,7 +473,7 @@ static int rna_find_sdna_member(SDNA *sdna,
         smember->arraylength = 0;
       }
       else {
-        smember->arraylength = DNA_elem_array_size(smember->name);
+        smember->arraylength = DNA_member_array_num(smember->name);
       }
 
       smember->pointerlevel = 0;
@@ -492,7 +492,8 @@ static int rna_find_sdna_member(SDNA *sdna,
       smember->arraylength = 0;
 
       membername = strstr(membername, ".") + strlen(".");
-      rna_find_sdna_member(sdna, sdna->alias.types[member->type], membername, smember, offset);
+      rna_find_sdna_member(
+          sdna, sdna->alias.types[member->type_index], membername, smember, offset);
 
       return 1;
     }
@@ -506,7 +507,8 @@ static int rna_find_sdna_member(SDNA *sdna,
 
       *offset = -1;
       membername = strstr(membername, "->") + strlen("->");
-      rna_find_sdna_member(sdna, sdna->alias.types[member->type], membername, smember, offset);
+      rna_find_sdna_member(
+          sdna, sdna->alias.types[member->type_index], membername, smember, offset);
 
       return 1;
     }
@@ -721,7 +723,7 @@ BlenderRNA *RNA_create()
 
 #ifndef RNA_RUNTIME
   DNA_alias_maps(
-      DNA_RENAME_STATIC_FROM_ALIAS, &g_version_data.struct_map_static_from_alias, nullptr);
+      DNA_RENAME_STATIC_FROM_ALIAS, &g_version_data.type_map_static_from_alias, nullptr);
 #endif
 
   return brna;
@@ -887,8 +889,8 @@ void RNA_free(BlenderRNA *brna)
   }
 
 #ifndef RNA_RUNTIME
-  BLI_ghash_free(g_version_data.struct_map_static_from_alias, nullptr, nullptr);
-  g_version_data.struct_map_static_from_alias = nullptr;
+  BLI_ghash_free(g_version_data.type_map_static_from_alias, nullptr, nullptr);
+  g_version_data.type_map_static_from_alias = nullptr;
 #endif
 }
 
@@ -1092,7 +1094,7 @@ void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
  * names, this can't be checked without adding an option to disable
  * (tested this and it means changes all over). */
 #if 0
-  if (DNA_struct_find_nr_wrapper(DefRNA.sdna, structname) == -1) {
+  if (DNA_struct_find_index_wrapper(DefRNA.sdna, structname) == -1) {
     if (!DefRNA.silent) {
       CLOG_ERROR(&LOG, "%s not found.", structname);
       DefRNA.error = true;
@@ -1120,7 +1122,7 @@ void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const cha
     return;
   }
 
-  if (DNA_struct_find_nr_wrapper(DefRNA.sdna, structname) == -1) {
+  if (DNA_struct_find_index_wrapper(DefRNA.sdna, structname) == -1) {
     if (!DefRNA.silent) {
       CLOG_ERROR(&LOG, "%s not found.", structname);
       DefRNA.error = true;
@@ -2367,7 +2369,7 @@ void RNA_def_property_boolean_sdna(PropertyRNA *prop,
 #ifndef RNA_RUNTIME
     /* Set the default if possible. */
     if (dp->dnaoffset != -1) {
-      int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
+      int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
       if (SDNAnr != -1) {
         const void *default_data = DNA_default_table[SDNAnr];
         if (default_data) {
@@ -2496,7 +2498,7 @@ void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const
 #ifndef RNA_RUNTIME
     /* Set the default if possible. */
     if (dp->dnaoffset != -1) {
-      int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
+      int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
       if (SDNAnr != -1) {
         const void *default_data = DNA_default_table[SDNAnr];
         if (default_data) {
@@ -2628,7 +2630,7 @@ void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, cons
 #ifndef RNA_RUNTIME
     /* Set the default if possible. */
     if (dp->dnaoffset != -1) {
-      int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
+      int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
       if (SDNAnr != -1) {
         const void *default_data = DNA_default_table[SDNAnr];
         if (default_data) {
@@ -2724,7 +2726,7 @@ void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const
 #ifndef RNA_RUNTIME
     /* Set the default if possible. */
     if (dp->dnaoffset != -1) {
-      int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
+      int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
       if (SDNAnr != -1) {
         const void *default_data = DNA_default_table[SDNAnr];
         if (default_data) {
@@ -2814,7 +2816,7 @@ void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, con
 #ifndef RNA_RUNTIME
     /* Set the default if possible. */
     if ((dp->dnaoffset != -1) && (dp->dnapointerlevel != 0)) {
-      int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
+      int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
       if (SDNAnr != -1) {
         const void *default_data = DNA_default_table[SDNAnr];
         if (default_data) {