[ntuple] fix type names with [U]Long64_t template args

Custom classes with [U]Long64_t template arguments need to use their
meta-normalized name as type alias. Otherwise, during reconstruction
with the RNTuple normalized name, the streamer info for the
`std::[u]int64_t` argument will be requested (typically `long`
instead of `long long`).

Author: jblomer

tree/ntuple/src/RFieldMeta.cxx

@@ -158,6 +158,10 @@ ROOT::RClassField::RClassField(std::string_view fieldName, TClass *classp)
    if (!(fClass->ClassProperty() & kClassHasExplicitDtor))
       fTraits |= kTraitTriviallyDestructible;
 
+   std::string renormalizedAlias;
+   if (Internal::NeedsMetaNameAsAlias(classp->GetName(), renormalizedAlias))
+      fTypeAlias = renormalizedAlias;
+
    int i = 0;
    const auto *bases = fClass->GetListOfBases();
    assert(bases);

tree/ntuple/test/CustomStruct.hxx

@@ -100,14 +100,19 @@ struct alignas(std::uint64_t) TestEBO : public EmptyStruct {
 template <typename T>
 class EdmWrapper {
 public:
+   struct Inner {
+      T fX;
+   };
+
    bool fIsPresent = true;
    T fMember;
 };
 
 class EdmContainer {
 public:
+   using EdmWrapperLong64_t = EdmWrapper<long long>;
    // Used to test that the streamer info for fWrapper will use long long
-   EdmWrapper<long long> fWrapper;
+   EdmWrapperLong64_t fWrapper;
 };
 
 template <typename T>

tree/ntuple/test/CustomStructLinkDef.h

@@ -33,7 +33,7 @@
 #pragma link C++ class EdmWrapper<CustomStruct> +;
 #pragma link C++ class EdmHash < 1> + ;
 #pragma link C++ class EdmWrapper<long long>+;
-#pragma link C++ class EdmContainer;
+#pragma link C++ class EdmContainer+;
 
 #pragma link C++ class DataVector < int, double> + ;
 #pragma link C++ class DataVector < int, float> + ;

tree/ntuple/test/rfield_class.cxx

@@ -395,37 +395,40 @@ TEST(RNTuple, TClassMetaName)
 
 TEST(RNTuple, StreamerInfoRecords)
 {
-   // Every testee consists of the type stored on disk and the expected streamer info records
-   std::vector<std::pair<std::string, std::vector<std::string>>> testees{
-      {"float", {}},
-      {"std::vector<float>", {}},
-      {"std::pair<float, float>", {}},
-      {"std::map<int, float>", {}},
-      {"CustomStruct", {"CustomStruct"}},
-      {"std::vector<CustomStruct>", {"CustomStruct"}},
-      {"std::map<int, CustomStruct>", {"CustomStruct"}},
-      {"DerivedA", {"DerivedA", "CustomStruct"}},
-      {"std::pair<CustomStruct, DerivedA>", {"DerivedA", "CustomStruct"}},
-      {"EdmWrapper<long long>", {"EdmWrapper<Long64_t>"}},
-      {"TRotation", {"TRotation"}}};
+   // Every testee consists of the type stored on disk, the expected streamer info records, and the expected type alias
+   std::vector<std::tuple<std::string, std::vector<std::string>, std::string>> testees{
+      {"float", {}, ""},
+      {"std::vector<float>", {}, ""},
+      {"std::pair<float, float>", {}, ""},
+      {"std::map<int, float>", {}, ""},
+      {"CustomStruct", {"CustomStruct"}, ""},
+      {"std::vector<CustomStruct>", {"CustomStruct"}, ""},
+      {"std::map<int, CustomStruct>", {"CustomStruct"}, ""},
+      {"DerivedA", {"DerivedA", "CustomStruct"}, ""},
+      {"std::pair<CustomStruct, DerivedA>", {"DerivedA", "CustomStruct"}, ""},
+      {"EdmWrapper<long long>", {"EdmWrapper<Long64_t>"}, "EdmWrapper<Long64_t>"},
+      {"EdmContainer", {"EdmContainer", "EdmWrapper<Long64_t>"}, ""},
+      {"EdmWrapper<long long>::Inner", {"EdmWrapper<Long64_t>::Inner"}, "EdmWrapper<Long64_t>::Inner"},
+      {"EdmContainer::EdmWrapperLong64_t", {"EdmWrapper<Long64_t>"}, "EdmContainer::EdmWrapperLong64_t"},
+      {"TRotation", {"TRotation"}, ""}};
 
    for (const auto &t : testees) {
       FileRaii fileGuard("test_ntuple_streamer_info_records.root");
 
       {
          auto model = ROOT::RNTupleModel::Create();
-         if (t.first == "TRotation") {
-            model->AddField(std::make_unique<ROOT::RStreamerField>("f", t.first));
+         if (std::get<0>(t) == "TRotation") {
+            model->AddField(std::make_unique<ROOT::RStreamerField>("f", std::get<0>(t)));
          } else {
-            model->AddField(ROOT::RFieldBase::Create("f", t.first).Unwrap());
+            model->AddField(ROOT::RFieldBase::Create("f", std::get<0>(t)).Unwrap());
          }
          auto writer = ROOT::RNTupleWriter::Recreate(std::move(model), "ntpl", fileGuard.GetPath());
       }
 
       auto f = std::unique_ptr<TFile>(TFile::Open(fileGuard.GetPath().c_str()));
       ASSERT_TRUE(f && !f->IsZombie());
 
-      std::unordered_set<std::string> expectedInfos{t.second.begin(), t.second.end()};
+      std::unordered_set<std::string> expectedInfos{std::get<1>(t).begin(), std::get<1>(t).end()};
       expectedInfos.insert("ROOT::RNTuple");
       for (const auto info : TRangeDynCast<TVirtualStreamerInfo>(*f->GetStreamerInfoList())) {
          auto itr = expectedInfos.find(info->GetName());
@@ -436,5 +439,12 @@ TEST(RNTuple, StreamerInfoRecords)
          expectedInfos.erase(itr);
       }
       EXPECT_TRUE(expectedInfos.empty());
+
+      // Make sure we can reconstruct the fields
+      auto reader = RNTupleReader::Open("ntpl", fileGuard.GetPath());
+      EXPECT_EQ(std::get<2>(t), reader->GetModel().GetConstField("f").GetTypeAlias());
+      if (auto field = dynamic_cast<const ROOT::RClassField *>(&reader->GetModel().GetConstField("f"))) {
+         EXPECT_EQ(std::get<1>(t)[0], field->GetClass()->GetName());
+      }
    }
 }