Allow Template argument accessors to automatically unwrap parameter packs

[JDevlieghere]

Summary

When looking at template arguments in LLDB, we usually care about what
the user passed in his code, not whether some of those arguments where
passed as a variadic parameter pack.

This patch extends all the C++ APIs to look at template parameters to
take an additional 'expand_pack' boolean that automatically unwraps the
potential argument packs. The equivalent SBAPI calls have been changed
to pass true for this parameter.

A byproduct of the patch is to also fix the support for template type
that have only a parameter pack as argument (like the OnlyPack type in
the test). Those were not recognized as template instanciations before.

The added test verifies that the SBAPI is able to iterate over the
arguments of a variadic template.

[clayborg]

Looks fine. A bit of cleanup might be nice on the TypeSystem.h to provide default implementations that just return 0 for some of these that every type system currently is required to override for no reason (all template related type system calls seem to have default "return 0;" functions in each type system. We can make future changes to these touch fewer files if we provide default implementations in TypeSystem.h.

include/lldb/Symbol/CompilerType.h

367–376

I know there wasn't documentation on these functions, but it might be nice to docuement what "expand_pack" means.

include/lldb/Symbol/GoASTContext.h

313–316

We should make a default implementation of this function in TypeSystem.h so not every TypeSystem subclass needs to make a do nothing and return 0 function. It will make future changes easier and touch less files.

include/lldb/Symbol/OCamlASTContext.h

230–233

We should make a default implementation of this function in TypeSystem.h so not every TypeSystem subclass needs to make a do nothing and return 0 function. It will make future changes easier and touch less files.

source/Symbol/JavaASTContext.cpp

881–885

We should make a default implementation of this function in TypeSystem.h so not every TypeSystem subclass needs to make a do nothing and return 0 function. It will make future changes easier and touch less files.

[shafik]

include/lldb/Symbol/ClangASTContext.h

284

Is this saying that an empty parameter pack is invalid? We can have an empty parameter pack

https://godbolt.org/z/8zCFz9

792

Why not default to false here?

794

Why not default to false here?

797

Why not default to false here?

source/Symbol/ClangASTContext.cpp

7569

Do we need to check num_args != 0

7664

The asset before we do math making this assumption i.e. args.size() - 1

[friss]

include/lldb/Symbol/ClangASTContext.h

284

That's a good question. I need to check what the DWARF looks like for an empty parameter pack. I would expect it not to be mentioned at all, but if it's there we need to support it.

include/lldb/Symbol/GoASTContext.h

313–316

I've done this in r341006, I'll rebase soon.

[friss]

include/lldb/Symbol/ClangASTContext.h

284

This was a good catch. The fact that there is an empty pack was recorded in the debug info and this made us consider the type as invalid. I've added a test to cover this.

792

I added the defaults at the top to keep the semantics for the existing code, but it turns out there's no code using those interfaces that I haven't updated. I'll remove the defaults from everywhere.

source/Symbol/ClangASTContext.cpp

7664

The assert is also wrong because of the empty pack issue. I'll update the patch.

[friss]

source/Symbol/ClangASTContext.cpp

7664

Actually, this is not true. The Decl will always have at least one argument which is the pack. The pack can be empty, but the Decl still records it as one argument. The assert should be hoisted though.

[friss]

Address feedback

[clayborg]

Looks good to me. Jim should take a look as well.

[friss]

@jingham ping

[jingham]

I'm a little worried that we have asserts with no backstops here. We ship in general with asserts off, so if some type is not copasetic we will probably crash shortly afterwards (in one case we assert num_args but then do an array access of num_args - 1)...

Seems like in the places where you've added asserts, we could return 0 (no template arguments) and though we wouldn't print the type correctly lldb wouldn't crash. We should always assume that debug info might a little crappy and not crash. Maybe these Decl's have been vetted earlier? If that's the case I withdraw the objection.

source/Symbol/ClangASTContext.cpp

7568–7570

IIUC, we would get into this state because debug information is messed up. lldb should never crash because of mal-formed debug information. It's fine to assert here so that if this happens say in a new compiler we can catch it in the test suite. But you should also return 0, since that's a straightforward workaround for bad debug information.

[clayborg]

Do we have any callers that call GetNumTemplateArguments with false? If not, remove the argument?

[JDevlieghere]

Commandeering this from Fred

[JDevlieghere]

• Rebase
• Address Jim's code review feedback

[JDevlieghere]

In D51387#1387074, @clayborg wrote:

Do we have any callers that call GetNumTemplateArguments with false? If not, remove the argument?

Yup, there's a bunch of uses in Language/CPlusPlus/LibCxx*.cpp

[Michael137]

LGTM

Just had some minor stylistic/documentation suggestions

lldb/source/API/SBType.cpp

576 ↗

(On Diff #451714)

Minor: this could be an opportunity to add documentation for this API in SBType.h, mentioning that parameter packs are always expanded

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

7122 ↗

(On Diff #451714)

7167 ↗

(On Diff #451714)

Do we use args.size() - 1 enough times throughout this function that it warrants something like const auto lastIdx = args.size() - 1;?

7172 ↗

(On Diff #451714)

In my opinion this series of checks is subtle enough to warrant some comments. But not a blocker

7175 ↗

(On Diff #451714)

7179 ↗

(On Diff #451714)

7181 ↗

(On Diff #451714)

Do we want a defensive check on 'idx' here? Something along the lines of

const auto pack_idx  = idx - (args.size() - 1);
const auto pack_size = pack.pack_size();
assert (pack_idx < pack_size && "Parameter pack index out-of-bounds");
if (pack_idx >= pack_size)
  return nullptr;

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

325 ↗

(On Diff #451714)

Minor: this comment applies to the condition on line 330 now. Could move it down?

[JDevlieghere]

Thanks for the review Michael. I've addressed all your comments in the version I landed.

include/lldb/Symbol/ClangASTContext.h

public:
   CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
                                 lldb::AccessType access_type, const char *name,
                                 int kind, lldb::LanguageType language,
                                 ClangASTMetadata *metadata = nullptr);
 
   class TemplateParameterInfos {
   public:
     bool IsValid() const {
-      if (args.empty())
+      if (args.empty() && (!packed_args || packed_args->args.empty()))
         return false;
       return args.size() == names.size() &&
              ((bool)pack_name == (bool)packed_args) &&
-        (!packed_args || !packed_args->packed_args);
+             (!packed_args || !packed_args->args.empty());
     }
 
     llvm::SmallVector<const char *, 2> names;
     llvm::SmallVector<clang::TemplateArgument, 2> args;
     
     const char * pack_name = nullptr;
     std::unique_ptr<TemplateParameterInfos> packed_args;
   };
public:
   // TODO: Return all matches for a given name by returning a
   // vector<vector<uint32_t>>
   // so we catch all names that match a given child name, not just the first.
   size_t
   GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
                                 const char *name, bool omit_empty_base_classes,
                                 std::vector<uint32_t> &child_indexes) override;
 
-  size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override;
+  size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
+                                 bool expand_pack = false) override;
 
   lldb::TemplateArgumentKind
-  GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
-                          size_t idx) override;
+  GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx,
+                          bool expand_pack) override;
   CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
-                                       size_t idx) override;
+                                       size_t idx, bool expand_pack) override;
   llvm::Optional<CompilerType::IntegralTemplateArgument>
-  GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type,
-                              size_t idx) override;
+  GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx,
+                              bool expand_pack) override;
 
   CompilerType GetTypeForFormatters(void *type) override;
 
 #define LLDB_INVALID_DECL_LEVEL UINT32_MAX
   // LLDB_INVALID_DECL_LEVEL is returned by CountDeclLevels if child_decl_ctx
   // could not be found in decl_ctx.
   uint32_t CountDeclLevels(clang::DeclContext *frame_decl_ctx,
                            clang::DeclContext *child_decl_ctx,

include/lldb/Symbol/CompilerType.h

public:
   // member in this class, or any base class that matches "name".
   // TODO: Return all matches for a given name by returning a
   // vector<vector<uint32_t>>
   // so we catch all names that match a given child name, not just the first.
   size_t
   GetIndexOfChildMemberWithName(const char *name, bool omit_empty_base_classes,
                                 std::vector<uint32_t> &child_indexes) const;
 
-  size_t GetNumTemplateArguments() const;
+  size_t GetNumTemplateArguments(bool expand_pack = false) const;
 
-  lldb::TemplateArgumentKind GetTemplateArgumentKind(size_t idx) const;
-  CompilerType GetTypeTemplateArgument(size_t idx) const;
+  lldb::TemplateArgumentKind
+  GetTemplateArgumentKind(size_t idx, bool expand_pack = false) const;
+  CompilerType GetTypeTemplateArgument(size_t idx,
+                                       bool expand_pack = false) const;
 
   // Returns the value of the template argument and its type.
   llvm::Optional<IntegralTemplateArgument>
-  GetIntegralTemplateArgument(size_t idx) const;
+  GetIntegralTemplateArgument(size_t idx, bool expand_pack = false) const;
 
   CompilerType GetTypeForFormatters() const;
 
   LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const;
 
   bool IsMeaninglessWithoutDynamicResolution() const;
 
   //------------------------------------------------------------------

include/lldb/Symbol/GoASTContext.h

public:
   // TODO: Return all matches for a given name by returning a
   // vector<vector<uint32_t>>
   // so we catch all names that match a given child name, not just the first.
   size_t
   GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
                                 const char *name, bool omit_empty_base_classes,
                                 std::vector<uint32_t> &child_indexes) override;
 
-  size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override {
+  size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
+                                 bool expand_pack) override {
     return 0;
   }
 
   //----------------------------------------------------------------------
   // Dumping types
   //----------------------------------------------------------------------
   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
                  Stream *s, lldb::Format format, const DataExtractor &data,
                  lldb::offset_t data_offset, size_t data_byte_size,
                  uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,

include/lldb/Symbol/JavaASTContext.h

public:
 
   lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
                              uint64_t &count) override;
 
   lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
 
   unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override;
 
-  size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override;
+  size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
+                                 bool expand_pack) override;
 
   int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
                                               size_t idx) override;
 
   CompilerType
   GetFunctionReturnType(lldb::opaque_compiler_type_t type) override;

include/lldb/Symbol/OCamlASTContext.h

uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
                                    const char *name,
                                    bool omit_empty_base_classes) override;
 
   size_t
   GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
                                 const char *name, bool omit_empty_base_classes,
                                 std::vector<uint32_t> &child_indexes) override;
 
-  size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override {
+  size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
+                                 bool expand_pack) override {
     return 0;
   }
 
   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
                  Stream *s, lldb::Format format, const DataExtractor &data,
                  lldb::offset_t data_offset, size_t data_byte_size,
                  uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                  bool show_types, bool show_summary, bool verbose,
                  uint32_t depth) override;
 

include/lldb/Symbol/TypeSystem.h

public:
   // TODO: Return all matches for a given name by returning a
   // vector<vector<uint32_t>>
   // so we catch all names that match a given child name, not just the first.
   virtual size_t
   GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type,
                                 const char *name, bool omit_empty_base_classes,
                                 std::vector<uint32_t> &child_indexes) = 0;
 
-  virtual size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type) = 0;
+  virtual size_t GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
+                                         bool expand_pack = false) = 0;
 
   virtual lldb::TemplateArgumentKind
-  GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx);
-  virtual CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
-                                           size_t idx);
+  GetTemplateArgumentKind(lldb::opaque_compiler_type_t type, size_t idx,
+                          bool expand_pack = false);
+  virtual CompilerType
+  GetTypeTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx,
+                          bool expand_pack = false);
   virtual llvm::Optional<CompilerType::IntegralTemplateArgument>
-  GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx);
+  GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx,
+                              bool expand_pack = false);
 
   //----------------------------------------------------------------------
   // Dumping types
   //----------------------------------------------------------------------
 
   virtual void DumpValue(lldb::opaque_compiler_type_t type,
                          ExecutionContext *exe_ctx, Stream *s,
                          lldb::Format format, const DataExtractor &data,

packages/Python/lldbsuite/test/lang/cpp/class-template-parameter-pack/TestTemplatePackArgs.py

+"""
+Test that the type of arguments to C++ template classes that have variadic
+parameters can be enumerated.
+"""
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TemplatePackArgsTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_template_argument_pack(self):
+        self.build()
+        (_, _, thread, _) = lldbutil.run_to_source_breakpoint(self,
+          'breakpoint here', lldb.SBFileSpec('main.cpp'), exe_name = 'a.out')
+        frame = thread.GetSelectedFrame()
+
+        only_pack = frame.FindVariable('onlyPack')
+        self.assertTrue(only_pack.IsValid(),
+                        'make sure we find the onlyPack variable')
+        self.assertEqual(only_pack.GetType().GetNumberOfTemplateArguments(), 4)
+        self.assertEqual(only_pack.GetType().GetTemplateArgumentType(0).GetName(), 'int')
+        self.assertEqual(only_pack.GetType().GetTemplateArgumentType(1).GetName(), 'char')
+        self.assertEqual(only_pack.GetType().GetTemplateArgumentType(2).GetName(), 'double')
+        # Access the C<double, 42> template parameter.
+        nested_template = only_pack.GetType().GetTemplateArgumentType(3)
+        self.assertEqual(nested_template.GetName(), 'D<int, int, bool>')
+        self.assertEqual(nested_template.GetNumberOfTemplateArguments(), 3)
+        self.assertEqual(nested_template.GetTemplateArgumentType(0).GetName(), 'int')
+        self.assertEqual(nested_template.GetTemplateArgumentType(1).GetName(), 'int')
+        self.assertEqual(nested_template.GetTemplateArgumentType(2).GetName(), 'bool')

packages/Python/lldbsuite/test/lang/cpp/class-template-parameter-pack/main.cpp

template <> struct D<int, int> {
   int member;
   bool isIntBool() { return false; }
 };
 
 template <> struct D<int, int, bool> : D<int, int> {
   bool isIntBool() { return true; }
 };
 
+template <typename... Args> struct OnlyPack {};
+
 int main (int argc, char const *argv[])
 {
+    OnlyPack<int, char, double, D<int, int, bool>> onlyPack;
+
     C<int,16,32> myC;
     C<int,16> myLesserC;
     myC.member = 64;
     (void)C<int,16,32>().isSixteenThirtyTwo();
     (void)C<int,16>().isSixteenThirtyTwo();
     (void)(myC.member != 64);   //% self.expect("expression -- myC", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["64"])
                                 //% self.expect("expression -- C<int, 16>().isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"])
                                 //% self.expect("expression -- C<int, 16, 32>().isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"])
                                 //% self.expect("expression -- myLesserC.isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"])
                                 //% self.expect("expression -- myC.isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"])
    
     D<int,int,bool> myD;
     D<int,int> myLesserD;
     myD.member = 64;
     (void)D<int,int,bool>().isIntBool();
-    (void)D<int,int>().isIntBool();
+    (void)D<int,int>().isIntBool(); // breakpoint here
     return myD.member != 64;  //% self.expect("expression -- myD", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["64"])
                                 //% self.expect("expression -- D<int, int>().isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"])
                                 //% self.expect("expression -- D<int, int, bool>().isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"])
                                 //% self.expect("expression -- myLesserD.isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"])
                                 //% self.expect("expression -- myD.isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"])
 }

source/API/SBType.cpp

 
 lldb::TypeClass SBType::GetTypeClass() {
   if (IsValid())
     return m_opaque_sp->GetCompilerType(true).GetTypeClass();
   return lldb::eTypeClassInvalid;
 }
 
 uint32_t SBType::GetNumberOfTemplateArguments() {
+  bool expand_pack = true;
   if (IsValid())
-    return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
+    return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments(
+        expand_pack);
   return 0;
 }
 
 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
   if (!IsValid())
     return SBType();
 
   CompilerType type;
+  bool expand_pack = true;
   switch(GetTemplateArgumentKind(idx)) {
     case eTemplateArgumentKindType:
-      type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(idx);
+      type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(
+          idx, expand_pack);
       break;
     case eTemplateArgumentKindIntegral:
       type = m_opaque_sp->GetCompilerType(false)
-                 .GetIntegralTemplateArgument(idx)
+                 .GetIntegralTemplateArgument(idx, expand_pack)
                  ->type;
       break;
     default:
       break;
   }
   if (type.IsValid())
     return SBType(type);
   return SBType();
 }
 
 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
+  bool expand_pack = true;
   if (IsValid())
-    return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
+    return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(
+        idx, expand_pack);
   return eTemplateArgumentKindNull;
 }
 
 SBTypeList::SBTypeList() : m_opaque_ap(new TypeListImpl()) {}
 
 SBTypeList::SBTypeList(const SBTypeList &rhs)
     : m_opaque_ap(new TypeListImpl()) {
   for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();

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();
+
+  return template_param_infos.IsValid();
 }
 
 bool DWARFASTParserClang::CompleteTypeFromDWARF(const DWARFDIE &die,
                                                 lldb_private::Type *type,
                                                 CompilerType &clang_type) {
   SymbolFileDWARF *dwarf = die.GetDWARF();
 
   std::lock_guard<std::recursive_mutex> guard(

source/Symbol/ClangASTContext.cpp

if (type && name && name[0]) {
     default:
       break;
     }
   }
   return UINT32_MAX;
 }
 
 size_t
-ClangASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
+ClangASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
+                                         bool expand_pack) {
   if (!type)
     return 0;
 
   clang::QualType qual_type(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl) {
         const clang::ClassTemplateSpecializationDecl *template_decl =
             llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
                 cxx_record_decl);
-        if (template_decl)
-          return template_decl->getTemplateArgs().size();
+        if (template_decl) {
+          const auto &template_arg_list = template_decl->getTemplateArgs();
+          int num_args = template_arg_list.size();
+          if (expand_pack) {
+            auto &pack = template_arg_list[num_args - 1];
+            if (pack.getKind() == clang::TemplateArgument::Pack)
+              num_args += pack.pack_size() - 1;
+          }
+          return num_args;
+        }
       }
     }
     break;
 
   case clang::Type::Typedef:
     return (CompilerType(getASTContext(),
                          llvm::cast<clang::TypedefType>(qual_type)
                              ->getDecl()
case clang::Type::Paren:
     return GetAsTemplateSpecialization(
         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
 
   default:
     return nullptr;
   }
 }
 
+const TemplateArgument *
+GetNthTemplateArgument(const clang::ClassTemplateSpecializationDecl *decl,
+                       int idx, bool expand_pack) {
+  const auto &args = decl->getTemplateArgs();
+
+  if (idx < args.size() - 1)
+    return &args[idx];
+
+  assert(args.size() &&
+         "We shouldn't have a template specialization without any args");
+  if (!expand_pack ||
+      args[args.size() - 1].getKind() != clang::TemplateArgument::Pack)
+    return idx >= args.size() ? nullptr : &args[idx];
+
+  const auto &pack = args[args.size() - 1];
+  return &pack.pack_elements()[idx - (args.size() - 1)];
+}
+
 lldb::TemplateArgumentKind
 ClangASTContext::GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
-                                         size_t arg_idx) {
+                                         size_t arg_idx, bool expand_pack) {
   const clang::ClassTemplateSpecializationDecl *template_decl =
       GetAsTemplateSpecialization(type);
-  if (! template_decl || arg_idx >= template_decl->getTemplateArgs().size())
+  if (!template_decl)
     return eTemplateArgumentKindNull;
 
-  switch (template_decl->getTemplateArgs()[arg_idx].getKind()) {
+  const auto *arg = GetNthTemplateArgument(template_decl, arg_idx, expand_pack);
+  if (!arg)
+    return eTemplateArgumentKindNull;
+
+  switch (arg->getKind()) {
   case clang::TemplateArgument::Null:
     return eTemplateArgumentKindNull;
 
   case clang::TemplateArgument::NullPtr:
     return eTemplateArgumentKindNullPtr;
 
   case clang::TemplateArgument::Type:
     return eTemplateArgumentKindType;
ClangASTContext::GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
   case clang::TemplateArgument::Pack:
     return eTemplateArgumentKindPack;
   }
   llvm_unreachable("Unhandled clang::TemplateArgument::ArgKind");
 }
 
 CompilerType
 ClangASTContext::GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
-                                         size_t idx) {
+                                         size_t idx, bool expand_pack) {
   const clang::ClassTemplateSpecializationDecl *template_decl =
       GetAsTemplateSpecialization(type);
-  if (!template_decl || idx >= template_decl->getTemplateArgs().size())
+  if (!template_decl)
     return CompilerType();
 
-  const clang::TemplateArgument &template_arg =
-      template_decl->getTemplateArgs()[idx];
-  if (template_arg.getKind() != clang::TemplateArgument::Type)
+  const auto *arg = GetNthTemplateArgument(template_decl, idx, expand_pack);
+  if (!arg || arg->getKind() != clang::TemplateArgument::Type)
     return CompilerType();
 
-  return CompilerType(getASTContext(), template_arg.getAsType());
+  return CompilerType(getASTContext(), arg->getAsType());
 }
 
 llvm::Optional<CompilerType::IntegralTemplateArgument>
 ClangASTContext::GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type,
-                                             size_t idx) {
+                                             size_t idx, bool expand_pack) {
   const clang::ClassTemplateSpecializationDecl *template_decl =
       GetAsTemplateSpecialization(type);
-  if (! template_decl || idx >= template_decl->getTemplateArgs().size())
+  if (!template_decl)
     return llvm::None;
 
-  const clang::TemplateArgument &template_arg =
-      template_decl->getTemplateArgs()[idx];
-  if (template_arg.getKind() != clang::TemplateArgument::Integral)
+  const auto *arg = GetNthTemplateArgument(template_decl, idx, expand_pack);
+  if (!arg || arg->getKind() != clang::TemplateArgument::Integral)
     return llvm::None;
 
-  return {{template_arg.getAsIntegral(),
-           CompilerType(getASTContext(), template_arg.getIntegralType())}};
+  return {{arg->getAsIntegral(),
+           CompilerType(getASTContext(), arg->getIntegralType())}};
 }
 
 CompilerType ClangASTContext::GetTypeForFormatters(void *type) {
   if (type)
     return ClangUtil::RemoveFastQualifiers(CompilerType(this, type));
   return CompilerType();
 }
 

source/Symbol/CompilerType.cpp

size_t CompilerType::GetIndexOfChildMemberWithName(
     std::vector<uint32_t> &child_indexes) const {
   if (IsValid() && name && name[0]) {
     return m_type_system->GetIndexOfChildMemberWithName(
         m_type, name, omit_empty_base_classes, child_indexes);
   }
   return 0;
 }
 
-size_t CompilerType::GetNumTemplateArguments() const {
+size_t CompilerType::GetNumTemplateArguments(bool expand_pack) const {
   if (IsValid()) {
-    return m_type_system->GetNumTemplateArguments(m_type);
+    return m_type_system->GetNumTemplateArguments(m_type, expand_pack);
   }
   return 0;
 }
 
-TemplateArgumentKind CompilerType::GetTemplateArgumentKind(size_t idx) const {
+TemplateArgumentKind
+CompilerType::GetTemplateArgumentKind(size_t idx, bool expand_pack) const {
   if (IsValid())
-    return m_type_system->GetTemplateArgumentKind(m_type, idx);
+    return m_type_system->GetTemplateArgumentKind(m_type, idx, expand_pack);
   return eTemplateArgumentKindNull;
 }
 
-CompilerType CompilerType::GetTypeTemplateArgument(size_t idx) const {
+CompilerType CompilerType::GetTypeTemplateArgument(size_t idx,
+                                                   bool expand_pack) const {
   if (IsValid()) {
-    return m_type_system->GetTypeTemplateArgument(m_type, idx);
+    return m_type_system->GetTypeTemplateArgument(m_type, idx, expand_pack);
   }
   return CompilerType();
 }
 
 llvm::Optional<CompilerType::IntegralTemplateArgument>
-CompilerType::GetIntegralTemplateArgument(size_t idx) const {
+CompilerType::GetIntegralTemplateArgument(size_t idx, bool expand_pack) const {
   if (IsValid())
-    return m_type_system->GetIntegralTemplateArgument(m_type, idx);
+    return m_type_system->GetIntegralTemplateArgument(m_type, idx, expand_pack);
   return llvm::None;
 }
 
 CompilerType CompilerType::GetTypeForFormatters() const {
   if (IsValid())
     return m_type_system->GetTypeForFormatters(m_type);
   return CompilerType();
 }

source/Symbol/JavaASTContext.cpp

 size_t
 JavaASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
                                           const char *s, uint8_t *dst,
                                           size_t dst_size) {
   assert(false && "Not implemented");
   return 0;
 }
 
 size_t
-JavaASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
+JavaASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
+                                        bool expand_pack) {
   return 0;
 }
 
 uint32_t JavaASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
   if (JavaObjectType *obj =
           llvm::dyn_cast<JavaObjectType>(static_cast<JavaType *>(type))) {
     GetCompleteType(type);
     return obj->GetNumFields();
   }
   return 0;

source/Symbol/TypeSystem.cpp

CompilerType TypeSystem::GetBuiltinTypeByName(const ConstString &name) {
   return CompilerType();
 }
 
 CompilerType TypeSystem::GetTypeForFormatters(void *type) {
   return CompilerType(this, type);
 }
 
 TemplateArgumentKind
-TypeSystem::GetTemplateArgumentKind(opaque_compiler_type_t type, size_t idx) {
+TypeSystem::GetTemplateArgumentKind(opaque_compiler_type_t type, size_t idx,
+                                    bool expand_pack) {
   return eTemplateArgumentKindNull;
 }
 
 CompilerType TypeSystem::GetTypeTemplateArgument(opaque_compiler_type_t type,
-                                                 size_t idx) {
+                                                 size_t idx, bool expand_pack) {
   return CompilerType();
 }
 
 llvm::Optional<CompilerType::IntegralTemplateArgument>
-TypeSystem::GetIntegralTemplateArgument(opaque_compiler_type_t type,
-                                        size_t idx) {
+TypeSystem::GetIntegralTemplateArgument(opaque_compiler_type_t type, size_t idx,
+                                        bool expand_pack) {
   return llvm::None;
 }
 
 LazyBool TypeSystem::ShouldPrintAsOneLiner(void *type, ValueObject *valobj) {
   return eLazyBoolCalculate;
 }
 
 bool TypeSystem::IsMeaninglessWithoutDynamicResolution(void *type) {