[ntuple] factor out GetTypeList() field methods

The variant field, the tuple field, and the pair field all use
approximately the same GetTypeList() private static method. Factor this
out in a single method in an anonymous namespace.

Author: jblomer

tree/ntuple/inc/ROOT/RField/RFieldRecord.hxx

@@ -134,9 +134,6 @@ public:
 
 /// The generic field for `std::pair<T1, T2>` types
 class RPairField : public RRecordField {
-private:
-   static std::string GetTypeList(const std::array<std::unique_ptr<RFieldBase>, 2> &itemFields);
-
 protected:
    RPairField(std::string_view fieldName, std::array<std::unique_ptr<RFieldBase>, 2> itemFields,
               const std::array<std::size_t, 2> &offsets);
@@ -188,9 +185,6 @@ public:
 
 /// The generic field for `std::tuple<Ts...>` types
 class RTupleField : public RRecordField {
-private:
-   static std::string GetTypeList(const std::vector<std::unique_ptr<RFieldBase>> &itemFields);
-
 protected:
    RTupleField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields,
                const std::vector<std::size_t> &offsets);

tree/ntuple/inc/ROOT/RField/RFieldSTLMisc.hxx

@@ -404,7 +404,6 @@ private:
    size_t fVariantOffset = 0;
    std::vector<ROOT::Internal::RColumnIndex::ValueType> fNWritten;
 
-   static std::string GetTypeList(const std::vector<std::unique_ptr<RFieldBase>> &itemFields);
    /// Extracts the index from an `std::variant` and transforms it into the 1-based index used for the switch column
    /// The implementation supports two memory layouts that are in use: a trailing unsigned byte, zero-indexed,
    /// having the exception caused empty state encoded by the max tag value,

tree/ntuple/src/RFieldMeta.cxx

@@ -71,6 +71,27 @@ TEnum *EnsureValidEnum(std::string_view enumName)
    return e;
 }
 
+/// Create a comma-separated list of type names from the given fields. Uses either the real type names or the
+/// type aliases (if there are any, otherwise the actual type name). Used to construct template argument lists
+/// for templated types such as std::pair<...>, std::tuple<...>, std::variant<...>.
+std::string GetTypeList(std::span<std::unique_ptr<ROOT::RFieldBase>> itemFields, bool useTypeAliases)
+{
+   std::string result;
+   for (size_t i = 0; i < itemFields.size(); ++i) {
+      if (useTypeAliases && !itemFields[i]->GetTypeAlias().empty()) {
+         result += itemFields[i]->GetTypeAlias();
+      } else {
+         result += itemFields[i]->GetTypeName();
+      }
+      result.push_back(',');
+   }
+   if (result.empty()) {
+      throw ROOT::RException(R__FAIL("invalid empty type list provided as template argument"));
+   }
+   result.pop_back(); // remove trailing comma
+   return result;
+}
+
 std::string BuildSetTypeName(ROOT::RSetField::ESetType setType, const ROOT::RFieldBase &innerField)
 {
    std::string typePrefix;
@@ -667,22 +688,17 @@ void ROOT::REnumField::AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const
 
 //------------------------------------------------------------------------------
 
-std::string ROOT::RPairField::RPairField::GetTypeList(const std::array<std::unique_ptr<RFieldBase>, 2> &itemFields)
-{
-   return itemFields[0]->GetTypeName() + "," + itemFields[1]->GetTypeName();
-}
-
 ROOT::RPairField::RPairField(std::string_view fieldName, std::array<std::unique_ptr<RFieldBase>, 2> itemFields,
                              const std::array<std::size_t, 2> &offsets)
-   : ROOT::RRecordField(fieldName, "std::pair<" + GetTypeList(itemFields) + ">")
+   : ROOT::RRecordField(fieldName, "std::pair<" + GetTypeList(itemFields, false /* useTypeAliases */) + ">")
 {
    AttachItemFields(std::move(itemFields));
    fOffsets.push_back(offsets[0]);
    fOffsets.push_back(offsets[1]);
 }
 
 ROOT::RPairField::RPairField(std::string_view fieldName, std::array<std::unique_ptr<RFieldBase>, 2> itemFields)
-   : ROOT::RRecordField(fieldName, "std::pair<" + GetTypeList(itemFields) + ">")
+   : ROOT::RRecordField(fieldName, "std::pair<" + GetTypeList(itemFields, false /* useTypeAliases */) + ">")
 {
    AttachItemFields(std::move(itemFields));
 
@@ -1268,28 +1284,16 @@ void ROOT::RField<TObject>::AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor)
 
 //------------------------------------------------------------------------------
 
-std::string ROOT::RTupleField::RTupleField::GetTypeList(const std::vector<std::unique_ptr<RFieldBase>> &itemFields)
-{
-   std::string result;
-   if (itemFields.empty())
-      throw RException(R__FAIL("the type list for std::tuple must have at least one element"));
-   for (size_t i = 0; i < itemFields.size(); ++i) {
-      result += itemFields[i]->GetTypeName() + ",";
-   }
-   result.pop_back(); // remove trailing comma
-   return result;
-}
-
 ROOT::RTupleField::RTupleField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields,
                                const std::vector<std::size_t> &offsets)
-   : ROOT::RRecordField(fieldName, "std::tuple<" + GetTypeList(itemFields) + ">")
+   : ROOT::RRecordField(fieldName, "std::tuple<" + GetTypeList(itemFields, false /* useTypeAliases */) + ">")
 {
    AttachItemFields(std::move(itemFields));
    fOffsets = offsets;
 }
 
 ROOT::RTupleField::RTupleField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields)
-   : ROOT::RRecordField(fieldName, "std::tuple<" + GetTypeList(itemFields) + ">")
+   : ROOT::RRecordField(fieldName, "std::tuple<" + GetTypeList(itemFields, false /* useTypeAliases */) + ">")
 {
    AttachItemFields(std::move(itemFields));
 
@@ -1362,17 +1366,6 @@ struct RVariantTag {
 
 } // anonymous namespace
 
-std::string ROOT::RVariantField::GetTypeList(const std::vector<std::unique_ptr<RFieldBase>> &itemFields)
-{
-   std::string result;
-   for (size_t i = 0; i < itemFields.size(); ++i) {
-      result += itemFields[i]->GetTypeName() + ",";
-   }
-   R__ASSERT(!result.empty()); // there is always at least one variant
-   result.pop_back();          // remove trailing comma
-   return result;
-}
-
 ROOT::RVariantField::RVariantField(std::string_view name, const RVariantField &source)
    : ROOT::RFieldBase(name, source.GetTypeName(), ROOT::ENTupleStructure::kVariant, false /* isSimple */),
      fMaxItemSize(source.fMaxItemSize),
@@ -1387,8 +1380,8 @@ ROOT::RVariantField::RVariantField(std::string_view name, const RVariantField &s
 }
 
 ROOT::RVariantField::RVariantField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields)
-   : ROOT::RFieldBase(fieldName, "std::variant<" + GetTypeList(itemFields) + ">", ROOT::ENTupleStructure::kVariant,
-                      false /* isSimple */)
+   : ROOT::RFieldBase(fieldName, "std::variant<" + GetTypeList(itemFields, false /* useTypeAliases */) + ">",
+                      ROOT::ENTupleStructure::kVariant, false /* isSimple */)
 {
    // The variant needs to initialize its own tag member
    fTraits |= kTraitTriviallyDestructible & ~kTraitTriviallyConstructible;