[lldb] Don't reject empty or unnamed template parameter packs

[teemperor]

Summary

We currently reject all templates that have either zero args or that have a parameter pack without
a name. Both cases are actually allowed in C++, so rejecting them leads to LLDB instead falling back to
a dummy 'void' type. This leads to all kind of errors later on (most notable, variables that have such
template types appear to be missing as we can't have 'void' variables and inheriting from such a template
type will cause Clang to hit some asserts when finding that the base class is 'void').

This just removes the too strict tests and adds a few tests for this stuff (+ some combinations of these
tests with preceding template parameters).

Things that I left for follow-up patches:

• All the possible interactions with template-template arguments which seem like a whole new source of possible bugs.
• Function templates which completely lack sanity checks.
• Variable templates are not implemented.
• Alias templates are not implemented too.
• The rather strange checks that just make sure that the separate list of template arg names and values always have the same length. I believe those ought to be asserts, but my current plan is to move both those things into a single list that can't end up in this inconsistent state.

[shafik]

There is also alias templates:

template<typename...>
using void_t = void;

might as well throw that in.

[shafik]

LGTM

[JDevlieghere]

There seems to be quite a bit of repetition in the test, maybe a little helper would ameliorate that. Otherwise LGTM.

[stella.stamenova]

This caused failures on the Windows lldb buildbot:

http://lab.llvm.org:8011/#/builders/83/builds/1294

Tests have to have unique names, so the two new added tests that use TestCase as the class name are both trying to write to the same log file and failing to do so.

[teemperor]

In D92425#2428844, @stella.stamenova wrote:

This caused failures on the Windows lldb buildbot:

http://lab.llvm.org:8011/#/builders/83/builds/1294

Tests have to have unique names, so the two new added tests that use TestCase as the class name are both trying to write to the same log file and failing to do so.

Thanks, fixed.

FWIW, this (frankly silly) requirement is actually supposed to be fixed by D83767.

[stella.stamenova]

In D92425#2428952, @teemperor wrote:

In D92425#2428844, @stella.stamenova wrote:

This caused failures on the Windows lldb buildbot:

http://lab.llvm.org:8011/#/builders/83/builds/1294

Tests have to have unique names, so the two new added tests that use TestCase as the class name are both trying to write to the same log file and failing to do so.

Thanks, fixed.

FWIW, this (frankly silly) requirement is actually supposed to be fixed by D83767.

It would be great to finally have it fixed so don't have random failures because of file names!

It looks like the two tests are still failing though (different reason):

http://lab.llvm.org:8011/#/builders/83/builds/1332/steps/7/logs/stdio

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
     case DW_TAG_GNU_template_template_param:
       ParseTemplateDIE(die, template_param_infos);
       break;
 
     default:
       break;
     }
   }
-  if (template_param_infos.args.empty())
-    return false;
   return template_param_infos.args.size() == template_param_infos.names.size();
 }
 
 bool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die,
                                              lldb_private::Type *type,
                                              CompilerType &clang_type) {
   const dw_tag_t tag = die.Tag();
   SymbolFileDWARF *dwarf = die.GetDWARF();

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
                                 llvm::StringRef name, int kind,
                                 lldb::LanguageType language,
                                 ClangASTMetadata *metadata = nullptr,
                                 bool exports_symbols = false);
 
   class TemplateParameterInfos {
   public:
     bool IsValid() const {
-      if (args.empty())
+      // Having a pack name but no packed args doesn't make sense, so mark
+      // these template parameters as invalid.
+      if (pack_name && !packed_args)
         return false;
       return args.size() == names.size() &&
-        ((bool)pack_name == (bool)packed_args) &&
         (!packed_args || !packed_args->packed_args);
     }
 
     llvm::SmallVector<const char *, 2> names;
     llvm::SmallVector<clang::TemplateArgument, 2> args;
     
     const char * pack_name = nullptr;
     std::unique_ptr<TemplateParameterInfos> packed_args;

lldb/test/API/lang/cpp/class-template-non-type-parameter-pack/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/lang/cpp/class-template-non-type-parameter-pack/TestClassTemplateNonTypeParameterPack.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test(self):
+        self.build()
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+
+        self.expect_expr("emptyNonTypePack", result_type="NonTypePack<>",
+            result_children=[ValueCheck(name="a", type="int")])
+        self.expect_expr("oneElemNonTypePack", result_type="NonTypePack<1>",
+            result_children=[ValueCheck(name="a", type="int")])
+        self.expect_expr("twoElemNonTypePack", result_type="NonTypePack<1, 2>",
+            result_children=[ValueCheck(name="a", type="int")])
+
+
+        self.expect_expr("emptyAnonNonTypePack", result_type="AnonNonTypePack<>",
+            result_children=[ValueCheck(name="b", type="int")])
+        self.expect_expr("oneElemAnonNonTypePack", result_type="AnonNonTypePack<1>",
+            result_children=[ValueCheck(name="b", type="int")])
+        self.expect_expr("twoElemAnonNonTypePack", result_type="AnonNonTypePack<1, 2>",
+            result_children=[ValueCheck(name="b", type="int")])
+
+
+        self.expect_expr("emptyAnonNonTypePackAfterTypeParam", result_type="AnonNonTypePackAfterTypeParam<int>",
+            result_children=[ValueCheck(name="c", type="int")])
+        self.expect_expr("oneElemAnonNonTypePackAfterTypeParam", result_type="AnonNonTypePackAfterTypeParam<int, 1>",
+            result_children=[ValueCheck(name="c", type="int")])
+
+
+
+        self.expect_expr("emptyAnonNonTypePackAfterAnonTypeParam", result_type="AnonNonTypePackAfterAnonTypeParam<int>",
+            result_children=[ValueCheck(name="d", type="float")])
+        self.expect_expr("oneElemAnonNonTypePackAfterAnonTypeParam", result_type="AnonNonTypePackAfterAnonTypeParam<int, 1>",
+            result_children=[ValueCheck(name="d", type="float")])
+
+
+        self.expect_expr("emptyNonTypePackAfterAnonTypeParam", result_type="NonTypePackAfterAnonTypeParam<int>",
+            result_children=[ValueCheck(name="e", type="int")])
+        self.expect_expr("oneElemNonTypePackAfterAnonTypeParam", result_type="NonTypePackAfterAnonTypeParam<int, 1>",
+            result_children=[ValueCheck(name="e", type="int")])
+
+
+        self.expect_expr("emptyNonTypePackAfterTypeParam", result_type="NonTypePackAfterTypeParam<int>",
+            result_children=[ValueCheck(name="f", type="int")])
+        self.expect_expr("oneElemNonTypePackAfterTypeParam", result_type="NonTypePackAfterTypeParam<int, 1>",
+            result_children=[ValueCheck(name="f", type="int")])
+
+        self.expect_expr("emptyAnonNonTypePackAfterNonTypeParam", result_type="AnonNonTypePackAfterNonTypeParam<1>",
+            result_children=[ValueCheck(name="g", type="int")])
+        self.expect_expr("oneElemAnonNonTypePackAfterNonTypeParam", result_type="AnonNonTypePackAfterNonTypeParam<1, 2>",
+            result_children=[ValueCheck(name="g", type="int")])
+
+
+        self.expect_expr("emptyAnonNonTypePackAfterAnonNonTypeParam", result_type="AnonNonTypePackAfterAnonNonTypeParam<1>",
+            result_children=[ValueCheck(name="h", type="float")])
+        self.expect_expr("oneElemAnonNonTypePackAfterAnonNonTypeParam", result_type="AnonNonTypePackAfterAnonNonTypeParam<1, 2>",
+            result_children=[ValueCheck(name="h", type="float")])
+
+
+        self.expect_expr("emptyNonTypePackAfterAnonNonTypeParam", result_type="NonTypePackAfterAnonNonTypeParam<1>",
+            result_children=[ValueCheck(name="i", type="int")])
+        self.expect_expr("oneElemNonTypePackAfterAnonNonTypeParam", result_type="NonTypePackAfterAnonNonTypeParam<1, 2>",
+            result_children=[ValueCheck(name="i", type="int")])
+
+
+        self.expect_expr("emptyNonTypePackAfterNonTypeParam", result_type="NonTypePackAfterNonTypeParam<1>",
+            result_children=[ValueCheck(name="j", type="int")])
+        self.expect_expr("oneElemNonTypePackAfterNonTypeParam", result_type="NonTypePackAfterNonTypeParam<1, 2>",
+            result_children=[ValueCheck(name="j", type="int")])
 No newline at end of file

lldb/test/API/lang/cpp/class-template-non-type-parameter-pack/main.cpp

+// Named type parameter pack.
+template <int... Is>
+struct NonTypePack { int a; };
+NonTypePack<> emptyNonTypePack;
+NonTypePack<1> oneElemNonTypePack;
+NonTypePack<1, 2> twoElemNonTypePack;
+
+// Unnamed type parameter pack.
+template <int... >
+struct AnonNonTypePack { int b; };
+AnonNonTypePack<> emptyAnonNonTypePack;
+AnonNonTypePack<1> oneElemAnonNonTypePack;
+AnonNonTypePack<1, 2> twoElemAnonNonTypePack;
+
+// Test type parameter packs combined with non-pack type template parameters.
+
+// Unnamed non-type parameter pack behind a named type parameter.
+template <typename T, int... >
+struct AnonNonTypePackAfterTypeParam { T c; };
+AnonNonTypePackAfterTypeParam<int> emptyAnonNonTypePackAfterTypeParam;
+AnonNonTypePackAfterTypeParam<int, 1> oneElemAnonNonTypePackAfterTypeParam;
+
+// Unnamed non-type parameter pack behind an unnamed type parameter.
+template <typename, int... >
+struct AnonNonTypePackAfterAnonTypeParam { float d; };
+AnonNonTypePackAfterAnonTypeParam<int> emptyAnonNonTypePackAfterAnonTypeParam;
+AnonNonTypePackAfterAnonTypeParam<int, 1> oneElemAnonNonTypePackAfterAnonTypeParam;
+
+// Named non-type parameter pack behind an unnamed type parameter.
+template <typename, int... Is>
+struct NonTypePackAfterAnonTypeParam { int e; };
+NonTypePackAfterAnonTypeParam<int> emptyNonTypePackAfterAnonTypeParam;
+NonTypePackAfterAnonTypeParam<int, 1> oneElemNonTypePackAfterAnonTypeParam;
+
+// Named non-type parameter pack behind a named type parameter.
+template <typename T, int... Is>
+struct NonTypePackAfterTypeParam { int f; };
+NonTypePackAfterTypeParam<int> emptyNonTypePackAfterTypeParam;
+NonTypePackAfterTypeParam<int, 1> oneElemNonTypePackAfterTypeParam;
+
+// Test non-type parameter packs combined with non-pack non-type template parameters.
+
+// Unnamed non-type parameter pack behind a named non-type parameter.
+template <int I, int... >
+struct AnonNonTypePackAfterNonTypeParam { int g; };
+AnonNonTypePackAfterNonTypeParam<1> emptyAnonNonTypePackAfterNonTypeParam;
+AnonNonTypePackAfterNonTypeParam<1, 2> oneElemAnonNonTypePackAfterNonTypeParam;
+
+// Unnamed non-type parameter pack behind an unnamed non-type parameter.
+template <int, int... >
+struct AnonNonTypePackAfterAnonNonTypeParam { float h; };
+AnonNonTypePackAfterAnonNonTypeParam<1> emptyAnonNonTypePackAfterAnonNonTypeParam;
+AnonNonTypePackAfterAnonNonTypeParam<1, 2> oneElemAnonNonTypePackAfterAnonNonTypeParam;
+
+// Named non-type parameter pack behind an unnamed non-type parameter.
+template <int, int... Is>
+struct NonTypePackAfterAnonNonTypeParam { int i; };
+NonTypePackAfterAnonNonTypeParam<1> emptyNonTypePackAfterAnonNonTypeParam;
+NonTypePackAfterAnonNonTypeParam<1, 2> oneElemNonTypePackAfterAnonNonTypeParam;
+
+// Named non-type parameter pack behind an unnamed non-type parameter.
+template <int I, int... Is>
+struct NonTypePackAfterNonTypeParam { int j; };
+NonTypePackAfterNonTypeParam<1> emptyNonTypePackAfterNonTypeParam;
+NonTypePackAfterNonTypeParam<1, 2> oneElemNonTypePackAfterNonTypeParam;
+
+int main() {
+  return 0; // break here
+}

lldb/test/API/lang/cpp/class-template-type-parameter-pack/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/lang/cpp/class-template-type-parameter-pack/TestClassTemplateTypeParameterPack.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test(self):
+        self.build()
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+
+        self.expect_expr("emptyTypePack", result_type="TypePack<>",
+            result_children=[ValueCheck(name="a", type="int")])
+        self.expect_expr("oneElemTypePack", result_type="TypePack<int>",
+            result_children=[ValueCheck(name="a", type="int")])
+        self.expect_expr("twoElemTypePack", result_type="TypePack<int, float>",
+            result_children=[ValueCheck(name="a", type="int")])
+
+
+        self.expect_expr("emptyAnonTypePack", result_type="AnonTypePack<>",
+            result_children=[ValueCheck(name="b", type="int")])
+        self.expect_expr("oneElemAnonTypePack", result_type="AnonTypePack<int>",
+            result_children=[ValueCheck(name="b", type="int")])
+        self.expect_expr("twoElemAnonTypePack", result_type="AnonTypePack<int, float>",
+            result_children=[ValueCheck(name="b", type="int")])
+
+
+        self.expect_expr("emptyAnonTypePackAfterTypeParam", result_type="AnonTypePackAfterTypeParam<int>",
+            result_children=[ValueCheck(name="c", type="int")])
+        self.expect_expr("oneElemAnonTypePackAfterTypeParam", result_type="AnonTypePackAfterTypeParam<int, float>",
+            result_children=[ValueCheck(name="c", type="int")])
+
+
+
+        self.expect_expr("emptyAnonTypePackAfterAnonTypeParam", result_type="AnonTypePackAfterAnonTypeParam<int>",
+            result_children=[ValueCheck(name="d", type="float")])
+        self.expect_expr("oneElemAnonTypePackAfterAnonTypeParam", result_type="AnonTypePackAfterAnonTypeParam<int, float>",
+            result_children=[ValueCheck(name="d", type="float")])
+
+
+        self.expect_expr("emptyTypePackAfterAnonTypeParam", result_type="TypePackAfterAnonTypeParam<int>",
+            result_children=[ValueCheck(name="e", type="int")])
+        self.expect_expr("oneElemTypePackAfterAnonTypeParam", result_type="TypePackAfterAnonTypeParam<int, float>",
+            result_children=[ValueCheck(name="e", type="int")])
+
+
+        self.expect_expr("emptyTypePackAfterTypeParam", result_type="TypePackAfterTypeParam<int>",
+            result_children=[ValueCheck(name="f", type="int")])
+        self.expect_expr("oneElemTypePackAfterTypeParam", result_type="TypePackAfterTypeParam<int, float>",
+            result_children=[ValueCheck(name="f", type="int")])
+
+        self.expect_expr("emptyAnonTypePackAfterNonTypeParam", result_type="AnonTypePackAfterNonTypeParam<1>",
+            result_children=[ValueCheck(name="g", type="int")])
+        self.expect_expr("oneElemAnonTypePackAfterNonTypeParam", result_type="AnonTypePackAfterNonTypeParam<1, int>",
+            result_children=[ValueCheck(name="g", type="int")])
+
+
+        self.expect_expr("emptyAnonTypePackAfterAnonNonTypeParam", result_type="AnonTypePackAfterAnonNonTypeParam<1>",
+            result_children=[ValueCheck(name="h", type="float")])
+        self.expect_expr("oneElemAnonTypePackAfterAnonNonTypeParam", result_type="AnonTypePackAfterAnonNonTypeParam<1, int>",
+            result_children=[ValueCheck(name="h", type="float")])
+
+
+        self.expect_expr("emptyTypePackAfterAnonNonTypeParam", result_type="TypePackAfterAnonNonTypeParam<1>",
+            result_children=[ValueCheck(name="i", type="int")])
+        self.expect_expr("oneElemTypePackAfterAnonNonTypeParam", result_type="TypePackAfterAnonNonTypeParam<1, int>",
+            result_children=[ValueCheck(name="i", type="int")])
+
+
+        self.expect_expr("emptyTypePackAfterNonTypeParam", result_type="TypePackAfterNonTypeParam<1>",
+            result_children=[ValueCheck(name="j", type="int")])
+        self.expect_expr("oneElemTypePackAfterNonTypeParam", result_type="TypePackAfterNonTypeParam<1, int>",
+            result_children=[ValueCheck(name="j", type="int")])
 No newline at end of file

lldb/test/API/lang/cpp/class-template-type-parameter-pack/main.cpp

+// Named type parameter pack.
+template <typename... Is>
+struct TypePack { int a; };
+TypePack<> emptyTypePack;
+TypePack<int> oneElemTypePack;
+TypePack<int, float> twoElemTypePack;
+
+// Unnamed type parameter pack.
+template <typename... >
+struct AnonTypePack { int b; };
+AnonTypePack<> emptyAnonTypePack;
+AnonTypePack<int> oneElemAnonTypePack;
+AnonTypePack<int, float> twoElemAnonTypePack;
+
+// Test type parameter packs combined with non-pack type template parameters.
+
+// Unnamed type parameter pack behind a named type parameter.
+template <typename T, typename... >
+struct AnonTypePackAfterTypeParam { T c; };
+AnonTypePackAfterTypeParam<int> emptyAnonTypePackAfterTypeParam;
+AnonTypePackAfterTypeParam<int, float> oneElemAnonTypePackAfterTypeParam;
+
+// Unnamed type parameter pack behind an unnamed type parameter.
+template <typename, typename... >
+struct AnonTypePackAfterAnonTypeParam { float d; };
+AnonTypePackAfterAnonTypeParam<int> emptyAnonTypePackAfterAnonTypeParam;
+AnonTypePackAfterAnonTypeParam<int, float> oneElemAnonTypePackAfterAnonTypeParam;
+
+// Named type parameter pack behind an unnamed type parameter.
+template <typename, typename... Ts>
+struct TypePackAfterAnonTypeParam { int e; };
+TypePackAfterAnonTypeParam<int> emptyTypePackAfterAnonTypeParam;
+TypePackAfterAnonTypeParam<int, float> oneElemTypePackAfterAnonTypeParam;
+
+// Named type parameter pack behind a named type parameter.
+template <typename T, typename... Ts>
+struct TypePackAfterTypeParam { int f; };
+TypePackAfterTypeParam<int> emptyTypePackAfterTypeParam;
+TypePackAfterTypeParam<int, float> oneElemTypePackAfterTypeParam;
+
+// Test type parameter packs combined with non-pack non-type template parameters.
+
+// Unnamed type parameter pack behind a named type parameter.
+template <int I, typename... >
+struct AnonTypePackAfterNonTypeParam { int g; };
+AnonTypePackAfterNonTypeParam<1> emptyAnonTypePackAfterNonTypeParam;
+AnonTypePackAfterNonTypeParam<1, int> oneElemAnonTypePackAfterNonTypeParam;
+
+// Unnamed type parameter pack behind an unnamed type parameter.
+template <int, typename... >
+struct AnonTypePackAfterAnonNonTypeParam { float h; };
+AnonTypePackAfterAnonNonTypeParam<1> emptyAnonTypePackAfterAnonNonTypeParam;
+AnonTypePackAfterAnonNonTypeParam<1, int> oneElemAnonTypePackAfterAnonNonTypeParam;
+
+// Named type parameter pack behind an unnamed type parameter.
+template <int, typename... Ts>
+struct TypePackAfterAnonNonTypeParam { int i; };
+TypePackAfterAnonNonTypeParam<1> emptyTypePackAfterAnonNonTypeParam;
+TypePackAfterAnonNonTypeParam<1, int> oneElemTypePackAfterAnonNonTypeParam;
+
+// Named type parameter pack behind an unnamed type parameter.
+template <int I, typename... Ts>
+struct TypePackAfterNonTypeParam { int j; };
+TypePackAfterNonTypeParam<1> emptyTypePackAfterNonTypeParam;
+TypePackAfterNonTypeParam<1, int> oneElemTypePackAfterNonTypeParam;
+
+int main() {
+  return 0; // break here
+}

lldb/unittests/Symbol/TestTypeSystemClang.cpp

EXPECT_EQ(m_ast->GetTypeTemplateArgument(t.GetOpaqueQualType(), 1),
               CompilerType());
     auto result = m_ast->GetIntegralTemplateArgument(t.GetOpaqueQualType(), 1);
     ASSERT_NE(llvm::None, result);
     EXPECT_EQ(arg, result->value);
     EXPECT_EQ(int_type, result->type);
   }
 }
 
+TEST_F(TestTypeSystemClang, OnlyPackName) {
+  TypeSystemClang::TemplateParameterInfos infos;
+  infos.pack_name = "A";
+  EXPECT_FALSE(infos.IsValid());
+}
+
 static QualType makeConstInt(clang::ASTContext &ctxt) {
   QualType result(ctxt.IntTy);
   result.addConst();
   return result;
 }
 
 TEST_F(TestTypeSystemClang, TestGetTypeClassDeclType) {
   clang::ASTContext &ctxt = m_ast->getASTContext();