[metacling] Instantiate empty parameter packs

bindings/pyroot/cppyy/cppyy/test/test_regression.py

@@ -1,4 +1,4 @@
 import os, sys, pytest
 from pytest import mark, raises, skip
 from support import setup_make, IS_WINDOWS, ispypy, IS_MAC, IS_MAC_ARM
 
@@ -7,7 +7,7 @@
     helpout = []
 
     def setup_class(cls):
         import cppyy
 
         if sys.hexversion < 0x30d0000:
             def stringpager(text, cls=cls):
@@ -22,7 +22,7 @@
     def test01_kdcraw(self):
         """Doc strings for KDcrawIface (used to crash)."""
 
         import cppyy, pydoc
 
         # TODO: run a find for these paths
         qtpath = "/usr/include/qt5"
@@ -54,9 +54,9 @@
         if ispypy:
             skip('hangs (??) in pypy')
 
         import cppyy, pydoc
 
         assert not '__abstractmethods__' in dir(cppyy.gbl.gInterpreter)
         assert '__class__' in dir(cppyy.gbl.gInterpreter)
 
         self.__class__.helpout = []
@@ -68,7 +68,7 @@
 
         cppyy.cppdef("namespace cppyy_regression_test { void iii() {}; }")
 
         assert not 'iii' in cppyy.gbl.cppyy_regression_test.__dict__
         assert not '__abstractmethods__' in dir(cppyy.gbl.cppyy_regression_test)
         assert '__class__' in dir(cppyy.gbl.cppyy_regression_test)
         assert 'iii' in dir(cppyy.gbl.cppyy_regression_test)
@@ -1410,6 +1410,26 @@
         assert out == ""
         assert err == ""
 
+    def test48_variadic_conversion(self):
+        """Conversion for a variadic template function"""
+
+        import cppyy
+        cppyy.cppdef("""\
+        namespace regression_test48 {
+        template <typename... Ts> void f(std::pair<double, double>) {}
+        class A {
+        public:
+            template <typename... Ts>
+            void m(std::pair<double, double>) {}
+        };
+        }""")
+
+        r48 = cppyy.gbl.regression_test48
+
+        r48.f((1, 1))
+        a = r48.A()
+        a.m((1, 1))
+
     @mark.xfail(run=False, condition=IS_MAC_ARM or IS_WINDOWS == 64, reason="LLVM JIT fails to catch exceptions")
     def test49_overloads_with_runtime_errors(self):
         """Regression test for https://github.com/root-project/root/issues/17497

core/metacling/src/TCling.cxx

@@ -4017,6 +4017,9 @@ static std::string AlternateTuple(const char *classname, const cling::LookupHelp
    {
       // Check if we can produce the tuple
       auto iter = tupleContent.fElements.begin() + 1; // Skip the template name (tuple).
+      if (iter->empty()) {                            // skip empty template parameter list
+         iter++;
+      }
       auto theEnd = tupleContent.fElements.end() - 1; // skip the 'stars'.
       auto deleter = [](TypeInfo_t *type) {
          gInterpreter->TypeInfo_Delete(type);
@@ -4054,6 +4057,9 @@ static std::string AlternateTuple(const char *classname, const cling::LookupHelp
       case ETupleOrdering::kAscending: {
          unsigned int nMember = 0;
          auto iter = tupleContent.fElements.begin() + 1; // Skip the template name (tuple).
+         if (iter->empty()) {                            // skip empty template parameter list
+            iter++;
+         }
          auto theEnd = tupleContent.fElements.end() - 1; // skip the 'stars'.
          auto sep = ':';
          while (iter != theEnd) {
@@ -4068,6 +4074,9 @@ static std::string AlternateTuple(const char *classname, const cling::LookupHelp
       case ETupleOrdering::kDescending: {
          unsigned int nMember = tupleContent.fElements.size() - 3;
          auto iter = tupleContent.fElements.rbegin() + 1; // skip the 'stars'.
+         if (iter->empty()) {                             // skip empty template parameter list
+            iter++;
+         }
          auto theEnd = tupleContent.fElements.rend() - 1; // Skip the template name (tuple).
          auto sep = ':';
          while (iter != theEnd) {

core/metacling/src/TClingMethodInfo.cxx

@@ -161,14 +161,7 @@ TClingCXXRecMethIter::InstantiateTemplateWithDefaults(const clang::RedeclarableT
    llvm::SmallVector<TemplateArgument, 8> defaultTemplateArgs;
    for (const NamedDecl *templateParm: *templateParms) {
       if (templateParm->isTemplateParameterPack()) {
-         // This would inject an emprt parameter pack, which is a good default.
-         // But for cases where instantiation fails, this hits bug in unloading
-         // of the failed instantiation, causing a missing symbol in subsequent
-         // transactions where a Decl instantiated by the failed instatiation
-         // is not re-emitted. So for now just give up default-instantiating
-         // templates with parameter packs, even if this is simply a work-around.
-         //defaultTemplateArgs.emplace_back(ArrayRef<TemplateArgument>{}); // empty pack.
-         return nullptr;
+         defaultTemplateArgs.emplace_back(ArrayRef<TemplateArgument>{}); // empty pack.
       } else if (auto TTP = dyn_cast<TemplateTypeParmDecl>(templateParm)) {
          if (!TTP->hasDefaultArgument())
             return nullptr;

core/metacling/test/TClingMethodInfoTests.cxx

@@ -456,17 +456,15 @@ namespace Templates {
    EXPECT_EQ(names.count("Nc"), 0);
    EXPECT_EQ(names.count("Nd"), 0);
 
-   //[1]: See comment in TClingCXXRecMethIter::InstantiateTemplateWithDefaults()
-   // handling parameter packs.
    EXPECT_EQ(names.count("Ya<int>"), 1);
-   //EXPECT_EQ(names.count("Yb"), 1); //[1]
+   EXPECT_EQ(names.count("Yb<>"), 1);
    EXPECT_EQ(names.count("Yc<12>"), 1);
    EXPECT_EQ(names.count("Yd1<Templates::TypeArg>"), 1);
    EXPECT_EQ(names.count("Yd2<Templates::TemplateArg>"), 1);
    EXPECT_EQ(names.count("Ye<int>"), 1);
    EXPECT_EQ(names.count("Yf<int>"), 1);
-   //EXPECT_EQ(names.count("Yg<int>"), 1); //[1]
-   //EXPECT_EQ(names.count("Yh<int, int>"), 1); //[1]
+   EXPECT_EQ(names.count("Yg<int>"), 1);
+   EXPECT_EQ(names.count("Yh<int, int>"), 1);
 
    // These do a lookup / overload set, and can materialize functions (like Yb)
    // that the enumeration above failed to catch; see overriding

core/metacling/test/TClingTests.cxx

@@ -435,3 +435,9 @@ TEST_F(TClingTests, UndeclaredIdentifierCrash)
    diagRAII.requiredDiag(kError, "cling", expectedError, false);
    gInterpreter->ProcessLine("for(i=0; i < 0;); // the second usage of `i` was enough to get a segfault");
 }
+
+TEST_F(TClingTests, TupleEmpty)
+{
+   auto cl = TClass::GetClass("tuple<>");
+   EXPECT_TRUE(cl);
+}

tree/dataframe/inc/ROOT/RDF/RLazyDSImpl.hxx

@@ -68,7 +68,12 @@ class RLazyDS final : public ROOT::RDF::RDataSource {
       return {};
    }
 
-   size_t GetEntriesNumber() { return std::get<0>(fColumns)->size(); }
+   size_t GetEntriesNumber()
+   {
+      if constexpr (sizeof...(ColumnTypes) > 0)
+         return std::get<0>(fColumns)->size();
+      return 0;
+   }
    template <std::size_t... S>
    void SetEntryHelper(unsigned int slot, ULong64_t entry, std::index_sequence<S...>)
    {

tree/dataframe/test/dataframe_cache.cxx

@@ -16,6 +16,13 @@
 using namespace ROOT::RDF;
 using namespace ROOT::VecOps;
 
+TEST(Cache, Empty)
+{
+   ROOT::RDataFrame df(5);
+   auto cached = df.Cache<>({});
+   EXPECT_EQ(*cached.Count(), 0);
+}
+
 TEST(Cache, FundType)
 {
    ROOT::RDataFrame tdf(5);

tree/dataframe/test/datasource_lazy.cxx

@@ -66,6 +66,14 @@ TEST(RLazyDS, Constructor)
    }
 }
 
+TEST(RLazyDS, Empty)
+{
+   RLazyDS<> lazy;
+   for (auto &&range : lazy.GetEntryRanges()) {
+      EXPECT_EQ(range.first, 0);
+      EXPECT_EQ(range.second, 0);
+   }
+}
 
 TEST(RLazyDS, RangesOneSlot)
 {